_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q168300 | Get | validation | func (s *Set) Get(v string) Dependency {
s.RLock()
defer s.RUnlock()
return s.set[v]
} | go | {
"resource": ""
} |
q168301 | List | validation | func (s *Set) List() []Dependency {
s.RLock()
defer s.RUnlock()
r := make([]Dependency, len(s.list))
for i, k := range s.list {
r[i] = s.set[k]
}
return r
} | go | {
"resource": ""
} |
q168302 | Len | validation | func (s *Set) Len() int {
s.RLock()
defer s.RUnlock()
return len(s.list)
} | go | {
"resource": ""
} |
q168303 | String | validation | func (s *Set) String() string {
s.RLock()
defer s.RUnlock()
return strings.Join(s.list, ", ")
} | go | {
"resource": ""
} |
q168304 | deepCopyAndSortTags | validation | func deepCopyAndSortTags(tags []string) []string {
newTags := make([]string, 0, len(tags))
for _, tag := range tags {
newTags = append(newTags, tag)
}
sort.Strings(newTags)
return newTags
} | go | {
"resource": ""
} |
q168305 | respWithMetadata | validation | func respWithMetadata(i interface{}) (interface{}, *ResponseMetadata, error) {
return i, &ResponseMetadata{
LastContact: 0,
LastIndex: uint64(time.Now().Unix()),
}, nil
} | go | {
"resource": ""
} |
q168306 | regexpMatch | validation | func regexpMatch(re *regexp.Regexp, q string) map[string]string {
names := re.SubexpNames()
match := re.FindAllStringSubmatch(q, -1)
if len(match) == 0 {
return map[string]string{}
}
m := map[string]string{}
for i, n := range match[0] {
if names[i] != "" {
m[names[i]] = n
}
}
return m
} | go | {
"resource": ""
} |
q168307 | NewCatalogServiceQuery | validation | func NewCatalogServiceQuery(s string) (*CatalogServiceQuery, error) {
if !CatalogServiceQueryRe.MatchString(s) {
return nil, fmt.Errorf("catalog.service: invalid format: %q", s)
}
m := regexpMatch(CatalogServiceQueryRe, s)
return &CatalogServiceQuery{
stopCh: make(chan struct{}, 1),
dc: m["dc"],
name: ... | go | {
"resource": ""
} |
q168308 | NewKVListQuery | validation | func NewKVListQuery(s string) (*KVListQuery, error) {
if s != "" && !KVListQueryRe.MatchString(s) {
return nil, fmt.Errorf("kv.list: invalid format: %q", s)
}
m := regexpMatch(KVListQueryRe, s)
return &KVListQuery{
stopCh: make(chan struct{}, 1),
dc: m["dc"],
prefix: m["prefix"],
}, nil
} | go | {
"resource": ""
} |
q168309 | NewDedupManager | validation | func NewDedupManager(config *config.DedupConfig, clients *dep.ClientSet, brain *template.Brain, templates []*template.Template) (*DedupManager, error) {
d := &DedupManager{
config: config,
clients: clients,
brain: brain,
templates: templates,
leader: make(map[*template.Template]<-chan struct{}),
... | go | {
"resource": ""
} |
q168310 | Start | validation | func (d *DedupManager) Start() error {
log.Printf("[INFO] (dedup) starting de-duplication manager")
client := d.clients.Consul()
go d.createSession(client)
// Start to watch each template
for _, t := range d.templates {
go d.watchTemplate(client, t)
}
return nil
} | go | {
"resource": ""
} |
q168311 | Stop | validation | func (d *DedupManager) Stop() error {
d.stopLock.Lock()
defer d.stopLock.Unlock()
if d.stop {
return nil
}
log.Printf("[INFO] (dedup) stopping de-duplication manager")
d.stop = true
close(d.stopCh)
d.wg.Wait()
return nil
} | go | {
"resource": ""
} |
q168312 | createSession | validation | func (d *DedupManager) createSession(client *consulapi.Client) {
START:
log.Printf("[INFO] (dedup) attempting to create session")
session := client.Session()
sessionCh := make(chan struct{})
ttl := fmt.Sprintf("%.6fs", float64(*d.config.TTL)/float64(time.Second))
se := &consulapi.SessionEntry{
Name: "Consul-... | go | {
"resource": ""
} |
q168313 | IsLeader | validation | func (d *DedupManager) IsLeader(tmpl *template.Template) bool {
d.leaderLock.RLock()
defer d.leaderLock.RUnlock()
lockCh, ok := d.leader[tmpl]
if !ok {
return false
}
select {
case <-lockCh:
return false
default:
return true
}
} | go | {
"resource": ""
} |
q168314 | UpdateDeps | validation | func (d *DedupManager) UpdateDeps(t *template.Template, deps []dep.Dependency) error {
// Calculate the path to write updates to
dataPath := path.Join(*d.config.Prefix, t.ID(), "data")
// Package up the dependency data
td := templateData{
Version: version.Version,
Data: make(map[string]interface{}),
}
for... | go | {
"resource": ""
} |
q168315 | setLeader | validation | func (d *DedupManager) setLeader(tmpl *template.Template, lockCh <-chan struct{}) {
// Update the lock state
d.leaderLock.Lock()
if lockCh != nil {
d.leader[tmpl] = lockCh
} else {
delete(d.leader, tmpl)
}
d.leaderLock.Unlock()
// Clear the lastWrite hash if we've lost leadership
if lockCh == nil {
d.las... | go | {
"resource": ""
} |
q168316 | parseData | validation | func (d *DedupManager) parseData(path string, raw []byte) {
// Setup the decompression and decoders
r := bytes.NewReader(raw)
decompress := lzw.NewReader(r, lzw.LSB, 8)
defer decompress.Close()
dec := gob.NewDecoder(decompress)
// Decode the data
var td templateData
if err := dec.Decode(&td); err != nil {
lo... | go | {
"resource": ""
} |
q168317 | NewFileQuery | validation | func NewFileQuery(s string) (*FileQuery, error) {
s = strings.TrimSpace(s)
if s == "" {
return nil, fmt.Errorf("file: invalid format: %q", s)
}
return &FileQuery{
stopCh: make(chan struct{}, 1),
path: s,
}, nil
} | go | {
"resource": ""
} |
q168318 | NewCLI | validation | func NewCLI(out, err io.Writer) *CLI {
return &CLI{
outStream: out,
errStream: err,
signalCh: make(chan os.Signal, 1),
stopCh: make(chan struct{}),
}
} | go | {
"resource": ""
} |
q168319 | Run | validation | func (cli *CLI) Run(args []string) int {
// Parse the flags
config, paths, once, dry, isVersion, err := cli.ParseFlags(args[1:])
if err != nil {
if err == flag.ErrHelp {
fmt.Fprintf(cli.errStream, usage, version.Name)
return 0
}
fmt.Fprintln(cli.errStream, err.Error())
return ExitCodeParseFlagsError
}... | go | {
"resource": ""
} |
q168320 | stop | validation | func (cli *CLI) stop() {
cli.Lock()
defer cli.Unlock()
if cli.stopped {
return
}
close(cli.stopCh)
cli.stopped = true
} | go | {
"resource": ""
} |
q168321 | loadConfigs | validation | func loadConfigs(paths []string, o *config.Config) (*config.Config, error) {
finalC := config.DefaultConfig()
for _, path := range paths {
c, err := config.FromPath(path)
if err != nil {
return nil, err
}
finalC = finalC.Merge(c)
}
finalC = finalC.Merge(o)
finalC.Finalize()
return finalC, nil
} | go | {
"resource": ""
} |
q168322 | logError | validation | func logError(err error, status int) int {
log.Printf("[ERR] (cli) %s", err)
return status
} | go | {
"resource": ""
} |
q168323 | FileModeGoString | validation | func FileModeGoString(o *os.FileMode) string {
if o == nil {
return "(*os.FileMode)(nil)"
}
return fmt.Sprintf("%q", *o)
} | go | {
"resource": ""
} |
q168324 | SignalVal | validation | func SignalVal(s *os.Signal) os.Signal {
if s == nil {
return (os.Signal)(nil)
}
return *s
} | go | {
"resource": ""
} |
q168325 | SignalGoString | validation | func SignalGoString(s *os.Signal) string {
if s == nil {
return "(*os.Signal)(nil)"
}
if *s == nil {
return "<nil>"
}
return fmt.Sprintf("%q", *s)
} | go | {
"resource": ""
} |
q168326 | SignalPresent | validation | func SignalPresent(s *os.Signal) bool {
if s == nil {
return false
}
return *s != signals.SIGNIL
} | go | {
"resource": ""
} |
q168327 | TimeDurationVal | validation | func TimeDurationVal(t *time.Duration) time.Duration {
if t == nil {
return time.Duration(0)
}
return *t
} | go | {
"resource": ""
} |
q168328 | TimeDurationGoString | validation | func TimeDurationGoString(t *time.Duration) string {
if t == nil {
return "(*time.Duration)(nil)"
}
return fmt.Sprintf("%s", t)
} | go | {
"resource": ""
} |
q168329 | CreateConsulClient | validation | func (c *ClientSet) CreateConsulClient(i *CreateConsulClientInput) error {
consulConfig := consulapi.DefaultConfig()
if i.Address != "" {
consulConfig.Address = i.Address
}
if i.Token != "" {
consulConfig.Token = i.Token
}
if i.AuthEnabled {
consulConfig.HttpAuth = &consulapi.HttpBasicAuth{
Username: ... | go | {
"resource": ""
} |
q168330 | Consul | validation | func (c *ClientSet) Consul() *consulapi.Client {
c.RLock()
defer c.RUnlock()
return c.consul.client
} | go | {
"resource": ""
} |
q168331 | Vault | validation | func (c *ClientSet) Vault() *vaultapi.Client {
c.RLock()
defer c.RUnlock()
return c.vault.client
} | go | {
"resource": ""
} |
q168332 | Stop | validation | func (c *ClientSet) Stop() {
c.Lock()
defer c.Unlock()
if c.consul != nil {
c.consul.transport.CloseIdleConnections()
}
if c.vault != nil {
c.vault.httpClient.Transport.(*http.Transport).CloseIdleConnections()
}
} | go | {
"resource": ""
} |
q168333 | NewVaultReadQuery | validation | func NewVaultReadQuery(s string) (*VaultReadQuery, error) {
s = strings.TrimSpace(s)
s = strings.Trim(s, "/")
if s == "" {
return nil, fmt.Errorf("vault.read: invalid format: %q", s)
}
secretURL, err := url.Parse(s)
if err != nil {
return nil, err
}
return &VaultReadQuery{
stopCh: make(chan struct{... | go | {
"resource": ""
} |
q168334 | NewKVGetQuery | validation | func NewKVGetQuery(s string) (*KVGetQuery, error) {
if s != "" && !KVGetQueryRe.MatchString(s) {
return nil, fmt.Errorf("kv.get: invalid format: %q", s)
}
m := regexpMatch(KVGetQueryRe, s)
return &KVGetQuery{
stopCh: make(chan struct{}, 1),
dc: m["dc"],
key: m["key"],
}, nil
} | go | {
"resource": ""
} |
q168335 | NewVaultAgentTokenQuery | validation | func NewVaultAgentTokenQuery(path string) (*VaultAgentTokenQuery, error) {
return &VaultAgentTokenQuery{
stopCh: make(chan struct{}, 1),
path: path,
}, nil
} | go | {
"resource": ""
} |
q168336 | watch | validation | func (d *VaultAgentTokenQuery) watch(lastStat os.FileInfo) <-chan *watchResult {
ch := make(chan *watchResult, 1)
go func(lastStat os.FileInfo) {
for {
stat, err := os.Stat(d.path)
if err != nil {
select {
case <-d.stopCh:
return
case ch <- &watchResult{err: err}:
return
}
}
... | go | {
"resource": ""
} |
q168337 | NewKVKeysQuery | validation | func NewKVKeysQuery(s string) (*KVKeysQuery, error) {
if s != "" && !KVKeysQueryRe.MatchString(s) {
return nil, fmt.Errorf("kv.keys: invalid format: %q", s)
}
m := regexpMatch(KVKeysQueryRe, s)
return &KVKeysQuery{
stopCh: make(chan struct{}, 1),
dc: m["dc"],
prefix: m["prefix"],
}, nil
} | go | {
"resource": ""
} |
q168338 | New | validation | func New(i *NewInput) (*Child, error) {
if i == nil {
i = new(NewInput)
}
if len(i.Command) == 0 {
return nil, ErrMissingCommand
}
child := &Child{
stdin: i.Stdin,
stdout: i.Stdout,
stderr: i.Stderr,
command: i.Command,
args: i.Args,
env: i.Env,
timeout:... | go | {
"resource": ""
} |
q168339 | ExitCh | validation | func (c *Child) ExitCh() <-chan int {
c.RLock()
defer c.RUnlock()
return c.exitCh
} | go | {
"resource": ""
} |
q168340 | Pid | validation | func (c *Child) Pid() int {
c.RLock()
defer c.RUnlock()
return c.pid()
} | go | {
"resource": ""
} |
q168341 | Command | validation | func (c *Child) Command() string {
list := append([]string{c.command}, c.args...)
return strings.Join(list, " ")
} | go | {
"resource": ""
} |
q168342 | Start | validation | func (c *Child) Start() error {
log.Printf("[INFO] (child) spawning: %s", c.Command())
c.Lock()
defer c.Unlock()
return c.start()
} | go | {
"resource": ""
} |
q168343 | Signal | validation | func (c *Child) Signal(s os.Signal) error {
log.Printf("[INFO] (child) receiving signal %q", s.String())
c.RLock()
defer c.RUnlock()
return c.signal(s)
} | go | {
"resource": ""
} |
q168344 | Reload | validation | func (c *Child) Reload() error {
if c.reloadSignal == nil {
log.Printf("[INFO] (child) restarting process")
// Take a full lock because start is going to replace the process. We also
// want to make sure that no other routines attempt to send reload signals
// during this transition.
c.Lock()
defer c.Unlo... | go | {
"resource": ""
} |
q168345 | Kill | validation | func (c *Child) Kill() {
log.Printf("[INFO] (child) killing process")
c.Lock()
defer c.Unlock()
c.kill()
} | go | {
"resource": ""
} |
q168346 | Stop | validation | func (c *Child) Stop() {
log.Printf("[INFO] (child) stopping process")
c.Lock()
defer c.Unlock()
c.stopLock.Lock()
defer c.stopLock.Unlock()
if c.stopped {
log.Printf("[WARN] (child) already stopped")
return
}
c.kill()
close(c.stopCh)
c.stopped = true
} | go | {
"resource": ""
} |
q168347 | Env | validation | func (c *EnvConfig) Env() []string {
// In pristine mode, just return the custom environment. If the user did not
// specify a custom environment, just return the empty slice to force an
// empty environment. We cannot return nil here because the later call to
// os/exec will think we want to inherit the parent.
i... | go | {
"resource": ""
} |
q168348 | NewHealthServiceQuery | validation | func NewHealthServiceQuery(s string) (*HealthServiceQuery, error) {
if !HealthServiceQueryRe.MatchString(s) {
return nil, fmt.Errorf("health.service: invalid format: %q", s)
}
m := regexpMatch(HealthServiceQueryRe, s)
var filters []string
if filter := m["filter"]; filter != "" {
split := strings.Split(filter... | go | {
"resource": ""
} |
q168349 | Fetch | validation | func (d *HealthServiceQuery) Fetch(clients *ClientSet, opts *QueryOptions) (interface{}, *ResponseMetadata, error) {
select {
case <-d.stopCh:
return nil, nil, ErrStopped
default:
}
opts = opts.Merge(&QueryOptions{
Datacenter: d.dc,
Near: d.near,
})
u := &url.URL{
Path: "/v1/health/service/" ... | go | {
"resource": ""
} |
q168350 | acceptStatus | validation | func acceptStatus(list []string, s string) bool {
for _, status := range list {
if status == s || status == HealthAny {
return true
}
}
return false
} | go | {
"resource": ""
} |
q168351 | RetryFunc | validation | func (c *RetryConfig) RetryFunc() RetryFunc {
return func(retry int) (bool, time.Duration) {
if !BoolVal(c.Enabled) {
return false, 0
}
if IntVal(c.Attempts) > 0 && retry > IntVal(c.Attempts)-1 {
return false, 0
}
baseSleep := TimeDurationVal(c.Backoff)
maxSleep := TimeDurationVal(c.MaxBackoff)
... | go | {
"resource": ""
} |
q168352 | NewRunner | validation | func NewRunner(config *config.Config, dry, once bool) (*Runner, error) {
log.Printf("[INFO] (runner) creating new runner (dry: %v, once: %v)", dry, once)
runner := &Runner{
config: config,
dry: dry,
once: once,
}
if err := runner.init(); err != nil {
return nil, err
}
return runner, nil
} | go | {
"resource": ""
} |
q168353 | Stop | validation | func (r *Runner) Stop() {
r.stopLock.Lock()
defer r.stopLock.Unlock()
if r.stopped {
return
}
log.Printf("[INFO] (runner) stopping")
r.stopDedup()
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)
}... | go | {
"resource": ""
} |
q168354 | RenderEvents | validation | func (r *Runner) RenderEvents() map[string]*RenderEvent {
r.renderEventsLock.RLock()
defer r.renderEventsLock.RUnlock()
times := make(map[string]*RenderEvent, len(r.renderEvents))
for k, v := range r.renderEvents {
times[k] = v
}
return times
} | go | {
"resource": ""
} |
q168355 | Signal | validation | func (r *Runner) Signal(s os.Signal) error {
r.childLock.RLock()
defer r.childLock.RUnlock()
if r.child == nil {
return nil
}
return r.child.Signal(s)
} | go | {
"resource": ""
} |
q168356 | diffAndUpdateDeps | validation | func (r *Runner) diffAndUpdateDeps(depsMap map[string]dep.Dependency) {
r.dependenciesLock.Lock()
defer r.dependenciesLock.Unlock()
// Diff and up the list of dependencies, stopping any unneeded watchers.
log.Printf("[DEBUG] (runner) diffing and updating dependencies")
for key, d := range r.dependencies {
if _... | go | {
"resource": ""
} |
q168357 | templateConfigsFor | validation | func (r *Runner) templateConfigsFor(tmpl *template.Template) []*config.TemplateConfig {
return r.ctemplatesMap[tmpl.ID()]
} | go | {
"resource": ""
} |
q168358 | TemplateConfigMapping | validation | func (r *Runner) TemplateConfigMapping() map[string][]config.TemplateConfig {
m := make(map[string][]config.TemplateConfig, len(r.ctemplatesMap))
for id, set := range r.ctemplatesMap {
ctmpls := make([]config.TemplateConfig, len(set))
m[id] = ctmpls
for i, ctmpl := range set {
ctmpls[i] = *ctmpl
}
}
re... | go | {
"resource": ""
} |
q168359 | allTemplatesRendered | validation | func (r *Runner) allTemplatesRendered() bool {
r.renderEventsLock.RLock()
defer r.renderEventsLock.RUnlock()
for _, tmpl := range r.templates {
event, rendered := r.renderEvents[tmpl.ID()]
if !rendered {
return false
}
// Skip evaluation of events from quiescence as they will
// be default unrendered ... | go | {
"resource": ""
} |
q168360 | childEnv | validation | func (r *Runner) childEnv() []string {
var m = make(map[string]string)
if config.StringPresent(r.config.Consul.Address) {
m["CONSUL_HTTP_ADDR"] = config.StringVal(r.config.Consul.Address)
}
if config.BoolVal(r.config.Consul.Auth.Enabled) {
m["CONSUL_HTTP_AUTH"] = r.config.Consul.Auth.String()
}
m["CONSUL_H... | go | {
"resource": ""
} |
q168361 | storePid | validation | func (r *Runner) storePid() error {
path := config.StringVal(r.config.PidFile)
if path == "" {
return nil
}
log.Printf("[INFO] creating pid file at %q", path)
f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0666)
if err != nil {
return fmt.Errorf("runner: could not open pid file: %s", err)
... | go | {
"resource": ""
} |
q168362 | deletePid | validation | func (r *Runner) deletePid() error {
path := config.StringVal(r.config.PidFile)
if path == "" {
return nil
}
log.Printf("[DEBUG] removing pid file at %q", path)
stat, err := os.Stat(path)
if err != nil {
return fmt.Errorf("runner: could not remove pid file: %s", err)
}
if stat.IsDir() {
return fmt.Error... | go | {
"resource": ""
} |
q168363 | spawnChild | validation | func spawnChild(i *spawnChildInput) (*child.Child, error) {
p := shellwords.NewParser()
p.ParseEnv = true
p.ParseBacktick = true
args, err := p.Parse(i.Command)
if err != nil {
return nil, errors.Wrap(err, "failed parsing command")
}
child, err := child.New(&child.NewInput{
Stdin: i.Stdin,
Stdout: ... | go | {
"resource": ""
} |
q168364 | newQuiescence | validation | func newQuiescence(ch chan *template.Template, min, max time.Duration, t *template.Template) *quiescence {
return &quiescence{
template: t,
min: min,
max: max,
ch: ch,
}
} | go | {
"resource": ""
} |
q168365 | tick | validation | func (q *quiescence) tick() {
now := time.Now()
// If this is the first tick, set up the timer and calculate the max
// deadline.
if q.timer == nil {
q.timer = time.NewTimer(q.min)
go func() {
select {
case <-q.timer.C:
q.ch <- q.template
}
}()
q.deadline = now.Add(q.max)
return
}
// Sno... | go | {
"resource": ""
} |
q168366 | findCommand | validation | func findCommand(c *config.TemplateConfig, templates []*config.TemplateConfig) *config.TemplateConfig {
needle := config.StringVal(c.Exec.Command)
for _, t := range templates {
if needle == config.StringVal(t.Exec.Command) {
return t
}
}
return nil
} | go | {
"resource": ""
} |
q168367 | newWatcher | validation | func newWatcher(c *config.Config, clients *dep.ClientSet, once bool) (*watch.Watcher, error) {
log.Printf("[INFO] (runner) creating watcher")
w, err := watch.NewWatcher(&watch.NewWatcherInput{
Clients: clients,
MaxStale: config.TimeDurationVal(c.MaxStale),
Once: once,
Re... | go | {
"resource": ""
} |
q168368 | NewCatalogServicesQuery | validation | func NewCatalogServicesQuery(s string) (*CatalogServicesQuery, error) {
if !CatalogServicesQueryRe.MatchString(s) {
return nil, fmt.Errorf("catalog.services: invalid format: %q", s)
}
m := regexpMatch(CatalogServicesQueryRe, s)
return &CatalogServicesQuery{
stopCh: make(chan struct{}, 1),
dc: m["dc"],
}... | go | {
"resource": ""
} |
q168369 | DefaultConsulConfig | validation | func DefaultConsulConfig() *ConsulConfig {
return &ConsulConfig{
Auth: DefaultAuthConfig(),
Retry: DefaultRetryConfig(),
SSL: DefaultSSLConfig(),
Transport: DefaultTransportConfig(),
}
} | go | {
"resource": ""
} |
q168370 | StringToSignalFunc | validation | func StringToSignalFunc() mapstructure.DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
data interface{}) (interface{}, error) {
if f.Kind() != reflect.String {
return data, nil
}
if t.String() != "os.Signal" {
return data, nil
}
if data == nil || data.(string) == "" {
return SI... | go | {
"resource": ""
} |
q168371 | String | validation | func (w *WaitVar) String() string {
return fmt.Sprintf("%s:%s", w.Min, w.Max)
} | go | {
"resource": ""
} |
q168372 | NewVaultTokenQuery | validation | func NewVaultTokenQuery(token string) (*VaultTokenQuery, error) {
vaultSecret := &api.Secret{
Auth: &api.SecretAuth{
ClientToken: token,
Renewable: true,
LeaseDuration: 1,
},
}
return &VaultTokenQuery{
stopCh: make(chan struct{}, 1),
vaultSecret: vaultSecret,
secret: transformSecre... | go | {
"resource": ""
} |
q168373 | NewLogFilter | validation | func NewLogFilter() *logutils.LevelFilter {
return &logutils.LevelFilter{
Levels: Levels,
MinLevel: "WARN",
Writer: ioutil.Discard,
}
} | go | {
"resource": ""
} |
q168374 | ValidateLevelFilter | validation | func ValidateLevelFilter(min logutils.LogLevel, filter *logutils.LevelFilter) bool {
for _, level := range filter.Levels {
if level == min {
return true
}
}
return false
} | go | {
"resource": ""
} |
q168375 | datacentersFunc | validation | func datacentersFunc(b *Brain, used, missing *dep.Set) func(ignore ...bool) ([]string, error) {
return func(i ...bool) ([]string, error) {
result := []string{}
var ignore bool
switch len(i) {
case 0:
ignore = false
case 1:
ignore = i[0]
default:
return result, fmt.Errorf("datacenters: wrong numbe... | go | {
"resource": ""
} |
q168376 | envFunc | validation | func envFunc(env []string) func(string) (string, error) {
return func(s string) (string, error) {
for _, e := range env {
split := strings.SplitN(e, "=", 2)
k, v := split[0], split[1]
if k == s {
return v, nil
}
}
return os.Getenv(s), nil
}
} | go | {
"resource": ""
} |
q168377 | executeTemplateFunc | validation | func executeTemplateFunc(t *template.Template) func(string, ...interface{}) (string, error) {
return func(s string, data ...interface{}) (string, error) {
var dot interface{}
switch len(data) {
case 0:
dot = nil
case 1:
dot = data[0]
default:
return "", fmt.Errorf("executeTemplate: wrong number of a... | go | {
"resource": ""
} |
q168378 | fileFunc | validation | func fileFunc(b *Brain, used, missing *dep.Set) func(string) (string, error) {
return func(s string) (string, error) {
if len(s) == 0 {
return "", nil
}
d, err := dep.NewFileQuery(s)
if err != nil {
return "", err
}
used.Add(d)
if value, ok := b.Recall(d); ok {
if value == nil {
return ""... | go | {
"resource": ""
} |
q168379 | keyFunc | validation | func keyFunc(b *Brain, used, missing *dep.Set) func(string) (string, error) {
return func(s string) (string, error) {
if len(s) == 0 {
return "", nil
}
d, err := dep.NewKVGetQuery(s)
if err != nil {
return "", err
}
d.EnableBlocking()
used.Add(d)
if value, ok := b.Recall(d); ok {
if value =... | go | {
"resource": ""
} |
q168380 | keyExistsFunc | validation | func keyExistsFunc(b *Brain, used, missing *dep.Set) func(string) (bool, error) {
return func(s string) (bool, error) {
if len(s) == 0 {
return false, nil
}
d, err := dep.NewKVGetQuery(s)
if err != nil {
return false, err
}
used.Add(d)
if value, ok := b.Recall(d); ok {
return value != nil, ni... | go | {
"resource": ""
} |
q168381 | nodeFunc | validation | func nodeFunc(b *Brain, used, missing *dep.Set) func(...string) (*dep.CatalogNode, error) {
return func(s ...string) (*dep.CatalogNode, error) {
d, err := dep.NewCatalogNodeQuery(strings.Join(s, ""))
if err != nil {
return nil, err
}
used.Add(d)
if value, ok := b.Recall(d); ok {
return value.(*dep.C... | go | {
"resource": ""
} |
q168382 | nodesFunc | validation | func nodesFunc(b *Brain, used, missing *dep.Set) func(...string) ([]*dep.Node, error) {
return func(s ...string) ([]*dep.Node, error) {
result := []*dep.Node{}
d, err := dep.NewCatalogNodesQuery(strings.Join(s, ""))
if err != nil {
return nil, err
}
used.Add(d)
if value, ok := b.Recall(d); ok {
re... | go | {
"resource": ""
} |
q168383 | secretFunc | validation | func secretFunc(b *Brain, used, missing *dep.Set) func(...string) (*dep.Secret, error) {
return func(s ...string) (*dep.Secret, error) {
var result *dep.Secret
if len(s) == 0 {
return result, nil
}
// TODO: Refactor into separate template functions
path, rest := s[0], s[1:]
data := make(map[string]int... | go | {
"resource": ""
} |
q168384 | secretsFunc | validation | func secretsFunc(b *Brain, used, missing *dep.Set) func(string) ([]string, error) {
return func(s string) ([]string, error) {
var result []string
if len(s) == 0 {
return result, nil
}
d, err := dep.NewVaultListQuery(s)
if err != nil {
return nil, err
}
used.Add(d)
if value, ok := b.Recall(d);... | go | {
"resource": ""
} |
q168385 | serviceFunc | validation | func serviceFunc(b *Brain, used, missing *dep.Set) func(...string) ([]*dep.HealthService, error) {
return func(s ...string) ([]*dep.HealthService, error) {
result := []*dep.HealthService{}
if len(s) == 0 || s[0] == "" {
return result, nil
}
d, err := dep.NewHealthServiceQuery(strings.Join(s, "|"))
if er... | go | {
"resource": ""
} |
q168386 | servicesFunc | validation | func servicesFunc(b *Brain, used, missing *dep.Set) func(...string) ([]*dep.CatalogSnippet, error) {
return func(s ...string) ([]*dep.CatalogSnippet, error) {
result := []*dep.CatalogSnippet{}
d, err := dep.NewCatalogServicesQuery(strings.Join(s, ""))
if err != nil {
return nil, err
}
used.Add(d)
if ... | go | {
"resource": ""
} |
q168387 | treeFunc | validation | func treeFunc(b *Brain, used, missing *dep.Set) func(string) ([]*dep.KeyPair, error) {
return func(s string) ([]*dep.KeyPair, error) {
result := []*dep.KeyPair{}
if len(s) == 0 {
return result, nil
}
d, err := dep.NewKVListQuery(s)
if err != nil {
return result, err
}
used.Add(d)
// Only retu... | go | {
"resource": ""
} |
q168388 | base64Decode | validation | func base64Decode(s string) (string, error) {
v, err := base64.StdEncoding.DecodeString(s)
if err != nil {
return "", errors.Wrap(err, "base64Decode")
}
return string(v), nil
} | go | {
"resource": ""
} |
q168389 | base64Encode | validation | func base64Encode(s string) (string, error) {
return base64.StdEncoding.EncodeToString([]byte(s)), nil
} | go | {
"resource": ""
} |
q168390 | base64URLDecode | validation | func base64URLDecode(s string) (string, error) {
v, err := base64.URLEncoding.DecodeString(s)
if err != nil {
return "", errors.Wrap(err, "base64URLDecode")
}
return string(v), nil
} | go | {
"resource": ""
} |
q168391 | base64URLEncode | validation | func base64URLEncode(s string) (string, error) {
return base64.URLEncoding.EncodeToString([]byte(s)), nil
} | go | {
"resource": ""
} |
q168392 | byTag | validation | func byTag(in interface{}) (map[string][]interface{}, error) {
m := make(map[string][]interface{})
switch typed := in.(type) {
case nil:
case []*dep.CatalogSnippet:
for _, s := range typed {
for _, t := range s.Tags {
m[t] = append(m[t], s)
}
}
case []*dep.CatalogService:
for _, s := range typed {... | go | {
"resource": ""
} |
q168393 | explode | validation | func explode(pairs []*dep.KeyPair) (map[string]interface{}, error) {
m := make(map[string]interface{})
for _, pair := range pairs {
if err := explodeHelper(m, pair.Key, pair.Value, pair.Key); err != nil {
return nil, errors.Wrap(err, "explode")
}
}
return m, nil
} | go | {
"resource": ""
} |
q168394 | explodeHelper | validation | func explodeHelper(m map[string]interface{}, k, v, p string) error {
if strings.Contains(k, "/") {
parts := strings.Split(k, "/")
top := parts[0]
key := strings.Join(parts[1:], "/")
if _, ok := m[top]; !ok {
m[top] = make(map[string]interface{})
}
nest, ok := m[top].(map[string]interface{})
if !ok {
... | go | {
"resource": ""
} |
q168395 | in | validation | func in(l, v interface{}) (bool, error) {
lv := reflect.ValueOf(l)
vv := reflect.ValueOf(v)
switch lv.Kind() {
case reflect.Array, reflect.Slice:
// if the slice contains 'interface' elements, then the element needs to be extracted directly to examine its type,
// otherwise it will just resolve to 'interface'.... | go | {
"resource": ""
} |
q168396 | indent | validation | func indent(spaces int, s string) (string, error) {
if spaces < 0 {
return "", fmt.Errorf("indent value must be a positive integer")
}
var output, prefix []byte
var sp bool
var size int
prefix = []byte(strings.Repeat(" ", spaces))
sp = true
for _, c := range []byte(s) {
if sp && c != '\n' {
output = appe... | go | {
"resource": ""
} |
q168397 | join | validation | func join(sep string, a []string) (string, error) {
return strings.Join(a, sep), nil
} | go | {
"resource": ""
} |
q168398 | parseBool | validation | func parseBool(s string) (bool, error) {
if s == "" {
return false, nil
}
result, err := strconv.ParseBool(s)
if err != nil {
return false, errors.Wrap(err, "parseBool")
}
return result, nil
} | go | {
"resource": ""
} |
q168399 | parseFloat | validation | func parseFloat(s string) (float64, error) {
if s == "" {
return 0.0, nil
}
result, err := strconv.ParseFloat(s, 10)
if err != nil {
return 0, errors.Wrap(err, "parseFloat")
}
return result, nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.