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.