_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.com/pkg/xattr/issues/16).
buf := make([]byte, size+1)
// Read into buffer of that size.
read, err := listxattrFunc(buf)
if err != nil {
return nil, &Error{myname, path, "", err}
}
return stringsFromByteSlice(buf[:read]), nil
}
return []string{}, nil
} | 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); castable {
ips = append(ips, ipNet.IP)
}
}
// Note that on non-IP interfaces it will be an empty slice
// and no error indicator. Maybe that's not super-perfect.
return ips, nil
} | 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 {
return ErrMissingEndpoint
}
if len(o.Protocol) == 0 {
o.Protocol = "tcp"
}
o.Protocol = strings.ToLower(o.Protocol)
switch o.Protocol {
case "tcp":
o.protocol = syscall.IPPROTO_TCP
case "udp":
o.protocol = syscall.IPPROTO_UDP
default:
return ErrUnknownProtocol
}
if o.Flags != "" {
for _, flag := range strings.Split(o.Flags, "|") {
if _, ok := schedulerFlags[flag]; !ok {
return ErrUnknownFlag
}
}
}
if len(o.Method) == 0 {
// WRR since Pulse will dynamically reweight backends.
o.Method = "wrr"
}
return nil
} | 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.Method = strings.ToLower(o.Method)
switch o.Method {
case "dr":
o.methodID = gnl2go.IPVS_DIRECTROUTE
case "nat":
o.methodID = gnl2go.IPVS_MASQUERADING
case "tunnel", "ipip":
o.methodID = gnl2go.IPVS_TUNNELING
default:
return ErrUnknownMethod
}
if o.Pulse == nil {
// It doesn't make much sense to have a backend with no Pulse.
o.Pulse = &pulse.Options{}
}
return nil
} | 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 o.interval, err = util.ParseInterval(o.Interval); err != nil {
return err
} else if o.interval <= 0 {
return ErrInvalidPulseInterval
}
return nil
} | 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(); m.Status != StatusUp {
m.Uptime, m.lastTs = 0, ts
} else {
m.Uptime, m.lastTs = m.Uptime+ts.Sub(m.lastTs)/time.Second, ts
}
return *m
} | 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 buffer.Bytes()
default:
return output
}
} | 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 {
// Recalculate metrics and statistics and send them to Context.
case pulseCh <- Update{id, p.metrics.Update(p.driver.Check())}:
case <-consumerStopCh:
// prevent blocking if the consumer stops before us
}
case <-p.stopCh:
log.Infof("stopping pulse for %s", id)
pulseCh <- Update{id, p.metrics.Update(StatusRemoved)}
return
}
// TODO(@kobolog): Add exponential back-offs, thresholds.
interval = p.interval
log.Debugf("current pulse for %s: %s", id, p.metrics.Status.String())
}
} | 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 {
return d
}
} | 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.Disco) > 0 {
log.Infof("creating Consul client with Agent URL: %s", options.Disco)
var err error
ctx.disco, err = disco.New(&disco.Options{
Type: "consul",
Args: util.DynamicMap{"URL": options.Disco}})
if err != nil {
return nil, err
}
} else {
ctx.disco, _ = disco.New(&disco.Options{Type: "none"})
}
if len(options.Endpoints) > 0 {
// TODO(@kobolog): Bind virtual services on multiple endpoints.
ctx.endpoint = options.Endpoints[0]
if options.ListenPort != 0 {
log.Info("Registered the REST service to Consul.")
ctx.disco.Expose("gorb", ctx.endpoint.String(), options.ListenPort)
}
}
if err := ctx.ipvs.Init(); err != nil {
log.Errorf("unable to initialize IPVS context: %s", err)
// Here and in other places: IPVS errors are abstracted to make GNL2GO
// replaceable in the future, since it's not really maintained anymore.
return nil, ErrIpvsSyscallFailed
}
if options.Flush && ctx.ipvs.Flush() != nil {
log.Errorf("unable to clean up IPVS pools - ensure ip_vs is loaded")
ctx.Close()
return nil, ErrIpvsSyscallFailed
}
if options.VipInterface != "" {
var err error
if ctx.vipInterface, err = netlink.LinkByName(options.VipInterface); err != nil {
ctx.Close()
return nil, fmt.Errorf(
"unable to find the interface '%s' for VIPs: %s",
options.VipInterface, err)
}
log.Infof("VIPs will be added to interface '%s'", ctx.vipInterface.Attrs().Name)
}
// Fire off a pulse notifications sink goroutine.
go ctx.run()
return ctx, nil
} | 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, backend := range ctx.backends {
if backend.service != vs {
continue
}
result.Backends = append(result.Backends, rsID)
result.Health += backend.metrics.Health
}
if len(result.Backends) == 0 {
// Service without backends is healthy, albeit useless.
result.Health = 1.0
} else {
result.Health /= float64(len(result.Backends))
}
return &result, nil
} | 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.NewReader(*data))
}
if err != nil {
return nil, err
}
if username != "" && password != "" {
req.SetBasicAuth(username, password)
}
if len(headers) > 0 {
for i := range headers {
req.Header.Add(headers[i][0], headers[i][1])
}
}
return makeRequest(client, req)
} | 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) > 0 {
for i := range headers {
req.Header.Add(headers[i][0], headers[i][1])
}
}
return makeRequest(client, req)
} | 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, params.Encode()), b, [][]string{{"Content-Type", "application/json"}}, c.username, c.password)
if err != nil {
return nil, err
}
resp, err := bytes2json(&r)
if err != nil {
return nil, err
}
// check error in resp
if !successStatus(resp) || hasError(resp) {
return &SolrUpdateResponse{Success: false, Result: resp}, nil
}
return &SolrUpdateResponse{Success: true, Result: resp}, nil
} | 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++ {
add := make([]Document, 0, chunk_size)
for j := 0; j < chunk_size; j++ {
if doc_counter >= docs_len {
break
}
add = append(add, docs[doc_counter])
doc_counter++
}
chunks[i] = M{"add": add}
}
return chunks
} | 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 {
return nil, err
}
result.Success = result.Success && res.Success
responses[fmt.Sprintf("chunk_%d", i+1)] = M{
"result": res.Result,
"success": res.Success,
"total": len(chunks[i]["add"].([]Document))}
}
result.Result = responses
return result, 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
}
status, ok := resp["status"].(string)
if ok == false {
return "", -1, fmt.Errorf("Unexpected response returned")
}
if QTime, ok := resp["responseHeader"].(map[string]interface{})["QTime"].(float64); ok {
qtime = int(QTime)
} else {
qtime = -1
}
return status, qtime, nil
} | 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 && fiDest.IsDir() {
destFile = filepath.Join(destFile, filepath.Base(srcFile))
}
return runSinkSession(s.client, srcFile, false, "", false, true, func(s *sinkSession) error {
h, err := s.ReadHeaderOrReply()
if err != nil {
return fmt.Errorf("failed to read scp message header: err=%s", err)
}
timeHeader, ok := h.(timeMsgHeader)
if !ok {
return fmt.Errorf("expected time message header, got %+v", h)
}
h, err = s.ReadHeaderOrReply()
if err != nil {
return fmt.Errorf("failed to read scp message header: err=%s", err)
}
fileHeader, ok := h.(fileMsgHeader)
if !ok {
return fmt.Errorf("expected file message header, got %+v", h)
}
return copyFileBodyFromRemote(s, destFile, timeHeader, fileHeader)
})
} | 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("failed to stat source file: err=%s", err)
}
fi := newFileInfoFromOS(osFileInfo, "")
file, err := os.Open(srcFile)
if err != nil {
return fmt.Errorf("failed to open source file: err=%s", err)
}
// NOTE: file will be closed by WriteFile.
err = s.WriteFile(fi, file)
if err != nil {
return fmt.Errorf("failed to copy file: err=%s", err)
}
return nil
})
} | 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 := false
endDirectories := func(prevDir, dir string) error {
rel, err := filepath.Rel(prevDir, dir)
if err != nil {
return err
}
for _, comp := range strings.Split(rel, string([]rune{filepath.Separator})) {
if comp == ".." {
if prevDirSkipped {
prevDirSkipped = false
} else {
err := s.EndDirectory()
if err != nil {
return err
}
}
}
}
return nil
}
prevDir := srcDir
myWalkFn := func(path string, info os.FileInfo, err error) error {
// We must check err is not nil first.
// See https://golang.org/pkg/path/filepath/#WalkFunc
if err != nil {
return err
}
isDir := info.IsDir()
var dir string
if isDir {
dir = path
} else {
dir = filepath.Dir(path)
}
defer func() {
prevDir = dir
}()
err = endDirectories(prevDir, dir)
if err != nil {
return err
}
scpFileInfo := newFileInfoFromOS(info, "")
accepted, err := acceptFn(filepath.Dir(path), scpFileInfo)
if err != nil {
return err
}
if isDir {
if !accepted {
prevDirSkipped = true
return filepath.SkipDir
}
err := s.StartDirectory(scpFileInfo)
if err != nil {
return err
}
} else {
if accepted {
fi := newFileInfoFromOS(info, "")
file, err := os.Open(path)
if err != nil {
return err
}
err = s.WriteFile(fi, file)
if err != nil {
return err
}
}
}
return nil
}
err := filepath.Walk(srcDir, myWalkFn)
if err != nil {
return err
}
return endDirectories(prevDir, srcDir)
})
} | 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.ErrUseLastResponse
},
Transport: &http.Transport{
Proxy: http.ProxyFromEnvironment,
TLSClientConfig: &tls.Config{
InsecureSkipVerify: true,
},
},
}
}
return client
} | 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 {
return err
}
req = req.WithContext(ctx)
req.Header.Add("Accept", s.Accept)
req.Header.Add("Accept-Encoding", s.Encoding)
req.Header.Add("Content-Type", "application/json")
req.Header.Add("Digest", "SHA-256="+digest(data))
req.Header.Add("Date", time.Now().UTC().Format(http.TimeFormat))
err = signer.SignRequest("hmac-key", s.Secret, req)
if err != nil {
return err
}
res, err := s.client().Do(req)
if err != nil {
return err
}
defer res.Body.Close()
body, err := ioutil.ReadAll(res.Body)
if err != nil {
return err
}
if res.StatusCode > 299 {
// if the response body includes an error message
// we should return the error string.
if len(body) != 0 {
return errors.New(
string(body),
)
}
// if the response body is empty we should return
// the default status code text.
return errors.New(
http.StatusText(res.StatusCode),
)
}
// if the response body return no content we exit
// immediately. We do not read or unmarshal the response
// and we do not return an error.
if res.StatusCode == 204 {
return nil
}
// the response body may be optionally encrypted
// using the aesgcm algorithm. If encrypted,
// decrypt using the shared secret.
if res.Header.Get("Content-Encoding") == "aesgcm" {
secret, err := aesgcm.Key(s.Secret)
if err != nil {
return err
}
plaintext, err := aesgcm.Decrypt(body, secret)
if err != nil {
return err
}
body = []byte(plaintext)
}
if out == nil {
return nil
}
return json.Unmarshal(body, out)
} | 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.