id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c168300 | defer s.RUnlock()
return s.set[v]
} | |
c168301 | := range s.list {
r[i] = s.set[k]
}
return r
} | |
c168302 | s.RUnlock()
return len(s.list)
} | |
c168303 | return strings.Join(s.list, ", ")
} | |
c168304 |
newTags = append(newTags, tag)
}
sort.Strings(newTags)
return newTags
} | |
c168305 | {
return i, &ResponseMetadata{
LastContact: 0,
LastIndex: uint64(time.Now().Unix()),
}, nil
} | |
c168306 | map[string]string{}
for i, n := range match[0] {
if names[i] != "" {
m[names[i]] = n
}
}
return m
} | |
c168307 | make(chan struct{}, 1),
dc: m["dc"],
name: m["name"],
near: m["near"],
tag: m["tag"],
}, nil
} | |
c168308 | := regexpMatch(KVListQueryRe, s)
return &KVListQuery{
stopCh: make(chan struct{}, 1),
dc: m["dc"],
prefix: m["prefix"],
}, nil
} | |
c168309 | config,
clients: clients,
brain: brain,
templates: templates,
leader: make(map[*template.Template]<-chan struct{}),
lastWrite: make(map[*template.Template]uint64),
updateCh: make(chan struct{}, 1),
stopCh: make(chan struct{}),
}
return d, nil
} | |
c168310 | watch each template
for _, t := range d.templates {
go d.watchTemplate(client, t)
}
return nil
} | |
c168311 | log.Printf("[INFO] (dedup) stopping de-duplication manager")
d.stop = true
close(d.stopCh)
d.wg.Wait()
return nil
} | |
c168312 | each template
for _, t := range d.templates {
d.wg.Add(1)
go d.attemptLock(client, id, sessionCh, t)
}
// Renew our session periodically
if err := session.RenewPeriodic("15s", id, nil, d.stopCh); err != nil {
log.Printf("[ERR] (dedup) failed to renew session: %v", err)
}
close(sessionCh)
d.wg.Wait()
WAI... | |
c168313 | {
return false
}
select {
case <-lockCh:
return false
default:
return true
}
} | |
c168314 | and LZW compress
var buf bytes.Buffer
compress := lzw.NewWriter(&buf, lzw.LSB, 8)
enc := gob.NewEncoder(compress)
if err := enc.Encode(&td); err != nil {
return fmt.Errorf("encode failed: %v", err)
}
compress.Close()
// Write the KV update
kvPair := consulapi.KVPair{
Key: dataPath,
Value: buf.Bytes(),... | |
c168315 | lockCh == nil {
d.lastWriteLock.Lock()
delete(d.lastWrite, tmpl)
d.lastWriteLock.Unlock()
}
// Do an async notify of an update
select {
case d.updateCh <- struct{}{}:
default:
}
} | |
c168316 | td.Version, version.Version)
return
}
log.Printf("[INFO] (dedup) loading %d dependencies from '%s'",
len(td.Data), path)
// Update the data in the brain
for hashCode, value := range td.Data {
d.brain.ForceSet(hashCode, value)
}
// Trigger the updateCh
select {
case d.updateCh <- struct{}{}:
default:
... | |
c168317 | }
return &FileQuery{
stopCh: make(chan struct{}, 1),
path: s,
}, nil
} | |
c168318 | os.Signal, 1),
stopCh: make(chan struct{}),
}
} | |
c168319 |
runner.Stop()
// Re-parse any configuration files or paths
config, err = loadConfigs(paths, cliConfig)
if err != nil {
return logError(err, ExitCodeConfigError)
}
config.Finalize()
// Load the new configuration from disk
config, err = cli.setup(config)
if err != nil {
re... | |
c168320 | }
close(cli.stopCh)
cli.stopped = true
} | |
c168321 | return nil, err
}
finalC = finalC.Merge(c)
}
finalC = finalC.Merge(o)
finalC.Finalize()
return finalC, nil
} | |
c168322 | {
log.Printf("[ERR] (cli) %s", err)
return status
} | |
c168323 | o == nil {
return "(*os.FileMode)(nil)"
}
return fmt.Sprintf("%q", *o)
} | |
c168324 | return (os.Signal)(nil)
}
return *s
} | |
c168325 |
return "<nil>"
}
return fmt.Sprintf("%q", *s)
} | |
c168326 | }
return *s != signals.SIGNIL
} | |
c168327 | return time.Duration(0)
}
return *t
} | |
c168328 | if t == nil {
return "(*time.Duration)(nil)"
}
return fmt.Sprintf("%s", t)
} | |
c168329 | {
return fmt.Errorf("client set: consul configuring TLS failed: %s", err)
}
}
// Construct all the certificates now
tlsConfig.BuildNameToCertificate()
// SSL verification
if i.ServerName != "" {
tlsConfig.ServerName = i.ServerName
tlsConfig.InsecureSkipVerify = false
}
if !i.SSLVerify {
... | |
c168330 | defer c.RUnlock()
return c.consul.client
} | |
c168331 | defer c.RUnlock()
return c.vault.client
} | |
c168332 |
c.vault.httpClient.Transport.(*http.Transport).CloseIdleConnections()
}
} | |
c168333 |
return nil, err
}
return &VaultReadQuery{
stopCh: make(chan struct{}, 1),
rawPath: secretURL.Path,
queryValues: secretURL.Query(),
}, nil
} | |
c168334 | := regexpMatch(KVGetQueryRe, s)
return &KVGetQuery{
stopCh: make(chan struct{}, 1),
dc: m["dc"],
key: m["key"],
}, nil
} | |
c168335 | {
return &VaultAgentTokenQuery{
stopCh: make(chan struct{}, 1),
path: path,
}, nil
} | |
c168336 | lastStat.Size() != stat.Size() ||
lastStat.ModTime() != stat.ModTime()
if changed {
select {
case <-d.stopCh:
return
case ch <- &watchResult{stat: stat}:
return
}
}
time.Sleep(VaultAgentTokenSleepTime)
}
}(lastStat)
return ch
} | |
c168337 | := regexpMatch(KVKeysQueryRe, s)
return &KVKeysQuery{
stopCh: make(chan struct{}, 1),
dc: m["dc"],
prefix: m["prefix"],
}, nil
} | |
c168338 | i.Env,
timeout: i.Timeout,
reloadSignal: i.ReloadSignal,
killSignal: i.KillSignal,
killTimeout: i.KillTimeout,
splay: i.Splay,
stopCh: make(chan struct{}, 1),
}
return child, nil
} | |
c168339 | defer c.RUnlock()
return c.exitCh
} | |
c168340 | c.RUnlock()
return c.pid()
} | |
c168341 | c.args...)
return strings.Join(list, " ")
} | |
c168342 | c.Lock()
defer c.Unlock()
return c.start()
} | |
c168343 | s.String())
c.RLock()
defer c.RUnlock()
return c.signal(s)
} | |
c168344 | to send reload signals
// during this transition.
c.Lock()
defer c.Unlock()
c.kill()
return c.start()
}
log.Printf("[INFO] (child) reloading process")
// We only need a read lock here because neither the process nor the exit
// channel are changing.
c.RLock()
defer c.RUnlock()
return c.reload()
} | |
c168345 | c.Lock()
defer c.Unlock()
c.kill()
} | |
c168346 | log.Printf("[WARN] (child) already stopped")
return
}
c.kill()
close(c.stopCh)
c.stopped = true
} | |
c168347 | of the given globs
// match the string.
anyGlobMatch := func(s string, patterns []string) bool {
for _, pattern := range patterns {
if matched, _ := filepath.Match(pattern, s); matched {
return true
}
}
return false
}
// Pull out any envvars that match the whitelist.
if len(c.Whitelist) > 0 {
n... | |
c168348 | = strings.TrimSpace(f)
switch f {
case HealthAny,
HealthPassing,
HealthWarning,
HealthCritical,
HealthMaint:
filters = append(filters, f)
case "":
default:
return nil, fmt.Errorf("health.service: invalid filter: %q in %q", f, s)
}
}
sort.Strings(filters)
} else {
filters =... | |
c168349 | entry.Node.ID,
NodeAddress: entry.Node.Address,
NodeTaggedAddresses: entry.Node.TaggedAddresses,
NodeMeta: entry.Node.Meta,
ServiceMeta: entry.Service.Meta,
Address: address,
ID: entry.Service.ID,
Name: entry.Service.Service... | |
c168350 | s || status == HealthAny {
return true
}
}
return false
} | |
c168351 | attemptsTillMaxBackoff := int(math.Log2(maxSleep.Seconds() / baseSleep.Seconds()))
if retry > attemptsTillMaxBackoff {
return true, maxSleep
}
}
base := math.Pow(2, float64(retry))
sleep := time.Duration(base) * baseSleep
return true, sleep
}
} | |
c168352 | dry,
once: once,
}
if err := runner.init(); err != nil {
return nil, err
}
return runner, nil
} | |
c168353 | r.stopWatcher()
r.stopChild()
if err := r.deletePid(); err != nil {
log.Printf("[WARN] (runner) could not remove pid at %v: %s",
r.config.PidFile, err)
}
r.stopped = true
close(r.DoneCh)
} | |
c168354 | make(map[string]*RenderEvent, len(r.renderEvents))
for k, v := range r.renderEvents {
times[k] = v
}
return times
} | |
c168355 |
defer r.childLock.RUnlock()
if r.child == nil {
return nil
}
return r.child.Signal(s)
} | |
c168356 | ok := depsMap[key]; !ok {
log.Printf("[DEBUG] (runner) %s is no longer needed", d)
r.watcher.Remove(d)
r.brain.Forget(d)
} else {
log.Printf("[DEBUG] (runner) %s is still needed", d)
}
}
r.dependencies = depsMap
} | |
c168357 | []*config.TemplateConfig {
return r.ctemplatesMap[tmpl.ID()]
} | |
c168358 |
ctmpls := make([]config.TemplateConfig, len(set))
m[id] = ctmpls
for i, ctmpl := range set {
ctmpls[i] = *ctmpl
}
}
return m
} | |
c168359 |
// The template might already exist on disk with the exact contents, but
// we still want to count that as "rendered" [GH-1000].
if !event.DidRender && !event.WouldRender {
return false
}
}
return true
} | |
c168360 | {
m["VAULT_CAPATH"] = config.StringVal(r.config.Vault.SSL.CaPath)
}
if config.StringPresent(r.config.Vault.SSL.CaCert) {
m["VAULT_CACERT"] = config.StringVal(r.config.Vault.SSL.CaCert)
}
if config.StringPresent(r.config.Vault.SSL.ServerName) {
m["VAULT_TLS_SERVER_NAME"] = config.StringVal(r.config.Vault.SS... | |
c168361 |
}
defer f.Close()
pid := os.Getpid()
_, err = f.WriteString(fmt.Sprintf("%d", pid))
if err != nil {
return fmt.Errorf("runner: could not write to pid file: %s", err)
}
return nil
} | |
c168362 | if stat.IsDir() {
return fmt.Errorf("runner: specified pid file path is directory")
}
err = os.Remove(path)
if err != nil {
return fmt.Errorf("runner: could not remove pid file: %s", err)
}
return nil
} | |
c168363 |
KillTimeout: i.KillTimeout,
Splay: i.Splay,
})
if err != nil {
return nil, errors.Wrap(err, "error creating child")
}
if err := child.Start(); err != nil {
return nil, errors.Wrap(err, "child")
}
return child, nil
} | |
c168364 | *quiescence {
return &quiescence{
template: t,
min: min,
max: max,
ch: ch,
}
} | |
c168365 | // doesn't work that's ok because we guarantee that the channel gets our
// template which means that we are obsolete and a fresh quiescence will
// be set up.
if now.Add(q.min).Before(q.deadline) {
q.timer.Reset(q.min)
} else if dur := q.deadline.Sub(now); dur > 0 {
q.timer.Reset(dur)
}
} | |
c168366 | templates {
if needle == config.StringVal(t.Exec.Command) {
return t
}
}
return nil
} | |
c168367 | from disk.
RetryFuncDefault: nil,
RetryFuncVault: watch.RetryFunc(c.Vault.Retry.RetryFunc()),
VaultGrace: config.TimeDurationVal(c.Vault.Grace),
VaultToken: clients.Vault().Token(),
})
if err != nil {
return nil, errors.Wrap(err, "runner")
}
return w, nil
} | |
c168368 | m := regexpMatch(CatalogServicesQueryRe, s)
return &CatalogServicesQuery{
stopCh: make(chan struct{}, 1),
dc: m["dc"],
}, nil
} | |
c168369 | Retry: DefaultRetryConfig(),
SSL: DefaultSSLConfig(),
Transport: DefaultTransportConfig(),
}
} | |
c168370 | if t.String() != "os.Signal" {
return data, nil
}
if data == nil || data.(string) == "" {
return SIGNIL, nil
}
return Parse(data.(string))
}
} | |
c168371 | {
return fmt.Sprintf("%s:%s", w.Min, w.Max)
} | |
c168372 | }
return &VaultTokenQuery{
stopCh: make(chan struct{}, 1),
vaultSecret: vaultSecret,
secret: transformSecret(vaultSecret),
}, nil
} | |
c168373 |
Levels: Levels,
MinLevel: "WARN",
Writer: ioutil.Discard,
}
} | |
c168374 | {
if level == min {
return true
}
}
return false
} | |
c168375 | := dep.NewCatalogDatacentersQuery(ignore)
if err != nil {
return result, err
}
used.Add(d)
if value, ok := b.Recall(d); ok {
return value.([]string), nil
}
missing.Add(d)
return result, nil
}
} | |
c168376 | := split[0], split[1]
if k == s {
return v, nil
}
}
return os.Getenv(s), nil
}
} | |
c168377 | ", but got %d", len(data)+1)
}
var b bytes.Buffer
if err := t.ExecuteTemplate(&b, s, dot); err != nil {
return "", err
}
return b.String(), nil
}
} | |
c168378 | err := dep.NewFileQuery(s)
if err != nil {
return "", err
}
used.Add(d)
if value, ok := b.Recall(d); ok {
if value == nil {
return "", nil
}
return value.(string), nil
}
missing.Add(d)
return "", nil
}
} | |
c168379 | if err != nil {
return "", err
}
d.EnableBlocking()
used.Add(d)
if value, ok := b.Recall(d); ok {
if value == nil {
return "", nil
}
return value.(string), nil
}
missing.Add(d)
return "", nil
}
} | |
c168380 |
}
d, err := dep.NewKVGetQuery(s)
if err != nil {
return false, err
}
used.Add(d)
if value, ok := b.Recall(d); ok {
return value != nil, nil
}
missing.Add(d)
return false, nil
}
} | |
c168381 | }
used.Add(d)
if value, ok := b.Recall(d); ok {
return value.(*dep.CatalogNode), nil
}
missing.Add(d)
return nil, nil
}
} | |
c168382 | return nil, err
}
used.Add(d)
if value, ok := b.Recall(d); ok {
return value.([]*dep.Node), nil
}
missing.Add(d)
return result, nil
}
} | |
c168383 | if len(parts) != 2 {
return result, fmt.Errorf("not k=v pair %q", str)
}
k, v := strings.TrimSpace(parts[0]), strings.TrimSpace(parts[1])
data[k] = v
}
var d dep.Dependency
var err error
if len(rest) == 0 {
d, err = dep.NewVaultReadQuery(path)
} else {
d, err = dep.NewVaultWriteQuery(p... | |
c168384 | if value, ok := b.Recall(d); ok {
result = value.([]string)
return result, nil
}
missing.Add(d)
return result, nil
}
} | |
c168385 | err
}
used.Add(d)
if value, ok := b.Recall(d); ok {
return value.([]*dep.HealthService), nil
}
missing.Add(d)
return result, nil
}
} | |
c168386 | return nil, err
}
used.Add(d)
if value, ok := b.Recall(d); ok {
return value.([]*dep.CatalogSnippet), nil
}
missing.Add(d)
return result, nil
}
} | |
c168387 | for _, pair := range value.([]*dep.KeyPair) {
parts := strings.Split(pair.Key, "/")
if parts[len(parts)-1] != "" {
result = append(result, pair)
}
}
return result, nil
}
missing.Add(d)
return result, nil
}
} | |
c168388 | "", errors.Wrap(err, "base64Decode")
}
return string(v), nil
} | |
c168389 | {
return base64.StdEncoding.EncodeToString([]byte(s)), nil
} | |
c168390 | "", errors.Wrap(err, "base64URLDecode")
}
return string(v), nil
} | |
c168391 | {
return base64.URLEncoding.EncodeToString([]byte(s)), nil
} | |
c168392 | append(m[t], s)
}
}
case []*dep.HealthService:
for _, s := range typed {
for _, t := range s.Tags {
m[t] = append(m[t], s)
}
}
default:
return nil, fmt.Errorf("byTag: wrong argument type %T", in)
}
return m, nil
} | |
c168393 | := explodeHelper(m, pair.Key, pair.Value, pair.Key); err != nil {
return nil, errors.Wrap(err, "explode")
}
}
return m, nil
} | |
c168394 | := m[top].(map[string]interface{})
if !ok {
return fmt.Errorf("not a map: %q: %q already has value %q", p, top, m[top])
}
return explodeHelper(nest, key, v, k)
}
if k != "" {
m[k] = v
}
return nil
} | |
c168395 | return true, nil
}
}
case reflect.Float32, reflect.Float64:
switch vv.Kind() {
case reflect.Float32, reflect.Float64:
if vv.Float() == lvv.Float() {
return true, nil
}
}
case reflect.String:
if vv.Type() == lvv.Type() && vv.String() == lvv.String() {
return true, ni... | |
c168396 |
prefix = []byte(strings.Repeat(" ", spaces))
sp = true
for _, c := range []byte(s) {
if sp && c != '\n' {
output = append(output, prefix...)
size += spaces
}
output = append(output, c)
sp = c == '\n'
size++
}
return string(output[:size]), nil
} | |
c168397 | strings.Join(a, sep), nil
} | |
c168398 |
return false, errors.Wrap(err, "parseBool")
}
return result, nil
} | |
c168399 | {
return 0, errors.Wrap(err, "parseFloat")
}
return result, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.