id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c181100 | r.Len(); i++ {
el := r.Index(i).Interface()
res = append(res, filter.Filter(k, el))
}
return res
}
return filter.Filter(k, v)
})
} | |
c181101 | := range r.MapKeys() {
str := key.String()
val := r.MapIndex(key).Interface()
res[str] = filter.Filter(str, val)
}
return res
}
return v
})
} | |
c181102 | string, v interface{}) interface{} {
if fieldName == k {
return filter.Filter(k, v)
}
return v
})
} | |
c181103 | string, v interface{}) interface{} {
return filter.Filter(strings.ToLower(k), v)
})
} | |
c181104 | code
panic(fmt.Errorf("Invalid batch point configuration: %s", err))
}
return bp
} | |
c181105 | &SinglePointWriter{
log: log,
writer: w,
}
} | |
c181106 | p *influxdb.Point) error {
bp := newBatchPoints(bpConf)
bp.AddPoint(p)
return w.writer.Write(bp)
} | |
c181107 | *BatchingWriter) {
w.scalingInterval = v
}
} | |
c181108 | limit: DefaultInstanceLimit,
pointChans: make(map[influxdb.BatchPointsConfig]chan *batchPoint),
}
for _, opt := range opts {
opt(bw)
}
bw.log = bw.log.WithFields(ttnlog.Fields{
"limit": bw.limit,
"scalingInterval": bw.scalingInterval,
})
return bw
} | |
c181109 | point := &batchPoint{
Point: p,
errch: make(chan error, 1),
}
select {
case ch <- point:
case <-time.After(w.scalingInterval):
w.mutex.Lock()
if w.active < w.limit {
w.active++
go writeInBatches(w.log, w.writer, bpConf, w.scalingInterval, ch, false)
}
w.mutex.Unlock()
ch <- point
}
return <-point.errch
} | |
c181110 |
if err != nil {
w.WithError(err).WithField("level", s).Fatal("Could not parse log level")
}
w.Level = level
} | |
c181111 | make(chan interface{}, bufferSize),
log: ttnlog.Get(),
}
} | |
c181112 | s.log = log
s.mu.Unlock()
} | |
c181113 | != nil {
close(s.recvBuffer)
s.recvBuffer = nil
}
s.mu.Unlock()
} | |
c181114 | {
return atomic.LoadUint64(&s.sent), atomic.LoadUint64(&s.dropped)
} | |
c181115 | err := stream.RecvMsg(r)
if err != nil {
s.log.WithError(err).Debug("streambuffer: error from stream.RecvMsg")
recvErr <- err
close(recvErr)
return
}
if s.recvFunc != nil {
s.recvMsg(r)
}
}
}()
defer stream.CloseSend()
for {
select {
case err := <-recvErr:
return err
case <-stream.Context().Done():
s.log.WithError(stream.Context().Err()).Debug("streambuffer: context done")
return stream.Context().Err()
case msg := <-s.sendBuffer:
if err = stream.SendMsg(msg); err != nil {
s.log.WithError(err).Debug("streambuffer: error from stream.SendMsg")
return err
}
atomic.AddUint64(&s.sent, 1)
}
}
} | |
c181116 | grpc.UnaryInterceptor(UnaryServerInterceptor(log)),
grpc.StreamInterceptor(StreamServerInterceptor(log)),
}
} | |
c181117 | grpc.WithStreamInterceptor(StreamClientInterceptor(log)),
}
} | |
c181118 |
log = log.WithField("duration", time.Since(start))
if err != nil {
log.WithError(err).Debug("rpc-server: call failed")
return
}
log.Debug("rpc-server: call done")
return
}
} | |
c181119 | || grpc.Code(err) == codes.Canceled {
log.Debug("rpc-server: stream canceled")
return
}
log.WithError(err).Debug("rpc-server: stream failed")
return
}
log.Debug("rpc-server: stream done")
return
}
} | |
c181120 | method, req, reply, cc, opts...)
log = log.WithField("duration", time.Since(start))
if err != nil {
log.WithError(err).Debug("rpc-client: call failed")
return
}
log.Debug("rpc-client: call done")
return
}
} | |
c181121 | log.Debug("rpc-client: stream canceled")
return
}
log.WithError(err).Debug("rpc-client: stream failed")
return
}
go func() {
<-stream.Context().Done()
if err := stream.Context().Err(); err != nil {
log = log.WithError(err)
}
log.Debug("rpc-client: stream done")
}()
return
}
} | |
c181122 |
if c.Prefix == "" {
c.Prefix = "logs"
}
} | |
c181123 | h.flush(h.batch)
h.batch = nil
}
} | |
c181124 | substring) {
useColor = true
break
}
}
}
return &Handler{
Writer: w,
UseColor: useColor,
}
} | |
c181125 | []byte
value = fmt.Sprintf("%X", t)
case [21]byte: // bundle IDs [21]byte
value = fmt.Sprintf("%X-%X-%X-%X", t[0], t[1:9], t[9:17], t[17:])
default:
value = f.Value
}
if h.UseColor {
fmt.Fprintf(h.Writer, " \033[%dm%s\033[0m=%v", color, f.Name, value)
} else {
fmt.Fprintf(h.Writer, " %s=%v", f.Name, value)
}
}
fmt.Fprintln(h.Writer)
return nil
} | |
c181126 |
Interface: &random.TTNRandom{
Source: rand.New(rand.NewSource(seed)),
},
}
} | |
c181127 | }
for _, term := range p.terms {
names = append(names, term.name)
}
}
return names
} | |
c181128 |
value += fmt.Sprintf(";%s;%s", fmtThreshold(p.warn), fmtThreshold(p.crit))
value += fmt.Sprintf(";%s;%s", fmtThreshold(p.min), fmtThreshold(p.max))
return value
} | |
c181129 | datum := range perfdata {
value += fmt.Sprintf(" %v", datum)
}
return value
} | |
c181130 | message)
os.Exit(int(status))
} | |
c181131 |
if options.StatusPolicy != nil {
c.statusPolicy = options.StatusPolicy
}
return c
} | |
c181132 | if (*c.statusPolicy)[result.status] > (*c.statusPolicy)[c.status] {
c.status = result.status
}
} | |
c181133 | msg := fmt.Sprintf(format, v...)
c.AddResult(status, msg)
} | |
c181134 | value += RenderPerfdata(c.perfdata)
return value
} | |
c181135 | fmt.Sprintf(format, v...)
c.AddResult(status, info)
c.Finish()
} | |
c181136 | c.Exitf(CRITICAL, format, v...)
} | |
c181137 | c.Exitf(UNKNOWN, format, v...)
} | |
c181138 |
WARNING: statusSeverity(WARNING),
CRITICAL: statusSeverity(CRITICAL),
UNKNOWN: statusSeverity(UNKNOWN),
}
} | |
c181139 | status := range *defaultPol {
_, ok := newPol[status]
if !ok {
return nil, fmt.Errorf("missing status: %v", status)
}
}
return &newPol, nil
} | |
c181140 | }
// Parse upper limit
if len(rangeStr) > 0 {
max, err := strconv.ParseFloat(rangeStr, 64)
if err != nil {
return nil, fmt.Errorf("failed to parse upper limit: %v", err)
}
t.End = max
}
if t.End < t.Start {
return nil, errors.New("Invalid range definition. min <= max violated!")
}
// OK
return t, nil
} | |
c181141 | r.End {
return r.AlertOnInside
}
return !r.AlertOnInside
} | |
c181142 | return r.Check(float64(val))
} | |
c181143 | return r.Check(float64(val))
} | |
c181144 | {
return nil, fmt.Errorf("invalid base URL: %s", err.Error())
}
apiURL := baseURL.ResolveReference(apiPath)
return &Client{
httpClient: httpClient,
apiURL: apiURL,
authToken: config.AuthToken,
}, nil
} | |
c181145 |
k := &KeyMeta{}
err := c.get([]string{"storage", "keys", path}, nil, k)
return k, err
} | |
c181146 | "keys", path}, nil, r)
if err != nil {
return nil, err
}
return r.Keys, nil
} | |
c181147 | "keys", path}, nil, "application/pgp-keys")
} | |
c181148 |
jobList := &jobSummaryList{}
err := c.get([]string{"project", projectName, "jobs"}, nil, jobList)
return jobList.Jobs, err
} | |
c181149 | "export"}, map[string]string{"project": projectName}, jobList)
if err != nil {
return nil, err
}
return jobList.Jobs, nil
} | |
c181150 | err != nil {
return nil, err
}
return &jobList.Jobs[0], nil
} | |
c181151 | return c.importJob(job, "create")
} | |
c181152 | return c.importJob(job, "update")
} | |
c181153 | c.delete([]string{"job", id})
} | |
c181154 | r.Name,
GroupName: r.GroupName,
ProjectName: r.ProjectName,
}
} | |
c181155 | := c.get([]string{"system", "info"}, nil, sysInfo)
return sysInfo, err
} | |
c181156 |
// so we don't need to handle the error case.
// (Famous last words?)
t, _ := time.Parse(time.RFC3339, ts.DateTimeStr)
return t
} | |
c181157 | {
p := &projects{}
err := c.get([]string{"projects"}, nil, p)
return p.Projects, err
} | |
c181158 | {
p := &Project{}
err := c.get([]string{"project", name}, nil, p)
return p, err
} | |
c181159 | {
p := &Project{}
err := c.post([]string{"projects"}, nil, project, p)
return p, err
} | |
c181160 | c.delete([]string{"project", name})
} | |
c181161 | error {
return c.put(
[]string{"project", projectName, "config"},
config,
nil,
)
} | |
c181162 | userName: c.username,
password: c.password,
client: c,
}
} | |
c181163 | return &Client{
token: c.token,
client: c,
}
} | |
c181164 | = strconv.Itoa(depth)
} | |
c181165 | + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Datacenters{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181166 | + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Datacenter{}
err := c.client.Post(url, dc, ret, http.StatusAccepted)
return ret, err
} | |
c181167 | c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Datacenter{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181168 | := &Datacenter{}
err := c.client.Patch(url, obj, ret, http.StatusAccepted)
return ret, err
} | |
c181169 | &http.Header{}
return ret, c.client.Delete(url, ret, http.StatusAccepted)
} | |
c181170 | if err != nil {
return err
}
if request.Metadata.Status == "DONE" {
return nil
}
time.Sleep(1 * time.Second)
i++
}
return fmt.Errorf("timeout expired while waiting for request to complete")
} | |
c181171 | strconv.FormatBool(c.client.pretty)
ret := &FirewallRules{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181172 | + strconv.FormatBool(c.client.pretty)
ret := &FirewallRule{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181173 | strconv.FormatBool(c.client.pretty)
ret := &FirewallRule{}
err := c.client.Post(url, fw, ret, http.StatusAccepted)
return ret, err
} | |
c181174 | + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &FirewallRule{}
err := c.client.Patch(url, obj, ret, http.StatusAccepted)
return ret, err
} | |
c181175 | + strconv.FormatBool(c.client.pretty)
ret := &http.Header{}
err := c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | |
c181176 | &Loadbalancers{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181177 | := &Loadbalancer{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181178 |
ret := &Loadbalancer{}
err := c.client.Patch(url, obj, ret, http.StatusAccepted)
return ret, err
} | |
c181179 | &http.Header{}
err := c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | |
c181180 | + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Nics{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181181 | strconv.FormatBool(c.client.pretty)
ret := &Nic{}
err := c.client.Post(url, sm, ret, http.StatusAccepted)
return ret, err
} | |
c181182 | + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Nic{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181183 | ret := &http.Header{}
err := c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | |
c181184 | + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Lans{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181185 | + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Lan{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181186 | c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | |
c181187 | + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Nics{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181188 | := &Nic{}
err := c.client.Post(url, nic, ret, http.StatusAccepted)
return ret, err
} | |
c181189 | `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Nic{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181190 | strconv.FormatBool(c.client.pretty)
ret := &Nic{}
err := c.client.Patch(url, obj, ret, http.StatusAccepted)
return ret, err
} | |
c181191 | := c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | |
c181192 | + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Snapshots{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181193 | ret := &Snapshot{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181194 | ret := &http.Header{}
err := c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | |
c181195 | &Snapshot{}
err := c.client.Patch(url, request, ret, http.StatusAccepted)
return ret, err
} | |
c181196 | + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &IPBlocks{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181197 | + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &IPBlock{}
err := c.client.Post(url, request, ret, http.StatusAccepted)
return ret, err
} | |
c181198 | + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &IPBlock{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | |
c181199 | ret := &IPBlock{}
err := c.client.Patch(url, props, ret, http.StatusAccepted)
return ret, err
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.