id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c15200 | if p.listenAddress != "" {
p.router = gin.Default()
}
} | |
c15201 | p.runServer()
} else {
e.GET(p.MetricsPath, prometheusHandler())
}
} | |
c15202 | p.runServer()
} else {
e.GET(p.MetricsPath, gin.BasicAuth(accounts), prometheusHandler())
}
} | |
c15203 | Subsystem: subsystem,
Name: m.Name,
Help: m.Description,
},
m.Args,
)
case "histogram":
metric = prometheus.NewHistogram(
prometheus.HistogramOpts{
Subsystem: subsystem,
Name: m.Name,
Help: m.Description,
},
)
case "summary_vec":
metric = prometheus.NewSum... | |
c15204 | e.Use(p.HandlerFunc())
p.SetMetricsPath(e)
} | |
c15205 | gin.Accounts) {
e.Use(p.HandlerFunc())
p.SetMetricsPathWithAuth(e, accounts)
} | |
c15206 | u, found := c.Get(p.URLLabelFromContext)
if !found {
u = "unknown"
}
url = u.(string)
}
p.reqCnt.WithLabelValues(status, c.Request.Method, c.HandlerName(), c.Request.Host, url).Inc()
p.reqSz.Observe(float64(reqSz))
p.resSz.Observe(resSz)
}
} | |
c15207 |
for n != nil && len(b) > 0 {
n = n.child[int(b[0])]
b = b[1:]
}
return n
} | |
c15208 | n := l.Remove(l.Front()).(*node)
for i := 0; i < 256; i++ {
c := n.child[i]
if c != nil {
l.PushBack(c)
for j := 1; j < len(c.b); j++ {
c.fail = m.findBlice(c.b[j:])
if c.fail != nil {
break
}
}
if c.fail == nil {
c.fail = m.root
}
for j := 1; j < len(c.b);... | |
c15209 | {
m := new(Matcher)
m.buildTrie(dictionary)
return m
} | |
c15210 | hits = append(hits, f.index)
f.counter = m.counter
}
for !f.suffix.root {
f = f.suffix
if f.counter != m.counter {
hits = append(hits, f.index)
f.counter = m.counter
} else {
// There's no point working our way up the
// suffixes if it's been done before for this call
... | |
c15211 | fmt.Printf(">>>>> STOP URL %s\n", ctx.Cmd.URL())
// generally not a good idea to stop/block from a handler goroutine
// so do it in a separate goroutine
go func() {
if cancel {
ctx.Q.Cancel()
} else {
ctx.Q.Close()
}
}()
return
}
wrapped.Handle(ctx, res, err)
})
} | |
c15212 | res.StatusCode, ctx.Cmd.Method(), ctx.Cmd.URL(), res.Header.Get("Content-Type"))
}
wrapped.Handle(ctx, res, err)
})
} | |
c15213 |
parsedURL, err := url.Parse(rawURL)
if err != nil {
return nil, err
}
return &HandlerCmd{&Cmd{parsedURL, method}, HandlerFunc(fn)}, nil
} | |
c15214 | res *http.Response, err error) {
h(ctx, res, err)
} | |
c15215 | make(map[error]Handler),
res: make(map[*ResponseMatcher]bool),
}
} | |
c15216 | var n = -1
for r := range mux.res {
if ok, cnt := r.match(res); ok {
if cnt > n {
h, n = r.h, cnt
}
}
}
if h != nil {
h.Handle(ctx, res, err)
return
}
}
mux.DefaultHandler.Handle(ctx, res, err)
} | |
c15217 | defer mux.mu.Unlock()
mux.errm[err] = h
} | |
c15218 | false, 0
}
}
if r.host != "" {
if res.Request.URL.Host != r.host {
return false, 0
}
}
if r.predicate != nil {
if !r.predicate(res) {
return false, 0
}
}
if r.path != "" {
if strings.HasPrefix(res.Request.URL.Path, r.path) {
return true, len(r.path)
}
return false, 0
}
return true, 0
} | |
c15219 |
r.minStatus = code
r.maxStatus = code
return r
} | |
c15220 | }
r.mux.mu.Lock()
defer r.mux.mu.Unlock()
r.minStatus = min
r.maxStatus = max
return r
} | |
c15221 | defer r.mux.mu.Unlock()
r.scheme = scheme
return r
} | |
c15222 | defer r.mux.mu.Unlock()
r.host = host
return r
} | |
c15223 | defer r.mux.mu.Unlock()
r.path = p
return r
} | |
c15224 |
defer r.mux.mu.Unlock()
r.predicate = predicate
return r
} | |
c15225 | !r.mux.res[r] {
r.mux.res[r] = true
}
return r
} | |
c15226 | HttpClient: http.DefaultClient,
UserAgent: DefaultUserAgent,
WorkerIdleTTL: DefaultWorkerIdleTTL,
dbg: make(chan *DebugInfo, 1),
}
} | |
c15227 | method sees the close signal.
q.ch <- nil
// Wait for the Fetcher to drain.
q.wg.Wait()
// Unblock any callers waiting on q.Block
close(q.done)
return nil
}
} | |
c15228 | queue as cancelled
close(q.cancelled)
// Close the Queue, that will wait for pending commands to drain
// will unblock any callers waiting on q.Block
return q.Close()
}
} | |
c15229 | case <-q.closed:
return ErrQueueClosed
default:
q.ch <- c
}
return nil
} | |
c15230 |
return q.sendWithMethod(method, rawurl)
} | |
c15231 | return q.sendWithMethod("HEAD", rawurl)
} | |
c15232 | return q.sendWithMethod("GET", rawurl)
} | |
c15233 | make(chan struct{}),
}
// Start the one and only queue processing goroutine.
f.q.wg.Add(1)
go f.processQueue()
return f.q
} | |
c15234 | f.dbgmu.Unlock()
f.debugging = true
return f.dbg
} | |
c15235 | v
// Send debug info, but do not block if full
f.dbgmu.Lock()
if f.debugging {
f.mu.Lock()
select {
case f.dbg <- &DebugInfo{len(f.hosts)}:
default:
}
f.mu.Unlock()
}
f.dbgmu.Unlock()
}
// Close all host channels now that it is impossible to send on those. Those are the `in`
// channel... | |
c15236 |
// Every time a command is received, reset the ttl channel
ttl = time.After(f.WorkerIdleTTL)
case <-ttl:
// Worker has been idle for WorkerIdleTTL, terminate it
f.mu.Lock()
inch, ok := f.hosts[hostKey]
delete(f.hosts, hostKey)
// Close the queue if AutoClose is set and there are no more hosts.... | |
c15237 | Ignore robots.txt parse error?
fmt.Fprintf(os.Stderr, "fetchbot: error parsing robots.txt: %s\n", err)
return nil
}
return robData.FindGroup(f.UserAgent)
} | |
c15238 | ok {
h.Handle(&Context{Cmd: cmd, Q: f.q}, res, err)
return
}
f.Handler.Handle(&Context{Cmd: cmd, Q: f.q}, res, err)
} | |
c15239 |
if !ok {
rc = ioutil.NopCloser(rdr)
}
req.Body = rc
} else if val, ok := cmd.(ValuesProvider); ok {
v := val.Values()
req.Body = ioutil.NopCloser(strings.NewReader(v.Encode()))
if req.Header.Get("Content-Type") == "" {
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
}
}
// If... | |
c15240 | flush values
break recv
}
pending = append(pending, v)
// Send queued values
case next <- pending[0]:
pending[0] = nil
pending = pending[1:]
}
}
// After in is closed, we may still have events to send
for _, v := range pending {
next <- v
}
} | |
c15241 | should always be nil
return &PQueue{
items: items,
elemsCount: 0,
comparator: cmp,
}
} | |
c15242 | priority)
pq.Lock()
pq.items = append(pq.items, item)
pq.elemsCount += 1
pq.swim(pq.size())
pq.Unlock()
} | |
c15243 | pq.RUnlock()
return pq.size()
} | |
c15244 | pq.RUnlock()
return pq.size() == 0
} | |
c15245 | list.New(),
capacity: capacity,
}
} | |
c15246 |
return s.container.Len()
} | |
c15247 | s.RLock()
defer s.RUnlock()
return s.capacity
} | |
c15248 |
return s.container.Len() == 0
} | |
c15249 | >= 0 && s.container.Len() >= s.capacity
} | |
c15250 |
(&st).assertSchedule(t.Schedule())
st.Workflow = t.WMap()
return st
} | |
c15251 |
SecureSide: secureSide,
TLSCertPath: certPath,
TLSKeyPath: keyPath,
}
} | |
c15252 |
return GRPCSecurity{
TLSEnabled: true,
SecureSide: secureSide,
TLSCertPath: certPath,
TLSKeyPath: keyPath,
CACertPaths: caCertPaths,
}
} | |
c15253 | plugin.CollectorPluginType)
if err != nil {
return nil, err
}
return p.(PluginCollectorClient), err
} | |
c15254 | security, plugin.StreamCollectorPluginType)
if err != nil {
return nil, err
}
return p.(PluginStreamCollectorClient), nil
} | |
c15255 | plugin.ProcessorPluginType)
if err != nil {
return nil, err
}
return p.(PluginProcessorClient), err
} | |
c15256 | plugin.PublisherPluginType)
if err != nil {
return nil, err
}
return p.(PluginPublisherClient), err
} | |
c15257 | credentials.TransportCredentials
if creds, err = buildCredentials(security); err != nil {
return nil, err
}
p, err = newGrpcClient(ctx, address, int(port), timeout, typ, creds)
if err != nil {
return nil, err
}
return p, nil
} | |
c15258 | p := cpolicy.NewPolicyNode()
p.Add(rule)
p.Add(rule2)
c.Add([]string{"intel", "mock", "foo"}, p)
return c, nil
} | |
c15259 |
if err != nil {
return fmt.Errorf("%v", err)
}
pClient.Password = password
pClient.Username = username
if err = checkTribeCommand(ctx); err != nil {
return fmt.Errorf("%v", err)
}
return nil
} | |
c15260 | if resp.Err != nil {
if resp.Err.Error() == "Invalid credentials" {
return resp.Err
}
return fmt.Errorf("Tribe mode must be enabled in snapteld to use tribe command")
}
return nil
} | |
c15261 |
}).Debug("plugin selected")
return aps[index], nil
}
l.logger.WithFields(log.Fields{
"block": "select",
"strategy": l.String(),
"error": ErrCouldNotSelect,
}).Error("error selecting")
return nil, ErrCouldNotSelect
} | |
c15262 | if err != nil {
return nil, err
}
return ap, nil
} | |
c15263 |
case rbody.TribeMemberListType:
// Success
return &ListMembersResult{resp.Body.(*rbody.TribeMemberList), nil}
case rbody.ErrorType:
return &ListMembersResult{Err: resp.Body.(*rbody.Error)}
default:
return &ListMembersResult{Err: ErrAPIResponseMetaType}
}
} | |
c15264 |
case rbody.ErrorType:
return &GetMemberResult{Err: resp.Body.(*rbody.Error)}
default:
return &GetMemberResult{Err: ErrAPIResponseMetaType}
}
} | |
c15265 | nil}
case rbody.ErrorType:
return &ListAgreementResult{Err: resp.Body.(*rbody.Error)}
default:
return &ListAgreementResult{Err: ErrAPIResponseMetaType}
}
} | |
c15266 | {
case rbody.TribeAddAgreementType:
return &AddAgreementResult{resp.Body.(*rbody.TribeAddAgreement), nil}
case rbody.ErrorType:
return &AddAgreementResult{Err: resp.Body.(*rbody.Error)}
default:
return &AddAgreementResult{Err: ErrAPIResponseMetaType}
}
} | |
c15267 |
}
switch resp.Meta.Type {
case rbody.TribeDeleteAgreementType:
return &DeleteAgreementResult{resp.Body.(*rbody.TribeDeleteAgreement), nil}
case rbody.ErrorType:
return &DeleteAgreementResult{Err: resp.Body.(*rbody.Error)}
default:
return &DeleteAgreementResult{Err: ErrAPIResponseMetaType}
}
} | |
c15268 |
}
switch resp.Meta.Type {
case rbody.TribeGetAgreementType:
return &GetAgreementResult{resp.Body.(*rbody.TribeGetAgreement), nil}
case rbody.ErrorType:
return &GetAgreementResult{Err: resp.Body.(*rbody.Error)}
default:
return &GetAgreementResult{Err: ErrAPIResponseMetaType}
}
} | |
c15269 | resp.Meta.Type {
case rbody.TribeJoinAgreementType:
return &JoinAgreementResult{resp.Body.(*rbody.TribeJoinAgreement), nil}
case rbody.ErrorType:
return &JoinAgreementResult{Err: resp.Body.(*rbody.Error)}
default:
return &JoinAgreementResult{Err: ErrAPIResponseMetaType}
}
} | |
c15270 | resp.Meta.Type {
case rbody.TribeLeaveAgreementType:
return &LeaveAgreementResult{resp.Body.(*rbody.TribeLeaveAgreement), nil}
case rbody.ErrorType:
return &LeaveAgreementResult{Err: resp.Body.(*rbody.Error)}
default:
return &LeaveAgreementResult{Err: ErrAPIResponseMetaType}
}
} | |
c15271 |
Description: value.Description,
Name: value.Name,
}
elements = append(elements, ne)
}
return elements
} | |
c15272 | mt.Unit,
}
switch mt.Data.(type) {
case *Metric_BytesData:
ret.data = mt.GetBytesData()
case *Metric_StringData:
ret.data = mt.GetStringData()
case *Metric_Float32Data:
ret.data = mt.GetFloat32Data()
case *Metric_Float64Data:
ret.data = mt.GetFloat64Data()
case *Metric_Int32Data:
ret.data ... | |
c15273 |
Name: val.Name,
}
namespace = append(namespace, ele)
}
return namespace
} | |
c15274 | TypeName: pl.TypeName(),
Name: pl.Name(),
Version: int64(pl.Version()),
Config: ConfigToConfigMap(pl.Config()),
}
} | |
c15275 | typeName: msg.TypeName,
name: msg.Name,
version: int(msg.Version),
config: ConfigMapToConfig(msg.Config),
}
} | |
c15276 | pl.Name(),
Version: int64(pl.Version()),
}
} | |
c15277 |
plugins[i] = ToCorePluginMsg(v)
}
return plugins
} | |
c15278 |
version: int(msg.Version),
}
return core.Plugin(pl)
} | |
c15279 |
plugins[i] = MsgToCorePlugin(v)
}
return plugins
} | |
c15280 | make([]core.SubscribedPlugin, len(msg))
for i, v := range msg {
plugins[i] = ToSubPlugin(v)
}
return plugins
} | |
c15281 | sp {
plugins[i] = ToSubPluginMsg(v)
}
return plugins
} | |
c15282 | if cfg == nil {
return nil
}
config := cdata.FromTable(ParseConfig(cfg))
return config
} | |
c15283 | return nil
}
return ToConfigMap(cd.Table())
} | |
c15284 |
rerrs[i] = serror.New(errors.New(err.ErrorString), GetFields(err))
}
return rerrs
} | |
c15285 | return serror.New(errors.New(e.ErrorString), GetFields(e))
} | |
c15286 | value := range s.ErrorFields {
fields[key] = value
}
return fields
} | |
c15287 | defer m.mutex.RUnlock()
if val, ok := m.remoteManagers[key]; ok {
return val, nil
} else {
return nil, errors.New(fmt.Sprintf("Client not found for: %v", key))
}
} | |
c15288 | return nil, err
}
// ***
// TODO validate workflow makes sense here
// - flows that don't end in publishers?
// - duplicate child nodes anywhere?
//***
// Retain a copy of the original workflow map
wf.workflowMap = wfMap
return wf, nil
} | |
c15289 | = errors
defer s.eventEmitter.Emit(event)
return
}
// Send event
event := new(scheduler_event.MetricCollectedEvent)
event.TaskID = t.id
event.Metrics = j.(*collectorJob).metrics
defer s.eventEmitter.Emit(event)
// walk through the tree and dispatch work
workJobs(s.processNodes, s.publishNodes, t, j)
} | |
c15290 | starting goroutine to prevent a race condition)
wg.Add(1)
// Start goroutine to submit the process job
go submitPublishJob(pj, t, wg, pu)
}
// Wait until all job submisson goroutines are done
wg.Wait()
workflowLogger.WithFields(log.Fields{
"_block": "work-jobs",
"task-id": t.id,
... | |
c15291 |
return GetClientConnectionWithCreds(ctx, addr, port, nil)
} | |
c15292 | != "" {
return true
}
return false
} | |
c15293 |
pem.Encode(w, &pem.Block{
Type: pemHeader,
Bytes: b,
})
w.Flush()
return nil
} | |
c15294 | time.Now().Add(keyValidPeriod),
KeyUsage: x509.KeyUsageCertSign | x509.KeyUsageCRLSign,
BasicConstraintsValid: true,
MaxPathLenZero: true,
IsCA: true,
SubjectKeyId: caPubSha256[:],
}
caCertBytes, err = x509.CreateCertificate(rand.Reader, caCertTpl, caCertT... | |
c15295 | x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment | x509.KeyUsageDataEncipherment | x509.KeyUsageKeyAgreement,
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
SubjectKeyId: subjPubSha256[:],
}
subjCertTpl.DNSNames = []string{"localhost"}
subjCertTpl.IPAddr... | |
c15296 | := strings.Split(ns_, "/")[1:]
cdn, err := configtoConfigDataNode(cmap, ns_)
if err != nil {
return nil, err
}
cdt.Add(ns, cdn)
}
return cdt, nil
} | |
c15297 | maxFailures, err := stringValToInt(maxFailuresStrVal)
if err != nil {
return err
}
t.MaxFailures = maxFailures
}
// set the schedule for the task from the CLI options (and return the results
// of that method call, indicating whether or not an error was encountered while
// setting up that schedule)
retu... | |
c15298 | err := range result.Errors() {
serr := serror.New(errors.New("Validate schema error"))
serr.SetFields(map[string]interface{}{
"value": err.Value(),
"context": err.Context().String("::"),
"description": err.Description(),
})
serrors = append(serrors, serr)
}
return serrors
} | |
c15299 | s,
state: core.TaskStopped,
creationTime: time.Now(),
workflow: wf,
manager: m,
metricsManager: mm,
deadlineDuration: DefaultDeadlineDuration,
stopOnFailure: DefaultStopOnFailure,
eventEmitter: emitter,
RemoteManagers: mgrs,
isStream: stream,... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.