_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q11900 | NewSentryHook | train | func NewSentryHook(DSN string, levels []logrus.Level) (*SentryHook, error) {
client, err := raven.New(DSN)
if err != nil {
return nil, err
}
return NewWithClientSentryHook(client, levels)
} | go | {
"resource": ""
} |
q11901 | NewWithTagsSentryHook | train | func NewWithTagsSentryHook(DSN string, tags map[string]string, levels []logrus.Level) (*SentryHook, error) {
client, err := raven.NewWithTags(DSN, tags)
if err != nil {
return nil, err
}
return NewWithClientSentryHook(client, levels)
} | go | {
"resource": ""
} |
q11902 | NewWithClientSentryHook | train | func NewWithClientSentryHook(client *raven.Client, levels []logrus.Level) (*SentryHook, error) {
return &SentryHook{
Timeout: 100 * time.Millisecond,
StacktraceConfiguration: StackTraceConfiguration{
Enable: false,
Level: logrus.ErrorLevel,
Skip: 6,
Context: 0,
InAppPrefixes: nil,
SendExceptionType: true,
},
client: client,
levels: levels,
ignoreFields: make(map[string]struct{}),
extraFilters: make(map[string]func(interface{}) interface{}),
}, nil
} | go | {
"resource": ""
} |
q11903 | NewAsyncSentryHook | train | func NewAsyncSentryHook(DSN string, levels []logrus.Level) (*SentryHook, error) {
hook, err := NewSentryHook(DSN, levels)
return setAsync(hook), err
} | go | {
"resource": ""
} |
q11904 | NewAsyncWithTagsSentryHook | train | func NewAsyncWithTagsSentryHook(DSN string, tags map[string]string, levels []logrus.Level) (*SentryHook, error) {
hook, err := NewWithTagsSentryHook(DSN, tags, levels)
return setAsync(hook), err
} | go | {
"resource": ""
} |
q11905 | NewAsyncWithClientSentryHook | train | func NewAsyncWithClientSentryHook(client *raven.Client, levels []logrus.Level) (*SentryHook, error) {
hook, err := NewWithClientSentryHook(client, levels)
return setAsync(hook), err
} | go | {
"resource": ""
} |
q11906 | Flush | train | func (hook *SentryHook) Flush() {
if !hook.asynchronous {
return
}
hook.mu.Lock() // Claim exclusive access; any logging goroutines will block until the flush completes
defer hook.mu.Unlock()
hook.wg.Wait()
} | go | {
"resource": ""
} |
q11907 | AddExtraFilter | train | func (hook *SentryHook) AddExtraFilter(name string, fn func(interface{}) interface{}) {
hook.extraFilters[name] = fn
} | go | {
"resource": ""
} |
q11908 | AddErrorHandler | train | func (hook *SentryHook) AddErrorHandler(fn func(entry *logrus.Entry, err error)) {
hook.errorHandlers = append(hook.errorHandlers, fn)
} | go | {
"resource": ""
} |
q11909 | formatData | train | func formatData(value interface{}) (formatted interface{}) {
switch value := value.(type) {
case json.Marshaler:
return value
case error:
return value.Error()
case fmt.Stringer:
return value.String()
default:
return value
}
} | go | {
"resource": ""
} |
q11910 | GetSymbolPointer | train | func (l *LibHandle) GetSymbolPointer(symbol string) (unsafe.Pointer, error) {
sym := C.CString(symbol)
defer C.free(unsafe.Pointer(sym))
C.dlerror()
p := C.dlsym(l.Handle, sym)
e := C.dlerror()
if e != nil {
return nil, fmt.Errorf("error resolving symbol %q: %v", symbol, errors.New(C.GoString(e)))
}
return p, nil
} | go | {
"resource": ""
} |
q11911 | Close | train | func (l *LibHandle) Close() error {
C.dlerror()
C.dlclose(l.Handle)
e := C.dlerror()
if e != nil {
return fmt.Errorf("error closing %v: %v", l.Libname, errors.New(C.GoString(e)))
}
return nil
} | go | {
"resource": ""
} |
q11912 | DeleteCookies | train | func DeleteCookies(w http.ResponseWriter, cookieNames ...string) {
for _, n := range cookieNames {
c := &http.Cookie{
Name: n,
Value: "",
Path: "/",
MaxAge: -1,
Expires: time.Time{},
}
http.SetCookie(w, c)
}
} | go | {
"resource": ""
} |
q11913 | NewLogFormatter | train | func NewLogFormatter(w io.Writer, prefix string, flag int) Formatter {
return &LogFormatter{
logger: log.New(w, "", flag), // don't use prefix here
prefix: prefix, // save it instead
}
} | go | {
"resource": ""
} |
q11914 | Format | train | func (lf *LogFormatter) Format(pkg string, _ LogLevel, _ int, entries ...interface{}) {
str := fmt.Sprint(entries...)
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
} | go | {
"resource": ""
} |
q11915 | Format | train | func (_ *NilFormatter) Format(_ string, _ LogLevel, _ int, _ ...interface{}) {
// noop
} | go | {
"resource": ""
} |
q11916 | Char | train | func (l LogLevel) Char() string {
switch l {
case CRITICAL:
return "C"
case ERROR:
return "E"
case WARNING:
return "W"
case NOTICE:
return "N"
case INFO:
return "I"
case DEBUG:
return "D"
case TRACE:
return "T"
default:
panic("Unhandled loglevel")
}
} | go | {
"resource": ""
} |
q11917 | Set | train | func (l *LogLevel) Set(s string) error {
value, err := ParseLevel(s)
if err != nil {
return err
}
*l = value
return nil
} | go | {
"resource": ""
} |
q11918 | ParseLevel | train | func ParseLevel(s string) (LogLevel, error) {
switch s {
case "CRITICAL", "C":
return CRITICAL, nil
case "ERROR", "0", "E":
return ERROR, nil
case "WARNING", "1", "W":
return WARNING, nil
case "NOTICE", "2", "N":
return NOTICE, nil
case "INFO", "3", "I":
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)
} | go | {
"resource": ""
} |
q11919 | SetGlobalLogLevel | train | func SetGlobalLogLevel(l LogLevel) {
logger.Lock()
defer logger.Unlock()
for _, r := range logger.repoMap {
r.setRepoLogLevelInternal(l)
}
} | go | {
"resource": ""
} |
q11920 | GetRepoLogger | train | func GetRepoLogger(repo string) (RepoLogger, error) {
logger.Lock()
defer logger.Unlock()
r, ok := logger.repoMap[repo]
if !ok {
return nil, errors.New("no packages registered for repo " + repo)
}
return r, nil
} | go | {
"resource": ""
} |
q11921 | MustRepoLogger | train | func MustRepoLogger(repo string) RepoLogger {
r, err := GetRepoLogger(repo)
if err != nil {
panic(err)
}
return r
} | go | {
"resource": ""
} |
q11922 | SetRepoLogLevel | train | func (r RepoLogger) SetRepoLogLevel(l LogLevel) {
logger.Lock()
defer logger.Unlock()
r.setRepoLogLevelInternal(l)
} | go | {
"resource": ""
} |
q11923 | ParseLogLevelConfig | train | func (r RepoLogger) ParseLogLevelConfig(conf string) (map[string]LogLevel, error) {
setlist := strings.Split(conf, ",")
out := make(map[string]LogLevel)
for _, setstring := range setlist {
setting := strings.Split(setstring, "=")
if len(setting) != 2 {
return 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
} | go | {
"resource": ""
} |
q11924 | SetFormatter | train | func SetFormatter(f Formatter) {
logger.Lock()
defer logger.Unlock()
logger.formatter = f
} | go | {
"resource": ""
} |
q11925 | NewPackageLogger | train | func NewPackageLogger(repo string, pkg string) (p *PackageLogger) {
logger.Lock()
defer logger.Unlock()
if logger.repoMap == nil {
logger.repoMap = make(map[string]RepoLogger)
}
r, rok := logger.repoMap[repo]
if !rok {
logger.repoMap[repo] = make(RepoLogger)
r = logger.repoMap[repo]
}
p, pok := r[pkg]
if !pok {
r[pkg] = &PackageLogger{
pkg: pkg,
level: INFO,
}
p = r[pkg]
}
return
} | go | {
"resource": ""
} |
q11926 | NewCopyProgressPrinter | train | func NewCopyProgressPrinter() *CopyProgressPrinter {
return &CopyProgressPrinter{
results: make(chan error),
cancel: make(chan struct{}),
pbp: &ProgressBarPrinter{PadToBeEven: true},
}
} | go | {
"resource": ""
} |
q11927 | AddCopy | train | func (cpp *CopyProgressPrinter) AddCopy(reader io.Reader, name string, size int64, dest io.Writer) error {
cpp.lock.Lock()
defer cpp.lock.Unlock()
if cpp.started {
return ErrAlreadyStarted
}
cr := ©Reader{
reader: reader,
current: 0,
total: size,
pb: 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
} | go | {
"resource": ""
} |
q11928 | PrintAndWait | train | func (cpp *CopyProgressPrinter) PrintAndWait(printTo io.Writer, printInterval time.Duration, cancel chan struct{}) error {
cpp.lock.Lock()
if cpp.started {
cpp.lock.Unlock()
return ErrAlreadyStarted
}
cpp.started = true
cpp.lock.Unlock()
n := len(cpp.readers)
if n == 0 {
// Nothing to do.
return nil
}
defer close(cpp.cancel)
t := time.NewTicker(printInterval)
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 err == nil && !allDone {
allDone, err = cpp.pbp.Print(printTo)
}
if err != nil {
return err
}
}
}
return nil
} | go | {
"resource": ""
} |
q11929 | ByteUnitStr | train | func ByteUnitStr(n int64) string {
var unit string
size := float64(n)
for i := 1; i < len(byteUnits); i++ {
if size < 1000 {
unit = byteUnits[i-1]
break
}
size = size / 1000
}
return fmt.Sprintf("%.3g %s", size, unit)
} | go | {
"resource": ""
} |
q11930 | MergeQuery | train | func MergeQuery(u url.URL, q url.Values) url.URL {
uv := u.Query()
for k, vs := range q {
for _, v := range vs {
uv.Add(k, v)
}
}
u.RawQuery = uv.Encode()
return u
} | go | {
"resource": ""
} |
q11931 | SetFlagsFromEnvFile | train | func SetFlagsFromEnvFile(fs *flag.FlagSet, prefix string, path string) (err error) {
alreadySet := make(map[string]bool)
fs.Visit(func(f *flag.Flag) {
alreadySet[f.Name] = true
})
envs, err := parseEnvFile(path)
if err != nil {
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)
}
}
}
})
return err
} | go | {
"resource": ""
} |
q11932 | SetLevel | train | func (p *PackageLogger) SetLevel(l LogLevel) {
logger.Lock()
defer logger.Unlock()
p.level = l
} | go | {
"resource": ""
} |
q11933 | LevelAt | train | func (p *PackageLogger) LevelAt(l LogLevel) bool {
logger.Lock()
defer logger.Unlock()
return p.level >= l
} | go | {
"resource": ""
} |
q11934 | Logf | train | func (p *PackageLogger) Logf(l LogLevel, format string, args ...interface{}) {
p.internalLog(calldepth, l, fmt.Sprintf(format, args...))
} | go | {
"resource": ""
} |
q11935 | Log | train | func (p *PackageLogger) Log(l LogLevel, args ...interface{}) {
p.internalLog(calldepth, l, fmt.Sprint(args...))
} | go | {
"resource": ""
} |
q11936 | Println | train | func (p *PackageLogger) Println(args ...interface{}) {
p.internalLog(calldepth, INFO, fmt.Sprintln(args...))
} | go | {
"resource": ""
} |
q11937 | Panicf | train | func (p *PackageLogger) Panicf(format string, args ...interface{}) {
s := fmt.Sprintf(format, args...)
p.internalLog(calldepth, CRITICAL, s)
panic(s)
} | go | {
"resource": ""
} |
q11938 | SetCurrentProgress | train | func (pb *ProgressBar) SetCurrentProgress(progress float64) error {
if progress < 0 || progress > 1 {
return ErrorProgressOutOfBounds
}
pb.lock.Lock()
pb.currentProgress = progress
pb.lock.Unlock()
return nil
} | go | {
"resource": ""
} |
q11939 | GetDone | train | func (pb *ProgressBar) GetDone() bool {
pb.lock.Lock()
val := pb.done
pb.lock.Unlock()
return val
} | go | {
"resource": ""
} |
q11940 | GetPrintBefore | train | func (pb *ProgressBar) GetPrintBefore() string {
pb.lock.Lock()
val := pb.printBefore
pb.lock.Unlock()
return val
} | go | {
"resource": ""
} |
q11941 | SetPrintBefore | train | func (pb *ProgressBar) SetPrintBefore(before string) {
pb.lock.Lock()
pb.printBefore = before
pb.lock.Unlock()
} | go | {
"resource": ""
} |
q11942 | GetPrintAfter | train | func (pb *ProgressBar) GetPrintAfter() string {
pb.lock.Lock()
val := pb.printAfter
pb.lock.Unlock()
return val
} | go | {
"resource": ""
} |
q11943 | SetPrintAfter | train | func (pb *ProgressBar) SetPrintAfter(after string) {
pb.lock.Lock()
pb.printAfter = after
pb.lock.Unlock()
} | go | {
"resource": ""
} |
q11944 | AddProgressBar | train | func (pbp *ProgressBarPrinter) AddProgressBar() *ProgressBar {
pb := &ProgressBar{}
pbp.lock.Lock()
pbp.progressBars = append(pbp.progressBars, pb)
pbp.lock.Unlock()
return pb
} | go | {
"resource": ""
} |
q11945 | Print | train | func (pbp *ProgressBarPrinter) Print(printTo io.Writer) (bool, error) {
pbp.lock.Lock()
var bars []*ProgressBar
for _, bar := range pbp.progressBars {
bars = append(bars, bar.clone())
}
numColumns := pbp.DisplayWidth
pbp.lock.Unlock()
if len(bars) == 0 {
return false, ErrorNoBarsAdded
}
if numColumns == 0 {
numColumns = 80
}
if pbp.isTerminal(printTo) {
moveCursorUp(printTo, pbp.numLinesInLastPrint)
}
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) {
bar.printToTerminal(printTo, numColumns, pbp.PadToBeEven, pbp.maxBefore, pbp.maxAfter)
} else {
bar.printToNonTerminal(printTo)
}
allDone = allDone && bar.GetCurrentProgress() == 1
}
pbp.numLinesInLastPrint = len(bars)
return allDone, nil
} | go | {
"resource": ""
} |
q11946 | moveCursorUp | train | func moveCursorUp(printTo io.Writer, numLines int) {
if numLines > 0 {
fmt.Fprintf(printTo, "\033[%dA", numLines)
}
} | go | {
"resource": ""
} |
q11947 | isTerminal | train | func (pbp *ProgressBarPrinter) isTerminal(w io.Writer) bool {
if pbp.printToTTYAlways {
return true
}
if f, ok := w.(*os.File); ok {
return terminal.IsTerminal(int(f.Fd()))
}
return false
} | go | {
"resource": ""
} |
q11948 | NewStandardEtcdConfigManager | train | func NewStandardEtcdConfigManager(machines []string) (ConfigManager, error) {
store, err := etcd.New(machines)
if err != nil {
return nil, err
}
return NewStandardConfigManager(store)
} | go | {
"resource": ""
} |
q11949 | NewStandardConsulConfigManager | train | func NewStandardConsulConfigManager(machines []string) (ConfigManager, error) {
store, err := consul.New(machines)
if err != nil {
return nil, err
}
return NewStandardConfigManager(store)
} | go | {
"resource": ""
} |
q11950 | NewEtcdConfigManager | train | func NewEtcdConfigManager(machines []string, keystore io.Reader) (ConfigManager, error) {
store, err := etcd.New(machines)
if err != nil {
return nil, err
}
return NewConfigManager(store, keystore)
} | go | {
"resource": ""
} |
q11951 | NewConsulConfigManager | train | func NewConsulConfigManager(machines []string, keystore io.Reader) (ConfigManager, error) {
store, err := consul.New(machines)
if err != nil {
return nil, err
}
return NewConfigManager(store, keystore)
} | go | {
"resource": ""
} |
q11952 | Get | train | func (c configManager) Get(key string) ([]byte, error) {
value, err := c.store.Get(key)
if err != nil {
return nil, err
}
return secconf.Decode(value, bytes.NewBuffer(c.keystore))
} | go | {
"resource": ""
} |
q11953 | Get | train | func (c standardConfigManager) Get(key string) ([]byte, error) {
value, err := c.store.Get(key)
if err != nil {
return nil, err
}
return value, err
} | go | {
"resource": ""
} |
q11954 | List | train | func (c configManager) List(key string) (KVPairs, error) {
list, err := c.store.List(key)
retList := make(KVPairs, len(list))
if err != nil {
return nil, err
}
for i, kv := range list {
retList[i].Key = kv.Key
retList[i].Value, err = secconf.Decode(kv.Value, bytes.NewBuffer(c.keystore))
if err != nil {
return nil, err
}
}
return retList, nil
} | go | {
"resource": ""
} |
q11955 | List | train | func (c standardConfigManager) List(key string) (KVPairs, error) {
list, err := c.store.List(key)
retList := make(KVPairs, len(list))
if err != nil {
return nil, err
}
for i, kv := range list {
retList[i].Key = kv.Key
retList[i].Value = kv.Value
}
return retList, err
} | go | {
"resource": ""
} |
q11956 | Decode | train | func Decode(data []byte, secertKeyring io.Reader) ([]byte, error) {
decoder := base64.NewDecoder(base64.StdEncoding, bytes.NewBuffer(data))
entityList, err := openpgp.ReadArmoredKeyRing(secertKeyring)
if err != nil {
return nil, err
}
md, err := openpgp.ReadMessage(decoder, entityList, nil, nil)
if err != nil {
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
} | go | {
"resource": ""
} |
q11957 | Encode | train | func Encode(data []byte, keyring io.Reader) ([]byte, error) {
entityList, err := openpgp.ReadArmoredKeyRing(keyring)
if err != nil {
return nil, err
}
buffer := new(bytes.Buffer)
encoder := base64.NewEncoder(base64.StdEncoding, buffer)
pgpWriter, err := openpgp.Encrypt(encoder, entityList, nil, nil, nil)
if err != nil {
return nil, err
}
gzWriter := gzip.NewWriter(pgpWriter)
if _, err := gzWriter.Write(data); err != nil {
return nil, err
}
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
} | go | {
"resource": ""
} |
q11958 | ConvertFieldNames | train | func ConvertFieldNames(obj interface{}, jsonFields string) string {
if jsonFields != "" {
fields := strings.Split(jsonFields, ",")
length := len(fields)
if length > 0 {
mapping := fieldNameMapping(obj)
var forceFields []string
for _, field := range fields {
if forceField, ok := mapping[field]; ok {
forceFields = append(forceFields, forceField)
}
}
return strings.Join(forceFields, ",")
}
}
return ""
} | go | {
"resource": ""
} |
q11959 | fieldNameMapping | train | func fieldNameMapping(obj interface{}) map[string]string {
st := reflect.TypeOf(obj)
fl := st.NumField()
jsonToForce := make(map[string]string, fl)
for i := 0; i < fl; i++ {
sf := st.Field(i)
jName := strings.SplitN(sf.Tag.Get("json"), ",", 2)[0]
fName := strings.SplitN(sf.Tag.Get("force"), ",", 2)[0]
if jName == "-" {
continue
}
if fName == "-" {
continue
}
if jName == "" {
jName = sf.Name
}
if fName == "" {
fName = sf.Name
}
jsonToForce[jName] = fName
}
for k, v := range baseFieldNameMap {
jsonToForce[k] = v
}
return jsonToForce
} | go | {
"resource": ""
} |
q11960 | Query | train | func (forceApi *ForceApi) Query(query string, out interface{}) (err error) {
uri := forceApi.apiResources[queryKey]
params := url.Values{
"q": {query},
}
err = forceApi.Get(uri, params, out)
return
} | go | {
"resource": ""
} |
q11961 | QueryAll | train | func (forceApi *ForceApi) QueryAll(query string, out interface{}) (err error) {
uri := forceApi.apiResources[queryAllKey]
params := url.Values{
"q": {query},
}
err = forceApi.Get(uri, params, out)
return
} | go | {
"resource": ""
} |
q11962 | nextValue | train | func nextValue(data []byte, scan *scanner) (value, rest []byte, err error) {
scan.reset()
for i, c := range data {
v := scan.step(scan, int(c))
if v >= 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
} | go | {
"resource": ""
} |
q11963 | Delete | train | func (forceApi *ForceApi) Delete(path string, params url.Values) error {
return forceApi.request("DELETE", path, params, nil, nil)
} | go | {
"resource": ""
} |
q11964 | saveError | train | func (d *decodeState) saveError(err error) {
if d.savedError == nil {
d.savedError = err
}
} | go | {
"resource": ""
} |
q11965 | String | train | func (f File) String() string {
if f.isdir {
return fmt.Sprintf("Dir : '%s' - '%s'", f.path, f.name)
}
return fmt.Sprintf("File: '%s' SIZE: %d MODIFIED: %s ETAG: %s CTYPE: %s", f.path, f.size, f.modified.String(), f.etag, f.contentType)
} | go | {
"resource": ""
} |
q11966 | PathEscape | train | func PathEscape(path string) string {
s := strings.Split(path, "/")
for i, e := range s {
s[i] = url.PathEscape(e)
}
return strings.Join(s, "/")
} | go | {
"resource": ""
} |
q11967 | Join | train | func Join(path0 string, path1 string) string {
return strings.TrimSuffix(path0, "/") + "/" + strings.TrimPrefix(path1, "/")
} | go | {
"resource": ""
} |
q11968 | String | train | func String(r io.Reader) string {
buf := new(bytes.Buffer)
// TODO - make String return an error as well
_, _ = buf.ReadFrom(r)
return buf.String()
} | go | {
"resource": ""
} |
q11969 | NewClient | train | func NewClient(uri, user, pw string) *Client {
return &Client{FixSlash(uri), make(http.Header), &http.Client{}, &NoAuth{user, pw}}
} | go | {
"resource": ""
} |
q11970 | SetTransport | train | func (c *Client) SetTransport(transport http.RoundTripper) {
c.c.Transport = transport
} | go | {
"resource": ""
} |
q11971 | Connect | train | func (c *Client) Connect() error {
rs, err := c.options("/")
if err != nil {
return err
}
err = rs.Body.Close()
if err != nil {
return err
}
if rs.StatusCode != 200 {
return newPathError("Connect", c.root, rs.StatusCode)
}
return nil
} | go | {
"resource": ""
} |
q11972 | ReadDir | train | func (c *Client) ReadDir(path string) ([]os.FileInfo, error) {
path = FixSlashes(path)
files := make([]os.FileInfo, 0)
skipSelf := true
parse := func(resp interface{}) error {
r := resp.(*response)
if skipSelf {
skipSelf = false
if p := getProps(r, "200"); p != nil && p.Type.Local == "collection" {
r.Props = nil
return nil
}
return newPathError("ReadDir", path, 405)
}
if p := getProps(r, "200"); p != nil {
f := new(File)
if ps, err := url.QueryUnescape(r.Href); err == nil {
f.name = pathpkg.Base(ps)
} else {
f.name = p.Name
}
f.path = path + f.name
f.modified = parseModified(&p.Modified)
f.etag = p.ETag
f.contentType = p.ContentType
if p.Type.Local == "collection" {
f.path += "/"
f.size = 0
f.isdir = true
} 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:getetag/>
<d:getlastmodified/>
</d:prop>
</d:propfind>`,
&response{},
parse)
if err != nil {
if _, ok := err.(*os.PathError); !ok {
err = newPathErrorErr("ReadDir", path, err)
}
}
return files, err
} | go | {
"resource": ""
} |
q11973 | Stat | train | func (c *Client) Stat(path string) (os.FileInfo, error) {
var f *File
parse := func(resp interface{}) error {
r := resp.(*response)
if p := getProps(r, "200"); p != nil && f == nil {
f = new(File)
f.name = p.Name
f.path = path
f.etag = p.ETag
f.contentType = p.ContentType
if p.Type.Local == "collection" {
if !strings.HasSuffix(f.path, "/") {
f.path += "/"
}
f.size = 0
f.modified = time.Unix(0, 0)
f.isdir = true
} else {
f.size = parseInt64(&p.Size)
f.modified = parseModified(&p.Modified)
f.isdir = false
}
}
r.Props = nil
return nil
}
err := c.propfind(path, true,
`<d:propfind xmlns:d='DAV:'>
<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)
}
}
return f, err
} | go | {
"resource": ""
} |
q11974 | RemoveAll | train | func (c *Client) RemoveAll(path string) error {
rs, err := c.req("DELETE", path, nil, nil)
if err != nil {
return newPathError("Remove", path, 400)
}
err = rs.Body.Close()
if err != nil {
return err
}
if rs.StatusCode == 200 || rs.StatusCode == 204 || rs.StatusCode == 404 {
return nil
}
return newPathError("Remove", path, rs.StatusCode)
} | go | {
"resource": ""
} |
q11975 | Mkdir | train | func (c *Client) Mkdir(path string, _ os.FileMode) error {
path = FixSlashes(path)
status := c.mkcol(path)
if status == 201 {
return nil
}
return newPathError("Mkdir", path, status)
} | go | {
"resource": ""
} |
q11976 | MkdirAll | train | func (c *Client) MkdirAll(path string, _ os.FileMode) error {
path = FixSlashes(path)
status := c.mkcol(path)
if status == 201 {
return nil
} else if status == 409 {
paths := strings.Split(path, "/")
sub := "/"
for _, e := range paths {
if e == "" {
continue
}
sub += e + "/"
status = c.mkcol(sub)
if status != 201 {
return newPathError("MkdirAll", sub, status)
}
}
return nil
}
return newPathError("MkdirAll", path, status)
} | go | {
"resource": ""
} |
q11977 | Rename | train | func (c *Client) Rename(oldpath, newpath string, overwrite bool) error {
return c.copymove("MOVE", oldpath, newpath, overwrite)
} | go | {
"resource": ""
} |
q11978 | Read | train | func (c *Client) Read(path string) ([]byte, error) {
var stream io.ReadCloser
var err error
if stream, err = c.ReadStream(path); err != nil {
return nil, err
}
defer stream.Close()
buf := new(bytes.Buffer)
_, err = buf.ReadFrom(stream)
if err != nil {
return nil, err
}
return buf.Bytes(), nil
} | go | {
"resource": ""
} |
q11979 | ReadStream | train | func (c *Client) ReadStream(path string) (io.ReadCloser, error) {
rs, err := c.req("GET", path, nil, nil)
if err != nil {
return nil, newPathErrorErr("ReadStream", path, err)
}
if rs.StatusCode == 200 {
return rs.Body, nil
}
rs.Body.Close()
return nil, newPathError("ReadStream", path, rs.StatusCode)
} | go | {
"resource": ""
} |
q11980 | Write | train | func (c *Client) Write(path string, data []byte, _ os.FileMode) error {
s := c.put(path, bytes.NewReader(data))
switch s {
case 200, 201, 204:
return nil
case 409:
err := c.createParentCollection(path)
if err != nil {
return err
}
s = c.put(path, bytes.NewReader(data))
if s == 200 || s == 201 || s == 204 {
return nil
}
}
return newPathError("Write", path, s)
} | go | {
"resource": ""
} |
q11981 | WriteStream | train | func (c *Client) WriteStream(path string, stream io.Reader, _ os.FileMode) error {
err := c.createParentCollection(path)
if err != nil {
return err
}
s := c.put(path, stream)
switch s {
case 200, 201, 204:
return nil
default:
return newPathError("WriteStream", path, s)
}
} | go | {
"resource": ""
} |
q11982 | Fanout | train | func Fanout(in interface{}, out ...interface{}) {
cases := newSendCases(out)
inChan := reflect.ValueOf(in)
for {
data, more := inChan.Recv()
if !more {
return
}
for i := range cases {
cases[i].Send = data
}
reflect.Select(cases)
}
} | go | {
"resource": ""
} |
q11983 | Funnel | train | func Funnel(out interface{}, in ...interface{}) {
cases := newRecvCases(in)
outChan := reflect.ValueOf(out)
for len(cases) > 0 {
idx, val, ok := reflect.Select(cases)
if !ok {
cases = removeCase(idx, cases)
continue
}
outChan.Send(val)
}
} | go | {
"resource": ""
} |
q11984 | Turnout | train | func Turnout(in []interface{}, out []interface{}) {
inCases := newRecvCases(in)
outCases := newSendCases(out)
for len(inCases) > 0 {
idx, val, ok := reflect.Select(inCases)
if !ok {
inCases = removeCase(idx, inCases)
continue
}
for i := range outCases {
outCases[i].Send = val
}
reflect.Select(outCases)
}
} | go | {
"resource": ""
} |
q11985 | WritePidFile | train | func WritePidFile(pid int, filename string) error {
pidString := strconv.Itoa(pid)
pidFile, err := os.OpenFile(filename, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0644)
if err != nil {
return err
}
defer pidFile.Close()
_, err = pidFile.WriteString(pidString)
return err
} | go | {
"resource": ""
} |
q11986 | WritePidFileForced | train | func WritePidFileForced(pid int, filename string) error {
pidString := strconv.Itoa(pid)
return ioutil.WriteFile(filename, []byte(pidString), 0644)
} | go | {
"resource": ""
} |
q11987 | GetPidFromFile | train | func GetPidFromFile(filename string) (int, error) {
var (
pidBytes []byte
pid int
err error
)
if pidBytes, err = ioutil.ReadFile(filename); err != nil {
return InvalidPID, fmt.Errorf("Could not read pidfile %s: %s", filename, err)
}
pidString := string(bytes.Trim(pidBytes, "\r\n\t "))
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
} | go | {
"resource": ""
} |
q11988 | GetProcFromFile | train | func GetProcFromFile(filename string) (*os.Process, error) {
var (
pid int
err error
proc *os.Process
)
if pid, err = GetPidFromFile(filename); err != nil {
return nil, err
}
// 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
} | go | {
"resource": ""
} |
q11989 | Swap | train | func (files FilesByDate) Swap(a, b int) {
files[a], files[b] = files[b], files[a]
} | go | {
"resource": ""
} |
q11990 | IsDirectory | train | func IsDirectory(filePath string) bool {
stat, err := os.Stat(filePath)
if err != nil {
return false
}
return stat.IsDir()
} | go | {
"resource": ""
} |
q11991 | CommonPath | train | func CommonPath(path1, path2 string) string {
parts1 := strings.Split(path1, "/")
parts2 := strings.Split(path2, "/")
maxIdx := len(parts1)
if len(parts2) < maxIdx {
maxIdx = len(parts2)
}
common := make([]string, 0, maxIdx)
for i := 0; i < maxIdx; i++ {
if parts1[i] == parts2[i] {
common = append(common, parts1[i])
}
}
return strings.Join(common, "/")
} | go | {
"resource": ""
} |
q11992 | FileCRC32 | train | func FileCRC32(path string) (uint32, error) {
data, err := ioutil.ReadFile(path)
if err != nil {
return 0, err
}
return crc32.ChecksumIEEE(data), nil
} | go | {
"resource": ""
} |
q11993 | NewStopListener | train | func NewStopListener(address string) (*StopListener, error) {
listen, err := net.Listen("tcp", address)
if err != nil {
return nil, err // ### return, could not connect ###
}
return &StopListener{
TCPListener: listen.(*net.TCPListener),
active: true,
}, nil
} | go | {
"resource": ""
} |
q11994 | Accept | train | func (listen *StopListener) Accept() (net.Conn, error) {
conn, err := listen.TCPListener.Accept()
if !listen.active {
return nil, StopRequestError{} // ### return, stop requested ###
}
if err != nil {
return nil, err // ### return, error ###
}
return conn, err
} | go | {
"resource": ""
} |
q11995 | Close | train | func (listen *StopListener) Close() error {
listen.active = false
return listen.TCPListener.Close()
} | go | {
"resource": ""
} |
q11996 | ChownByName | train | func ChownByName(filePath, usr, grp string) error {
var uid, gid int
var err error
if uid, err = GetUid(usr); err != nil {
return err
}
if gid, err = GetGid(grp); err != nil {
return err
}
return Chown(filePath, uid, gid)
} | go | {
"resource": ""
} |
q11997 | Chown | train | func Chown(filePath string, uid, gid int) error {
stat, err := os.Lstat(filePath)
if err != nil {
return err
}
if stat.IsDir() {
files, err := ioutil.ReadDir(filePath)
if err != nil {
return err
}
for _, file := range files {
if err := Chown(filePath+"/"+file.Name(), uid, gid); err != nil {
return err
}
}
}
if stat.Mode()&os.ModeSymlink != 0 {
// TODO: os.Chown fails on symlinks
return nil
}
return os.Chown(filePath, uid, gid)
} | go | {
"resource": ""
} |
q11998 | Chmod | train | func Chmod(filePath string, mode os.FileMode) error {
stat, err := os.Lstat(filePath)
if err != nil {
return err
}
if stat.IsDir() {
files, err := ioutil.ReadDir(filePath)
if err != nil {
return err
}
for _, file := range files {
if err := Chmod(filePath+"/"+file.Name(), mode); err != nil {
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 stat.Mode()&os.ModeSymlink != 0 {
// TODO: os.Chmod fails on symlinks
return nil
}
return os.Chmod(filePath, mode)
} | go | {
"resource": ""
} |
q11999 | IsSymlink | train | func IsSymlink(file string) (bool, error) {
fileStat, err := os.Lstat(file)
if err != nil {
return false, err
}
return fileStat.Mode()&os.ModeSymlink != 0, nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.