id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c20200 | MaybePrintln(c, fmt.Sprintf("%s is not formatted. Use hostess fix to format it", GetHostsPath()))
os.Exit(1)
}
} | |
c20201 | MaybeError(c, err.Error())
}
fmt.Println(fmt.Sprintf("%s", jsonbytes))
} | |
c20202 |
if err != nil {
MaybeError(c, fmt.Sprintf("Error applying changes to hosts file: %s", err))
}
MaybeSaveHostFile(c, hostfile)
MaybePrintln(c, fmt.Sprintf("%s applied", filename))
} | |
c20203 | err := ParseLine(line)
if err != nil {
panic(err)
}
return hostlist
} | |
c20204 | nil {
h.data = data
}
return err
} | |
c20205 | {
// This index is longer than A, so A is shorter. A wins!
if charIndex >= aLength {
return true
}
// This index is longer than B, so B is shorter. A loses!
if charIndex >= bLength {
return false
}
// A and B differ at this index and A is less. A wins!
if h[A].Domain[charIndex] < h[B].Domain[char... | |
c20206 | h[i], h[j] = h[j], h[i]
} | |
c20207 | a.Equal(b) {
return true
}
}
return false
} | |
c20208 | == domain {
return true
}
}
return false
} | |
c20209 | := range *h {
if hostname.EqualIP(IP) {
return true
}
}
return false
} | |
c20210 | found := range *h {
if found.Equal(host) {
return index
}
}
return -1
} | |
c20211 | {
if hostname.Domain == domain && hostname.IPv6 == (version == 6) {
return index
}
}
return -1
} | |
c20212 | {
return h.RemoveDomainV(domain, 4) + h.RemoveDomainV(domain, 6)
} | |
c20213 | return h.Remove(h.IndexOfDomainV(domain, version))
} | |
c20214 | domain {
hostname.Enabled = true
found = true
}
}
return found
} | |
c20215 | }
for _, hostname := range *h {
if hostname.Domain == domain && hostname.IPv6 == (version == 6) {
hostname.Enabled = true
found = true
}
}
return found
} | |
c20216 | {
hostnames = append(hostnames, hostname)
}
}
return
} | |
c20217 | hostname.Domain == domain {
hostnames = append(hostnames, hostname)
}
}
return
} | |
c20218 | }
for _, hostname := range *h {
if hostname.Domain == domain && hostname.IPv6 == (version == 6) {
hostnames = append(hostnames, hostname)
}
}
return
} | |
c20219 |
if err != nil {
return err
}
for _, hostname := range hostnames {
h.Add(hostname)
}
return nil
} | |
c20220 | b.Error(fmt.Sprintf("logged from helper: %s", msg))
} | |
c20221 | z.Error(fmt.Sprintf("logged from helper: %s", msg))
} | |
c20222 | ioutil.Discard,
Formatter: new(logrus.JSONFormatter),
Level: logrus.DebugLevel,
})
} | |
c20223 | return barker{l.WithOptions(zap.AddCallerSkip(_barkifyCallerSkip)).Sugar()}
} | |
c20224 | len(o.Include) > 0 || o.VCS
} | |
c20225 |
// Direct file paths cannot have archive options
if !fi.IsDir() && opts.IsSet() {
return nil, fmt.Errorf(
"options such as exclude, include, and VCS can't be set when " +
"the path is a file.")
}
if fi.IsDir() {
return archiveDir(path, opts)
} else {
return archiveFile(path)
}
} | |
c20226 | err := c.Request("POST", endpoint, &RequestOptions{
Body: bytes.NewReader(body),
Headers: map[string]string{
"Content-Type": "application/json",
},
})
if err != nil {
return nil, err
}
response, err := checkResp(c.HTTPClient.Do(request))
if err != nil {
return nil, err
}
var app App
if err := de... | |
c20227 | BodyLength: int64(len(m)),
}
}
request, err := c.Request("POST", endpoint, ro)
if err != nil {
return 0, err
}
response, err := checkResp(c.HTTPClient.Do(request))
if err != nil {
return 0, err
}
var av appVersion
if err := decodeJSON(response, &av); err != nil {
return 0, err
}
if err := c.pu... | |
c20228 | "" {
atlasEndpoint = atlasDefaultEndpoint
}
client, err := NewClient(atlasEndpoint)
if err != nil {
panic(err)
}
return client
} | |
c20229 | {
log.Printf("[DEBUG] request: appending token (%s)", maskString(c.Token))
if ro.Headers == nil {
ro.Headers = make(map[string]string)
}
ro.Headers[atlasTokenHeader] = c.Token
}
return c.rawRequest(verb, &u, ro)
} | |
c20230 | nil, err
}
// set our default headers first
for k, v := range c.DefaultHeader {
request.Header[k] = v
}
// Add any request headers (auth will be here if set)
for k, v := range ro.Headers {
request.Header.Add(k, v)
}
// Add content-length if we have it
if ro.BodyLength > 0 {
request.ContentLength = ro... | |
c20231 | fmt.Errorf("error decoding JSON body: %s", err)
}
return re
} | |
c20232 | nil, err
}
response, err := checkResp(c.HTTPClient.Do(request))
if err != nil {
return nil, err
}
var bc BuildConfig
if err := decodeJSON(response, &bc); err != nil {
return nil, err
}
return &bc, nil
} | |
c20233 | },
})
if err != nil {
return nil, err
}
response, err := checkResp(c.HTTPClient.Do(request))
if err != nil {
return nil, err
}
var bc BuildConfig
if err := decodeJSON(response, &bc); err != nil {
return nil, err
}
return &bc, nil
} | |
c20234 | o.File != nil,
"metadata": o.Metadata,
"build_id": o.BuildID,
"compile_id": o.CompileID,
},
})
} | |
c20235 | := checkResp(c.HTTPClient.Do(request))
if err != nil {
return nil, err
}
var aw artifactWrapper
if err := decodeJSON(response, &aw); err != nil {
return nil, err
}
return aw.Artifact, nil
} | |
c20236 | opts.Name, opts.Type)
request, err := c.Request("GET", endpoint, &RequestOptions{
Params: params,
})
if err != nil {
return nil, err
}
response, err := checkResp(c.HTTPClient.Do(request))
if err != nil {
return nil, err
}
var w artifactSearchWrapper
if err := decodeJSON(response, &w); err != nil {
r... | |
c20237 |
}
response, err := checkResp(c.HTTPClient.Do(request))
if err != nil {
return nil, err
}
var aw artifactWrapper
if err := decodeJSON(response, &aw); err != nil {
return nil, err
}
return aw.Artifact, nil
} | |
c20238 |
u.Path = fmt.Sprintf("/api/v1/artifacts/%s/%s/%s/%d/file",
av.User, av.Name, av.Type, av.Version)
return &u, nil
} | |
c20239 | response, err := checkResp(c.HTTPClient.Do(request))
if err != nil {
return nil, err
}
var av ArtifactVersion
if err := decodeJSON(response, &av); err != nil {
return nil, err
}
if opts.File != nil {
if err := c.putFile(av.UploadPath, opts.File, opts.FileSize); err != nil {
return nil, err
}
}
re... | |
c20240 |
},
})
if err != nil {
return 0, err
}
response, err := checkResp(c.HTTPClient.Do(request))
if err != nil {
return 0, err
}
var result tfConfigVersionCreate
if err := decodeJSON(response, &result); err != nil {
return 0, err
}
if err := c.putFile(result.UploadPath, data, size); err != nil {
retur... | |
c20241 | if err != nil {
return "", err
}
// Make the request
response, err := checkResp(c.HTTPClient.Do(request))
if err != nil {
return "", err
}
// Decode the body
var tResponse struct{ Token string }
if err := decodeJSON(response, &tResponse); err != nil {
return "", nil
}
// Set the token
log.Printf("[... | |
c20242 | {
return err
}
_, err = checkResp(c.HTTPClient.Do(request))
return err
} | |
c20243 | lastDir := dir
dir = filepath.Dir(dir)
if dir == lastDir {
break
}
}
return nil, fmt.Errorf("no VCS found for path: %s", path)
} | |
c20244 |
if vcs.Preflight != nil {
return vcs.Preflight(path)
}
return nil
} | |
c20245 | err)
}
if vcs.Files != nil {
return vcs.Files(path)
}
return nil, nil
} | |
c20246 |
result := make([]string, 0, 100)
scanner := bufio.NewScanner(&stdout)
for scanner.Scan() {
result = append(result, scanner.Text())
}
// Always use *nix-style paths (for Windows)
for idx, value := range result {
result[idx] = filepath.ToSlash(value)
}
return result, nil
}
} | |
c20247 | := make([]string, 0, len(fs))
for _, f := range fs {
if !strings.HasPrefix(f, absPath) {
continue
}
f, err = filepath.Rel(absPath, f)
if err != nil {
return nil, fmt.Errorf(
"error determining path: %s", err)
}
result = append(result, f)
}
return result, nil
}
} | |
c20248 | {
return nil, fmt.Errorf("error detecting VCS: %s", err)
}
if vcs.Metadata != nil {
return vcs.Metadata(path)
}
return nil, nil
} | |
c20249 | nil {
if strings.Contains(stderr.String(), ignorableDetachedHeadError) {
return "", nil
} else {
return "",
fmt.Errorf("error getting git branch: %s\nstdout: %s\nstderr: %s",
err, stdout.String(), stderr.String())
}
}
branch := strings.TrimSpace(stdout.String())
return branch, nil
} | |
c20250 | fmt.Errorf("error getting git commit: %s\nstdout: %s\nstderr: %s",
err, stdout.String(), stderr.String())
}
commit := strings.TrimSpace(stdout.String())
return commit, nil
} | |
c20251 | return nil, fmt.Errorf("invalid response from git remote: %s", stdout.String())
}
remote := fmt.Sprintf("remote.%s", strings.TrimSpace(split[0]))
if _, ok := result[remote]; !ok {
// https://github.com/foo/bar.git (fetch) #=> https://github.com/foo/bar.git
urlSplit := strings.Split(split[1], " ")
resul... | |
c20252 | if err != nil {
log.Printf("[WARN] could not parse version output from Git")
return nil
}
constraint, err := version.NewConstraint("> 1.8")
if err != nil {
log.Printf("[WARN] could not create version constraint to check")
return nil
}
if !constraint.Check(gitv) {
return fmt.Errorf("git version (%s) is ... | |
c20253 | if err != nil {
return nil, err
}
// Make the return result (we already know the size)
result := make(map[string]string, 2+len(remotes))
result["branch"] = branch
result["commit"] = commit
for remote, value := range remotes {
result[remote] = value
}
return result, nil
} | |
c20254 | c.mockers = append(c.mockers, m)
c.Unlock()
} | |
c20255 | _, m := range c.mockers {
m.MinimockFinish()
}
c.Unlock()
} | |
c20256 | for _, m := range c.mockers {
go func(m Mocker) {
defer wg.Done()
m.MinimockWait(d)
}(m)
}
wg.Wait()
} | |
c20257 | } else {
if m != 0 {
b.indent()
b.write(m)
m = 0
w = false
}
b.write(ch)
}
}
if m != 0 {
if !w {
b.indent()
}
b.write(m)
}
return string(b.r)
} | |
c20258 | err != nil {
return err
}
if j != i && ipath == jpath {
return errors.Errorf("duplicate output file name: %s", ipath)
}
}
}
return nil
} | |
c20259 | == b
}
return reflect.DeepEqual(a, b)
} | |
c20260 | difflib.SplitLines(es),
B: difflib.SplitLines(as),
Context: 1,
FromFile: "Expected params",
ToFile: "Actual params",
})
if err != nil {
panic(err)
}
return "\n\nDiff:\n" + diff
} | |
c20261 | actionHandler).Methods("GET", "POST")
r.HandleFunc("/{account}/{queueName}", actionHandler).Methods("GET", "POST")
r.HandleFunc("/SimpleNotificationService/{id}.pem", pemHandler).Methods("GET")
r.HandleFunc("/health", health).Methods("GET")
return r
} | |
c20262 | policies. That feature can be added here
// ref: https://docs.aws.amazon.com/sns/latest/dg/message-filtering.html
if attrValue.DataType != "String" {
return false
}
if !stringInSlice(attrValue.Value, policyAttrValues) {
return false // the attribute value has to be among filtered ones
}
}
return tr... | |
c20263 | if l.callcount > 15 {
l.callcount = 0
return false
}
if l.callcount > 10 {
return true
}
return false
} | |
c20264 | just broke")
}
// You can return additional information pertaining to the check as long
// as it can be JSON marshalled
return map[string]int{"foo": 123, "bar": 456}, nil
} | |
c20265 | diskUsage)
}
if diskUsage >= d.Config.WarningThreshold {
return nil, fmt.Errorf("Warning: disk usage too high %.2f percent", diskUsage)
}
return nil, nil
} | |
c20266 | states: make(map[string]State, 0),
runners: make(map[string]chan struct{}, 0),
active: newBool(),
statesLock: sync.Mutex{},
}
} | |
c20267 | h.configs = append(h.configs, cfg)
return nil
} | |
c20268 | // Reset runner map
h.runners = make(map[string]chan struct{}, 0)
// Reset states
h.safeResetStates()
return nil
} | |
c20269 | val.Fatal && val.isFailure() {
return true
}
}
return false
} | |
c20270 | h.states = make(map[string]State, 0)
} | |
c20271 |
// update states here
h.statesLock.Lock()
defer h.statesLock.Unlock()
h.states[stateEntry.Name] = *stateEntry
} | |
c20272 | statesCopy := make(map[string]State, 0)
for k, v := range h.states {
statesCopy[k] = v
}
return statesCopy
} | |
c20273 |
}
stateEntry.ContiguousFailures = prevState.ContiguousFailures + 1
} else if prevState.isFailure() {
// recovery, previous state was failure
failureSeconds := time.Now().Sub(prevState.TimeOfFirstFailure).Seconds()
if h.StatusListener != nil {
go h.StatusListener.HealthCheckRecovered(stateEntry, prevStat... | |
c20274 |
val, err := r.client.Get(r.Config.Get.Key).Result()
if err != nil {
if err == redis.Nil {
if !r.Config.Get.NoErrorMissingKey {
return nil, fmt.Errorf("Unable to complete get: '%v' not found", r.Config.Get.Key)
}
} else {
return nil, fmt.Errorf("Unable to complete get: %v", err)
}
}
i... | |
c20275 | {
d = cfg.Dialer
}
n := ReachableDefaultNetwork
if cfg.Network != "" {
n = cfg.Network
}
r := &ReachableChecker{
dialer: d,
timeout: t,
network: n,
url: cfg.URL,
datadog: cfg.DatadogClient,
tags: cfg.DatadogTags,
}
return r, nil
} | |
c20276 |
if err != nil {
return r.fail(err)
}
if conn != nil {
if errClose := conn.Close(); errClose != nil {
return r.fail(errClose)
}
}
return nil, nil
} | |
c20277 | return nil, fmt.Errorf("Unable to read response body to perform content expectancy check: %v", err)
}
if !strings.Contains(string(data), h.Config.Expect) {
return nil, fmt.Errorf("Received response body '%v' does not contain expected content '%v'",
string(data), h.Config.Expect)
}
}
return nil, nil
... | |
c20278 | rows.Close()
numRows := 0
for rows.Next() {
numRows++
}
return numRows == 1, nil
} | |
c20279 |
return false, err
}
return affectedRows == int64(1), nil
} | |
c20280 |
if (cfg.Execer != nil || cfg.Queryer != nil) && len(cfg.Query) == 0 {
return fmt.Errorf("SQLConfig.Query is required")
}
return nil
} | |
c20281 | the default
if s.Config.QueryerResultHandler == nil {
s.Config.QueryerResultHandler = DefaultQueryHandler
}
// run the queryer
return s.runQueryer()
// finally, must be a pinger
default:
ctx := context.Background()
return nil, s.Config.Pinger.PingContext(ctx)
}
} | |
c20282 | s.Config.ExecerResultHandler(result)
if err != nil {
return nil, err
}
if !ok {
return nil, fmt.Errorf("userland exec result handler returned false")
}
return nil, nil
} | |
c20283 |
ok, err := s.Config.QueryerResultHandler(rows)
if err != nil {
return nil, err
}
if !ok {
return nil, fmt.Errorf("userland query result handler returned false")
}
return nil, nil
} | |
c20284 | float64) {
svcLogger.Printf("Recovering from %d contiguous errors, lasting %1.2f seconds: %+v", recordedFailures, failureDurationSeconds, entry)
} | |
c20285 | = &sync.Pool{New: func() interface{} {
return &encoder{
e: e,
namespace: make([]byte, 0, 64),
}
}}
return e
} | |
c20286 | val.Type() != timeType {
enc.traverseStruct(val, enc.namespace[0:0], -1)
} else {
enc.setFieldByType(val, enc.namespace[0:0], -1, false)
}
if len(enc.errs) > 0 {
err = enc.errs
enc.errs = nil
}
values = enc.values
e.dataPool.Put(enc)
return
} | |
c20287 | = &sync.Pool{New: func() interface{} {
return &decoder{
d: d,
namespace: make([]byte, 0, 64),
}
}}
return d
} | |
c20288 | {
return current, reflect.Interface
}
return ExtractType(current.Elem())
default:
return current, current.Kind()
}
} | |
c20289 | return field.IsValid() && field.Interface() != reflect.Zero(field.Type()).Interface()
}
} | |
c20290 | DefaultOptions
compiler.mixins = make(map[string]*parser.Mixin)
return compiler
} | |
c20291 | {
t, err := Compile(input, options)
if err != nil {
panic(err)
}
return t
} | |
c20292 | := CompileFile(filename, options)
if err != nil {
panic(err)
}
return t
} | |
c20293 | := CompileDir(dirname, dopt, opt)
if err != nil {
panic(err)
}
return m
} | |
c20294 |
parser.SetVirtualFilesystem(c.VirtualFilesystem)
}
if err != nil {
return
}
c.node = parser.Parse()
return
} | |
c20295 | parser.FileParser(filename)
if err != nil && c.VirtualFilesystem != nil {
p, err = parser.VirtualFileParser(filename, c.VirtualFilesystem)
}
if err != nil {
return
}
c.node = p.Parse()
c.filename = filename
return
} | |
c20296 | c.CompileWithTemplate(template.New(name))
} | |
c20297 | := t.Funcs(FuncMap).Parse(data)
if err != nil {
return nil, err
}
return tpl, nil
} | |
c20298 |
}
if tok := s.scanMixinCall(); tok != nil {
return tok
}
if tok := s.scanDoctype(); tok != nil {
return tok
}
if tok := s.scanCondition(); tok != nil {
return tok
}
if tok := s.scanEach(); tok != nil {
return tok
}
if tok := s.scanImport(); tok != nil {
return tok
}
if tok ... | |
c20299 | protocols, DEC RT-11, Windows, CP/M, MS-DOS, OS/2, Symbian OS
if len(buf) > 0 && buf[len(buf)-1] == '\r' {
buf = buf[:len(buf)-1]
}
s.state = scnNewLine
s.buffer = buf
s.line += 1
s.col = 0
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.