_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q16600 | FSet | train | func FSet(f *os.File, name string, data []byte) error {
if err := fsetxattr(f, name, data, 0); err != nil {
return &Error{"xattr.FSet", f.Name(), name, err}
}
return nil
} | go | {
"resource": ""
} |
q16601 | SetWithFlags | train | func SetWithFlags(path, name string, data []byte, flags int) error {
if err := setxattr(path, name, data, flags); err != nil {
return &Error{"xattr.SetWithFlags", path, name, err}
}
return nil
} | go | {
"resource": ""
} |
q16602 | LSetWithFlags | train | func LSetWithFlags(path, name string, data []byte, flags int) error {
if err := lsetxattr(path, name, data, flags); err != nil {
return &Error{"xattr.LSetWithFlags", path, name, err}
}
return nil
} | go | {
"resource": ""
} |
q16603 | FSetWithFlags | train | func FSetWithFlags(f *os.File, name string, data []byte, flags int) error {
if err := fsetxattr(f, name, data, flags); err != nil {
return &Error{"xattr.FSetWithFlags", f.Name(), name, err}
}
return nil
} | go | {
"resource": ""
} |
q16604 | Remove | train | func Remove(path, name string) error {
if err := removexattr(path, name); err != nil {
return &Error{"xattr.Remove", path, name, err}
}
return nil
} | go | {
"resource": ""
} |
q16605 | LRemove | train | func LRemove(path, name string) error {
if err := lremovexattr(path, name); err != nil {
return &Error{"xattr.LRemove", path, name, err}
}
return nil
} | go | {
"resource": ""
} |
q16606 | FRemove | train | func FRemove(f *os.File, name string) error {
if err := fremovexattr(f, name); err != nil {
return &Error{"xattr.FRemove", f.Name(), name, err}
}
return nil
} | go | {
"resource": ""
} |
q16607 | List | train | func List(path string) ([]string, error) {
return list(path, func(data []byte) (int, error) {
return listxattr(path, data)
})
} | go | {
"resource": ""
} |
q16608 | LList | train | func LList(path string) ([]string, error) {
return list(path, func(data []byte) (int, error) {
return llistxattr(path, data)
})
} | go | {
"resource": ""
} |
q16609 | FList | train | func FList(f *os.File) ([]string, error) {
return list(f.Name(), func(data []byte) (int, error) {
return flistxattr(f, data)
})
} | go | {
"resource": ""
} |
q16610 | list | train | func list(path string, listxattrFunc listxattrFunc) ([]string, error) {
myname := "xattr.list"
// find size.
size, err := listxattrFunc(nil)
if err != nil {
return nil, &Error{myname, path, "", err}
}
if size > 0 {
// `size + 1` because of ERANGE error when reading
// from a SMB1 mount point (https://github... | go | {
"resource": ""
} |
q16611 | bytePtrFromSlice | train | func bytePtrFromSlice(data []byte) (ptr *byte, size int) {
size = len(data)
if size > 0 {
ptr = &data[0]
}
return
} | go | {
"resource": ""
} |
q16612 | AddrFamily | train | func AddrFamily(ip net.IP) int {
if len(ip) == v4Length {
return IPv4
}
if len(ip) == v6Length && bytes.HasPrefix(ip, v4Prefix) {
return IPv4
}
return IPv6
} | go | {
"resource": ""
} |
q16613 | InterfaceIPs | train | func InterfaceIPs(device string) (ips []net.IP, _ error) {
var networks []net.Addr
if iface, err := net.InterfaceByName(device); err != nil {
return nil, err
} else if networks, err = iface.Addrs(); err != nil {
return nil, err
}
for _, network := range networks {
if ipNet, castable := network.(*net.IPNet)... | go | {
"resource": ""
} |
q16614 | Validate | train | func (o *ServiceOptions) Validate(defaultHost net.IP) error {
if o.Port == 0 {
return ErrMissingEndpoint
}
if len(o.Host) != 0 {
if addr, err := net.ResolveIPAddr("ip", o.Host); err == nil {
o.host = addr.IP
} else {
return err
}
} else if defaultHost != nil {
o.host = defaultHost
} else {
retur... | go | {
"resource": ""
} |
q16615 | Validate | train | func (o *BackendOptions) Validate() error {
if len(o.Host) == 0 || o.Port == 0 {
return ErrMissingEndpoint
}
if addr, err := net.ResolveIPAddr("ip", o.Host); err == nil {
o.host = addr.IP
} else {
return err
}
if o.Weight <= 0 {
o.Weight = 100
}
if len(o.Method) == 0 {
o.Method = "nat"
}
o.Metho... | go | {
"resource": ""
} |
q16616 | Validate | train | func (o *Options) Validate() error {
if len(o.Type) == 0 {
// TCP is a safe guess: the majority of services are TCP-based.
o.Type = "tcp"
}
if len(o.Interval) == 0 {
o.Interval = "1m"
}
o.Type = strings.ToLower(o.Type)
if fn := get[o.Type]; fn == nil {
return ErrUnknownPulseType
}
var err error
if... | go | {
"resource": ""
} |
q16617 | NewMetrics | train | func NewMetrics() *Metrics {
return &Metrics{Status: StatusUp, Health: 1, Uptime: 0, lastTs: time.Now()}
} | go | {
"resource": ""
} |
q16618 | Update | train | func (m *Metrics) Update(status StatusType) Metrics {
m.Status = status
m.Health = 0
m.record = append(m.record, status)
if len(m.record) > 100 {
m.record = m.record[1:]
}
for _, result := range m.record {
m.Health += float64(result)
}
m.Health = 1.0 - m.Health/float64(len(m.record))
if ts := time.Now(... | go | {
"resource": ""
} |
q16619 | ParseInterval | train | func ParseInterval(s string) (time.Duration, error) {
if m := reInterval.FindStringSubmatch(strings.TrimSpace(s)); len(m) != 0 {
value, _ := strconv.ParseInt(m[1], 10, 32)
duration := intervals[strings.ToLower(m[2])]
return duration * time.Duration(value), nil
}
return 0, errInvalidIntervalFormat
} | go | {
"resource": ""
} |
q16620 | MustMarshal | train | func MustMarshal(object interface{}, options JSONOptions) []byte {
output, err := json.Marshal(&object)
if err != nil {
panic(err)
}
switch {
case options.Indent:
buffer := bytes.Buffer{}
// TODO(@kobolog): Expose indentation options via JSONOptions.
json.Indent(&buffer, output, "", "\t")
return buff... | go | {
"resource": ""
} |
q16621 | New | train | func New(opts *Options) (Driver, error) {
switch opts.Type {
case "consul":
return newConsulDriver(opts.Args)
default:
return &noopDriver{}, nil
}
} | go | {
"resource": ""
} |
q16622 | New | train | func New(host string, port uint16, opts *Options) (*Pulse, error) {
if err := opts.Validate(); err != nil {
return nil, err
}
d, err := get[opts.Type](host, port, opts.Args)
if err != nil {
return nil, err
}
stopCh := make(chan struct{})
return &Pulse{d, opts.interval, stopCh, NewMetrics()}, nil
} | go | {
"resource": ""
} |
q16623 | Loop | train | func (p *Pulse) Loop(id ID, pulseCh chan Update, consumerStopCh <-chan struct{}) {
log.Infof("starting pulse for %s", id)
// Randomize the first health-check to avoid thundering herd syndrome.
interval := time.Duration(rng.Int63n(int64(p.interval)))
for {
select {
case <-time.After(interval):
select {
/... | go | {
"resource": ""
} |
q16624 | Get | train | func (do DynamicMap) Get(key string, d interface{}) interface{} {
if v, exists := do[key]; !exists {
return d
} else if vt, dt := reflect.TypeOf(v), reflect.TypeOf(d); vt.ConvertibleTo(dt) {
return v
} else if isInt(v.(string)) {
convertedValue, _ := strconv.Atoi(v.(string))
return convertedValue
} else {
... | go | {
"resource": ""
} |
q16625 | NewContext | train | func NewContext(options ContextOptions) (*Context, error) {
log.Info("initializing IPVS context")
ctx := &Context{
ipvs: &gnl2go.IpvsClient{},
services: make(map[string]*service),
backends: make(map[string]*backend),
pulseCh: make(chan pulse.Update),
stopCh: make(chan struct{}),
}
if len(options.... | go | {
"resource": ""
} |
q16626 | Close | train | func (ctx *Context) Close() {
log.Info("shutting down IPVS context")
// This will also shutdown the pulse notification sink goroutine.
close(ctx.stopCh)
for vsID := range ctx.services {
ctx.RemoveService(vsID)
}
// This is not strictly required, as far as I know.
ctx.ipvs.Exit()
} | go | {
"resource": ""
} |
q16627 | ListServices | train | func (ctx *Context) ListServices() ([]string, error) {
ctx.mutex.RLock()
defer ctx.mutex.RUnlock()
r := make([]string, 0, len(ctx.services))
for vsID := range ctx.services {
r = append(r, vsID)
}
return r, nil
} | go | {
"resource": ""
} |
q16628 | GetService | train | func (ctx *Context) GetService(vsID string) (*ServiceInfo, error) {
ctx.mutex.RLock()
defer ctx.mutex.RUnlock()
vs, exists := ctx.services[vsID]
if !exists {
return nil, ErrObjectNotFound
}
result := ServiceInfo{Options: vs.options}
// This is O(n), can be optimized with reverse backend map.
for rsID, bac... | go | {
"resource": ""
} |
q16629 | GetBackend | train | func (ctx *Context) GetBackend(vsID, rsID string) (*BackendInfo, error) {
ctx.mutex.RLock()
defer ctx.mutex.RUnlock()
rs, exists := ctx.backends[rsID]
if !exists {
return nil, ErrObjectNotFound
}
return &BackendInfo{rs.options, rs.metrics}, nil
} | go | {
"resource": ""
} |
q16630 | ParseFacets | train | func (parser *ExtensiveResultParser) ParseFacets(response *SolrResponse, sr *SolrResult) {
if fc, ok := response.Response["facet_counts"].(map[string]interface{}); ok {
sr.FacetCounts = fc
if f, ok := fc["facet_fields"].(map[string]interface{}); ok {
sr.Facets = f
}
}
} | go | {
"resource": ""
} |
q16631 | ParseJsonFacets | train | func (parser *ExtensiveResultParser) ParseJsonFacets(response *SolrResponse, sr *SolrResult) {
if jf, ok := response.Response["facets"].(map[string]interface{}); ok {
sr.JsonFacets = jf
}
} | go | {
"resource": ""
} |
q16632 | ParseFacetCounts | train | func (parser *StandardResultParser) ParseFacetCounts(response *SolrResponse, sr *SolrResult) {
if facetCounts, ok := response.Response["facet_counts"].(map[string]interface{}); ok {
sr.FacetCounts = facetCounts
}
} | go | {
"resource": ""
} |
q16633 | ParseHighlighting | train | func (parser *StandardResultParser) ParseHighlighting(response *SolrResponse, sr *SolrResult) {
if highlighting, ok := response.Response["highlighting"].(map[string]interface{}); ok {
sr.Highlighting = highlighting
}
} | go | {
"resource": ""
} |
q16634 | ParseStats | train | func (parser *StandardResultParser) ParseStats(response *SolrResponse, sr *SolrResult) {
if stats, ok := response.Response["stats"].(map[string]interface{}); ok {
sr.Stats = stats
}
} | go | {
"resource": ""
} |
q16635 | SetBasicAuth | train | func (ca *CoreAdmin) SetBasicAuth(username, password string) {
ca.username = username
ca.password = password
} | go | {
"resource": ""
} |
q16636 | HTTPPost | train | func HTTPPost(path string, data *[]byte, headers [][]string, username, password string) ([]byte, error) {
var (
req *http.Request
err error
)
client := &http.Client{Transport: &transport}
if data == nil {
req, err = http.NewRequest("POST", path, nil)
} else {
req, err = http.NewRequest("POST", path, bytes... | go | {
"resource": ""
} |
q16637 | HTTPGet | train | func HTTPGet(url string, headers [][]string, username, password string) ([]byte, error) {
client := &http.Client{Transport: &transport}
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return nil, err
}
if username != "" && password != "" {
req.SetBasicAuth(username, password)
}
if len(headers... | go | {
"resource": ""
} |
q16638 | NewConnection | train | func NewConnection(solrUrl, core string) (*Connection, error) {
u, err := url.ParseRequestURI(strings.TrimRight(solrUrl, "/"))
if err != nil {
return nil, err
}
return &Connection{url: u, core: core}, nil
} | go | {
"resource": ""
} |
q16639 | Update | train | func (c *Connection) Update(data interface{}, params *url.Values) (*SolrUpdateResponse, error) {
b, err := json2bytes(data)
if err != nil {
return nil, err
}
if params == nil {
params = &url.Values{}
}
params.Set("wt", "json")
r, err := HTTPPost(fmt.Sprintf("%s/%s/update/?%s", c.url.String(), c.core, pa... | go | {
"resource": ""
} |
q16640 | NewSearch | train | func NewSearch(c *Connection, q *Query) *Search {
s := new(Search)
if q != nil {
s.SetQuery(q)
}
if c != nil {
s.conn = c
}
return s
} | go | {
"resource": ""
} |
q16641 | QueryParams | train | func (s *Search) QueryParams() *url.Values {
if s.query == nil {
s.query = NewQuery()
}
if s.Debug != "" {
s.query.params.Set("debug", s.Debug)
s.query.params.Set("indent", "true")
}
return s.query.params
} | go | {
"resource": ""
} |
q16642 | Result | train | func (s *Search) Result(parser ResultParser) (*SolrResult, error) {
resp, err := s.Resource("select", s.QueryParams())
if err != nil {
return nil, err
}
if parser == nil {
parser = new(StandardResultParser)
}
return parser.Parse(resp)
} | go | {
"resource": ""
} |
q16643 | NewSchema | train | func NewSchema(solrUrl, core string) (*Schema, error) {
u, err := url.ParseRequestURI(strings.TrimRight(solrUrl, "/"))
if err != nil {
return nil, err
}
return &Schema{url: u, core: core}, nil
} | go | {
"resource": ""
} |
q16644 | Start | train | func (q *Query) Start(start int) {
q.params.Set("start", fmt.Sprintf("%d", start))
} | go | {
"resource": ""
} |
q16645 | Rows | train | func (q *Query) Rows(rows int) {
q.params.Set("rows", fmt.Sprintf("%d", rows))
} | go | {
"resource": ""
} |
q16646 | Has | train | func (d Document) Has(k string) bool {
_, ok := d[k]
return ok
} | go | {
"resource": ""
} |
q16647 | Get | train | func (d Document) Get(k string) interface{} {
v, _ := d[k]
return v
} | go | {
"resource": ""
} |
q16648 | NewSolrInterface | train | func NewSolrInterface(solrUrl, core string) (*SolrInterface, error) {
c, err := NewConnection(solrUrl, core)
if err != nil {
return nil, err
}
return &SolrInterface{conn: c}, nil
} | go | {
"resource": ""
} |
q16649 | Search | train | func (si *SolrInterface) Search(q *Query) *Search {
return NewSearch(si.conn, q)
} | go | {
"resource": ""
} |
q16650 | makeAddChunks | train | func makeAddChunks(docs []Document, chunk_size int) []map[string]interface{} {
if chunk_size < 1 {
chunk_size = 100
}
docs_len := len(docs)
num_chunk := int(math.Ceil(float64(docs_len) / float64(chunk_size)))
doc_counter := 0
chunks := make([]map[string]interface{}, num_chunk)
for i := 0; i < num_chunk; i++ {
... | go | {
"resource": ""
} |
q16651 | Add | train | func (si *SolrInterface) Add(docs []Document, chunk_size int, params *url.Values) (*SolrUpdateResponse, error) {
result := &SolrUpdateResponse{Success: true}
responses := M{}
chunks := makeAddChunks(docs, chunk_size)
for i := 0; i < len(chunks); i++ {
res, err := si.Update(chunks[i], params)
if err != nil {
... | go | {
"resource": ""
} |
q16652 | DeleteAll | train | func (si *SolrInterface) DeleteAll() (*SolrUpdateResponse, error) {
params := &url.Values{}
params.Add("commit", "true")
return si.Delete(M{"query": "*:*"}, params)
} | go | {
"resource": ""
} |
q16653 | Commit | train | func (si *SolrInterface) Commit() (*SolrUpdateResponse, error) {
params := &url.Values{}
params.Add("commit", "true")
return si.Update(M{}, params)
} | go | {
"resource": ""
} |
q16654 | CoreAdmin | train | func (si *SolrInterface) CoreAdmin() (*CoreAdmin, error) {
ca, err := NewCoreAdmin(si.conn.url.String())
if err != nil {
return nil, err
}
ca.SetBasicAuth(si.conn.username, si.conn.password)
return ca, nil
} | go | {
"resource": ""
} |
q16655 | Schema | train | func (si *SolrInterface) Schema() (*Schema, error) {
s, err := NewSchema(si.conn.url.String(), si.conn.core)
if err != nil {
return nil, err
}
s.SetBasicAuth(si.conn.username, si.conn.password)
return s, nil
} | go | {
"resource": ""
} |
q16656 | Ping | train | func (si *SolrInterface) Ping() (status string, qtime int, err error) {
r, err := HTTPGet(fmt.Sprintf("%s/%s/admin/ping?wt=json", si.conn.url.String(), si.conn.core), nil, si.conn.username, si.conn.password)
if err != nil {
return "", -1, err
}
resp, err := bytes2json(&r)
if err != nil {
return "", -1, err
}... | go | {
"resource": ""
} |
q16657 | Vectorize | train | func Vectorize(features []Feature) Vector {
var v Vector
for _, feature := range features {
sum := feature.Sum()
weight := feature.Weight()
for i := uint8(0); i < 64; i++ {
bit := ((sum >> i) & 1)
if bit == 1 {
v[i] += weight
} else {
v[i] -= weight
}
}
}
return v
} | go | {
"resource": ""
} |
q16658 | NewFeature | train | func NewFeature(f []byte) feature {
h := fnv.New64()
h.Write(f)
return feature{h.Sum64(), 1}
} | go | {
"resource": ""
} |
q16659 | NewFeatureWithWeight | train | func NewFeatureWithWeight(f []byte, weight int) feature {
fw := NewFeature(f)
fw.weight = weight
return fw
} | go | {
"resource": ""
} |
q16660 | ReceiveFile | train | func (s *SCP) ReceiveFile(srcFile, destFile string) error {
srcFile = realPath(filepath.Clean(srcFile))
destFile = filepath.Clean(destFile)
fiDest, err := os.Stat(destFile)
if err != nil && !os.IsNotExist(err) {
return fmt.Errorf("failed to get information of destnation file: err=%s", err)
}
if err == nil && fi... | go | {
"resource": ""
} |
q16661 | SendFile | train | func (s *SCP) SendFile(srcFile, destFile string) error {
srcFile = filepath.Clean(srcFile)
destFile = realPath(filepath.Clean(destFile))
return runSourceSession(s.client, destFile, false, "", false, true, func(s *sourceSession) error {
osFileInfo, err := os.Stat(srcFile)
if err != nil {
return fmt.Errorf("fa... | go | {
"resource": ""
} |
q16662 | SendDir | train | func (s *SCP) SendDir(srcDir, destDir string, acceptFn AcceptFunc) error {
srcDir = filepath.Clean(srcDir)
destDir = realPath(filepath.Clean(destDir))
if acceptFn == nil {
acceptFn = acceptAny
}
return runSourceSession(s.client, destDir, false, "", true, true, func(s *sourceSession) error {
prevDirSkipped := ... | go | {
"resource": ""
} |
q16663 | AddPlural | train | func AddPlural(find, replace string) {
pluralInflections = append(pluralInflections, Regular{find, replace})
compile()
} | go | {
"resource": ""
} |
q16664 | AddSingular | train | func AddSingular(find, replace string) {
singularInflections = append(singularInflections, Regular{find, replace})
compile()
} | go | {
"resource": ""
} |
q16665 | AddIrregular | train | func AddIrregular(singular, plural string) {
irregularInflections = append(irregularInflections, Irregular{singular, plural})
compile()
} | go | {
"resource": ""
} |
q16666 | GetPlural | train | func GetPlural() RegularSlice {
plurals := make(RegularSlice, len(pluralInflections))
copy(plurals, pluralInflections)
return plurals
} | go | {
"resource": ""
} |
q16667 | GetSingular | train | func GetSingular() RegularSlice {
singulars := make(RegularSlice, len(singularInflections))
copy(singulars, singularInflections)
return singulars
} | go | {
"resource": ""
} |
q16668 | GetIrregular | train | func GetIrregular() IrregularSlice {
irregular := make(IrregularSlice, len(irregularInflections))
copy(irregular, irregularInflections)
return irregular
} | go | {
"resource": ""
} |
q16669 | GetUncountable | train | func GetUncountable() []string {
uncountables := make([]string, len(uncountableInflections))
copy(uncountables, uncountableInflections)
return uncountables
} | go | {
"resource": ""
} |
q16670 | Plural | train | func Plural(str string) string {
for _, inflection := range compiledPluralMaps {
if inflection.regexp.MatchString(str) {
return inflection.regexp.ReplaceAllString(str, inflection.replace)
}
}
return str
} | go | {
"resource": ""
} |
q16671 | Singular | train | func Singular(str string) string {
for _, inflection := range compiledSingularMaps {
if inflection.regexp.MatchString(str) {
return inflection.regexp.ReplaceAllString(str, inflection.replace)
}
}
return str
} | go | {
"resource": ""
} |
q16672 | Handler | train | func Handler(plugin Plugin, secret string, logs logger.Logger) http.Handler {
handler := &handler{
secret: secret,
plugin: plugin,
logger: logs,
}
if handler.logger == nil {
handler.logger = logger.Discard()
}
return handler
} | go | {
"resource": ""
} |
q16673 | New | train | func New(endpoint, secret string, skipverify bool) *Client {
client := &Client{
Accept: "application/json",
Encoding: "identity",
Endpoint: endpoint,
Secret: secret,
}
if skipverify {
client.Client = &http.Client{
CheckRedirect: func(*http.Request, []*http.Request) error {
return http.ErrUseLast... | go | {
"resource": ""
} |
q16674 | Do | train | func (s *Client) Do(in, out interface{}) error {
ctx := context.Background()
ctx, cancel := context.WithTimeout(ctx, time.Minute)
defer cancel()
data, err := json.Marshal(in)
if err != nil {
return err
}
buf := bytes.NewBuffer(data)
req, err := http.NewRequest("POST", s.Endpoint, buf)
if err != nil {
ret... | go | {
"resource": ""
} |
q16675 | New | train | func New(uri string) Client {
return &client{http.DefaultClient, strings.TrimSuffix(uri, "/")}
} | go | {
"resource": ""
} |
q16676 | Self | train | func (c *client) Self() (*User, error) {
out := new(User)
uri := fmt.Sprintf(pathSelf, c.addr)
err := c.get(uri, out)
return out, err
} | go | {
"resource": ""
} |
q16677 | User | train | func (c *client) User(login string) (*User, error) {
out := new(User)
uri := fmt.Sprintf(pathUser, c.addr, login)
err := c.get(uri, out)
return out, err
} | go | {
"resource": ""
} |
q16678 | UserList | train | func (c *client) UserList() ([]*User, error) {
var out []*User
uri := fmt.Sprintf(pathUsers, c.addr)
err := c.get(uri, &out)
return out, err
} | go | {
"resource": ""
} |
q16679 | UserCreate | train | func (c *client) UserCreate(in *User) (*User, error) {
out := new(User)
uri := fmt.Sprintf(pathUsers, c.addr)
err := c.post(uri, in, out)
return out, err
} | go | {
"resource": ""
} |
q16680 | UserUpdate | train | func (c *client) UserUpdate(login string, in *UserPatch) (*User, error) {
out := new(User)
uri := fmt.Sprintf(pathUser, c.addr, login)
err := c.patch(uri, in, out)
return out, err
} | go | {
"resource": ""
} |
q16681 | UserDelete | train | func (c *client) UserDelete(login string) error {
uri := fmt.Sprintf(pathUser, c.addr, login)
err := c.delete(uri)
return err
} | go | {
"resource": ""
} |
q16682 | Repo | train | func (c *client) Repo(owner string, name string) (*Repo, error) {
out := new(Repo)
uri := fmt.Sprintf(pathRepo, c.addr, owner, name)
err := c.get(uri, out)
return out, err
} | go | {
"resource": ""
} |
q16683 | RepoList | train | func (c *client) RepoList() ([]*Repo, error) {
var out []*Repo
uri := fmt.Sprintf(pathRepos, c.addr)
err := c.get(uri, &out)
return out, err
} | go | {
"resource": ""
} |
q16684 | RepoListSync | train | func (c *client) RepoListSync() ([]*Repo, error) {
var out []*Repo
uri := fmt.Sprintf(pathRepos, c.addr)
err := c.post(uri, nil, &out)
return out, err
} | go | {
"resource": ""
} |
q16685 | RepoEnable | train | func (c *client) RepoEnable(owner, name string) (*Repo, error) {
out := new(Repo)
uri := fmt.Sprintf(pathRepo, c.addr, owner, name)
err := c.post(uri, nil, out)
return out, err
} | go | {
"resource": ""
} |
q16686 | RepoDisable | train | func (c *client) RepoDisable(owner, name string) error {
uri := fmt.Sprintf(pathRepo, c.addr, owner, name)
err := c.delete(uri)
return err
} | go | {
"resource": ""
} |
q16687 | RepoUpdate | train | func (c *client) RepoUpdate(owner, name string, in *RepoPatch) (*Repo, error) {
out := new(Repo)
uri := fmt.Sprintf(pathRepo, c.addr, owner, name)
err := c.patch(uri, in, out)
return out, err
} | go | {
"resource": ""
} |
q16688 | RepoRepair | train | func (c *client) RepoRepair(owner, name string) error {
uri := fmt.Sprintf(pathRepair, c.addr, owner, name)
return c.post(uri, nil, nil)
} | go | {
"resource": ""
} |
q16689 | Build | train | func (c *client) Build(owner, name string, num int) (*Build, error) {
out := new(Build)
uri := fmt.Sprintf(pathBuild, c.addr, owner, name, num)
err := c.get(uri, out)
return out, err
} | go | {
"resource": ""
} |
q16690 | BuildLast | train | func (c *client) BuildLast(owner, name, branch string) (*Build, error) {
out := new(Build)
uri := fmt.Sprintf(pathBuild, c.addr, owner, name, "latest")
if len(branch) != 0 {
uri += "?branch=" + branch
}
err := c.get(uri, out)
return out, err
} | go | {
"resource": ""
} |
q16691 | BuildList | train | func (c *client) BuildList(owner, name string, opts ListOptions) ([]*Build, error) {
var out []*Build
uri := fmt.Sprintf(pathBuilds, c.addr, owner, name, encodeListOptions(opts))
err := c.get(uri, &out)
return out, err
} | go | {
"resource": ""
} |
q16692 | BuildRestart | train | func (c *client) BuildRestart(owner, name string, build int, params map[string]string) (*Build, error) {
out := new(Build)
val := mapValues(params)
uri := fmt.Sprintf(pathBuild, c.addr, owner, name, build)
if len(params) > 0 {
uri = uri + "?" + val.Encode()
}
err := c.post(uri, nil, out)
return out, err
} | go | {
"resource": ""
} |
q16693 | BuildCancel | train | func (c *client) BuildCancel(owner, name string, build int) error {
uri := fmt.Sprintf(pathBuild, c.addr, owner, name, build)
err := c.delete(uri)
return err
} | go | {
"resource": ""
} |
q16694 | BuildPurge | train | func (c *client) BuildPurge(owner, name string, before int) error {
param := fmt.Sprintf("before=%d", before)
uri := fmt.Sprintf(pathBuilds, c.addr, owner, name, param)
err := c.delete(uri)
return err
} | go | {
"resource": ""
} |
q16695 | Rollback | train | func (c *client) Rollback(namespace, name string, build int, target string, params map[string]string) (*Build, error) {
out := new(Build)
val := mapValues(params)
val.Set("target", target)
uri := fmt.Sprintf(pathRollback, c.addr, namespace, name, build, val.Encode())
err := c.post(uri, nil, out)
return out, err
} | go | {
"resource": ""
} |
q16696 | Approve | train | func (c *client) Approve(namespace, name string, build, stage int) error {
uri := fmt.Sprintf(pathApprove, c.addr, namespace, name, build, stage)
err := c.post(uri, nil, nil)
return err
} | go | {
"resource": ""
} |
q16697 | Logs | train | func (c *client) Logs(owner, name string, build, stage, step int) ([]*Line, error) {
var out []*Line
uri := fmt.Sprintf(pathLog, c.addr, owner, name, build, stage, step)
err := c.get(uri, &out)
return out, err
} | go | {
"resource": ""
} |
q16698 | LogsPurge | train | func (c *client) LogsPurge(owner, name string, build, stage, step int) error {
uri := fmt.Sprintf(pathLog, c.addr, owner, name, build, stage, step)
err := c.delete(uri)
return err
} | go | {
"resource": ""
} |
q16699 | Sign | train | func (c *client) Sign(owner, name, file string) (string, error) {
in := struct {
Data string `json:"data"`
}{Data: file}
out := struct {
Data string `json:"data"`
}{}
uri := fmt.Sprintf(pathSign, c.addr, owner, name)
err := c.post(uri, &in, &out)
return out.Data, err
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.