id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c11900 |
return nil, err
}
return NewWithClientSentryHook(client, levels)
} | |
c11901 | if err != nil {
return nil, err
}
return NewWithClientSentryHook(client, levels)
} | |
c11902 | },
client: client,
levels: levels,
ignoreFields: make(map[string]struct{}),
extraFilters: make(map[string]func(interface{}) interface{}),
}, nil
} | |
c11903 | err := NewSentryHook(DSN, levels)
return setAsync(hook), err
} | |
c11904 | (*SentryHook, error) {
hook, err := NewWithTagsSentryHook(DSN, tags, levels)
return setAsync(hook), err
} | |
c11905 | (*SentryHook, error) {
hook, err := NewWithClientSentryHook(client, levels)
return setAsync(hook), err
} | |
c11906 | until the flush completes
defer hook.mu.Unlock()
hook.wg.Wait()
} | |
c11907 | interface{}) {
hook.extraFilters[name] = fn
} | |
c11908 | hook.errorHandlers = append(hook.errorHandlers, fn)
} | |
c11909 | return value.Error()
case fmt.Stringer:
return value.String()
default:
return value
}
} | |
c11910 |
return nil, fmt.Errorf("error resolving symbol %q: %v", symbol, errors.New(C.GoString(e)))
}
return p, nil
} | |
c11911 | fmt.Errorf("error closing %v: %v", l.Libname, errors.New(C.GoString(e)))
}
return nil
} | |
c11912 | "",
Path: "/",
MaxAge: -1,
Expires: time.Time{},
}
http.SetCookie(w, c)
}
} | |
c11913 | prefix here
prefix: prefix, // save it instead
}
} | |
c11914 | prefix := lf.prefix
if pkg != "" {
prefix = fmt.Sprintf("%s%s: ", prefix, pkg)
}
lf.logger.Output(5, fmt.Sprintf("%s%v", prefix, str)) // call depth is 5
} | |
c11915 | _ ...interface{}) {
// noop
} | |
c11916 |
case DEBUG:
return "D"
case TRACE:
return "T"
default:
panic("Unhandled loglevel")
}
} | |
c11917 | return err
}
*l = value
return nil
} | |
c11918 |
return INFO, nil
case "DEBUG", "4", "D":
return DEBUG, nil
case "TRACE", "5", "T":
return TRACE, nil
}
return CRITICAL, errors.New("couldn't parse log level " + s)
} | |
c11919 | logger.Unlock()
for _, r := range logger.repoMap {
r.setRepoLogLevelInternal(l)
}
} | |
c11920 |
return nil, errors.New("no packages registered for repo " + repo)
}
return r, nil
} | |
c11921 | if err != nil {
panic(err)
}
return r
} | |
c11922 | defer logger.Unlock()
r.setRepoLogLevelInternal(l)
} | |
c11923 | nil, errors.New("oddly structured `pkg=level` option: " + setstring)
}
l, err := ParseLevel(setting[1])
if err != nil {
return nil, err
}
out[setting[0]] = l
}
return out, nil
} | |
c11924 | logger.Unlock()
logger.formatter = f
} | |
c11925 | r = logger.repoMap[repo]
}
p, pok := r[pkg]
if !pok {
r[pkg] = &PackageLogger{
pkg: pkg,
level: INFO,
}
p = r[pkg]
}
return
} | |
c11926 | make(chan struct{}),
pbp: &ProgressBarPrinter{PadToBeEven: true},
}
} | |
c11927 | cpp.pbp.AddProgressBar(),
}
cr.pb.SetPrintBefore(name)
cr.pb.SetPrintAfter(cr.formattedProgress())
cpp.readers = append(cpp.readers, cr)
go func() {
_, err := io.Copy(dest, cr)
select {
case <-cpp.cancel:
return
case cpp.results <- err:
return
}
}()
return nil
} | |
c11928 |
allDone := false
for i := 0; i < n; {
select {
case <-cancel:
return nil
case <-t.C:
_, err := cpp.pbp.Print(printTo)
if err != nil {
return err
}
case err := <-cpp.results:
i++
// Once completion is signaled, further on this just drains
// (unlikely) errors from the channel.
if e... | |
c11929 | break
}
size = size / 1000
}
return fmt.Sprintf("%.3g %s", size, unit)
} | |
c11930 | uv.Add(k, v)
}
}
u.RawQuery = uv.Encode()
return u
} | |
c11931 | return err
}
fs.VisitAll(func(f *flag.Flag) {
if !alreadySet[f.Name] {
key := prefix + "_" + strings.ToUpper(strings.Replace(f.Name, "-", "_", -1))
val := envs[key]
if val != "" {
if serr := fs.Set(f.Name, val); serr != nil {
err = fmt.Errorf("invalid value %q for %s: %v", val, key, serr)
}
... | |
c11932 | defer logger.Unlock()
p.level = l
} | |
c11933 | defer logger.Unlock()
return p.level >= l
} | |
c11934 | p.internalLog(calldepth, l, fmt.Sprintf(format, args...))
} | |
c11935 | p.internalLog(calldepth, l, fmt.Sprint(args...))
} | |
c11936 | p.internalLog(calldepth, INFO, fmt.Sprintln(args...))
} | |
c11937 | {
s := fmt.Sprintf(format, args...)
p.internalLog(calldepth, CRITICAL, s)
panic(s)
} | |
c11938 | }
pb.lock.Lock()
pb.currentProgress = progress
pb.lock.Unlock()
return nil
} | |
c11939 |
pb.lock.Unlock()
return val
} | |
c11940 | := pb.printBefore
pb.lock.Unlock()
return val
} | |
c11941 | pb.printBefore = before
pb.lock.Unlock()
} | |
c11942 | := pb.printAfter
pb.lock.Unlock()
return val
} | |
c11943 | pb.printAfter = after
pb.lock.Unlock()
} | |
c11944 | = append(pbp.progressBars, pb)
pbp.lock.Unlock()
return pb
} | |
c11945 | for _, bar := range bars {
beforeSize := len(bar.GetPrintBefore())
afterSize := len(bar.GetPrintAfter())
if beforeSize > pbp.maxBefore {
pbp.maxBefore = beforeSize
}
if afterSize > pbp.maxAfter {
pbp.maxAfter = afterSize
}
}
allDone := true
for _, bar := range bars {
if pbp.isTerminal(printTo) ... | |
c11946 | fmt.Fprintf(printTo, "\033[%dA", numLines)
}
} | |
c11947 |
return true
}
if f, ok := w.(*os.File); ok {
return terminal.IsTerminal(int(f.Fd()))
}
return false
} | |
c11948 | nil {
return nil, err
}
return NewStandardConfigManager(store)
} | |
c11949 | nil {
return nil, err
}
return NewStandardConfigManager(store)
} | |
c11950 | != nil {
return nil, err
}
return NewConfigManager(store, keystore)
} | |
c11951 | != nil {
return nil, err
}
return NewConfigManager(store, keystore)
} | |
c11952 | nil, err
}
return secconf.Decode(value, bytes.NewBuffer(c.keystore))
} | |
c11953 | != nil {
return nil, err
}
return value, err
} | |
c11954 |
retList[i].Value, err = secconf.Decode(kv.Value, bytes.NewBuffer(c.keystore))
if err != nil {
return nil, err
}
}
return retList, nil
} | |
c11955 | := range list {
retList[i].Key = kv.Key
retList[i].Value = kv.Value
}
return retList, err
} | |
c11956 | {
return nil, err
}
gzReader, err := gzip.NewReader(md.UnverifiedBody)
if err != nil {
return nil, err
}
defer gzReader.Close()
bytes, err := ioutil.ReadAll(gzReader)
if err != nil {
return nil, err
}
return bytes, nil
} | |
c11957 |
}
if err := gzWriter.Close(); err != nil {
return nil, err
}
if err := pgpWriter.Close(); err != nil {
return nil, err
}
if err := encoder.Close(); err != nil {
return nil, err
}
return buffer.Bytes(), nil
} | |
c11958 | range fields {
if forceField, ok := mapping[field]; ok {
forceFields = append(forceFields, forceField)
}
}
return strings.Join(forceFields, ",")
}
}
return ""
} | |
c11959 |
}
if jName == "" {
jName = sf.Name
}
if fName == "" {
fName = sf.Name
}
jsonToForce[jName] = fName
}
for k, v := range baseFieldNameMap {
jsonToForce[k] = v
}
return jsonToForce
} | |
c11960 | forceApi.apiResources[queryKey]
params := url.Values{
"q": {query},
}
err = forceApi.Get(uri, params, out)
return
} | |
c11961 | forceApi.apiResources[queryAllKey]
params := url.Values{
"q": {query},
}
err = forceApi.Get(uri, params, out)
return
} | |
c11962 | scanEnd {
switch v {
case scanError:
return nil, nil, scan.err
case scanEnd:
return data[0:i], data[i:], nil
}
}
}
if scan.eof() == scanError {
return nil, nil, scan.err
}
return data, nil, nil
} | |
c11963 | forceApi.request("DELETE", path, params, nil, nil)
} | |
c11964 | == nil {
d.savedError = err
}
} | |
c11965 | MODIFIED: %s ETAG: %s CTYPE: %s", f.path, f.size, f.modified.String(), f.etag, f.contentType)
} | |
c11966 |
s[i] = url.PathEscape(e)
}
return strings.Join(s, "/")
} | |
c11967 | strings.TrimSuffix(path0, "/") + "/" + strings.TrimPrefix(path1, "/")
} | |
c11968 |
_, _ = buf.ReadFrom(r)
return buf.String()
} | |
c11969 | &Client{FixSlash(uri), make(http.Header), &http.Client{}, &NoAuth{user, pw}}
} | |
c11970 | http.RoundTripper) {
c.c.Transport = transport
} | |
c11971 | 200 {
return newPathError("Connect", c.root, rs.StatusCode)
}
return nil
} | |
c11972 |
} else {
f.size = parseInt64(&p.Size)
f.isdir = false
}
files = append(files, *f)
}
r.Props = nil
return nil
}
err := c.propfind(path, false,
`<d:propfind xmlns:d='DAV:'>
<d:prop>
<d:displayname/>
<d:resourcetype/>
<d:getcontentlength/>
<d:getcontenttype/>
<d:geteta... | |
c11973 |
<d:prop>
<d:displayname/>
<d:resourcetype/>
<d:getcontentlength/>
<d:getcontenttype/>
<d:getetag/>
<d:getlastmodified/>
</d:prop>
</d:propfind>`,
&response{},
parse)
if err != nil {
if _, ok := err.(*os.PathError); !ok {
err = newPathErrorErr("ReadDir", path, err)
}
}
ret... | |
c11974 | }
if rs.StatusCode == 200 || rs.StatusCode == 204 || rs.StatusCode == 404 {
return nil
}
return newPathError("Remove", path, rs.StatusCode)
} | |
c11975 | {
return nil
}
return newPathError("Mkdir", path, status)
} | |
c11976 | += e + "/"
status = c.mkcol(sub)
if status != 201 {
return newPathError("MkdirAll", sub, status)
}
}
return nil
}
return newPathError("MkdirAll", path, status)
} | |
c11977 | return c.copymove("MOVE", oldpath, newpath, overwrite)
} | |
c11978 | new(bytes.Buffer)
_, err = buf.ReadFrom(stream)
if err != nil {
return nil, err
}
return buf.Bytes(), nil
} | |
c11979 | newPathErrorErr("ReadStream", path, err)
}
if rs.StatusCode == 200 {
return rs.Body, nil
}
rs.Body.Close()
return nil, newPathError("ReadStream", path, rs.StatusCode)
} | |
c11980 | return err
}
s = c.put(path, bytes.NewReader(data))
if s == 200 || s == 201 || s == 204 {
return nil
}
}
return newPathError("Write", path, s)
} | |
c11981 |
switch s {
case 200, 201, 204:
return nil
default:
return newPathError("WriteStream", path, s)
}
} | |
c11982 | return
}
for i := range cases {
cases[i].Send = data
}
reflect.Select(cases)
}
} | |
c11983 |
for len(cases) > 0 {
idx, val, ok := reflect.Select(cases)
if !ok {
cases = removeCase(idx, cases)
continue
}
outChan.Send(val)
}
} | |
c11984 | removeCase(idx, inCases)
continue
}
for i := range outCases {
outCases[i].Send = val
}
reflect.Select(outCases)
}
} | |
c11985 | return err
}
defer pidFile.Close()
_, err = pidFile.WriteString(pidString)
return err
} | |
c11986 | ioutil.WriteFile(filename, []byte(pidString), 0644)
} | |
c11987 | if pid, err = strconv.Atoi(string(pidString)); err != nil {
return InvalidPID, fmt.Errorf("Could not read pid from pidfile %s: %s", filename, err)
}
return pid, nil
} | |
c11988 |
// FindProcess always returns a proc on unix
if proc, err = os.FindProcess(pid); err != nil {
return nil, err
}
// Try to signal the process to check if it is running
if err = proc.Signal(syscall.Signal(0)); err != nil {
return nil, err
}
return proc, nil
} | |
c11989 | files[b] = files[b], files[a]
} | |
c11990 | return false
}
return stat.IsDir()
} | |
c11991 | for i := 0; i < maxIdx; i++ {
if parts1[i] == parts2[i] {
common = append(common, parts1[i])
}
}
return strings.Join(common, "/")
} | |
c11992 | 0, err
}
return crc32.ChecksumIEEE(data), nil
} | |
c11993 |
return &StopListener{
TCPListener: listen.(*net.TCPListener),
active: true,
}, nil
} | |
c11994 |
return nil, StopRequestError{} // ### return, stop requested ###
}
if err != nil {
return nil, err // ### return, error ###
}
return conn, err
} | |
c11995 | false
return listen.TCPListener.Close()
} | |
c11996 | = GetGid(grp); err != nil {
return err
}
return Chown(filePath, uid, gid)
} | |
c11997 | return err
}
}
}
if stat.Mode()&os.ModeSymlink != 0 {
// TODO: os.Chown fails on symlinks
return nil
}
return os.Chown(filePath, uid, gid)
} | |
c11998 | return err
}
}
// Set executable rights for folders if read or write is allowed
execRights := 0
if mode&0600 != 0 {
execRights |= 0100
}
if mode&0060 != 0 {
execRights |= 0010
}
if mode&0006 != 0 {
execRights |= 0001
}
return os.Chmod(filePath, mode|os.FileMode(execRights))
}
if... | |
c11999 | false, err
}
return fileStat.Mode()&os.ModeSymlink != 0, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.