id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
11,900 | evalphobia/logrus_sentry | sentry.go | NewSentryHook | 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 | func NewSentryHook(DSN string, levels []logrus.Level) (*SentryHook, error) {
client, err := raven.New(DSN)
if err != nil {
return nil, err
}
return NewWithClientSentryHook(client, levels)
} | [
"func",
"NewSentryHook",
"(",
"DSN",
"string",
",",
"levels",
"[",
"]",
"logrus",
".",
"Level",
")",
"(",
"*",
"SentryHook",
",",
"error",
")",
"{",
"client",
",",
"err",
":=",
"raven",
".",
"New",
"(",
"DSN",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewWithClientSentryHook",
"(",
"client",
",",
"levels",
")",
"\n",
"}"
]
| // NewSentryHook creates a hook to be added to an instance of logger
// and initializes the raven client.
// This method sets the timeout to 100 milliseconds. | [
"NewSentryHook",
"creates",
"a",
"hook",
"to",
"be",
"added",
"to",
"an",
"instance",
"of",
"logger",
"and",
"initializes",
"the",
"raven",
"client",
".",
"This",
"method",
"sets",
"the",
"timeout",
"to",
"100",
"milliseconds",
"."
]
| ab0fa2ee9517a8e8c1de1c07e492e8164f852529 | https://github.com/evalphobia/logrus_sentry/blob/ab0fa2ee9517a8e8c1de1c07e492e8164f852529/sentry.go#L93-L99 |
11,901 | evalphobia/logrus_sentry | sentry.go | NewWithTagsSentryHook | 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 | 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)
} | [
"func",
"NewWithTagsSentryHook",
"(",
"DSN",
"string",
",",
"tags",
"map",
"[",
"string",
"]",
"string",
",",
"levels",
"[",
"]",
"logrus",
".",
"Level",
")",
"(",
"*",
"SentryHook",
",",
"error",
")",
"{",
"client",
",",
"err",
":=",
"raven",
".",
"NewWithTags",
"(",
"DSN",
",",
"tags",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewWithClientSentryHook",
"(",
"client",
",",
"levels",
")",
"\n",
"}"
]
| // NewWithTagsSentryHook creates a hook with tags to be added to an instance
// of logger and initializes the raven client. This method sets the timeout to
// 100 milliseconds. | [
"NewWithTagsSentryHook",
"creates",
"a",
"hook",
"with",
"tags",
"to",
"be",
"added",
"to",
"an",
"instance",
"of",
"logger",
"and",
"initializes",
"the",
"raven",
"client",
".",
"This",
"method",
"sets",
"the",
"timeout",
"to",
"100",
"milliseconds",
"."
]
| ab0fa2ee9517a8e8c1de1c07e492e8164f852529 | https://github.com/evalphobia/logrus_sentry/blob/ab0fa2ee9517a8e8c1de1c07e492e8164f852529/sentry.go#L104-L110 |
11,902 | evalphobia/logrus_sentry | sentry.go | NewWithClientSentryHook | 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 | 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
} | [
"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",
"\n",
"}"
]
| // NewWithClientSentryHook creates a hook using an initialized raven client.
// This method sets the timeout to 100 milliseconds. | [
"NewWithClientSentryHook",
"creates",
"a",
"hook",
"using",
"an",
"initialized",
"raven",
"client",
".",
"This",
"method",
"sets",
"the",
"timeout",
"to",
"100",
"milliseconds",
"."
]
| ab0fa2ee9517a8e8c1de1c07e492e8164f852529 | https://github.com/evalphobia/logrus_sentry/blob/ab0fa2ee9517a8e8c1de1c07e492e8164f852529/sentry.go#L114-L130 |
11,903 | evalphobia/logrus_sentry | sentry.go | NewAsyncSentryHook | func NewAsyncSentryHook(DSN string, levels []logrus.Level) (*SentryHook, error) {
hook, err := NewSentryHook(DSN, levels)
return setAsync(hook), err
} | go | func NewAsyncSentryHook(DSN string, levels []logrus.Level) (*SentryHook, error) {
hook, err := NewSentryHook(DSN, levels)
return setAsync(hook), err
} | [
"func",
"NewAsyncSentryHook",
"(",
"DSN",
"string",
",",
"levels",
"[",
"]",
"logrus",
".",
"Level",
")",
"(",
"*",
"SentryHook",
",",
"error",
")",
"{",
"hook",
",",
"err",
":=",
"NewSentryHook",
"(",
"DSN",
",",
"levels",
")",
"\n",
"return",
"setAsync",
"(",
"hook",
")",
",",
"err",
"\n",
"}"
]
| // NewAsyncSentryHook creates a hook same as NewSentryHook, but in asynchronous
// mode. | [
"NewAsyncSentryHook",
"creates",
"a",
"hook",
"same",
"as",
"NewSentryHook",
"but",
"in",
"asynchronous",
"mode",
"."
]
| ab0fa2ee9517a8e8c1de1c07e492e8164f852529 | https://github.com/evalphobia/logrus_sentry/blob/ab0fa2ee9517a8e8c1de1c07e492e8164f852529/sentry.go#L134-L137 |
11,904 | evalphobia/logrus_sentry | sentry.go | NewAsyncWithTagsSentryHook | func NewAsyncWithTagsSentryHook(DSN string, tags map[string]string, levels []logrus.Level) (*SentryHook, error) {
hook, err := NewWithTagsSentryHook(DSN, tags, levels)
return setAsync(hook), err
} | go | func NewAsyncWithTagsSentryHook(DSN string, tags map[string]string, levels []logrus.Level) (*SentryHook, error) {
hook, err := NewWithTagsSentryHook(DSN, tags, levels)
return setAsync(hook), err
} | [
"func",
"NewAsyncWithTagsSentryHook",
"(",
"DSN",
"string",
",",
"tags",
"map",
"[",
"string",
"]",
"string",
",",
"levels",
"[",
"]",
"logrus",
".",
"Level",
")",
"(",
"*",
"SentryHook",
",",
"error",
")",
"{",
"hook",
",",
"err",
":=",
"NewWithTagsSentryHook",
"(",
"DSN",
",",
"tags",
",",
"levels",
")",
"\n",
"return",
"setAsync",
"(",
"hook",
")",
",",
"err",
"\n",
"}"
]
| // NewAsyncWithTagsSentryHook creates a hook same as NewWithTagsSentryHook, but
// in asynchronous mode. | [
"NewAsyncWithTagsSentryHook",
"creates",
"a",
"hook",
"same",
"as",
"NewWithTagsSentryHook",
"but",
"in",
"asynchronous",
"mode",
"."
]
| ab0fa2ee9517a8e8c1de1c07e492e8164f852529 | https://github.com/evalphobia/logrus_sentry/blob/ab0fa2ee9517a8e8c1de1c07e492e8164f852529/sentry.go#L141-L144 |
11,905 | evalphobia/logrus_sentry | sentry.go | NewAsyncWithClientSentryHook | func NewAsyncWithClientSentryHook(client *raven.Client, levels []logrus.Level) (*SentryHook, error) {
hook, err := NewWithClientSentryHook(client, levels)
return setAsync(hook), err
} | go | func NewAsyncWithClientSentryHook(client *raven.Client, levels []logrus.Level) (*SentryHook, error) {
hook, err := NewWithClientSentryHook(client, levels)
return setAsync(hook), err
} | [
"func",
"NewAsyncWithClientSentryHook",
"(",
"client",
"*",
"raven",
".",
"Client",
",",
"levels",
"[",
"]",
"logrus",
".",
"Level",
")",
"(",
"*",
"SentryHook",
",",
"error",
")",
"{",
"hook",
",",
"err",
":=",
"NewWithClientSentryHook",
"(",
"client",
",",
"levels",
")",
"\n",
"return",
"setAsync",
"(",
"hook",
")",
",",
"err",
"\n",
"}"
]
| // NewAsyncWithClientSentryHook creates a hook same as NewWithClientSentryHook,
// but in asynchronous mode. | [
"NewAsyncWithClientSentryHook",
"creates",
"a",
"hook",
"same",
"as",
"NewWithClientSentryHook",
"but",
"in",
"asynchronous",
"mode",
"."
]
| ab0fa2ee9517a8e8c1de1c07e492e8164f852529 | https://github.com/evalphobia/logrus_sentry/blob/ab0fa2ee9517a8e8c1de1c07e492e8164f852529/sentry.go#L148-L151 |
11,906 | evalphobia/logrus_sentry | sentry.go | Flush | 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 | 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()
} | [
"func",
"(",
"hook",
"*",
"SentryHook",
")",
"Flush",
"(",
")",
"{",
"if",
"!",
"hook",
".",
"asynchronous",
"{",
"return",
"\n",
"}",
"\n",
"hook",
".",
"mu",
".",
"Lock",
"(",
")",
"// Claim exclusive access; any logging goroutines will block until the flush completes",
"\n",
"defer",
"hook",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"hook",
".",
"wg",
".",
"Wait",
"(",
")",
"\n",
"}"
]
| // Flush waits for the log queue to empty. This function only does anything in
// asynchronous mode. | [
"Flush",
"waits",
"for",
"the",
"log",
"queue",
"to",
"empty",
".",
"This",
"function",
"only",
"does",
"anything",
"in",
"asynchronous",
"mode",
"."
]
| ab0fa2ee9517a8e8c1de1c07e492e8164f852529 | https://github.com/evalphobia/logrus_sentry/blob/ab0fa2ee9517a8e8c1de1c07e492e8164f852529/sentry.go#L296-L304 |
11,907 | evalphobia/logrus_sentry | sentry.go | AddExtraFilter | func (hook *SentryHook) AddExtraFilter(name string, fn func(interface{}) interface{}) {
hook.extraFilters[name] = fn
} | go | func (hook *SentryHook) AddExtraFilter(name string, fn func(interface{}) interface{}) {
hook.extraFilters[name] = fn
} | [
"func",
"(",
"hook",
"*",
"SentryHook",
")",
"AddExtraFilter",
"(",
"name",
"string",
",",
"fn",
"func",
"(",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
")",
"{",
"hook",
".",
"extraFilters",
"[",
"name",
"]",
"=",
"fn",
"\n",
"}"
]
| // AddExtraFilter adds a custom filter function. | [
"AddExtraFilter",
"adds",
"a",
"custom",
"filter",
"function",
"."
]
| ab0fa2ee9517a8e8c1de1c07e492e8164f852529 | https://github.com/evalphobia/logrus_sentry/blob/ab0fa2ee9517a8e8c1de1c07e492e8164f852529/sentry.go#L364-L366 |
11,908 | evalphobia/logrus_sentry | sentry.go | AddErrorHandler | func (hook *SentryHook) AddErrorHandler(fn func(entry *logrus.Entry, err error)) {
hook.errorHandlers = append(hook.errorHandlers, fn)
} | go | func (hook *SentryHook) AddErrorHandler(fn func(entry *logrus.Entry, err error)) {
hook.errorHandlers = append(hook.errorHandlers, fn)
} | [
"func",
"(",
"hook",
"*",
"SentryHook",
")",
"AddErrorHandler",
"(",
"fn",
"func",
"(",
"entry",
"*",
"logrus",
".",
"Entry",
",",
"err",
"error",
")",
")",
"{",
"hook",
".",
"errorHandlers",
"=",
"append",
"(",
"hook",
".",
"errorHandlers",
",",
"fn",
")",
"\n",
"}"
]
| // AddErrorHandler adds a error handler function used when Sentry returns error. | [
"AddErrorHandler",
"adds",
"a",
"error",
"handler",
"function",
"used",
"when",
"Sentry",
"returns",
"error",
"."
]
| ab0fa2ee9517a8e8c1de1c07e492e8164f852529 | https://github.com/evalphobia/logrus_sentry/blob/ab0fa2ee9517a8e8c1de1c07e492e8164f852529/sentry.go#L369-L371 |
11,909 | evalphobia/logrus_sentry | sentry.go | formatData | 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 | 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
}
} | [
"func",
"formatData",
"(",
"value",
"interface",
"{",
"}",
")",
"(",
"formatted",
"interface",
"{",
"}",
")",
"{",
"switch",
"value",
":=",
"value",
".",
"(",
"type",
")",
"{",
"case",
"json",
".",
"Marshaler",
":",
"return",
"value",
"\n",
"case",
"error",
":",
"return",
"value",
".",
"Error",
"(",
")",
"\n",
"case",
"fmt",
".",
"Stringer",
":",
"return",
"value",
".",
"String",
"(",
")",
"\n",
"default",
":",
"return",
"value",
"\n",
"}",
"\n",
"}"
]
| // formatData returns value as a suitable format. | [
"formatData",
"returns",
"value",
"as",
"a",
"suitable",
"format",
"."
]
| ab0fa2ee9517a8e8c1de1c07e492e8164f852529 | https://github.com/evalphobia/logrus_sentry/blob/ab0fa2ee9517a8e8c1de1c07e492e8164f852529/sentry.go#L395-L406 |
11,910 | coreos/pkg | dlopen/dlopen.go | GetSymbolPointer | 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 | 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
} | [
"func",
"(",
"l",
"*",
"LibHandle",
")",
"GetSymbolPointer",
"(",
"symbol",
"string",
")",
"(",
"unsafe",
".",
"Pointer",
",",
"error",
")",
"{",
"sym",
":=",
"C",
".",
"CString",
"(",
"symbol",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"sym",
")",
")",
"\n\n",
"C",
".",
"dlerror",
"(",
")",
"\n",
"p",
":=",
"C",
".",
"dlsym",
"(",
"l",
".",
"Handle",
",",
"sym",
")",
"\n",
"e",
":=",
"C",
".",
"dlerror",
"(",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"symbol",
",",
"errors",
".",
"New",
"(",
"C",
".",
"GoString",
"(",
"e",
")",
")",
")",
"\n",
"}",
"\n\n",
"return",
"p",
",",
"nil",
"\n",
"}"
]
| // GetSymbolPointer takes a symbol name and returns a pointer to the symbol. | [
"GetSymbolPointer",
"takes",
"a",
"symbol",
"name",
"and",
"returns",
"a",
"pointer",
"to",
"the",
"symbol",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/dlopen/dlopen.go#L58-L70 |
11,911 | coreos/pkg | dlopen/dlopen.go | Close | 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 | 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
} | [
"func",
"(",
"l",
"*",
"LibHandle",
")",
"Close",
"(",
")",
"error",
"{",
"C",
".",
"dlerror",
"(",
")",
"\n",
"C",
".",
"dlclose",
"(",
"l",
".",
"Handle",
")",
"\n",
"e",
":=",
"C",
".",
"dlerror",
"(",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"l",
".",
"Libname",
",",
"errors",
".",
"New",
"(",
"C",
".",
"GoString",
"(",
"e",
")",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| // Close closes a LibHandle. | [
"Close",
"closes",
"a",
"LibHandle",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/dlopen/dlopen.go#L73-L82 |
11,912 | coreos/pkg | httputil/cookie.go | DeleteCookies | 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 | 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)
}
} | [
"func",
"DeleteCookies",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"cookieNames",
"...",
"string",
")",
"{",
"for",
"_",
",",
"n",
":=",
"range",
"cookieNames",
"{",
"c",
":=",
"&",
"http",
".",
"Cookie",
"{",
"Name",
":",
"n",
",",
"Value",
":",
"\"",
"\"",
",",
"Path",
":",
"\"",
"\"",
",",
"MaxAge",
":",
"-",
"1",
",",
"Expires",
":",
"time",
".",
"Time",
"{",
"}",
",",
"}",
"\n",
"http",
".",
"SetCookie",
"(",
"w",
",",
"c",
")",
"\n",
"}",
"\n",
"}"
]
| // DeleteCookies effectively deletes all named cookies
// by wiping all data and setting to expire immediately. | [
"DeleteCookies",
"effectively",
"deletes",
"all",
"named",
"cookies",
"by",
"wiping",
"all",
"data",
"and",
"setting",
"to",
"expire",
"immediately",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/httputil/cookie.go#L10-L21 |
11,913 | coreos/pkg | capnslog/formatters.go | NewLogFormatter | 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 | 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
}
} | [
"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",
"}",
"\n",
"}"
]
| // NewLogFormatter is a helper to produce a new LogFormatter struct. It uses the
// golang log package to actually do the logging work so that logs look similar. | [
"NewLogFormatter",
"is",
"a",
"helper",
"to",
"produce",
"a",
"new",
"LogFormatter",
"struct",
".",
"It",
"uses",
"the",
"golang",
"log",
"package",
"to",
"actually",
"do",
"the",
"logging",
"work",
"so",
"that",
"logs",
"look",
"similar",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/formatters.go#L117-L122 |
11,914 | coreos/pkg | capnslog/formatters.go | Format | 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 | 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
} | [
"func",
"(",
"lf",
"*",
"LogFormatter",
")",
"Format",
"(",
"pkg",
"string",
",",
"_",
"LogLevel",
",",
"_",
"int",
",",
"entries",
"...",
"interface",
"{",
"}",
")",
"{",
"str",
":=",
"fmt",
".",
"Sprint",
"(",
"entries",
"...",
")",
"\n",
"prefix",
":=",
"lf",
".",
"prefix",
"\n",
"if",
"pkg",
"!=",
"\"",
"\"",
"{",
"prefix",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"prefix",
",",
"pkg",
")",
"\n",
"}",
"\n",
"lf",
".",
"logger",
".",
"Output",
"(",
"5",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"prefix",
",",
"str",
")",
")",
"// call depth is 5",
"\n",
"}"
]
| // Format builds a log message for the LogFormatter. The LogLevel is ignored. | [
"Format",
"builds",
"a",
"log",
"message",
"for",
"the",
"LogFormatter",
".",
"The",
"LogLevel",
"is",
"ignored",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/formatters.go#L125-L132 |
11,915 | coreos/pkg | capnslog/formatters.go | Format | func (_ *NilFormatter) Format(_ string, _ LogLevel, _ int, _ ...interface{}) {
// noop
} | go | func (_ *NilFormatter) Format(_ string, _ LogLevel, _ int, _ ...interface{}) {
// noop
} | [
"func",
"(",
"_",
"*",
"NilFormatter",
")",
"Format",
"(",
"_",
"string",
",",
"_",
"LogLevel",
",",
"_",
"int",
",",
"_",
"...",
"interface",
"{",
"}",
")",
"{",
"// noop",
"}"
]
| // Format does nothing. | [
"Format",
"does",
"nothing",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/formatters.go#L150-L152 |
11,916 | coreos/pkg | capnslog/logmap.go | Char | 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 | 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")
}
} | [
"func",
"(",
"l",
"LogLevel",
")",
"Char",
"(",
")",
"string",
"{",
"switch",
"l",
"{",
"case",
"CRITICAL",
":",
"return",
"\"",
"\"",
"\n",
"case",
"ERROR",
":",
"return",
"\"",
"\"",
"\n",
"case",
"WARNING",
":",
"return",
"\"",
"\"",
"\n",
"case",
"NOTICE",
":",
"return",
"\"",
"\"",
"\n",
"case",
"INFO",
":",
"return",
"\"",
"\"",
"\n",
"case",
"DEBUG",
":",
"return",
"\"",
"\"",
"\n",
"case",
"TRACE",
":",
"return",
"\"",
"\"",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
]
| // Char returns a single-character representation of the log level. | [
"Char",
"returns",
"a",
"single",
"-",
"character",
"representation",
"of",
"the",
"log",
"level",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/logmap.go#L44-L63 |
11,917 | coreos/pkg | capnslog/logmap.go | Set | func (l *LogLevel) Set(s string) error {
value, err := ParseLevel(s)
if err != nil {
return err
}
*l = value
return nil
} | go | func (l *LogLevel) Set(s string) error {
value, err := ParseLevel(s)
if err != nil {
return err
}
*l = value
return nil
} | [
"func",
"(",
"l",
"*",
"LogLevel",
")",
"Set",
"(",
"s",
"string",
")",
"error",
"{",
"value",
",",
"err",
":=",
"ParseLevel",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"*",
"l",
"=",
"value",
"\n",
"return",
"nil",
"\n",
"}"
]
| // Update using the given string value. Fulfills the flag.Value interface. | [
"Update",
"using",
"the",
"given",
"string",
"value",
".",
"Fulfills",
"the",
"flag",
".",
"Value",
"interface",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/logmap.go#L88-L96 |
11,918 | coreos/pkg | capnslog/logmap.go | ParseLevel | 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 | 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)
} | [
"func",
"ParseLevel",
"(",
"s",
"string",
")",
"(",
"LogLevel",
",",
"error",
")",
"{",
"switch",
"s",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"CRITICAL",
",",
"nil",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"ERROR",
",",
"nil",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"WARNING",
",",
"nil",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"NOTICE",
",",
"nil",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"INFO",
",",
"nil",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"DEBUG",
",",
"nil",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"TRACE",
",",
"nil",
"\n",
"}",
"\n",
"return",
"CRITICAL",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"s",
")",
"\n",
"}"
]
| // ParseLevel translates some potential loglevel strings into their corresponding levels. | [
"ParseLevel",
"translates",
"some",
"potential",
"loglevel",
"strings",
"into",
"their",
"corresponding",
"levels",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/logmap.go#L104-L122 |
11,919 | coreos/pkg | capnslog/logmap.go | SetGlobalLogLevel | func SetGlobalLogLevel(l LogLevel) {
logger.Lock()
defer logger.Unlock()
for _, r := range logger.repoMap {
r.setRepoLogLevelInternal(l)
}
} | go | func SetGlobalLogLevel(l LogLevel) {
logger.Lock()
defer logger.Unlock()
for _, r := range logger.repoMap {
r.setRepoLogLevelInternal(l)
}
} | [
"func",
"SetGlobalLogLevel",
"(",
"l",
"LogLevel",
")",
"{",
"logger",
".",
"Lock",
"(",
")",
"\n",
"defer",
"logger",
".",
"Unlock",
"(",
")",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"logger",
".",
"repoMap",
"{",
"r",
".",
"setRepoLogLevelInternal",
"(",
"l",
")",
"\n",
"}",
"\n",
"}"
]
| // SetGlobalLogLevel sets the log level for all packages in all repositories
// registered with capnslog. | [
"SetGlobalLogLevel",
"sets",
"the",
"log",
"level",
"for",
"all",
"packages",
"in",
"all",
"repositories",
"registered",
"with",
"capnslog",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/logmap.go#L137-L143 |
11,920 | coreos/pkg | capnslog/logmap.go | GetRepoLogger | 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 | 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
} | [
"func",
"GetRepoLogger",
"(",
"repo",
"string",
")",
"(",
"RepoLogger",
",",
"error",
")",
"{",
"logger",
".",
"Lock",
"(",
")",
"\n",
"defer",
"logger",
".",
"Unlock",
"(",
")",
"\n",
"r",
",",
"ok",
":=",
"logger",
".",
"repoMap",
"[",
"repo",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"repo",
")",
"\n",
"}",
"\n",
"return",
"r",
",",
"nil",
"\n",
"}"
]
| // GetRepoLogger may return the handle to the repository's set of packages' loggers. | [
"GetRepoLogger",
"may",
"return",
"the",
"handle",
"to",
"the",
"repository",
"s",
"set",
"of",
"packages",
"loggers",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/logmap.go#L146-L154 |
11,921 | coreos/pkg | capnslog/logmap.go | MustRepoLogger | func MustRepoLogger(repo string) RepoLogger {
r, err := GetRepoLogger(repo)
if err != nil {
panic(err)
}
return r
} | go | func MustRepoLogger(repo string) RepoLogger {
r, err := GetRepoLogger(repo)
if err != nil {
panic(err)
}
return r
} | [
"func",
"MustRepoLogger",
"(",
"repo",
"string",
")",
"RepoLogger",
"{",
"r",
",",
"err",
":=",
"GetRepoLogger",
"(",
"repo",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"r",
"\n",
"}"
]
| // MustRepoLogger returns the handle to the repository's packages' loggers. | [
"MustRepoLogger",
"returns",
"the",
"handle",
"to",
"the",
"repository",
"s",
"packages",
"loggers",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/logmap.go#L157-L163 |
11,922 | coreos/pkg | capnslog/logmap.go | SetRepoLogLevel | func (r RepoLogger) SetRepoLogLevel(l LogLevel) {
logger.Lock()
defer logger.Unlock()
r.setRepoLogLevelInternal(l)
} | go | func (r RepoLogger) SetRepoLogLevel(l LogLevel) {
logger.Lock()
defer logger.Unlock()
r.setRepoLogLevelInternal(l)
} | [
"func",
"(",
"r",
"RepoLogger",
")",
"SetRepoLogLevel",
"(",
"l",
"LogLevel",
")",
"{",
"logger",
".",
"Lock",
"(",
")",
"\n",
"defer",
"logger",
".",
"Unlock",
"(",
")",
"\n",
"r",
".",
"setRepoLogLevelInternal",
"(",
"l",
")",
"\n",
"}"
]
| // SetRepoLogLevel sets the log level for all packages in the repository. | [
"SetRepoLogLevel",
"sets",
"the",
"log",
"level",
"for",
"all",
"packages",
"in",
"the",
"repository",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/logmap.go#L166-L170 |
11,923 | coreos/pkg | capnslog/logmap.go | ParseLogLevelConfig | 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 | 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
} | [
"func",
"(",
"r",
"RepoLogger",
")",
"ParseLogLevelConfig",
"(",
"conf",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"LogLevel",
",",
"error",
")",
"{",
"setlist",
":=",
"strings",
".",
"Split",
"(",
"conf",
",",
"\"",
"\"",
")",
"\n",
"out",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"LogLevel",
")",
"\n",
"for",
"_",
",",
"setstring",
":=",
"range",
"setlist",
"{",
"setting",
":=",
"strings",
".",
"Split",
"(",
"setstring",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"setting",
")",
"!=",
"2",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"setstring",
")",
"\n",
"}",
"\n",
"l",
",",
"err",
":=",
"ParseLevel",
"(",
"setting",
"[",
"1",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"out",
"[",
"setting",
"[",
"0",
"]",
"]",
"=",
"l",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
]
| // ParseLogLevelConfig parses a comma-separated string of "package=loglevel", in
// order, and returns a map of the results, for use in SetLogLevel. | [
"ParseLogLevelConfig",
"parses",
"a",
"comma",
"-",
"separated",
"string",
"of",
"package",
"=",
"loglevel",
"in",
"order",
"and",
"returns",
"a",
"map",
"of",
"the",
"results",
"for",
"use",
"in",
"SetLogLevel",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/logmap.go#L180-L195 |
11,924 | coreos/pkg | capnslog/logmap.go | SetFormatter | func SetFormatter(f Formatter) {
logger.Lock()
defer logger.Unlock()
logger.formatter = f
} | go | func SetFormatter(f Formatter) {
logger.Lock()
defer logger.Unlock()
logger.formatter = f
} | [
"func",
"SetFormatter",
"(",
"f",
"Formatter",
")",
"{",
"logger",
".",
"Lock",
"(",
")",
"\n",
"defer",
"logger",
".",
"Unlock",
"(",
")",
"\n",
"logger",
".",
"formatter",
"=",
"f",
"\n",
"}"
]
| // SetFormatter sets the formatting function for all logs. | [
"SetFormatter",
"sets",
"the",
"formatting",
"function",
"for",
"all",
"logs",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/logmap.go#L217-L221 |
11,925 | coreos/pkg | capnslog/logmap.go | NewPackageLogger | 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 | 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
} | [
"func",
"NewPackageLogger",
"(",
"repo",
"string",
",",
"pkg",
"string",
")",
"(",
"p",
"*",
"PackageLogger",
")",
"{",
"logger",
".",
"Lock",
"(",
")",
"\n",
"defer",
"logger",
".",
"Unlock",
"(",
")",
"\n",
"if",
"logger",
".",
"repoMap",
"==",
"nil",
"{",
"logger",
".",
"repoMap",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"RepoLogger",
")",
"\n",
"}",
"\n",
"r",
",",
"rok",
":=",
"logger",
".",
"repoMap",
"[",
"repo",
"]",
"\n",
"if",
"!",
"rok",
"{",
"logger",
".",
"repoMap",
"[",
"repo",
"]",
"=",
"make",
"(",
"RepoLogger",
")",
"\n",
"r",
"=",
"logger",
".",
"repoMap",
"[",
"repo",
"]",
"\n",
"}",
"\n",
"p",
",",
"pok",
":=",
"r",
"[",
"pkg",
"]",
"\n",
"if",
"!",
"pok",
"{",
"r",
"[",
"pkg",
"]",
"=",
"&",
"PackageLogger",
"{",
"pkg",
":",
"pkg",
",",
"level",
":",
"INFO",
",",
"}",
"\n",
"p",
"=",
"r",
"[",
"pkg",
"]",
"\n",
"}",
"\n",
"return",
"\n",
"}"
]
| // NewPackageLogger creates a package logger object.
// This should be defined as a global var in your package, referencing your repo. | [
"NewPackageLogger",
"creates",
"a",
"package",
"logger",
"object",
".",
"This",
"should",
"be",
"defined",
"as",
"a",
"global",
"var",
"in",
"your",
"package",
"referencing",
"your",
"repo",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/logmap.go#L225-L245 |
11,926 | coreos/pkg | progressutil/iocopy.go | NewCopyProgressPrinter | func NewCopyProgressPrinter() *CopyProgressPrinter {
return &CopyProgressPrinter{
results: make(chan error),
cancel: make(chan struct{}),
pbp: &ProgressBarPrinter{PadToBeEven: true},
}
} | go | func NewCopyProgressPrinter() *CopyProgressPrinter {
return &CopyProgressPrinter{
results: make(chan error),
cancel: make(chan struct{}),
pbp: &ProgressBarPrinter{PadToBeEven: true},
}
} | [
"func",
"NewCopyProgressPrinter",
"(",
")",
"*",
"CopyProgressPrinter",
"{",
"return",
"&",
"CopyProgressPrinter",
"{",
"results",
":",
"make",
"(",
"chan",
"error",
")",
",",
"cancel",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"pbp",
":",
"&",
"ProgressBarPrinter",
"{",
"PadToBeEven",
":",
"true",
"}",
",",
"}",
"\n",
"}"
]
| // NewCopyProgressPrinter returns a new CopyProgressPrinter | [
"NewCopyProgressPrinter",
"returns",
"a",
"new",
"CopyProgressPrinter"
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/progressutil/iocopy.go#L57-L63 |
11,927 | coreos/pkg | progressutil/iocopy.go | AddCopy | 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 | 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
} | [
"func",
"(",
"cpp",
"*",
"CopyProgressPrinter",
")",
"AddCopy",
"(",
"reader",
"io",
".",
"Reader",
",",
"name",
"string",
",",
"size",
"int64",
",",
"dest",
"io",
".",
"Writer",
")",
"error",
"{",
"cpp",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"cpp",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"cpp",
".",
"started",
"{",
"return",
"ErrAlreadyStarted",
"\n",
"}",
"\n\n",
"cr",
":=",
"&",
"copyReader",
"{",
"reader",
":",
"reader",
",",
"current",
":",
"0",
",",
"total",
":",
"size",
",",
"pb",
":",
"cpp",
".",
"pbp",
".",
"AddProgressBar",
"(",
")",
",",
"}",
"\n",
"cr",
".",
"pb",
".",
"SetPrintBefore",
"(",
"name",
")",
"\n",
"cr",
".",
"pb",
".",
"SetPrintAfter",
"(",
"cr",
".",
"formattedProgress",
"(",
")",
")",
"\n\n",
"cpp",
".",
"readers",
"=",
"append",
"(",
"cpp",
".",
"readers",
",",
"cr",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"dest",
",",
"cr",
")",
"\n",
"select",
"{",
"case",
"<-",
"cpp",
".",
"cancel",
":",
"return",
"\n",
"case",
"cpp",
".",
"results",
"<-",
"err",
":",
"return",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
]
| // AddCopy adds a copy for this CopyProgressPrinter to perform. An io.Copy call
// will be made to copy bytes from reader to dest, and name and size will be
// used to label the progress bar and display how much progress has been made.
// If size is 0, the total size of the reader is assumed to be unknown.
// AddCopy can only be called before PrintAndWait; otherwise, ErrAlreadyStarted
// will be returned. | [
"AddCopy",
"adds",
"a",
"copy",
"for",
"this",
"CopyProgressPrinter",
"to",
"perform",
".",
"An",
"io",
".",
"Copy",
"call",
"will",
"be",
"made",
"to",
"copy",
"bytes",
"from",
"reader",
"to",
"dest",
"and",
"name",
"and",
"size",
"will",
"be",
"used",
"to",
"label",
"the",
"progress",
"bar",
"and",
"display",
"how",
"much",
"progress",
"has",
"been",
"made",
".",
"If",
"size",
"is",
"0",
"the",
"total",
"size",
"of",
"the",
"reader",
"is",
"assumed",
"to",
"be",
"unknown",
".",
"AddCopy",
"can",
"only",
"be",
"called",
"before",
"PrintAndWait",
";",
"otherwise",
"ErrAlreadyStarted",
"will",
"be",
"returned",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/progressutil/iocopy.go#L84-L113 |
11,928 | coreos/pkg | progressutil/iocopy.go | PrintAndWait | 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 | 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
} | [
"func",
"(",
"cpp",
"*",
"CopyProgressPrinter",
")",
"PrintAndWait",
"(",
"printTo",
"io",
".",
"Writer",
",",
"printInterval",
"time",
".",
"Duration",
",",
"cancel",
"chan",
"struct",
"{",
"}",
")",
"error",
"{",
"cpp",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"if",
"cpp",
".",
"started",
"{",
"cpp",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"ErrAlreadyStarted",
"\n",
"}",
"\n",
"cpp",
".",
"started",
"=",
"true",
"\n",
"cpp",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"n",
":=",
"len",
"(",
"cpp",
".",
"readers",
")",
"\n",
"if",
"n",
"==",
"0",
"{",
"// Nothing to do.",
"return",
"nil",
"\n",
"}",
"\n\n",
"defer",
"close",
"(",
"cpp",
".",
"cancel",
")",
"\n",
"t",
":=",
"time",
".",
"NewTicker",
"(",
"printInterval",
")",
"\n",
"allDone",
":=",
"false",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"{",
"select",
"{",
"case",
"<-",
"cancel",
":",
"return",
"nil",
"\n",
"case",
"<-",
"t",
".",
"C",
":",
"_",
",",
"err",
":=",
"cpp",
".",
"pbp",
".",
"Print",
"(",
"printTo",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"case",
"err",
":=",
"<-",
"cpp",
".",
"results",
":",
"i",
"++",
"\n",
"// Once completion is signaled, further on this just drains",
"// (unlikely) errors from the channel.",
"if",
"err",
"==",
"nil",
"&&",
"!",
"allDone",
"{",
"allDone",
",",
"err",
"=",
"cpp",
".",
"pbp",
".",
"Print",
"(",
"printTo",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
]
| // PrintAndWait will print the progress for each copy operation added with
// AddCopy to printTo every printInterval. This will continue until every added
// copy is finished, or until cancel is written to.
// PrintAndWait may only be called once; any subsequent calls will immediately
// return ErrAlreadyStarted. After PrintAndWait has been called, no more
// copies may be added to the CopyProgressPrinter. | [
"PrintAndWait",
"will",
"print",
"the",
"progress",
"for",
"each",
"copy",
"operation",
"added",
"with",
"AddCopy",
"to",
"printTo",
"every",
"printInterval",
".",
"This",
"will",
"continue",
"until",
"every",
"added",
"copy",
"is",
"finished",
"or",
"until",
"cancel",
"is",
"written",
"to",
".",
"PrintAndWait",
"may",
"only",
"be",
"called",
"once",
";",
"any",
"subsequent",
"calls",
"will",
"immediately",
"return",
"ErrAlreadyStarted",
".",
"After",
"PrintAndWait",
"has",
"been",
"called",
"no",
"more",
"copies",
"may",
"be",
"added",
"to",
"the",
"CopyProgressPrinter",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/progressutil/iocopy.go#L121-L161 |
11,929 | coreos/pkg | progressutil/iocopy.go | ByteUnitStr | 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 | 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)
} | [
"func",
"ByteUnitStr",
"(",
"n",
"int64",
")",
"string",
"{",
"var",
"unit",
"string",
"\n",
"size",
":=",
"float64",
"(",
"n",
")",
"\n",
"for",
"i",
":=",
"1",
";",
"i",
"<",
"len",
"(",
"byteUnits",
")",
";",
"i",
"++",
"{",
"if",
"size",
"<",
"1000",
"{",
"unit",
"=",
"byteUnits",
"[",
"i",
"-",
"1",
"]",
"\n",
"break",
"\n",
"}",
"\n\n",
"size",
"=",
"size",
"/",
"1000",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"size",
",",
"unit",
")",
"\n",
"}"
]
| // ByteUnitStr pretty prints a number of bytes. | [
"ByteUnitStr",
"pretty",
"prints",
"a",
"number",
"of",
"bytes",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/progressutil/iocopy.go#L176-L189 |
11,930 | coreos/pkg | netutil/url.go | MergeQuery | 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 | 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
} | [
"func",
"MergeQuery",
"(",
"u",
"url",
".",
"URL",
",",
"q",
"url",
".",
"Values",
")",
"url",
".",
"URL",
"{",
"uv",
":=",
"u",
".",
"Query",
"(",
")",
"\n",
"for",
"k",
",",
"vs",
":=",
"range",
"q",
"{",
"for",
"_",
",",
"v",
":=",
"range",
"vs",
"{",
"uv",
".",
"Add",
"(",
"k",
",",
"v",
")",
"\n",
"}",
"\n",
"}",
"\n",
"u",
".",
"RawQuery",
"=",
"uv",
".",
"Encode",
"(",
")",
"\n",
"return",
"u",
"\n",
"}"
]
| // MergeQuery appends additional query values to an existing URL. | [
"MergeQuery",
"appends",
"additional",
"query",
"values",
"to",
"an",
"existing",
"URL",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/netutil/url.go#L8-L17 |
11,931 | coreos/pkg | flagutil/env_file.go | SetFlagsFromEnvFile | 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 | 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
} | [
"func",
"SetFlagsFromEnvFile",
"(",
"fs",
"*",
"flag",
".",
"FlagSet",
",",
"prefix",
"string",
",",
"path",
"string",
")",
"(",
"err",
"error",
")",
"{",
"alreadySet",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"fs",
".",
"Visit",
"(",
"func",
"(",
"f",
"*",
"flag",
".",
"Flag",
")",
"{",
"alreadySet",
"[",
"f",
".",
"Name",
"]",
"=",
"true",
"\n",
"}",
")",
"\n",
"envs",
",",
"err",
":=",
"parseEnvFile",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"fs",
".",
"VisitAll",
"(",
"func",
"(",
"f",
"*",
"flag",
".",
"Flag",
")",
"{",
"if",
"!",
"alreadySet",
"[",
"f",
".",
"Name",
"]",
"{",
"key",
":=",
"prefix",
"+",
"\"",
"\"",
"+",
"strings",
".",
"ToUpper",
"(",
"strings",
".",
"Replace",
"(",
"f",
".",
"Name",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
")",
"\n",
"val",
":=",
"envs",
"[",
"key",
"]",
"\n",
"if",
"val",
"!=",
"\"",
"\"",
"{",
"if",
"serr",
":=",
"fs",
".",
"Set",
"(",
"f",
".",
"Name",
",",
"val",
")",
";",
"serr",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"val",
",",
"key",
",",
"serr",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
")",
"\n",
"return",
"err",
"\n",
"}"
]
| // SetFlagsFromEnvFile iterates the given flagset and if any flags are not
// already set it attempts to set their values from the given env file. Env
// files may have KEY=VALUE lines where the environment variable names are
// in UPPERCASE, prefixed by the given PREFIX, and dashes are replaced by
// underscores. For example, if prefix=PREFIX, some-flag is named
// PREFIX_SOME_FLAG.
// Comment lines are skipped, but more complex env file parsing is not
// performed. | [
"SetFlagsFromEnvFile",
"iterates",
"the",
"given",
"flagset",
"and",
"if",
"any",
"flags",
"are",
"not",
"already",
"set",
"it",
"attempts",
"to",
"set",
"their",
"values",
"from",
"the",
"given",
"env",
"file",
".",
"Env",
"files",
"may",
"have",
"KEY",
"=",
"VALUE",
"lines",
"where",
"the",
"environment",
"variable",
"names",
"are",
"in",
"UPPERCASE",
"prefixed",
"by",
"the",
"given",
"PREFIX",
"and",
"dashes",
"are",
"replaced",
"by",
"underscores",
".",
"For",
"example",
"if",
"prefix",
"=",
"PREFIX",
"some",
"-",
"flag",
"is",
"named",
"PREFIX_SOME_FLAG",
".",
"Comment",
"lines",
"are",
"skipped",
"but",
"more",
"complex",
"env",
"file",
"parsing",
"is",
"not",
"performed",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/flagutil/env_file.go#L19-L40 |
11,932 | coreos/pkg | capnslog/pkg_logger.go | SetLevel | func (p *PackageLogger) SetLevel(l LogLevel) {
logger.Lock()
defer logger.Unlock()
p.level = l
} | go | func (p *PackageLogger) SetLevel(l LogLevel) {
logger.Lock()
defer logger.Unlock()
p.level = l
} | [
"func",
"(",
"p",
"*",
"PackageLogger",
")",
"SetLevel",
"(",
"l",
"LogLevel",
")",
"{",
"logger",
".",
"Lock",
"(",
")",
"\n",
"defer",
"logger",
".",
"Unlock",
"(",
")",
"\n",
"p",
".",
"level",
"=",
"l",
"\n",
"}"
]
| // SetLevel allows users to change the current logging level. | [
"SetLevel",
"allows",
"users",
"to",
"change",
"the",
"current",
"logging",
"level",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/pkg_logger.go#L41-L45 |
11,933 | coreos/pkg | capnslog/pkg_logger.go | LevelAt | func (p *PackageLogger) LevelAt(l LogLevel) bool {
logger.Lock()
defer logger.Unlock()
return p.level >= l
} | go | func (p *PackageLogger) LevelAt(l LogLevel) bool {
logger.Lock()
defer logger.Unlock()
return p.level >= l
} | [
"func",
"(",
"p",
"*",
"PackageLogger",
")",
"LevelAt",
"(",
"l",
"LogLevel",
")",
"bool",
"{",
"logger",
".",
"Lock",
"(",
")",
"\n",
"defer",
"logger",
".",
"Unlock",
"(",
")",
"\n",
"return",
"p",
".",
"level",
">=",
"l",
"\n",
"}"
]
| // LevelAt checks if the given log level will be outputted under current setting. | [
"LevelAt",
"checks",
"if",
"the",
"given",
"log",
"level",
"will",
"be",
"outputted",
"under",
"current",
"setting",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/pkg_logger.go#L48-L52 |
11,934 | coreos/pkg | capnslog/pkg_logger.go | Logf | func (p *PackageLogger) Logf(l LogLevel, format string, args ...interface{}) {
p.internalLog(calldepth, l, fmt.Sprintf(format, args...))
} | go | func (p *PackageLogger) Logf(l LogLevel, format string, args ...interface{}) {
p.internalLog(calldepth, l, fmt.Sprintf(format, args...))
} | [
"func",
"(",
"p",
"*",
"PackageLogger",
")",
"Logf",
"(",
"l",
"LogLevel",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"p",
".",
"internalLog",
"(",
"calldepth",
",",
"l",
",",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"args",
"...",
")",
")",
"\n",
"}"
]
| // Log a formatted string at any level between ERROR and TRACE | [
"Log",
"a",
"formatted",
"string",
"at",
"any",
"level",
"between",
"ERROR",
"and",
"TRACE"
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/pkg_logger.go#L55-L57 |
11,935 | coreos/pkg | capnslog/pkg_logger.go | Log | func (p *PackageLogger) Log(l LogLevel, args ...interface{}) {
p.internalLog(calldepth, l, fmt.Sprint(args...))
} | go | func (p *PackageLogger) Log(l LogLevel, args ...interface{}) {
p.internalLog(calldepth, l, fmt.Sprint(args...))
} | [
"func",
"(",
"p",
"*",
"PackageLogger",
")",
"Log",
"(",
"l",
"LogLevel",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"p",
".",
"internalLog",
"(",
"calldepth",
",",
"l",
",",
"fmt",
".",
"Sprint",
"(",
"args",
"...",
")",
")",
"\n",
"}"
]
| // Log a message at any level between ERROR and TRACE | [
"Log",
"a",
"message",
"at",
"any",
"level",
"between",
"ERROR",
"and",
"TRACE"
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/pkg_logger.go#L60-L62 |
11,936 | coreos/pkg | capnslog/pkg_logger.go | Println | func (p *PackageLogger) Println(args ...interface{}) {
p.internalLog(calldepth, INFO, fmt.Sprintln(args...))
} | go | func (p *PackageLogger) Println(args ...interface{}) {
p.internalLog(calldepth, INFO, fmt.Sprintln(args...))
} | [
"func",
"(",
"p",
"*",
"PackageLogger",
")",
"Println",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"p",
".",
"internalLog",
"(",
"calldepth",
",",
"INFO",
",",
"fmt",
".",
"Sprintln",
"(",
"args",
"...",
")",
")",
"\n",
"}"
]
| // log stdlib compatibility | [
"log",
"stdlib",
"compatibility"
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/pkg_logger.go#L66-L68 |
11,937 | coreos/pkg | capnslog/pkg_logger.go | Panicf | func (p *PackageLogger) Panicf(format string, args ...interface{}) {
s := fmt.Sprintf(format, args...)
p.internalLog(calldepth, CRITICAL, s)
panic(s)
} | go | func (p *PackageLogger) Panicf(format string, args ...interface{}) {
s := fmt.Sprintf(format, args...)
p.internalLog(calldepth, CRITICAL, s)
panic(s)
} | [
"func",
"(",
"p",
"*",
"PackageLogger",
")",
"Panicf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
":=",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"p",
".",
"internalLog",
"(",
"calldepth",
",",
"CRITICAL",
",",
"s",
")",
"\n",
"panic",
"(",
"s",
")",
"\n",
"}"
]
| // Panic and fatal | [
"Panic",
"and",
"fatal"
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/capnslog/pkg_logger.go#L80-L84 |
11,938 | coreos/pkg | progressutil/progressbar.go | SetCurrentProgress | 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 | 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
} | [
"func",
"(",
"pb",
"*",
"ProgressBar",
")",
"SetCurrentProgress",
"(",
"progress",
"float64",
")",
"error",
"{",
"if",
"progress",
"<",
"0",
"||",
"progress",
">",
"1",
"{",
"return",
"ErrorProgressOutOfBounds",
"\n",
"}",
"\n",
"pb",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"pb",
".",
"currentProgress",
"=",
"progress",
"\n",
"pb",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
]
| // SetCurrentProgress sets the progress of this ProgressBar. The progress must
// be between 0 and 1 inclusive. | [
"SetCurrentProgress",
"sets",
"the",
"progress",
"of",
"this",
"ProgressBar",
".",
"The",
"progress",
"must",
"be",
"between",
"0",
"and",
"1",
"inclusive",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/progressutil/progressbar.go#L70-L78 |
11,939 | coreos/pkg | progressutil/progressbar.go | GetDone | func (pb *ProgressBar) GetDone() bool {
pb.lock.Lock()
val := pb.done
pb.lock.Unlock()
return val
} | go | func (pb *ProgressBar) GetDone() bool {
pb.lock.Lock()
val := pb.done
pb.lock.Unlock()
return val
} | [
"func",
"(",
"pb",
"*",
"ProgressBar",
")",
"GetDone",
"(",
")",
"bool",
"{",
"pb",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"val",
":=",
"pb",
".",
"done",
"\n",
"pb",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"val",
"\n",
"}"
]
| // GetDone returns whether or not this progress bar is done | [
"GetDone",
"returns",
"whether",
"or",
"not",
"this",
"progress",
"bar",
"is",
"done"
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/progressutil/progressbar.go#L81-L86 |
11,940 | coreos/pkg | progressutil/progressbar.go | GetPrintBefore | func (pb *ProgressBar) GetPrintBefore() string {
pb.lock.Lock()
val := pb.printBefore
pb.lock.Unlock()
return val
} | go | func (pb *ProgressBar) GetPrintBefore() string {
pb.lock.Lock()
val := pb.printBefore
pb.lock.Unlock()
return val
} | [
"func",
"(",
"pb",
"*",
"ProgressBar",
")",
"GetPrintBefore",
"(",
")",
"string",
"{",
"pb",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"val",
":=",
"pb",
".",
"printBefore",
"\n",
"pb",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"val",
"\n",
"}"
]
| // GetPrintBefore gets the text printed on the line before the progress bar. | [
"GetPrintBefore",
"gets",
"the",
"text",
"printed",
"on",
"the",
"line",
"before",
"the",
"progress",
"bar",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/progressutil/progressbar.go#L96-L101 |
11,941 | coreos/pkg | progressutil/progressbar.go | SetPrintBefore | func (pb *ProgressBar) SetPrintBefore(before string) {
pb.lock.Lock()
pb.printBefore = before
pb.lock.Unlock()
} | go | func (pb *ProgressBar) SetPrintBefore(before string) {
pb.lock.Lock()
pb.printBefore = before
pb.lock.Unlock()
} | [
"func",
"(",
"pb",
"*",
"ProgressBar",
")",
"SetPrintBefore",
"(",
"before",
"string",
")",
"{",
"pb",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"pb",
".",
"printBefore",
"=",
"before",
"\n",
"pb",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"}"
]
| // SetPrintBefore sets the text printed on the line before the progress bar. | [
"SetPrintBefore",
"sets",
"the",
"text",
"printed",
"on",
"the",
"line",
"before",
"the",
"progress",
"bar",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/progressutil/progressbar.go#L104-L108 |
11,942 | coreos/pkg | progressutil/progressbar.go | GetPrintAfter | func (pb *ProgressBar) GetPrintAfter() string {
pb.lock.Lock()
val := pb.printAfter
pb.lock.Unlock()
return val
} | go | func (pb *ProgressBar) GetPrintAfter() string {
pb.lock.Lock()
val := pb.printAfter
pb.lock.Unlock()
return val
} | [
"func",
"(",
"pb",
"*",
"ProgressBar",
")",
"GetPrintAfter",
"(",
")",
"string",
"{",
"pb",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"val",
":=",
"pb",
".",
"printAfter",
"\n",
"pb",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"val",
"\n",
"}"
]
| // GetPrintAfter gets the text printed on the line after the progress bar. | [
"GetPrintAfter",
"gets",
"the",
"text",
"printed",
"on",
"the",
"line",
"after",
"the",
"progress",
"bar",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/progressutil/progressbar.go#L111-L116 |
11,943 | coreos/pkg | progressutil/progressbar.go | SetPrintAfter | func (pb *ProgressBar) SetPrintAfter(after string) {
pb.lock.Lock()
pb.printAfter = after
pb.lock.Unlock()
} | go | func (pb *ProgressBar) SetPrintAfter(after string) {
pb.lock.Lock()
pb.printAfter = after
pb.lock.Unlock()
} | [
"func",
"(",
"pb",
"*",
"ProgressBar",
")",
"SetPrintAfter",
"(",
"after",
"string",
")",
"{",
"pb",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"pb",
".",
"printAfter",
"=",
"after",
"\n",
"pb",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"}"
]
| // SetPrintAfter sets the text printed on the line after the progress bar. | [
"SetPrintAfter",
"sets",
"the",
"text",
"printed",
"on",
"the",
"line",
"after",
"the",
"progress",
"bar",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/progressutil/progressbar.go#L119-L123 |
11,944 | coreos/pkg | progressutil/progressbar.go | AddProgressBar | func (pbp *ProgressBarPrinter) AddProgressBar() *ProgressBar {
pb := &ProgressBar{}
pbp.lock.Lock()
pbp.progressBars = append(pbp.progressBars, pb)
pbp.lock.Unlock()
return pb
} | go | func (pbp *ProgressBarPrinter) AddProgressBar() *ProgressBar {
pb := &ProgressBar{}
pbp.lock.Lock()
pbp.progressBars = append(pbp.progressBars, pb)
pbp.lock.Unlock()
return pb
} | [
"func",
"(",
"pbp",
"*",
"ProgressBarPrinter",
")",
"AddProgressBar",
"(",
")",
"*",
"ProgressBar",
"{",
"pb",
":=",
"&",
"ProgressBar",
"{",
"}",
"\n",
"pbp",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"pbp",
".",
"progressBars",
"=",
"append",
"(",
"pbp",
".",
"progressBars",
",",
"pb",
")",
"\n",
"pbp",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"pb",
"\n",
"}"
]
| // AddProgressBar will create a new ProgressBar, register it with this
// ProgressBarPrinter, and return it. This must be called at least once before
// PrintAndWait is called. | [
"AddProgressBar",
"will",
"create",
"a",
"new",
"ProgressBar",
"register",
"it",
"with",
"this",
"ProgressBarPrinter",
"and",
"return",
"it",
".",
"This",
"must",
"be",
"called",
"at",
"least",
"once",
"before",
"PrintAndWait",
"is",
"called",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/progressutil/progressbar.go#L152-L158 |
11,945 | coreos/pkg | progressutil/progressbar.go | Print | 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 | 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
} | [
"func",
"(",
"pbp",
"*",
"ProgressBarPrinter",
")",
"Print",
"(",
"printTo",
"io",
".",
"Writer",
")",
"(",
"bool",
",",
"error",
")",
"{",
"pbp",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"var",
"bars",
"[",
"]",
"*",
"ProgressBar",
"\n",
"for",
"_",
",",
"bar",
":=",
"range",
"pbp",
".",
"progressBars",
"{",
"bars",
"=",
"append",
"(",
"bars",
",",
"bar",
".",
"clone",
"(",
")",
")",
"\n",
"}",
"\n",
"numColumns",
":=",
"pbp",
".",
"DisplayWidth",
"\n",
"pbp",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"len",
"(",
"bars",
")",
"==",
"0",
"{",
"return",
"false",
",",
"ErrorNoBarsAdded",
"\n",
"}",
"\n\n",
"if",
"numColumns",
"==",
"0",
"{",
"numColumns",
"=",
"80",
"\n",
"}",
"\n\n",
"if",
"pbp",
".",
"isTerminal",
"(",
"printTo",
")",
"{",
"moveCursorUp",
"(",
"printTo",
",",
"pbp",
".",
"numLinesInLastPrint",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"bar",
":=",
"range",
"bars",
"{",
"beforeSize",
":=",
"len",
"(",
"bar",
".",
"GetPrintBefore",
"(",
")",
")",
"\n",
"afterSize",
":=",
"len",
"(",
"bar",
".",
"GetPrintAfter",
"(",
")",
")",
"\n",
"if",
"beforeSize",
">",
"pbp",
".",
"maxBefore",
"{",
"pbp",
".",
"maxBefore",
"=",
"beforeSize",
"\n",
"}",
"\n",
"if",
"afterSize",
">",
"pbp",
".",
"maxAfter",
"{",
"pbp",
".",
"maxAfter",
"=",
"afterSize",
"\n",
"}",
"\n",
"}",
"\n\n",
"allDone",
":=",
"true",
"\n",
"for",
"_",
",",
"bar",
":=",
"range",
"bars",
"{",
"if",
"pbp",
".",
"isTerminal",
"(",
"printTo",
")",
"{",
"bar",
".",
"printToTerminal",
"(",
"printTo",
",",
"numColumns",
",",
"pbp",
".",
"PadToBeEven",
",",
"pbp",
".",
"maxBefore",
",",
"pbp",
".",
"maxAfter",
")",
"\n",
"}",
"else",
"{",
"bar",
".",
"printToNonTerminal",
"(",
"printTo",
")",
"\n",
"}",
"\n",
"allDone",
"=",
"allDone",
"&&",
"bar",
".",
"GetCurrentProgress",
"(",
")",
"==",
"1",
"\n",
"}",
"\n\n",
"pbp",
".",
"numLinesInLastPrint",
"=",
"len",
"(",
"bars",
")",
"\n\n",
"return",
"allDone",
",",
"nil",
"\n",
"}"
]
| // Print will print out progress information for each ProgressBar that has been
// added to this ProgressBarPrinter. The progress will be written to printTo,
// and if printTo is a terminal it will draw progress bars. AddProgressBar
// must be called at least once before Print is called. If printing to a
// terminal, all draws after the first one will move the cursor up to draw over
// the previously printed bars. | [
"Print",
"will",
"print",
"out",
"progress",
"information",
"for",
"each",
"ProgressBar",
"that",
"has",
"been",
"added",
"to",
"this",
"ProgressBarPrinter",
".",
"The",
"progress",
"will",
"be",
"written",
"to",
"printTo",
"and",
"if",
"printTo",
"is",
"a",
"terminal",
"it",
"will",
"draw",
"progress",
"bars",
".",
"AddProgressBar",
"must",
"be",
"called",
"at",
"least",
"once",
"before",
"Print",
"is",
"called",
".",
"If",
"printing",
"to",
"a",
"terminal",
"all",
"draws",
"after",
"the",
"first",
"one",
"will",
"move",
"the",
"cursor",
"up",
"to",
"draw",
"over",
"the",
"previously",
"printed",
"bars",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/progressutil/progressbar.go#L166-L211 |
11,946 | coreos/pkg | progressutil/progressbar.go | moveCursorUp | func moveCursorUp(printTo io.Writer, numLines int) {
if numLines > 0 {
fmt.Fprintf(printTo, "\033[%dA", numLines)
}
} | go | func moveCursorUp(printTo io.Writer, numLines int) {
if numLines > 0 {
fmt.Fprintf(printTo, "\033[%dA", numLines)
}
} | [
"func",
"moveCursorUp",
"(",
"printTo",
"io",
".",
"Writer",
",",
"numLines",
"int",
")",
"{",
"if",
"numLines",
">",
"0",
"{",
"fmt",
".",
"Fprintf",
"(",
"printTo",
",",
"\"",
"\\033",
"\"",
",",
"numLines",
")",
"\n",
"}",
"\n",
"}"
]
| // moveCursorUp moves the cursor up numLines in the terminal | [
"moveCursorUp",
"moves",
"the",
"cursor",
"up",
"numLines",
"in",
"the",
"terminal"
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/progressutil/progressbar.go#L214-L218 |
11,947 | coreos/pkg | progressutil/progressbar.go | isTerminal | 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 | 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
} | [
"func",
"(",
"pbp",
"*",
"ProgressBarPrinter",
")",
"isTerminal",
"(",
"w",
"io",
".",
"Writer",
")",
"bool",
"{",
"if",
"pbp",
".",
"printToTTYAlways",
"{",
"return",
"true",
"\n",
"}",
"\n",
"if",
"f",
",",
"ok",
":=",
"w",
".",
"(",
"*",
"os",
".",
"File",
")",
";",
"ok",
"{",
"return",
"terminal",
".",
"IsTerminal",
"(",
"int",
"(",
"f",
".",
"Fd",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
]
| // isTerminal returns True when w is going to a tty, and false otherwise. | [
"isTerminal",
"returns",
"True",
"when",
"w",
"is",
"going",
"to",
"a",
"tty",
"and",
"false",
"otherwise",
"."
]
| 399ea9e2e55f791b6e3d920860dbecb99c3692f0 | https://github.com/coreos/pkg/blob/399ea9e2e55f791b6e3d920860dbecb99c3692f0/progressutil/progressbar.go#L255-L263 |
11,948 | xordataexchange/crypt | config/config.go | NewStandardEtcdConfigManager | func NewStandardEtcdConfigManager(machines []string) (ConfigManager, error) {
store, err := etcd.New(machines)
if err != nil {
return nil, err
}
return NewStandardConfigManager(store)
} | go | func NewStandardEtcdConfigManager(machines []string) (ConfigManager, error) {
store, err := etcd.New(machines)
if err != nil {
return nil, err
}
return NewStandardConfigManager(store)
} | [
"func",
"NewStandardEtcdConfigManager",
"(",
"machines",
"[",
"]",
"string",
")",
"(",
"ConfigManager",
",",
"error",
")",
"{",
"store",
",",
"err",
":=",
"etcd",
".",
"New",
"(",
"machines",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewStandardConfigManager",
"(",
"store",
")",
"\n",
"}"
]
| // NewStandardEtcdConfigManager returns a new ConfigManager backed by etcd. | [
"NewStandardEtcdConfigManager",
"returns",
"a",
"new",
"ConfigManager",
"backed",
"by",
"etcd",
"."
]
| b2862e3d0a775f18c7cfe02273500ae307b61218 | https://github.com/xordataexchange/crypt/blob/b2862e3d0a775f18c7cfe02273500ae307b61218/config/config.go#L50-L57 |
11,949 | xordataexchange/crypt | config/config.go | NewStandardConsulConfigManager | func NewStandardConsulConfigManager(machines []string) (ConfigManager, error) {
store, err := consul.New(machines)
if err != nil {
return nil, err
}
return NewStandardConfigManager(store)
} | go | func NewStandardConsulConfigManager(machines []string) (ConfigManager, error) {
store, err := consul.New(machines)
if err != nil {
return nil, err
}
return NewStandardConfigManager(store)
} | [
"func",
"NewStandardConsulConfigManager",
"(",
"machines",
"[",
"]",
"string",
")",
"(",
"ConfigManager",
",",
"error",
")",
"{",
"store",
",",
"err",
":=",
"consul",
".",
"New",
"(",
"machines",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewStandardConfigManager",
"(",
"store",
")",
"\n",
"}"
]
| // NewStandardConsulConfigManager returns a new ConfigManager backed by consul. | [
"NewStandardConsulConfigManager",
"returns",
"a",
"new",
"ConfigManager",
"backed",
"by",
"consul",
"."
]
| b2862e3d0a775f18c7cfe02273500ae307b61218 | https://github.com/xordataexchange/crypt/blob/b2862e3d0a775f18c7cfe02273500ae307b61218/config/config.go#L60-L66 |
11,950 | xordataexchange/crypt | config/config.go | NewEtcdConfigManager | 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 | func NewEtcdConfigManager(machines []string, keystore io.Reader) (ConfigManager, error) {
store, err := etcd.New(machines)
if err != nil {
return nil, err
}
return NewConfigManager(store, keystore)
} | [
"func",
"NewEtcdConfigManager",
"(",
"machines",
"[",
"]",
"string",
",",
"keystore",
"io",
".",
"Reader",
")",
"(",
"ConfigManager",
",",
"error",
")",
"{",
"store",
",",
"err",
":=",
"etcd",
".",
"New",
"(",
"machines",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewConfigManager",
"(",
"store",
",",
"keystore",
")",
"\n",
"}"
]
| // NewEtcdConfigManager returns a new ConfigManager backed by etcd.
// Data will be encrypted. | [
"NewEtcdConfigManager",
"returns",
"a",
"new",
"ConfigManager",
"backed",
"by",
"etcd",
".",
"Data",
"will",
"be",
"encrypted",
"."
]
| b2862e3d0a775f18c7cfe02273500ae307b61218 | https://github.com/xordataexchange/crypt/blob/b2862e3d0a775f18c7cfe02273500ae307b61218/config/config.go#L70-L76 |
11,951 | xordataexchange/crypt | config/config.go | NewConsulConfigManager | 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 | func NewConsulConfigManager(machines []string, keystore io.Reader) (ConfigManager, error) {
store, err := consul.New(machines)
if err != nil {
return nil, err
}
return NewConfigManager(store, keystore)
} | [
"func",
"NewConsulConfigManager",
"(",
"machines",
"[",
"]",
"string",
",",
"keystore",
"io",
".",
"Reader",
")",
"(",
"ConfigManager",
",",
"error",
")",
"{",
"store",
",",
"err",
":=",
"consul",
".",
"New",
"(",
"machines",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"NewConfigManager",
"(",
"store",
",",
"keystore",
")",
"\n",
"}"
]
| // NewConsulConfigManager returns a new ConfigManager backed by consul.
// Data will be encrypted. | [
"NewConsulConfigManager",
"returns",
"a",
"new",
"ConfigManager",
"backed",
"by",
"consul",
".",
"Data",
"will",
"be",
"encrypted",
"."
]
| b2862e3d0a775f18c7cfe02273500ae307b61218 | https://github.com/xordataexchange/crypt/blob/b2862e3d0a775f18c7cfe02273500ae307b61218/config/config.go#L80-L86 |
11,952 | xordataexchange/crypt | config/config.go | Get | 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 | 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))
} | [
"func",
"(",
"c",
"configManager",
")",
"Get",
"(",
"key",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"value",
",",
"err",
":=",
"c",
".",
"store",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"secconf",
".",
"Decode",
"(",
"value",
",",
"bytes",
".",
"NewBuffer",
"(",
"c",
".",
"keystore",
")",
")",
"\n",
"}"
]
| // Get retrieves and decodes a secconf value stored at key. | [
"Get",
"retrieves",
"and",
"decodes",
"a",
"secconf",
"value",
"stored",
"at",
"key",
"."
]
| b2862e3d0a775f18c7cfe02273500ae307b61218 | https://github.com/xordataexchange/crypt/blob/b2862e3d0a775f18c7cfe02273500ae307b61218/config/config.go#L89-L95 |
11,953 | xordataexchange/crypt | config/config.go | Get | func (c standardConfigManager) Get(key string) ([]byte, error) {
value, err := c.store.Get(key)
if err != nil {
return nil, err
}
return value, err
} | go | func (c standardConfigManager) Get(key string) ([]byte, error) {
value, err := c.store.Get(key)
if err != nil {
return nil, err
}
return value, err
} | [
"func",
"(",
"c",
"standardConfigManager",
")",
"Get",
"(",
"key",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"value",
",",
"err",
":=",
"c",
".",
"store",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"value",
",",
"err",
"\n",
"}"
]
| // Get retrieves a value stored at key.
// convenience function, no additional value provided over
// `etcdctl` | [
"Get",
"retrieves",
"a",
"value",
"stored",
"at",
"key",
".",
"convenience",
"function",
"no",
"additional",
"value",
"provided",
"over",
"etcdctl"
]
| b2862e3d0a775f18c7cfe02273500ae307b61218 | https://github.com/xordataexchange/crypt/blob/b2862e3d0a775f18c7cfe02273500ae307b61218/config/config.go#L100-L106 |
11,954 | xordataexchange/crypt | config/config.go | List | 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 | 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
} | [
"func",
"(",
"c",
"configManager",
")",
"List",
"(",
"key",
"string",
")",
"(",
"KVPairs",
",",
"error",
")",
"{",
"list",
",",
"err",
":=",
"c",
".",
"store",
".",
"List",
"(",
"key",
")",
"\n",
"retList",
":=",
"make",
"(",
"KVPairs",
",",
"len",
"(",
"list",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"kv",
":=",
"range",
"list",
"{",
"retList",
"[",
"i",
"]",
".",
"Key",
"=",
"kv",
".",
"Key",
"\n",
"retList",
"[",
"i",
"]",
".",
"Value",
",",
"err",
"=",
"secconf",
".",
"Decode",
"(",
"kv",
".",
"Value",
",",
"bytes",
".",
"NewBuffer",
"(",
"c",
".",
"keystore",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"retList",
",",
"nil",
"\n",
"}"
]
| // List retrieves and decodes all secconf value stored under key. | [
"List",
"retrieves",
"and",
"decodes",
"all",
"secconf",
"value",
"stored",
"under",
"key",
"."
]
| b2862e3d0a775f18c7cfe02273500ae307b61218 | https://github.com/xordataexchange/crypt/blob/b2862e3d0a775f18c7cfe02273500ae307b61218/config/config.go#L109-L123 |
11,955 | xordataexchange/crypt | config/config.go | List | 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 | 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
} | [
"func",
"(",
"c",
"standardConfigManager",
")",
"List",
"(",
"key",
"string",
")",
"(",
"KVPairs",
",",
"error",
")",
"{",
"list",
",",
"err",
":=",
"c",
".",
"store",
".",
"List",
"(",
"key",
")",
"\n",
"retList",
":=",
"make",
"(",
"KVPairs",
",",
"len",
"(",
"list",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"for",
"i",
",",
"kv",
":=",
"range",
"list",
"{",
"retList",
"[",
"i",
"]",
".",
"Key",
"=",
"kv",
".",
"Key",
"\n",
"retList",
"[",
"i",
"]",
".",
"Value",
"=",
"kv",
".",
"Value",
"\n",
"}",
"\n",
"return",
"retList",
",",
"err",
"\n",
"}"
]
| // List retrieves all values under key.
// convenience function, no additional value provided over
// `etcdctl` | [
"List",
"retrieves",
"all",
"values",
"under",
"key",
".",
"convenience",
"function",
"no",
"additional",
"value",
"provided",
"over",
"etcdctl"
]
| b2862e3d0a775f18c7cfe02273500ae307b61218 | https://github.com/xordataexchange/crypt/blob/b2862e3d0a775f18c7cfe02273500ae307b61218/config/config.go#L128-L139 |
11,956 | xordataexchange/crypt | encoding/secconf/secconf.go | Decode | 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 | 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
} | [
"func",
"Decode",
"(",
"data",
"[",
"]",
"byte",
",",
"secertKeyring",
"io",
".",
"Reader",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"decoder",
":=",
"base64",
".",
"NewDecoder",
"(",
"base64",
".",
"StdEncoding",
",",
"bytes",
".",
"NewBuffer",
"(",
"data",
")",
")",
"\n",
"entityList",
",",
"err",
":=",
"openpgp",
".",
"ReadArmoredKeyRing",
"(",
"secertKeyring",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"md",
",",
"err",
":=",
"openpgp",
".",
"ReadMessage",
"(",
"decoder",
",",
"entityList",
",",
"nil",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"gzReader",
",",
"err",
":=",
"gzip",
".",
"NewReader",
"(",
"md",
".",
"UnverifiedBody",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"gzReader",
".",
"Close",
"(",
")",
"\n",
"bytes",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"gzReader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"bytes",
",",
"nil",
"\n",
"}"
]
| // Deocde decodes data using the secconf codec. | [
"Deocde",
"decodes",
"data",
"using",
"the",
"secconf",
"codec",
"."
]
| b2862e3d0a775f18c7cfe02273500ae307b61218 | https://github.com/xordataexchange/crypt/blob/b2862e3d0a775f18c7cfe02273500ae307b61218/encoding/secconf/secconf.go#L19-L39 |
11,957 | xordataexchange/crypt | encoding/secconf/secconf.go | Encode | 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 | 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
} | [
"func",
"Encode",
"(",
"data",
"[",
"]",
"byte",
",",
"keyring",
"io",
".",
"Reader",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"entityList",
",",
"err",
":=",
"openpgp",
".",
"ReadArmoredKeyRing",
"(",
"keyring",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"buffer",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"encoder",
":=",
"base64",
".",
"NewEncoder",
"(",
"base64",
".",
"StdEncoding",
",",
"buffer",
")",
"\n",
"pgpWriter",
",",
"err",
":=",
"openpgp",
".",
"Encrypt",
"(",
"encoder",
",",
"entityList",
",",
"nil",
",",
"nil",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"gzWriter",
":=",
"gzip",
".",
"NewWriter",
"(",
"pgpWriter",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"gzWriter",
".",
"Write",
"(",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"gzWriter",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"pgpWriter",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"encoder",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"buffer",
".",
"Bytes",
"(",
")",
",",
"nil",
"\n",
"}"
]
| // Encode encodes data to a base64 encoded using the secconf codec.
// data is encrypted with all public keys found in the supplied keyring. | [
"Encode",
"encodes",
"data",
"to",
"a",
"base64",
"encoded",
"using",
"the",
"secconf",
"codec",
".",
"data",
"is",
"encrypted",
"with",
"all",
"public",
"keys",
"found",
"in",
"the",
"supplied",
"keyring",
"."
]
| b2862e3d0a775f18c7cfe02273500ae307b61218 | https://github.com/xordataexchange/crypt/blob/b2862e3d0a775f18c7cfe02273500ae307b61218/encoding/secconf/secconf.go#L43-L68 |
11,958 | nimajalali/go-force | sobjects/base.go | ConvertFieldNames | 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 | 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 ""
} | [
"func",
"ConvertFieldNames",
"(",
"obj",
"interface",
"{",
"}",
",",
"jsonFields",
"string",
")",
"string",
"{",
"if",
"jsonFields",
"!=",
"\"",
"\"",
"{",
"fields",
":=",
"strings",
".",
"Split",
"(",
"jsonFields",
",",
"\"",
"\"",
")",
"\n\n",
"length",
":=",
"len",
"(",
"fields",
")",
"\n",
"if",
"length",
">",
"0",
"{",
"mapping",
":=",
"fieldNameMapping",
"(",
"obj",
")",
"\n\n",
"var",
"forceFields",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"field",
":=",
"range",
"fields",
"{",
"if",
"forceField",
",",
"ok",
":=",
"mapping",
"[",
"field",
"]",
";",
"ok",
"{",
"forceFields",
"=",
"append",
"(",
"forceFields",
",",
"forceField",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"strings",
".",
"Join",
"(",
"forceFields",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
"\n",
"}"
]
| // ConvertFieldNames takes in any interface that inplements SObject and a comma separated list of json field names.
// It converts the json field names to the force struct tag stated equivalent. | [
"ConvertFieldNames",
"takes",
"in",
"any",
"interface",
"that",
"inplements",
"SObject",
"and",
"a",
"comma",
"separated",
"list",
"of",
"json",
"field",
"names",
".",
"It",
"converts",
"the",
"json",
"field",
"names",
"to",
"the",
"force",
"struct",
"tag",
"stated",
"equivalent",
"."
]
| 2b94c45dfae2031455d916cef1a4a16b04a0f453 | https://github.com/nimajalali/go-force/blob/2b94c45dfae2031455d916cef1a4a16b04a0f453/sobjects/base.go#L60-L80 |
11,959 | nimajalali/go-force | sobjects/base.go | fieldNameMapping | 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 | 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
} | [
"func",
"fieldNameMapping",
"(",
"obj",
"interface",
"{",
"}",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"st",
":=",
"reflect",
".",
"TypeOf",
"(",
"obj",
")",
"\n",
"fl",
":=",
"st",
".",
"NumField",
"(",
")",
"\n\n",
"jsonToForce",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"fl",
")",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"fl",
";",
"i",
"++",
"{",
"sf",
":=",
"st",
".",
"Field",
"(",
"i",
")",
"\n",
"jName",
":=",
"strings",
".",
"SplitN",
"(",
"sf",
".",
"Tag",
".",
"Get",
"(",
"\"",
"\"",
")",
",",
"\"",
"\"",
",",
"2",
")",
"[",
"0",
"]",
"\n",
"fName",
":=",
"strings",
".",
"SplitN",
"(",
"sf",
".",
"Tag",
".",
"Get",
"(",
"\"",
"\"",
")",
",",
"\"",
"\"",
",",
"2",
")",
"[",
"0",
"]",
"\n\n",
"if",
"jName",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"fName",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"jName",
"==",
"\"",
"\"",
"{",
"jName",
"=",
"sf",
".",
"Name",
"\n",
"}",
"\n\n",
"if",
"fName",
"==",
"\"",
"\"",
"{",
"fName",
"=",
"sf",
".",
"Name",
"\n",
"}",
"\n\n",
"jsonToForce",
"[",
"jName",
"]",
"=",
"fName",
"\n",
"}",
"\n\n",
"for",
"k",
",",
"v",
":=",
"range",
"baseFieldNameMap",
"{",
"jsonToForce",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n\n",
"return",
"jsonToForce",
"\n",
"}"
]
| // Helper function used in ConvertFieldNames | [
"Helper",
"function",
"used",
"in",
"ConvertFieldNames"
]
| 2b94c45dfae2031455d916cef1a4a16b04a0f453 | https://github.com/nimajalali/go-force/blob/2b94c45dfae2031455d916cef1a4a16b04a0f453/sobjects/base.go#L83-L118 |
11,960 | nimajalali/go-force | force/query.go | Query | 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 | 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
} | [
"func",
"(",
"forceApi",
"*",
"ForceApi",
")",
"Query",
"(",
"query",
"string",
",",
"out",
"interface",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"uri",
":=",
"forceApi",
".",
"apiResources",
"[",
"queryKey",
"]",
"\n\n",
"params",
":=",
"url",
".",
"Values",
"{",
"\"",
"\"",
":",
"{",
"query",
"}",
",",
"}",
"\n\n",
"err",
"=",
"forceApi",
".",
"Get",
"(",
"uri",
",",
"params",
",",
"out",
")",
"\n\n",
"return",
"\n",
"}"
]
| // Use the Query resource to execute a SOQL query that returns all the results in a single response,
// or if needed, returns part of the results and an identifier used to retrieve the remaining results. | [
"Use",
"the",
"Query",
"resource",
"to",
"execute",
"a",
"SOQL",
"query",
"that",
"returns",
"all",
"the",
"results",
"in",
"a",
"single",
"response",
"or",
"if",
"needed",
"returns",
"part",
"of",
"the",
"results",
"and",
"an",
"identifier",
"used",
"to",
"retrieve",
"the",
"remaining",
"results",
"."
]
| 2b94c45dfae2031455d916cef1a4a16b04a0f453 | https://github.com/nimajalali/go-force/blob/2b94c45dfae2031455d916cef1a4a16b04a0f453/force/query.go#L24-L34 |
11,961 | nimajalali/go-force | force/query.go | QueryAll | 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 | 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
} | [
"func",
"(",
"forceApi",
"*",
"ForceApi",
")",
"QueryAll",
"(",
"query",
"string",
",",
"out",
"interface",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"uri",
":=",
"forceApi",
".",
"apiResources",
"[",
"queryAllKey",
"]",
"\n\n",
"params",
":=",
"url",
".",
"Values",
"{",
"\"",
"\"",
":",
"{",
"query",
"}",
",",
"}",
"\n\n",
"err",
"=",
"forceApi",
".",
"Get",
"(",
"uri",
",",
"params",
",",
"out",
")",
"\n\n",
"return",
"\n",
"}"
]
| // Use the QueryAll resource to execute a SOQL query that includes information about records that have
// been deleted because of a merge or delete. Use QueryAll rather than Query, because the Query resource
// will automatically filter out items that have been deleted. | [
"Use",
"the",
"QueryAll",
"resource",
"to",
"execute",
"a",
"SOQL",
"query",
"that",
"includes",
"information",
"about",
"records",
"that",
"have",
"been",
"deleted",
"because",
"of",
"a",
"merge",
"or",
"delete",
".",
"Use",
"QueryAll",
"rather",
"than",
"Query",
"because",
"the",
"Query",
"resource",
"will",
"automatically",
"filter",
"out",
"items",
"that",
"have",
"been",
"deleted",
"."
]
| 2b94c45dfae2031455d916cef1a4a16b04a0f453 | https://github.com/nimajalali/go-force/blob/2b94c45dfae2031455d916cef1a4a16b04a0f453/force/query.go#L39-L49 |
11,962 | nimajalali/go-force | forcejson/scanner.go | nextValue | 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 | 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
} | [
"func",
"nextValue",
"(",
"data",
"[",
"]",
"byte",
",",
"scan",
"*",
"scanner",
")",
"(",
"value",
",",
"rest",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"scan",
".",
"reset",
"(",
")",
"\n",
"for",
"i",
",",
"c",
":=",
"range",
"data",
"{",
"v",
":=",
"scan",
".",
"step",
"(",
"scan",
",",
"int",
"(",
"c",
")",
")",
"\n",
"if",
"v",
">=",
"scanEnd",
"{",
"switch",
"v",
"{",
"case",
"scanError",
":",
"return",
"nil",
",",
"nil",
",",
"scan",
".",
"err",
"\n",
"case",
"scanEnd",
":",
"return",
"data",
"[",
"0",
":",
"i",
"]",
",",
"data",
"[",
"i",
":",
"]",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"scan",
".",
"eof",
"(",
")",
"==",
"scanError",
"{",
"return",
"nil",
",",
"nil",
",",
"scan",
".",
"err",
"\n",
"}",
"\n",
"return",
"data",
",",
"nil",
",",
"nil",
"\n",
"}"
]
| // nextValue splits data after the next whole JSON value,
// returning that value and the bytes that follow it as separate slices.
// scan is passed in for use by nextValue to avoid an allocation. | [
"nextValue",
"splits",
"data",
"after",
"the",
"next",
"whole",
"JSON",
"value",
"returning",
"that",
"value",
"and",
"the",
"bytes",
"that",
"follow",
"it",
"as",
"separate",
"slices",
".",
"scan",
"is",
"passed",
"in",
"for",
"use",
"by",
"nextValue",
"to",
"avoid",
"an",
"allocation",
"."
]
| 2b94c45dfae2031455d916cef1a4a16b04a0f453 | https://github.com/nimajalali/go-force/blob/2b94c45dfae2031455d916cef1a4a16b04a0f453/forcejson/scanner.go#L37-L54 |
11,963 | nimajalali/go-force | force/client.go | Delete | func (forceApi *ForceApi) Delete(path string, params url.Values) error {
return forceApi.request("DELETE", path, params, nil, nil)
} | go | func (forceApi *ForceApi) Delete(path string, params url.Values) error {
return forceApi.request("DELETE", path, params, nil, nil)
} | [
"func",
"(",
"forceApi",
"*",
"ForceApi",
")",
"Delete",
"(",
"path",
"string",
",",
"params",
"url",
".",
"Values",
")",
"error",
"{",
"return",
"forceApi",
".",
"request",
"(",
"\"",
"\"",
",",
"path",
",",
"params",
",",
"nil",
",",
"nil",
")",
"\n",
"}"
]
| // Delete issues a DELETE to the specified path with the given payload | [
"Delete",
"issues",
"a",
"DELETE",
"to",
"the",
"specified",
"path",
"with",
"the",
"given",
"payload"
]
| 2b94c45dfae2031455d916cef1a4a16b04a0f453 | https://github.com/nimajalali/go-force/blob/2b94c45dfae2031455d916cef1a4a16b04a0f453/force/client.go#L46-L48 |
11,964 | nimajalali/go-force | forcejson/decode.go | saveError | func (d *decodeState) saveError(err error) {
if d.savedError == nil {
d.savedError = err
}
} | go | func (d *decodeState) saveError(err error) {
if d.savedError == nil {
d.savedError = err
}
} | [
"func",
"(",
"d",
"*",
"decodeState",
")",
"saveError",
"(",
"err",
"error",
")",
"{",
"if",
"d",
".",
"savedError",
"==",
"nil",
"{",
"d",
".",
"savedError",
"=",
"err",
"\n",
"}",
"\n",
"}"
]
| // saveError saves the first err it is called with,
// for reporting at the end of the unmarshal. | [
"saveError",
"saves",
"the",
"first",
"err",
"it",
"is",
"called",
"with",
"for",
"reporting",
"at",
"the",
"end",
"of",
"the",
"unmarshal",
"."
]
| 2b94c45dfae2031455d916cef1a4a16b04a0f453 | https://github.com/nimajalali/go-force/blob/2b94c45dfae2031455d916cef1a4a16b04a0f453/forcejson/decode.go#L194-L198 |
11,965 | studio-b12/gowebdav | file.go | String | 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 | 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)
} | [
"func",
"(",
"f",
"File",
")",
"String",
"(",
")",
"string",
"{",
"if",
"f",
".",
"isdir",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"f",
".",
"path",
",",
"f",
".",
"name",
")",
"\n",
"}",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"f",
".",
"path",
",",
"f",
".",
"size",
",",
"f",
".",
"modified",
".",
"String",
"(",
")",
",",
"f",
".",
"etag",
",",
"f",
".",
"contentType",
")",
"\n",
"}"
]
| // String lets us see file information | [
"String",
"lets",
"us",
"see",
"file",
"information"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/file.go#L66-L72 |
11,966 | studio-b12/gowebdav | utils.go | PathEscape | func PathEscape(path string) string {
s := strings.Split(path, "/")
for i, e := range s {
s[i] = url.PathEscape(e)
}
return strings.Join(s, "/")
} | go | func PathEscape(path string) string {
s := strings.Split(path, "/")
for i, e := range s {
s[i] = url.PathEscape(e)
}
return strings.Join(s, "/")
} | [
"func",
"PathEscape",
"(",
"path",
"string",
")",
"string",
"{",
"s",
":=",
"strings",
".",
"Split",
"(",
"path",
",",
"\"",
"\"",
")",
"\n",
"for",
"i",
",",
"e",
":=",
"range",
"s",
"{",
"s",
"[",
"i",
"]",
"=",
"url",
".",
"PathEscape",
"(",
"e",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"s",
",",
"\"",
"\"",
")",
"\n",
"}"
]
| // PathEscape escapes all segemnts of a given path | [
"PathEscape",
"escapes",
"all",
"segemnts",
"of",
"a",
"given",
"path"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/utils.go#L36-L42 |
11,967 | studio-b12/gowebdav | utils.go | Join | func Join(path0 string, path1 string) string {
return strings.TrimSuffix(path0, "/") + "/" + strings.TrimPrefix(path1, "/")
} | go | func Join(path0 string, path1 string) string {
return strings.TrimSuffix(path0, "/") + "/" + strings.TrimPrefix(path1, "/")
} | [
"func",
"Join",
"(",
"path0",
"string",
",",
"path1",
"string",
")",
"string",
"{",
"return",
"strings",
".",
"TrimSuffix",
"(",
"path0",
",",
"\"",
"\"",
")",
"+",
"\"",
"\"",
"+",
"strings",
".",
"TrimPrefix",
"(",
"path1",
",",
"\"",
"\"",
")",
"\n",
"}"
]
| // Join joins two paths | [
"Join",
"joins",
"two",
"paths"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/utils.go#L61-L63 |
11,968 | studio-b12/gowebdav | utils.go | String | 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 | func String(r io.Reader) string {
buf := new(bytes.Buffer)
// TODO - make String return an error as well
_, _ = buf.ReadFrom(r)
return buf.String()
} | [
"func",
"String",
"(",
"r",
"io",
".",
"Reader",
")",
"string",
"{",
"buf",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"// TODO - make String return an error as well",
"_",
",",
"_",
"=",
"buf",
".",
"ReadFrom",
"(",
"r",
")",
"\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
]
| // String pulls a string out of our io.Reader | [
"String",
"pulls",
"a",
"string",
"out",
"of",
"our",
"io",
".",
"Reader"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/utils.go#L66-L71 |
11,969 | studio-b12/gowebdav | client.go | NewClient | func NewClient(uri, user, pw string) *Client {
return &Client{FixSlash(uri), make(http.Header), &http.Client{}, &NoAuth{user, pw}}
} | go | func NewClient(uri, user, pw string) *Client {
return &Client{FixSlash(uri), make(http.Header), &http.Client{}, &NoAuth{user, pw}}
} | [
"func",
"NewClient",
"(",
"uri",
",",
"user",
",",
"pw",
"string",
")",
"*",
"Client",
"{",
"return",
"&",
"Client",
"{",
"FixSlash",
"(",
"uri",
")",
",",
"make",
"(",
"http",
".",
"Header",
")",
",",
"&",
"http",
".",
"Client",
"{",
"}",
",",
"&",
"NoAuth",
"{",
"user",
",",
"pw",
"}",
"}",
"\n",
"}"
]
| // NewClient creates a new instance of client | [
"NewClient",
"creates",
"a",
"new",
"instance",
"of",
"client"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/client.go#L57-L59 |
11,970 | studio-b12/gowebdav | client.go | SetTransport | func (c *Client) SetTransport(transport http.RoundTripper) {
c.c.Transport = transport
} | go | func (c *Client) SetTransport(transport http.RoundTripper) {
c.c.Transport = transport
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SetTransport",
"(",
"transport",
"http",
".",
"RoundTripper",
")",
"{",
"c",
".",
"c",
".",
"Transport",
"=",
"transport",
"\n",
"}"
]
| // SetTransport exposes the ability to define custom transports | [
"SetTransport",
"exposes",
"the",
"ability",
"to",
"define",
"custom",
"transports"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/client.go#L72-L74 |
11,971 | studio-b12/gowebdav | client.go | Connect | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Connect",
"(",
")",
"error",
"{",
"rs",
",",
"err",
":=",
"c",
".",
"options",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"rs",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"rs",
".",
"StatusCode",
"!=",
"200",
"{",
"return",
"newPathError",
"(",
"\"",
"\"",
",",
"c",
".",
"root",
",",
"rs",
".",
"StatusCode",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
]
| // Connect connects to our dav server | [
"Connect",
"connects",
"to",
"our",
"dav",
"server"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/client.go#L77-L93 |
11,972 | studio-b12/gowebdav | client.go | ReadDir | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ReadDir",
"(",
"path",
"string",
")",
"(",
"[",
"]",
"os",
".",
"FileInfo",
",",
"error",
")",
"{",
"path",
"=",
"FixSlashes",
"(",
"path",
")",
"\n",
"files",
":=",
"make",
"(",
"[",
"]",
"os",
".",
"FileInfo",
",",
"0",
")",
"\n",
"skipSelf",
":=",
"true",
"\n",
"parse",
":=",
"func",
"(",
"resp",
"interface",
"{",
"}",
")",
"error",
"{",
"r",
":=",
"resp",
".",
"(",
"*",
"response",
")",
"\n\n",
"if",
"skipSelf",
"{",
"skipSelf",
"=",
"false",
"\n",
"if",
"p",
":=",
"getProps",
"(",
"r",
",",
"\"",
"\"",
")",
";",
"p",
"!=",
"nil",
"&&",
"p",
".",
"Type",
".",
"Local",
"==",
"\"",
"\"",
"{",
"r",
".",
"Props",
"=",
"nil",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"newPathError",
"(",
"\"",
"\"",
",",
"path",
",",
"405",
")",
"\n",
"}",
"\n\n",
"if",
"p",
":=",
"getProps",
"(",
"r",
",",
"\"",
"\"",
")",
";",
"p",
"!=",
"nil",
"{",
"f",
":=",
"new",
"(",
"File",
")",
"\n",
"if",
"ps",
",",
"err",
":=",
"url",
".",
"QueryUnescape",
"(",
"r",
".",
"Href",
")",
";",
"err",
"==",
"nil",
"{",
"f",
".",
"name",
"=",
"pathpkg",
".",
"Base",
"(",
"ps",
")",
"\n",
"}",
"else",
"{",
"f",
".",
"name",
"=",
"p",
".",
"Name",
"\n",
"}",
"\n",
"f",
".",
"path",
"=",
"path",
"+",
"f",
".",
"name",
"\n",
"f",
".",
"modified",
"=",
"parseModified",
"(",
"&",
"p",
".",
"Modified",
")",
"\n",
"f",
".",
"etag",
"=",
"p",
".",
"ETag",
"\n",
"f",
".",
"contentType",
"=",
"p",
".",
"ContentType",
"\n\n",
"if",
"p",
".",
"Type",
".",
"Local",
"==",
"\"",
"\"",
"{",
"f",
".",
"path",
"+=",
"\"",
"\"",
"\n",
"f",
".",
"size",
"=",
"0",
"\n",
"f",
".",
"isdir",
"=",
"true",
"\n",
"}",
"else",
"{",
"f",
".",
"size",
"=",
"parseInt64",
"(",
"&",
"p",
".",
"Size",
")",
"\n",
"f",
".",
"isdir",
"=",
"false",
"\n",
"}",
"\n\n",
"files",
"=",
"append",
"(",
"files",
",",
"*",
"f",
")",
"\n",
"}",
"\n\n",
"r",
".",
"Props",
"=",
"nil",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"err",
":=",
"c",
".",
"propfind",
"(",
"path",
",",
"false",
",",
"`<d:propfind xmlns:d='DAV:'>\n\t\t\t<d:prop>\n\t\t\t\t<d:displayname/>\n\t\t\t\t<d:resourcetype/>\n\t\t\t\t<d:getcontentlength/>\n\t\t\t\t<d:getcontenttype/>\n\t\t\t\t<d:getetag/>\n\t\t\t\t<d:getlastmodified/>\n\t\t\t</d:prop>\n\t\t</d:propfind>`",
",",
"&",
"response",
"{",
"}",
",",
"parse",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"os",
".",
"PathError",
")",
";",
"!",
"ok",
"{",
"err",
"=",
"newPathErrorErr",
"(",
"\"",
"\"",
",",
"path",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"files",
",",
"err",
"\n",
"}"
]
| // ReadDir reads the contents of a remote directory | [
"ReadDir",
"reads",
"the",
"contents",
"of",
"a",
"remote",
"directory"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/client.go#L120-L184 |
11,973 | studio-b12/gowebdav | client.go | Stat | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Stat",
"(",
"path",
"string",
")",
"(",
"os",
".",
"FileInfo",
",",
"error",
")",
"{",
"var",
"f",
"*",
"File",
"\n",
"parse",
":=",
"func",
"(",
"resp",
"interface",
"{",
"}",
")",
"error",
"{",
"r",
":=",
"resp",
".",
"(",
"*",
"response",
")",
"\n",
"if",
"p",
":=",
"getProps",
"(",
"r",
",",
"\"",
"\"",
")",
";",
"p",
"!=",
"nil",
"&&",
"f",
"==",
"nil",
"{",
"f",
"=",
"new",
"(",
"File",
")",
"\n",
"f",
".",
"name",
"=",
"p",
".",
"Name",
"\n",
"f",
".",
"path",
"=",
"path",
"\n",
"f",
".",
"etag",
"=",
"p",
".",
"ETag",
"\n",
"f",
".",
"contentType",
"=",
"p",
".",
"ContentType",
"\n\n",
"if",
"p",
".",
"Type",
".",
"Local",
"==",
"\"",
"\"",
"{",
"if",
"!",
"strings",
".",
"HasSuffix",
"(",
"f",
".",
"path",
",",
"\"",
"\"",
")",
"{",
"f",
".",
"path",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"f",
".",
"size",
"=",
"0",
"\n",
"f",
".",
"modified",
"=",
"time",
".",
"Unix",
"(",
"0",
",",
"0",
")",
"\n",
"f",
".",
"isdir",
"=",
"true",
"\n",
"}",
"else",
"{",
"f",
".",
"size",
"=",
"parseInt64",
"(",
"&",
"p",
".",
"Size",
")",
"\n",
"f",
".",
"modified",
"=",
"parseModified",
"(",
"&",
"p",
".",
"Modified",
")",
"\n",
"f",
".",
"isdir",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"r",
".",
"Props",
"=",
"nil",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"err",
":=",
"c",
".",
"propfind",
"(",
"path",
",",
"true",
",",
"`<d:propfind xmlns:d='DAV:'>\n\t\t\t<d:prop>\n\t\t\t\t<d:displayname/>\n\t\t\t\t<d:resourcetype/>\n\t\t\t\t<d:getcontentlength/>\n\t\t\t\t<d:getcontenttype/>\n\t\t\t\t<d:getetag/>\n\t\t\t\t<d:getlastmodified/>\n\t\t\t</d:prop>\n\t\t</d:propfind>`",
",",
"&",
"response",
"{",
"}",
",",
"parse",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"os",
".",
"PathError",
")",
";",
"!",
"ok",
"{",
"err",
"=",
"newPathErrorErr",
"(",
"\"",
"\"",
",",
"path",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"f",
",",
"err",
"\n",
"}"
]
| // Stat returns the file stats for a specified path | [
"Stat",
"returns",
"the",
"file",
"stats",
"for",
"a",
"specified",
"path"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/client.go#L187-L236 |
11,974 | studio-b12/gowebdav | client.go | RemoveAll | 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 | 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)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"RemoveAll",
"(",
"path",
"string",
")",
"error",
"{",
"rs",
",",
"err",
":=",
"c",
".",
"req",
"(",
"\"",
"\"",
",",
"path",
",",
"nil",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"newPathError",
"(",
"\"",
"\"",
",",
"path",
",",
"400",
")",
"\n",
"}",
"\n",
"err",
"=",
"rs",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"rs",
".",
"StatusCode",
"==",
"200",
"||",
"rs",
".",
"StatusCode",
"==",
"204",
"||",
"rs",
".",
"StatusCode",
"==",
"404",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"newPathError",
"(",
"\"",
"\"",
",",
"path",
",",
"rs",
".",
"StatusCode",
")",
"\n",
"}"
]
| // RemoveAll removes remote files | [
"RemoveAll",
"removes",
"remote",
"files"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/client.go#L244-L259 |
11,975 | studio-b12/gowebdav | client.go | Mkdir | 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 | 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)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Mkdir",
"(",
"path",
"string",
",",
"_",
"os",
".",
"FileMode",
")",
"error",
"{",
"path",
"=",
"FixSlashes",
"(",
"path",
")",
"\n",
"status",
":=",
"c",
".",
"mkcol",
"(",
"path",
")",
"\n",
"if",
"status",
"==",
"201",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"newPathError",
"(",
"\"",
"\"",
",",
"path",
",",
"status",
")",
"\n",
"}"
]
| // Mkdir makes a directory | [
"Mkdir",
"makes",
"a",
"directory"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/client.go#L262-L270 |
11,976 | studio-b12/gowebdav | client.go | MkdirAll | 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 | 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)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"MkdirAll",
"(",
"path",
"string",
",",
"_",
"os",
".",
"FileMode",
")",
"error",
"{",
"path",
"=",
"FixSlashes",
"(",
"path",
")",
"\n",
"status",
":=",
"c",
".",
"mkcol",
"(",
"path",
")",
"\n",
"if",
"status",
"==",
"201",
"{",
"return",
"nil",
"\n",
"}",
"else",
"if",
"status",
"==",
"409",
"{",
"paths",
":=",
"strings",
".",
"Split",
"(",
"path",
",",
"\"",
"\"",
")",
"\n",
"sub",
":=",
"\"",
"\"",
"\n",
"for",
"_",
",",
"e",
":=",
"range",
"paths",
"{",
"if",
"e",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n",
"sub",
"+=",
"e",
"+",
"\"",
"\"",
"\n",
"status",
"=",
"c",
".",
"mkcol",
"(",
"sub",
")",
"\n",
"if",
"status",
"!=",
"201",
"{",
"return",
"newPathError",
"(",
"\"",
"\"",
",",
"sub",
",",
"status",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"newPathError",
"(",
"\"",
"\"",
",",
"path",
",",
"status",
")",
"\n",
"}"
]
| // MkdirAll like mkdir -p, but for webdav | [
"MkdirAll",
"like",
"mkdir",
"-",
"p",
"but",
"for",
"webdav"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/client.go#L273-L295 |
11,977 | studio-b12/gowebdav | client.go | Rename | func (c *Client) Rename(oldpath, newpath string, overwrite bool) error {
return c.copymove("MOVE", oldpath, newpath, overwrite)
} | go | func (c *Client) Rename(oldpath, newpath string, overwrite bool) error {
return c.copymove("MOVE", oldpath, newpath, overwrite)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Rename",
"(",
"oldpath",
",",
"newpath",
"string",
",",
"overwrite",
"bool",
")",
"error",
"{",
"return",
"c",
".",
"copymove",
"(",
"\"",
"\"",
",",
"oldpath",
",",
"newpath",
",",
"overwrite",
")",
"\n",
"}"
]
| // Rename moves a file from A to B | [
"Rename",
"moves",
"a",
"file",
"from",
"A",
"to",
"B"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/client.go#L298-L300 |
11,978 | studio-b12/gowebdav | client.go | Read | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Read",
"(",
"path",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"stream",
"io",
".",
"ReadCloser",
"\n",
"var",
"err",
"error",
"\n\n",
"if",
"stream",
",",
"err",
"=",
"c",
".",
"ReadStream",
"(",
"path",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"stream",
".",
"Close",
"(",
")",
"\n\n",
"buf",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"_",
",",
"err",
"=",
"buf",
".",
"ReadFrom",
"(",
"stream",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"buf",
".",
"Bytes",
"(",
")",
",",
"nil",
"\n",
"}"
]
| // Read reads the contents of a remote file | [
"Read",
"reads",
"the",
"contents",
"of",
"a",
"remote",
"file"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/client.go#L308-L323 |
11,979 | studio-b12/gowebdav | client.go | ReadStream | 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 | 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)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"ReadStream",
"(",
"path",
"string",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"rs",
",",
"err",
":=",
"c",
".",
"req",
"(",
"\"",
"\"",
",",
"path",
",",
"nil",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"newPathErrorErr",
"(",
"\"",
"\"",
",",
"path",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"rs",
".",
"StatusCode",
"==",
"200",
"{",
"return",
"rs",
".",
"Body",
",",
"nil",
"\n",
"}",
"\n\n",
"rs",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"newPathError",
"(",
"\"",
"\"",
",",
"path",
",",
"rs",
".",
"StatusCode",
")",
"\n",
"}"
]
| // ReadStream reads the stream for a given path | [
"ReadStream",
"reads",
"the",
"stream",
"for",
"a",
"given",
"path"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/client.go#L326-L338 |
11,980 | studio-b12/gowebdav | client.go | Write | 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 | 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)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Write",
"(",
"path",
"string",
",",
"data",
"[",
"]",
"byte",
",",
"_",
"os",
".",
"FileMode",
")",
"error",
"{",
"s",
":=",
"c",
".",
"put",
"(",
"path",
",",
"bytes",
".",
"NewReader",
"(",
"data",
")",
")",
"\n",
"switch",
"s",
"{",
"case",
"200",
",",
"201",
",",
"204",
":",
"return",
"nil",
"\n\n",
"case",
"409",
":",
"err",
":=",
"c",
".",
"createParentCollection",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"s",
"=",
"c",
".",
"put",
"(",
"path",
",",
"bytes",
".",
"NewReader",
"(",
"data",
")",
")",
"\n",
"if",
"s",
"==",
"200",
"||",
"s",
"==",
"201",
"||",
"s",
"==",
"204",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"newPathError",
"(",
"\"",
"\"",
",",
"path",
",",
"s",
")",
"\n",
"}"
]
| // Write writes data to a given path | [
"Write",
"writes",
"data",
"to",
"a",
"given",
"path"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/client.go#L341-L361 |
11,981 | studio-b12/gowebdav | client.go | WriteStream | 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 | 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)
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"WriteStream",
"(",
"path",
"string",
",",
"stream",
"io",
".",
"Reader",
",",
"_",
"os",
".",
"FileMode",
")",
"error",
"{",
"err",
":=",
"c",
".",
"createParentCollection",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"s",
":=",
"c",
".",
"put",
"(",
"path",
",",
"stream",
")",
"\n\n",
"switch",
"s",
"{",
"case",
"200",
",",
"201",
",",
"204",
":",
"return",
"nil",
"\n\n",
"default",
":",
"return",
"newPathError",
"(",
"\"",
"\"",
",",
"path",
",",
"s",
")",
"\n",
"}",
"\n",
"}"
]
| // WriteStream writes a stream | [
"WriteStream",
"writes",
"a",
"stream"
]
| 38f79aeaf1ac948ed7b23e8524a6f7f9612243bb | https://github.com/studio-b12/gowebdav/blob/38f79aeaf1ac948ed7b23e8524a6f7f9612243bb/client.go#L364-L380 |
11,982 | trivago/tgo | tsync/flow.go | Fanout | 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 | 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)
}
} | [
"func",
"Fanout",
"(",
"in",
"interface",
"{",
"}",
",",
"out",
"...",
"interface",
"{",
"}",
")",
"{",
"cases",
":=",
"newSendCases",
"(",
"out",
")",
"\n",
"inChan",
":=",
"reflect",
".",
"ValueOf",
"(",
"in",
")",
"\n\n",
"for",
"{",
"data",
",",
"more",
":=",
"inChan",
".",
"Recv",
"(",
")",
"\n",
"if",
"!",
"more",
"{",
"return",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"cases",
"{",
"cases",
"[",
"i",
"]",
".",
"Send",
"=",
"data",
"\n",
"}",
"\n",
"reflect",
".",
"Select",
"(",
"cases",
")",
"\n",
"}",
"\n",
"}"
]
| // Fanout receives from the given in channel and forwards the data to the first
// non-blocking out channel. Fanout returns when in has been closed. | [
"Fanout",
"receives",
"from",
"the",
"given",
"in",
"channel",
"and",
"forwards",
"the",
"data",
"to",
"the",
"first",
"non",
"-",
"blocking",
"out",
"channel",
".",
"Fanout",
"returns",
"when",
"in",
"has",
"been",
"closed",
"."
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tsync/flow.go#L9-L23 |
11,983 | trivago/tgo | tsync/flow.go | Funnel | 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 | 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)
}
} | [
"func",
"Funnel",
"(",
"out",
"interface",
"{",
"}",
",",
"in",
"...",
"interface",
"{",
"}",
")",
"{",
"cases",
":=",
"newRecvCases",
"(",
"in",
")",
"\n",
"outChan",
":=",
"reflect",
".",
"ValueOf",
"(",
"out",
")",
"\n\n",
"for",
"len",
"(",
"cases",
")",
">",
"0",
"{",
"idx",
",",
"val",
",",
"ok",
":=",
"reflect",
".",
"Select",
"(",
"cases",
")",
"\n",
"if",
"!",
"ok",
"{",
"cases",
"=",
"removeCase",
"(",
"idx",
",",
"cases",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"outChan",
".",
"Send",
"(",
"val",
")",
"\n",
"}",
"\n",
"}"
]
| // Funnel receives from the first non-blocking in channel and forwards it to the
// given out channel. Funnel returns when all in channels have been closed. | [
"Funnel",
"receives",
"from",
"the",
"first",
"non",
"-",
"blocking",
"in",
"channel",
"and",
"forwards",
"it",
"to",
"the",
"given",
"out",
"channel",
".",
"Funnel",
"returns",
"when",
"all",
"in",
"channels",
"have",
"been",
"closed",
"."
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tsync/flow.go#L27-L39 |
11,984 | trivago/tgo | tsync/flow.go | Turnout | 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 | 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)
}
} | [
"func",
"Turnout",
"(",
"in",
"[",
"]",
"interface",
"{",
"}",
",",
"out",
"[",
"]",
"interface",
"{",
"}",
")",
"{",
"inCases",
":=",
"newRecvCases",
"(",
"in",
")",
"\n",
"outCases",
":=",
"newSendCases",
"(",
"out",
")",
"\n\n",
"for",
"len",
"(",
"inCases",
")",
">",
"0",
"{",
"idx",
",",
"val",
",",
"ok",
":=",
"reflect",
".",
"Select",
"(",
"inCases",
")",
"\n",
"if",
"!",
"ok",
"{",
"inCases",
"=",
"removeCase",
"(",
"idx",
",",
"inCases",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"range",
"outCases",
"{",
"outCases",
"[",
"i",
"]",
".",
"Send",
"=",
"val",
"\n",
"}",
"\n",
"reflect",
".",
"Select",
"(",
"outCases",
")",
"\n",
"}",
"\n",
"}"
]
| // Turnout multiplexes data between the list of in and out channels. The data of
// the first non-blocking in channel will be forwarded to the first non-blocking
// out channel. Turnout returns when all in channels have been closed. | [
"Turnout",
"multiplexes",
"data",
"between",
"the",
"list",
"of",
"in",
"and",
"out",
"channels",
".",
"The",
"data",
"of",
"the",
"first",
"non",
"-",
"blocking",
"in",
"channel",
"will",
"be",
"forwarded",
"to",
"the",
"first",
"non",
"-",
"blocking",
"out",
"channel",
".",
"Turnout",
"returns",
"when",
"all",
"in",
"channels",
"have",
"been",
"closed",
"."
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tsync/flow.go#L44-L60 |
11,985 | trivago/tgo | tos/pidfile.go | WritePidFile | 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 | 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
} | [
"func",
"WritePidFile",
"(",
"pid",
"int",
",",
"filename",
"string",
")",
"error",
"{",
"pidString",
":=",
"strconv",
".",
"Itoa",
"(",
"pid",
")",
"\n",
"pidFile",
",",
"err",
":=",
"os",
".",
"OpenFile",
"(",
"filename",
",",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_EXCL",
"|",
"os",
".",
"O_WRONLY",
",",
"0644",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"pidFile",
".",
"Close",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"pidFile",
".",
"WriteString",
"(",
"pidString",
")",
"\n",
"return",
"err",
"\n",
"}"
]
| // WritePidFile writes this a process id into a file.
// An error will be returned if the file already exists. | [
"WritePidFile",
"writes",
"this",
"a",
"process",
"id",
"into",
"a",
"file",
".",
"An",
"error",
"will",
"be",
"returned",
"if",
"the",
"file",
"already",
"exists",
"."
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tos/pidfile.go#L33-L42 |
11,986 | trivago/tgo | tos/pidfile.go | WritePidFileForced | func WritePidFileForced(pid int, filename string) error {
pidString := strconv.Itoa(pid)
return ioutil.WriteFile(filename, []byte(pidString), 0644)
} | go | func WritePidFileForced(pid int, filename string) error {
pidString := strconv.Itoa(pid)
return ioutil.WriteFile(filename, []byte(pidString), 0644)
} | [
"func",
"WritePidFileForced",
"(",
"pid",
"int",
",",
"filename",
"string",
")",
"error",
"{",
"pidString",
":=",
"strconv",
".",
"Itoa",
"(",
"pid",
")",
"\n",
"return",
"ioutil",
".",
"WriteFile",
"(",
"filename",
",",
"[",
"]",
"byte",
"(",
"pidString",
")",
",",
"0644",
")",
"\n",
"}"
]
| // WritePidFileForced writes this a process id into a file.
// An existing file will be overwritten. | [
"WritePidFileForced",
"writes",
"this",
"a",
"process",
"id",
"into",
"a",
"file",
".",
"An",
"existing",
"file",
"will",
"be",
"overwritten",
"."
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tos/pidfile.go#L46-L49 |
11,987 | trivago/tgo | tos/pidfile.go | GetPidFromFile | 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 | 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
} | [
"func",
"GetPidFromFile",
"(",
"filename",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"var",
"(",
"pidBytes",
"[",
"]",
"byte",
"\n",
"pid",
"int",
"\n",
"err",
"error",
"\n",
")",
"\n\n",
"if",
"pidBytes",
",",
"err",
"=",
"ioutil",
".",
"ReadFile",
"(",
"filename",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"InvalidPID",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"filename",
",",
"err",
")",
"\n",
"}",
"\n\n",
"pidString",
":=",
"string",
"(",
"bytes",
".",
"Trim",
"(",
"pidBytes",
",",
"\"",
"\\r",
"\\n",
"\\t",
"\"",
")",
")",
"\n",
"if",
"pid",
",",
"err",
"=",
"strconv",
".",
"Atoi",
"(",
"string",
"(",
"pidString",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"InvalidPID",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"filename",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"pid",
",",
"nil",
"\n",
"}"
]
| // GetPidFromFile tries loads the content of a pid file.
// A pidfile is expected to contain only an integer with a valid process id. | [
"GetPidFromFile",
"tries",
"loads",
"the",
"content",
"of",
"a",
"pid",
"file",
".",
"A",
"pidfile",
"is",
"expected",
"to",
"contain",
"only",
"an",
"integer",
"with",
"a",
"valid",
"process",
"id",
"."
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tos/pidfile.go#L53-L70 |
11,988 | trivago/tgo | tos/pidfile.go | GetProcFromFile | 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 | 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
} | [
"func",
"GetProcFromFile",
"(",
"filename",
"string",
")",
"(",
"*",
"os",
".",
"Process",
",",
"error",
")",
"{",
"var",
"(",
"pid",
"int",
"\n",
"err",
"error",
"\n",
"proc",
"*",
"os",
".",
"Process",
"\n",
")",
"\n\n",
"if",
"pid",
",",
"err",
"=",
"GetPidFromFile",
"(",
"filename",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// FindProcess always returns a proc on unix",
"if",
"proc",
",",
"err",
"=",
"os",
".",
"FindProcess",
"(",
"pid",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Try to signal the process to check if it is running",
"if",
"err",
"=",
"proc",
".",
"Signal",
"(",
"syscall",
".",
"Signal",
"(",
"0",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"proc",
",",
"nil",
"\n",
"}"
]
| // GetProcFromFile utilizes GetPidFromFile to create a os.Process handle for
// the pid contained in the given pid file. | [
"GetProcFromFile",
"utilizes",
"GetPidFromFile",
"to",
"create",
"a",
"os",
".",
"Process",
"handle",
"for",
"the",
"pid",
"contained",
"in",
"the",
"given",
"pid",
"file",
"."
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tos/pidfile.go#L74-L96 |
11,989 | trivago/tgo | tio/files.go | Swap | func (files FilesByDate) Swap(a, b int) {
files[a], files[b] = files[b], files[a]
} | go | func (files FilesByDate) Swap(a, b int) {
files[a], files[b] = files[b], files[a]
} | [
"func",
"(",
"files",
"FilesByDate",
")",
"Swap",
"(",
"a",
",",
"b",
"int",
")",
"{",
"files",
"[",
"a",
"]",
",",
"files",
"[",
"b",
"]",
"=",
"files",
"[",
"b",
"]",
",",
"files",
"[",
"a",
"]",
"\n",
"}"
]
| // Swap exchanges the values stored at indexes a and b | [
"Swap",
"exchanges",
"the",
"values",
"stored",
"at",
"indexes",
"a",
"and",
"b"
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tio/files.go#L36-L38 |
11,990 | trivago/tgo | tio/files.go | IsDirectory | func IsDirectory(filePath string) bool {
stat, err := os.Stat(filePath)
if err != nil {
return false
}
return stat.IsDir()
} | go | func IsDirectory(filePath string) bool {
stat, err := os.Stat(filePath)
if err != nil {
return false
}
return stat.IsDir()
} | [
"func",
"IsDirectory",
"(",
"filePath",
"string",
")",
"bool",
"{",
"stat",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"stat",
".",
"IsDir",
"(",
")",
"\n",
"}"
]
| // IsDirectory returns true if a given path points to a directory. | [
"IsDirectory",
"returns",
"true",
"if",
"a",
"given",
"path",
"points",
"to",
"a",
"directory",
"."
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tio/files.go#L99-L105 |
11,991 | trivago/tgo | tio/files.go | CommonPath | 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 | 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, "/")
} | [
"func",
"CommonPath",
"(",
"path1",
",",
"path2",
"string",
")",
"string",
"{",
"parts1",
":=",
"strings",
".",
"Split",
"(",
"path1",
",",
"\"",
"\"",
")",
"\n",
"parts2",
":=",
"strings",
".",
"Split",
"(",
"path2",
",",
"\"",
"\"",
")",
"\n",
"maxIdx",
":=",
"len",
"(",
"parts1",
")",
"\n",
"if",
"len",
"(",
"parts2",
")",
"<",
"maxIdx",
"{",
"maxIdx",
"=",
"len",
"(",
"parts2",
")",
"\n",
"}",
"\n\n",
"common",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"maxIdx",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"maxIdx",
";",
"i",
"++",
"{",
"if",
"parts1",
"[",
"i",
"]",
"==",
"parts2",
"[",
"i",
"]",
"{",
"common",
"=",
"append",
"(",
"common",
",",
"parts1",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"strings",
".",
"Join",
"(",
"common",
",",
"\"",
"\"",
")",
"\n",
"}"
]
| // CommonPath returns the longest common path of both paths given. | [
"CommonPath",
"returns",
"the",
"longest",
"common",
"path",
"of",
"both",
"paths",
"given",
"."
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tio/files.go#L108-L124 |
11,992 | trivago/tgo | tio/files.go | FileCRC32 | func FileCRC32(path string) (uint32, error) {
data, err := ioutil.ReadFile(path)
if err != nil {
return 0, err
}
return crc32.ChecksumIEEE(data), nil
} | go | func FileCRC32(path string) (uint32, error) {
data, err := ioutil.ReadFile(path)
if err != nil {
return 0, err
}
return crc32.ChecksumIEEE(data), nil
} | [
"func",
"FileCRC32",
"(",
"path",
"string",
")",
"(",
"uint32",
",",
"error",
")",
"{",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"crc32",
".",
"ChecksumIEEE",
"(",
"data",
")",
",",
"nil",
"\n",
"}"
]
| // FileCRC32 returns the checksum of a given file | [
"FileCRC32",
"returns",
"the",
"checksum",
"of",
"a",
"given",
"file"
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tio/files.go#L127-L133 |
11,993 | trivago/tgo | tnet/stoplistener.go | NewStopListener | 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 | 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
} | [
"func",
"NewStopListener",
"(",
"address",
"string",
")",
"(",
"*",
"StopListener",
",",
"error",
")",
"{",
"listen",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"// ### return, could not connect ###",
"\n",
"}",
"\n\n",
"return",
"&",
"StopListener",
"{",
"TCPListener",
":",
"listen",
".",
"(",
"*",
"net",
".",
"TCPListener",
")",
",",
"active",
":",
"true",
",",
"}",
",",
"nil",
"\n",
"}"
]
| // NewStopListener creates a new, stoppable TCP server connection.
// Address needs to be cmpliant to net.Listen. | [
"NewStopListener",
"creates",
"a",
"new",
"stoppable",
"TCP",
"server",
"connection",
".",
"Address",
"needs",
"to",
"be",
"cmpliant",
"to",
"net",
".",
"Listen",
"."
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tnet/stoplistener.go#L34-L44 |
11,994 | trivago/tgo | tnet/stoplistener.go | Accept | 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 | 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
} | [
"func",
"(",
"listen",
"*",
"StopListener",
")",
"Accept",
"(",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"listen",
".",
"TCPListener",
".",
"Accept",
"(",
")",
"\n",
"if",
"!",
"listen",
".",
"active",
"{",
"return",
"nil",
",",
"StopRequestError",
"{",
"}",
"// ### return, stop requested ###",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"// ### return, error ###",
"\n",
"}",
"\n\n",
"return",
"conn",
",",
"err",
"\n",
"}"
]
| // Accept is analogous to net.TCPListener.Accept but may return a connection
// closed error if the connection was requested to shut down. | [
"Accept",
"is",
"analogous",
"to",
"net",
".",
"TCPListener",
".",
"Accept",
"but",
"may",
"return",
"a",
"connection",
"closed",
"error",
"if",
"the",
"connection",
"was",
"requested",
"to",
"shut",
"down",
"."
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tnet/stoplistener.go#L53-L63 |
11,995 | trivago/tgo | tnet/stoplistener.go | Close | func (listen *StopListener) Close() error {
listen.active = false
return listen.TCPListener.Close()
} | go | func (listen *StopListener) Close() error {
listen.active = false
return listen.TCPListener.Close()
} | [
"func",
"(",
"listen",
"*",
"StopListener",
")",
"Close",
"(",
")",
"error",
"{",
"listen",
".",
"active",
"=",
"false",
"\n",
"return",
"listen",
".",
"TCPListener",
".",
"Close",
"(",
")",
"\n",
"}"
]
| // Close requests a connection close on this listener | [
"Close",
"requests",
"a",
"connection",
"close",
"on",
"this",
"listener"
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tnet/stoplistener.go#L66-L69 |
11,996 | trivago/tgo | tos/file.go | ChownByName | 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 | 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)
} | [
"func",
"ChownByName",
"(",
"filePath",
",",
"usr",
",",
"grp",
"string",
")",
"error",
"{",
"var",
"uid",
",",
"gid",
"int",
"\n",
"var",
"err",
"error",
"\n\n",
"if",
"uid",
",",
"err",
"=",
"GetUid",
"(",
"usr",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"gid",
",",
"err",
"=",
"GetGid",
"(",
"grp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"Chown",
"(",
"filePath",
",",
"uid",
",",
"gid",
")",
"\n",
"}"
]
| // ChownByName is a wrapper around ChownId that allows changing user and group by name. | [
"ChownByName",
"is",
"a",
"wrapper",
"around",
"ChownId",
"that",
"allows",
"changing",
"user",
"and",
"group",
"by",
"name",
"."
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tos/file.go#L24-L37 |
11,997 | trivago/tgo | tos/file.go | Chown | 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 | 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)
} | [
"func",
"Chown",
"(",
"filePath",
"string",
",",
"uid",
",",
"gid",
"int",
")",
"error",
"{",
"stat",
",",
"err",
":=",
"os",
".",
"Lstat",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"stat",
".",
"IsDir",
"(",
")",
"{",
"files",
",",
"err",
":=",
"ioutil",
".",
"ReadDir",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"file",
":=",
"range",
"files",
"{",
"if",
"err",
":=",
"Chown",
"(",
"filePath",
"+",
"\"",
"\"",
"+",
"file",
".",
"Name",
"(",
")",
",",
"uid",
",",
"gid",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"stat",
".",
"Mode",
"(",
")",
"&",
"os",
".",
"ModeSymlink",
"!=",
"0",
"{",
"// TODO: os.Chown fails on symlinks",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"os",
".",
"Chown",
"(",
"filePath",
",",
"uid",
",",
"gid",
")",
"\n",
"}"
]
| // ChownId is a wrapper around os.Chown that allows changing user and group
// recursively if given a directory. | [
"ChownId",
"is",
"a",
"wrapper",
"around",
"os",
".",
"Chown",
"that",
"allows",
"changing",
"user",
"and",
"group",
"recursively",
"if",
"given",
"a",
"directory",
"."
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tos/file.go#L41-L65 |
11,998 | trivago/tgo | tos/file.go | Chmod | 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 | 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)
} | [
"func",
"Chmod",
"(",
"filePath",
"string",
",",
"mode",
"os",
".",
"FileMode",
")",
"error",
"{",
"stat",
",",
"err",
":=",
"os",
".",
"Lstat",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"stat",
".",
"IsDir",
"(",
")",
"{",
"files",
",",
"err",
":=",
"ioutil",
".",
"ReadDir",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"file",
":=",
"range",
"files",
"{",
"if",
"err",
":=",
"Chmod",
"(",
"filePath",
"+",
"\"",
"\"",
"+",
"file",
".",
"Name",
"(",
")",
",",
"mode",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Set executable rights for folders if read or write is allowed",
"execRights",
":=",
"0",
"\n",
"if",
"mode",
"&",
"0600",
"!=",
"0",
"{",
"execRights",
"|=",
"0100",
"\n",
"}",
"\n",
"if",
"mode",
"&",
"0060",
"!=",
"0",
"{",
"execRights",
"|=",
"0010",
"\n",
"}",
"\n",
"if",
"mode",
"&",
"0006",
"!=",
"0",
"{",
"execRights",
"|=",
"0001",
"\n",
"}",
"\n\n",
"return",
"os",
".",
"Chmod",
"(",
"filePath",
",",
"mode",
"|",
"os",
".",
"FileMode",
"(",
"execRights",
")",
")",
"\n",
"}",
"\n\n",
"if",
"stat",
".",
"Mode",
"(",
")",
"&",
"os",
".",
"ModeSymlink",
"!=",
"0",
"{",
"// TODO: os.Chmod fails on symlinks",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"os",
".",
"Chmod",
"(",
"filePath",
",",
"mode",
")",
"\n",
"}"
]
| // Chmod is a wrapper around os.Chmod that allows changing rights recursively
// if a directory is given. | [
"Chmod",
"is",
"a",
"wrapper",
"around",
"os",
".",
"Chmod",
"that",
"allows",
"changing",
"rights",
"recursively",
"if",
"a",
"directory",
"is",
"given",
"."
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tos/file.go#L69-L107 |
11,999 | trivago/tgo | tos/file.go | IsSymlink | 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 | func IsSymlink(file string) (bool, error) {
fileStat, err := os.Lstat(file)
if err != nil {
return false, err
}
return fileStat.Mode()&os.ModeSymlink != 0, nil
} | [
"func",
"IsSymlink",
"(",
"file",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"fileStat",
",",
"err",
":=",
"os",
".",
"Lstat",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"fileStat",
".",
"Mode",
"(",
")",
"&",
"os",
".",
"ModeSymlink",
"!=",
"0",
",",
"nil",
"\n",
"}"
]
| // IsSymlink returns true if a file is a symlink | [
"IsSymlink",
"returns",
"true",
"if",
"a",
"file",
"is",
"a",
"symlink"
]
| efdb64f40efe6e7cd3f50415710e7af6a7c316ad | https://github.com/trivago/tgo/blob/efdb64f40efe6e7cd3f50415710e7af6a7c316ad/tos/file.go#L110-L117 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.