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 list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
10,600 | gravitational/trace | errors.go | IsRetryError | func IsRetryError(e error) bool {
type ad interface {
IsRetryError() bool
}
_, ok := Unwrap(e).(ad)
return ok
} | go | func IsRetryError(e error) bool {
type ad interface {
IsRetryError() bool
}
_, ok := Unwrap(e).(ad)
return ok
} | [
"func",
"IsRetryError",
"(",
"e",
"error",
")",
"bool",
"{",
"type",
"ad",
"interface",
"{",
"IsRetryError",
"(",
")",
"bool",
"\n",
"}",
"\n",
"_",
",",
"ok",
":=",
"Unwrap",
"(",
"e",
")",
".",
"(",
"ad",
")",
"\n",
"return",
"ok",
"\n",
"}"
] | // IsRetryError returns whether this error is of ConnectionProblemError | [
"IsRetryError",
"returns",
"whether",
"this",
"error",
"is",
"of",
"ConnectionProblemError"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/errors.go#L479-L485 |
10,601 | gravitational/trace | log.go | IsTerminal | func IsTerminal(w io.Writer) bool {
switch v := w.(type) {
case *os.File:
return terminal.IsTerminal(int(v.Fd()))
default:
return false
}
} | go | func IsTerminal(w io.Writer) bool {
switch v := w.(type) {
case *os.File:
return terminal.IsTerminal(int(v.Fd()))
default:
return false
}
} | [
"func",
"IsTerminal",
"(",
"w",
"io",
".",
"Writer",
")",
"bool",
"{",
"switch",
"v",
":=",
"w",
".",
"(",
"type",
")",
"{",
"case",
"*",
"os",
".",
"File",
":",
"return",
"terminal",
".",
"IsTerminal",
"(",
"int",
"(",
"v",
".",
"Fd",
"(",
")"... | // IsTerminal checks whether writer is a terminal | [
"IsTerminal",
"checks",
"whether",
"writer",
"is",
"a",
"terminal"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/log.go#L57-L64 |
10,602 | gravitational/trace | log.go | Format | func (tf *TextFormatter) Format(e *log.Entry) (data []byte, err error) {
defer func() {
if r := recover(); r != nil {
data = append([]byte("panic in log formatter\n"), rundebug.Stack()...)
return
}
}()
var file string
if cursor := findFrame(); cursor != nil {
t := newTraceFromFrames(*cursor, nil)
file = t.Loc()
}
w := &writer{}
// time
if !tf.DisableTimestamp {
w.writeField(e.Time.Format(time.RFC3339), noColor)
}
// level
color := noColor
if tf.EnableColors {
switch e.Level {
case log.DebugLevel:
color = gray
case log.WarnLevel:
color = yellow
case log.ErrorLevel, log.FatalLevel, log.PanicLevel:
color = red
default:
color = blue
}
}
w.writeField(strings.ToUpper(padMax(e.Level.String(), DefaultLevelPadding)), color)
// always output the component field if available
padding := DefaultComponentPadding
if tf.ComponentPadding != 0 {
padding = tf.ComponentPadding
}
if w.Len() > 0 {
w.WriteByte(' ')
}
value := e.Data[Component]
var component string
if reflect.ValueOf(value).IsValid() {
component = fmt.Sprintf("[%v]", value)
}
component = strings.ToUpper(padMax(component, padding))
if component[len(component)-1] != ' ' {
component = component[:len(component)-1] + "]"
}
w.WriteString(component)
// message
if e.Message != "" {
w.writeField(e.Message, noColor)
}
// rest of the fields
if len(e.Data) > 0 {
w.writeMap(e.Data)
}
// file, if present, always last
if file != "" {
w.writeField(file, noColor)
}
w.WriteByte('\n')
data = w.Bytes()
return
} | go | func (tf *TextFormatter) Format(e *log.Entry) (data []byte, err error) {
defer func() {
if r := recover(); r != nil {
data = append([]byte("panic in log formatter\n"), rundebug.Stack()...)
return
}
}()
var file string
if cursor := findFrame(); cursor != nil {
t := newTraceFromFrames(*cursor, nil)
file = t.Loc()
}
w := &writer{}
// time
if !tf.DisableTimestamp {
w.writeField(e.Time.Format(time.RFC3339), noColor)
}
// level
color := noColor
if tf.EnableColors {
switch e.Level {
case log.DebugLevel:
color = gray
case log.WarnLevel:
color = yellow
case log.ErrorLevel, log.FatalLevel, log.PanicLevel:
color = red
default:
color = blue
}
}
w.writeField(strings.ToUpper(padMax(e.Level.String(), DefaultLevelPadding)), color)
// always output the component field if available
padding := DefaultComponentPadding
if tf.ComponentPadding != 0 {
padding = tf.ComponentPadding
}
if w.Len() > 0 {
w.WriteByte(' ')
}
value := e.Data[Component]
var component string
if reflect.ValueOf(value).IsValid() {
component = fmt.Sprintf("[%v]", value)
}
component = strings.ToUpper(padMax(component, padding))
if component[len(component)-1] != ' ' {
component = component[:len(component)-1] + "]"
}
w.WriteString(component)
// message
if e.Message != "" {
w.writeField(e.Message, noColor)
}
// rest of the fields
if len(e.Data) > 0 {
w.writeMap(e.Data)
}
// file, if present, always last
if file != "" {
w.writeField(file, noColor)
}
w.WriteByte('\n')
data = w.Bytes()
return
} | [
"func",
"(",
"tf",
"*",
"TextFormatter",
")",
"Format",
"(",
"e",
"*",
"log",
".",
"Entry",
")",
"(",
"data",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=... | // Format implements logrus.Formatter interface and adds file and line | [
"Format",
"implements",
"logrus",
".",
"Formatter",
"interface",
"and",
"adds",
"file",
"and",
"line"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/log.go#L80-L154 |
10,603 | gravitational/trace | log.go | Format | func (j *JSONFormatter) Format(e *log.Entry) ([]byte, error) {
if cursor := findFrame(); cursor != nil {
t := newTraceFromFrames(*cursor, nil)
new := e.WithFields(log.Fields{
FileField: t.Loc(),
FunctionField: t.FuncName(),
})
new.Time = e.Time
new.Level = e.Level
new.Message = e.Message
e = new
}
return j.JSONFormatter.Format(e)
} | go | func (j *JSONFormatter) Format(e *log.Entry) ([]byte, error) {
if cursor := findFrame(); cursor != nil {
t := newTraceFromFrames(*cursor, nil)
new := e.WithFields(log.Fields{
FileField: t.Loc(),
FunctionField: t.FuncName(),
})
new.Time = e.Time
new.Level = e.Level
new.Message = e.Message
e = new
}
return j.JSONFormatter.Format(e)
} | [
"func",
"(",
"j",
"*",
"JSONFormatter",
")",
"Format",
"(",
"e",
"*",
"log",
".",
"Entry",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"cursor",
":=",
"findFrame",
"(",
")",
";",
"cursor",
"!=",
"nil",
"{",
"t",
":=",
"newTraceFromF... | // Format implements logrus.Formatter interface | [
"Format",
"implements",
"logrus",
".",
"Formatter",
"interface"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/log.go#L163-L176 |
10,604 | gravitational/trace | log.go | findFrame | func findFrame() *frameCursor {
var buf [32]uintptr
// Skip enough frames to start at user code.
// This number is a mere hint to the following loop
// to start as close to user code as possible and getting it right is not mandatory.
// The skip count might need to get updated if the call to findFrame is
// moved up/down the call stack
n := runtime.Callers(4, buf[:])
pcs := buf[:n]
frames := runtime.CallersFrames(pcs)
for i := 0; i < n; i++ {
frame, _ := frames.Next()
if !frameIgnorePattern.MatchString(frame.File) {
return &frameCursor{
current: &frame,
rest: frames,
n: n,
}
}
}
return nil
} | go | func findFrame() *frameCursor {
var buf [32]uintptr
// Skip enough frames to start at user code.
// This number is a mere hint to the following loop
// to start as close to user code as possible and getting it right is not mandatory.
// The skip count might need to get updated if the call to findFrame is
// moved up/down the call stack
n := runtime.Callers(4, buf[:])
pcs := buf[:n]
frames := runtime.CallersFrames(pcs)
for i := 0; i < n; i++ {
frame, _ := frames.Next()
if !frameIgnorePattern.MatchString(frame.File) {
return &frameCursor{
current: &frame,
rest: frames,
n: n,
}
}
}
return nil
} | [
"func",
"findFrame",
"(",
")",
"*",
"frameCursor",
"{",
"var",
"buf",
"[",
"32",
"]",
"uintptr",
"\n",
"// Skip enough frames to start at user code.",
"// This number is a mere hint to the following loop",
"// to start as close to user code as possible and getting it right is not man... | // findFrames positions the stack pointer to the first
// function that does not match the frameIngorePattern
// and returns the rest of the stack frames | [
"findFrames",
"positions",
"the",
"stack",
"pointer",
"to",
"the",
"first",
"function",
"that",
"does",
"not",
"match",
"the",
"frameIngorePattern",
"and",
"returns",
"the",
"rest",
"of",
"the",
"stack",
"frames"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/log.go#L183-L204 |
10,605 | gravitational/trace | trace.go | Wrap | func Wrap(err error, args ...interface{}) Error {
if len(args) > 0 {
format := args[0]
args = args[1:]
return WrapWithMessage(err, format, args...)
}
return wrapWithDepth(err, 2)
} | go | func Wrap(err error, args ...interface{}) Error {
if len(args) > 0 {
format := args[0]
args = args[1:]
return WrapWithMessage(err, format, args...)
}
return wrapWithDepth(err, 2)
} | [
"func",
"Wrap",
"(",
"err",
"error",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"len",
"(",
"args",
")",
">",
"0",
"{",
"format",
":=",
"args",
"[",
"0",
"]",
"\n",
"args",
"=",
"args",
"[",
"1",
":",
"]",
"\n",
"retu... | // Wrap takes the original error and wraps it into the Trace struct
// memorizing the context of the error. | [
"Wrap",
"takes",
"the",
"original",
"error",
"and",
"wraps",
"it",
"into",
"the",
"Trace",
"struct",
"memorizing",
"the",
"context",
"of",
"the",
"error",
"."
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L50-L57 |
10,606 | gravitational/trace | trace.go | Unwrap | func Unwrap(err error) error {
if terr, ok := err.(Error); ok {
return terr.OrigError()
}
return err
} | go | func Unwrap(err error) error {
if terr, ok := err.(Error); ok {
return terr.OrigError()
}
return err
} | [
"func",
"Unwrap",
"(",
"err",
"error",
")",
"error",
"{",
"if",
"terr",
",",
"ok",
":=",
"err",
".",
"(",
"Error",
")",
";",
"ok",
"{",
"return",
"terr",
".",
"OrigError",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // Unwrap unwraps error to it's original error | [
"Unwrap",
"unwraps",
"error",
"to",
"it",
"s",
"original",
"error"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L60-L65 |
10,607 | gravitational/trace | trace.go | UserMessage | func UserMessage(err error) string {
if err == nil {
return ""
}
if wrap, ok := err.(Error); ok {
return wrap.UserMessage()
}
return err.Error()
} | go | func UserMessage(err error) string {
if err == nil {
return ""
}
if wrap, ok := err.(Error); ok {
return wrap.UserMessage()
}
return err.Error()
} | [
"func",
"UserMessage",
"(",
"err",
"error",
")",
"string",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"wrap",
",",
"ok",
":=",
"err",
".",
"(",
"Error",
")",
";",
"ok",
"{",
"return",
"wrap",
".",
"UserMessag... | // UserMessage returns user-friendly part of the error | [
"UserMessage",
"returns",
"user",
"-",
"friendly",
"part",
"of",
"the",
"error"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L68-L76 |
10,608 | gravitational/trace | trace.go | DebugReport | func DebugReport(err error) string {
if err == nil {
return ""
}
if wrap, ok := err.(Error); ok {
return wrap.DebugReport()
}
return err.Error()
} | go | func DebugReport(err error) string {
if err == nil {
return ""
}
if wrap, ok := err.(Error); ok {
return wrap.DebugReport()
}
return err.Error()
} | [
"func",
"DebugReport",
"(",
"err",
"error",
")",
"string",
"{",
"if",
"err",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"wrap",
",",
"ok",
":=",
"err",
".",
"(",
"Error",
")",
";",
"ok",
"{",
"return",
"wrap",
".",
"DebugRepor... | // DebugReport returns debug report with all known information
// about the error including stack trace if it was captured | [
"DebugReport",
"returns",
"debug",
"report",
"with",
"all",
"known",
"information",
"about",
"the",
"error",
"including",
"stack",
"trace",
"if",
"it",
"was",
"captured"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L80-L88 |
10,609 | gravitational/trace | trace.go | WrapWithMessage | func WrapWithMessage(err error, message interface{}, args ...interface{}) Error {
trace := wrapWithDepth(err, 3)
if trace != nil {
trace.AddUserMessage(message, args...)
}
return trace
} | go | func WrapWithMessage(err error, message interface{}, args ...interface{}) Error {
trace := wrapWithDepth(err, 3)
if trace != nil {
trace.AddUserMessage(message, args...)
}
return trace
} | [
"func",
"WrapWithMessage",
"(",
"err",
"error",
",",
"message",
"interface",
"{",
"}",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"trace",
":=",
"wrapWithDepth",
"(",
"err",
",",
"3",
")",
"\n",
"if",
"trace",
"!=",
"nil",
"{",
"tr... | // WrapWithMessage wraps the original error into Error and adds user message if any | [
"WrapWithMessage",
"wraps",
"the",
"original",
"error",
"into",
"Error",
"and",
"adds",
"user",
"message",
"if",
"any"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L91-L97 |
10,610 | gravitational/trace | trace.go | Errorf | func Errorf(format string, args ...interface{}) (err error) {
err = fmt.Errorf(format, args...)
trace := wrapWithDepth(err, 2)
trace.AddUserMessage(format, args...)
return trace
} | go | func Errorf(format string, args ...interface{}) (err error) {
err = fmt.Errorf(format, args...)
trace := wrapWithDepth(err, 2)
trace.AddUserMessage(format, args...)
return trace
} | [
"func",
"Errorf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"trace",
":=",
"wrapWithDepth",
"(",
"err",
",... | // Errorf is similar to fmt.Errorf except that it captures
// more information about the origin of error, such as
// callee, line number and function that simplifies debugging | [
"Errorf",
"is",
"similar",
"to",
"fmt",
".",
"Errorf",
"except",
"that",
"it",
"captures",
"more",
"information",
"about",
"the",
"origin",
"of",
"error",
"such",
"as",
"callee",
"line",
"number",
"and",
"function",
"that",
"simplifies",
"debugging"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L116-L121 |
10,611 | gravitational/trace | trace.go | Fatalf | func Fatalf(format string, args ...interface{}) error {
if IsDebug() {
panic(fmt.Sprintf(format, args...))
} else {
return Errorf(format, args...)
}
} | go | func Fatalf(format string, args ...interface{}) error {
if IsDebug() {
panic(fmt.Sprintf(format, args...))
} else {
return Errorf(format, args...)
}
} | [
"func",
"Fatalf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"IsDebug",
"(",
")",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"args",
"...",
")",
")",
"\n",
"}",
"else",
"{",
"re... | // Fatalf - If debug is false Fatalf calls Errorf. If debug is
// true Fatalf calls panic | [
"Fatalf",
"-",
"If",
"debug",
"is",
"false",
"Fatalf",
"calls",
"Errorf",
".",
"If",
"debug",
"is",
"true",
"Fatalf",
"calls",
"panic"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L125-L131 |
10,612 | gravitational/trace | trace.go | FuncName | func (s Traces) FuncName() string {
if len(s) == 0 {
return ""
}
fn := filepath.ToSlash(s[0].Func)
idx := strings.LastIndex(fn, "/")
if idx == -1 || idx == len(fn)-1 {
return fn
}
return fn[idx+1:]
} | go | func (s Traces) FuncName() string {
if len(s) == 0 {
return ""
}
fn := filepath.ToSlash(s[0].Func)
idx := strings.LastIndex(fn, "/")
if idx == -1 || idx == len(fn)-1 {
return fn
}
return fn[idx+1:]
} | [
"func",
"(",
"s",
"Traces",
")",
"FuncName",
"(",
")",
"string",
"{",
"if",
"len",
"(",
"s",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"fn",
":=",
"filepath",
".",
"ToSlash",
"(",
"s",
"[",
"0",
"]",
".",
"Func",
")",
"\n",
... | // Func returns just function name | [
"Func",
"returns",
"just",
"function",
"name"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L198-L208 |
10,613 | gravitational/trace | trace.go | String | func (s Traces) String() string {
if len(s) == 0 {
return ""
}
out := make([]string, len(s))
for i, t := range s {
out[i] = fmt.Sprintf("\t%v:%v %v", t.Path, t.Line, t.Func)
}
return strings.Join(out, "\n")
} | go | func (s Traces) String() string {
if len(s) == 0 {
return ""
}
out := make([]string, len(s))
for i, t := range s {
out[i] = fmt.Sprintf("\t%v:%v %v", t.Path, t.Line, t.Func)
}
return strings.Join(out, "\n")
} | [
"func",
"(",
"s",
"Traces",
")",
"String",
"(",
")",
"string",
"{",
"if",
"len",
"(",
"s",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"out",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"s",
")",
")",
"\n",
"for"... | // String returns debug-friendly representaton of trace stack | [
"String",
"returns",
"debug",
"-",
"friendly",
"representaton",
"of",
"trace",
"stack"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L219-L228 |
10,614 | gravitational/trace | trace.go | String | func (t *Trace) String() string {
dir, file := filepath.Split(t.Path)
dirs := strings.Split(filepath.ToSlash(filepath.Clean(dir)), "/")
if len(dirs) != 0 {
file = filepath.Join(dirs[len(dirs)-1], file)
}
return fmt.Sprintf("%v:%v", file, t.Line)
} | go | func (t *Trace) String() string {
dir, file := filepath.Split(t.Path)
dirs := strings.Split(filepath.ToSlash(filepath.Clean(dir)), "/")
if len(dirs) != 0 {
file = filepath.Join(dirs[len(dirs)-1], file)
}
return fmt.Sprintf("%v:%v", file, t.Line)
} | [
"func",
"(",
"t",
"*",
"Trace",
")",
"String",
"(",
")",
"string",
"{",
"dir",
",",
"file",
":=",
"filepath",
".",
"Split",
"(",
"t",
".",
"Path",
")",
"\n",
"dirs",
":=",
"strings",
".",
"Split",
"(",
"filepath",
".",
"ToSlash",
"(",
"filepath",
... | // String returns debug-friendly representation of this trace | [
"String",
"returns",
"debug",
"-",
"friendly",
"representation",
"of",
"this",
"trace"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L241-L248 |
10,615 | gravitational/trace | trace.go | AddUserMessage | func (e *TraceErr) AddUserMessage(formatArg interface{}, rest ...interface{}) {
newMessage := fmt.Sprintf(fmt.Sprintf("%v", formatArg), rest...)
if len(e.Message) == 0 {
e.Message = newMessage
} else {
e.Message = strings.Join([]string{e.Message, newMessage}, ", ")
}
} | go | func (e *TraceErr) AddUserMessage(formatArg interface{}, rest ...interface{}) {
newMessage := fmt.Sprintf(fmt.Sprintf("%v", formatArg), rest...)
if len(e.Message) == 0 {
e.Message = newMessage
} else {
e.Message = strings.Join([]string{e.Message, newMessage}, ", ")
}
} | [
"func",
"(",
"e",
"*",
"TraceErr",
")",
"AddUserMessage",
"(",
"formatArg",
"interface",
"{",
"}",
",",
"rest",
"...",
"interface",
"{",
"}",
")",
"{",
"newMessage",
":=",
"fmt",
".",
"Sprintf",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"form... | // AddUserMessage adds user-friendly message describing the error nature | [
"AddUserMessage",
"adds",
"user",
"-",
"friendly",
"message",
"describing",
"the",
"error",
"nature"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L265-L272 |
10,616 | gravitational/trace | trace.go | UserMessage | func (e *TraceErr) UserMessage() string {
if e.Message != "" {
return e.Message
}
return UserMessage(e.Err)
} | go | func (e *TraceErr) UserMessage() string {
if e.Message != "" {
return e.Message
}
return UserMessage(e.Err)
} | [
"func",
"(",
"e",
"*",
"TraceErr",
")",
"UserMessage",
"(",
")",
"string",
"{",
"if",
"e",
".",
"Message",
"!=",
"\"",
"\"",
"{",
"return",
"e",
".",
"Message",
"\n",
"}",
"\n",
"return",
"UserMessage",
"(",
"e",
".",
"Err",
")",
"\n",
"}"
] | // UserMessage returns user-friendly error message | [
"UserMessage",
"returns",
"user",
"-",
"friendly",
"error",
"message"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L275-L280 |
10,617 | gravitational/trace | trace.go | DebugReport | func (e *TraceErr) DebugReport() string {
return fmt.Sprintf("\nERROR REPORT:\nOriginal Error: %T %v\nStack Trace:\n%v\nUser Message: %v\n", e.Err, e.Err.Error(), e.Traces.String(), e.Message)
} | go | func (e *TraceErr) DebugReport() string {
return fmt.Sprintf("\nERROR REPORT:\nOriginal Error: %T %v\nStack Trace:\n%v\nUser Message: %v\n", e.Err, e.Err.Error(), e.Traces.String(), e.Message)
} | [
"func",
"(",
"e",
"*",
"TraceErr",
")",
"DebugReport",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\\n",
"\\n",
"\\n",
"\\n",
"\\n",
"\"",
",",
"e",
".",
"Err",
",",
"e",
".",
"Err",
".",
"Error",
"(",
")",
",",... | // DebugReport returns develeoper-friendly error report | [
"DebugReport",
"returns",
"develeoper",
"-",
"friendly",
"error",
"report"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L283-L285 |
10,618 | gravitational/trace | trace.go | OrigError | func (e *TraceErr) OrigError() error {
err := e.Err
// this is not an endless loop because I'm being
// paranoid, this is a safe protection against endless
// loops
for i := 0; i < maxHops; i++ {
newerr, ok := err.(Error)
if !ok {
break
}
if newerr.OrigError() != err {
err = newerr.OrigError()
}
}
return err
} | go | func (e *TraceErr) OrigError() error {
err := e.Err
// this is not an endless loop because I'm being
// paranoid, this is a safe protection against endless
// loops
for i := 0; i < maxHops; i++ {
newerr, ok := err.(Error)
if !ok {
break
}
if newerr.OrigError() != err {
err = newerr.OrigError()
}
}
return err
} | [
"func",
"(",
"e",
"*",
"TraceErr",
")",
"OrigError",
"(",
")",
"error",
"{",
"err",
":=",
"e",
".",
"Err",
"\n",
"// this is not an endless loop because I'm being",
"// paranoid, this is a safe protection against endless",
"// loops",
"for",
"i",
":=",
"0",
";",
"i"... | // OrigError returns original wrapped error | [
"OrigError",
"returns",
"original",
"wrapped",
"error"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L293-L308 |
10,619 | gravitational/trace | trace.go | NewAggregate | func NewAggregate(errs ...error) error {
// filter out possible nil values
var nonNils []error
for _, err := range errs {
if err != nil {
nonNils = append(nonNils, err)
}
}
if len(nonNils) == 0 {
return nil
}
return wrapWithDepth(aggregate(nonNils), 2)
} | go | func NewAggregate(errs ...error) error {
// filter out possible nil values
var nonNils []error
for _, err := range errs {
if err != nil {
nonNils = append(nonNils, err)
}
}
if len(nonNils) == 0 {
return nil
}
return wrapWithDepth(aggregate(nonNils), 2)
} | [
"func",
"NewAggregate",
"(",
"errs",
"...",
"error",
")",
"error",
"{",
"// filter out possible nil values",
"var",
"nonNils",
"[",
"]",
"error",
"\n",
"for",
"_",
",",
"err",
":=",
"range",
"errs",
"{",
"if",
"err",
"!=",
"nil",
"{",
"nonNils",
"=",
"ap... | // NewAggregate creates a new aggregate instance from the specified
// list of errors | [
"NewAggregate",
"creates",
"a",
"new",
"aggregate",
"instance",
"from",
"the",
"specified",
"list",
"of",
"errors"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L342-L354 |
10,620 | gravitational/trace | trace.go | IsAggregate | func IsAggregate(err error) bool {
_, ok := Unwrap(err).(Aggregate)
return ok
} | go | func IsAggregate(err error) bool {
_, ok := Unwrap(err).(Aggregate)
return ok
} | [
"func",
"IsAggregate",
"(",
"err",
"error",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"Unwrap",
"(",
"err",
")",
".",
"(",
"Aggregate",
")",
"\n",
"return",
"ok",
"\n",
"}"
] | // IsAggregate returns whether this error of Aggregate error type | [
"IsAggregate",
"returns",
"whether",
"this",
"error",
"of",
"Aggregate",
"error",
"type"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/trace.go#L408-L411 |
10,621 | gravitational/trace | udphook.go | NewUDPHook | func NewUDPHook(opts ...UDPOptionSetter) (*UDPHook, error) {
f := &UDPHook{}
for _, o := range opts {
o(f)
}
if f.Clock == nil {
f.Clock = clockwork.NewRealClock()
}
if f.clientNet == "" {
f.clientNet = UDPDefaultNet
}
if f.clientAddr == "" {
f.clientAddr = UDPDefaultAddr
}
addr, err := net.ResolveUDPAddr(f.clientNet, f.clientAddr)
if err != nil {
return nil, Wrap(err)
}
conn, err := net.ListenPacket("udp", ":0")
if err != nil {
return nil, Wrap(err)
}
f.addr = addr
f.conn = conn.(*net.UDPConn)
return f, nil
} | go | func NewUDPHook(opts ...UDPOptionSetter) (*UDPHook, error) {
f := &UDPHook{}
for _, o := range opts {
o(f)
}
if f.Clock == nil {
f.Clock = clockwork.NewRealClock()
}
if f.clientNet == "" {
f.clientNet = UDPDefaultNet
}
if f.clientAddr == "" {
f.clientAddr = UDPDefaultAddr
}
addr, err := net.ResolveUDPAddr(f.clientNet, f.clientAddr)
if err != nil {
return nil, Wrap(err)
}
conn, err := net.ListenPacket("udp", ":0")
if err != nil {
return nil, Wrap(err)
}
f.addr = addr
f.conn = conn.(*net.UDPConn)
return f, nil
} | [
"func",
"NewUDPHook",
"(",
"opts",
"...",
"UDPOptionSetter",
")",
"(",
"*",
"UDPHook",
",",
"error",
")",
"{",
"f",
":=",
"&",
"UDPHook",
"{",
"}",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"opts",
"{",
"o",
"(",
"f",
")",
"\n",
"}",
"\n",
"if... | // NewUDPHook returns logrus-compatible hook that sends data to UDP socket | [
"NewUDPHook",
"returns",
"logrus",
"-",
"compatible",
"hook",
"that",
"sends",
"data",
"to",
"UDP",
"socket"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/udphook.go#L23-L48 |
10,622 | gravitational/trace | udphook.go | Fire | func (elk *UDPHook) Fire(e *log.Entry) error {
// Make a copy to safely modify
entry := e.WithFields(nil)
if cursor := findFrame(); cursor != nil {
t := newTraceFromFrames(*cursor, nil)
entry.Data[FileField] = t.String()
entry.Data[FunctionField] = t.Func()
}
data, err := json.Marshal(Frame{
Time: elk.Clock.Now().UTC(),
Type: "trace",
Entry: entry.Data,
Message: entry.Message,
Level: entry.Level.String(),
})
if err != nil {
return Wrap(err)
}
conn, err := net.ListenPacket("udp", ":0")
if err != nil {
return Wrap(err)
}
defer conn.Close()
resolvedAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:5000")
if err != nil {
return Wrap(err)
}
_, err = (conn.(*net.UDPConn)).WriteToUDP(data, resolvedAddr)
return Wrap(err)
} | go | func (elk *UDPHook) Fire(e *log.Entry) error {
// Make a copy to safely modify
entry := e.WithFields(nil)
if cursor := findFrame(); cursor != nil {
t := newTraceFromFrames(*cursor, nil)
entry.Data[FileField] = t.String()
entry.Data[FunctionField] = t.Func()
}
data, err := json.Marshal(Frame{
Time: elk.Clock.Now().UTC(),
Type: "trace",
Entry: entry.Data,
Message: entry.Message,
Level: entry.Level.String(),
})
if err != nil {
return Wrap(err)
}
conn, err := net.ListenPacket("udp", ":0")
if err != nil {
return Wrap(err)
}
defer conn.Close()
resolvedAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:5000")
if err != nil {
return Wrap(err)
}
_, err = (conn.(*net.UDPConn)).WriteToUDP(data, resolvedAddr)
return Wrap(err)
} | [
"func",
"(",
"elk",
"*",
"UDPHook",
")",
"Fire",
"(",
"e",
"*",
"log",
".",
"Entry",
")",
"error",
"{",
"// Make a copy to safely modify",
"entry",
":=",
"e",
".",
"WithFields",
"(",
"nil",
")",
"\n",
"if",
"cursor",
":=",
"findFrame",
"(",
")",
";",
... | // Fire fires the event to the ELK beat | [
"Fire",
"fires",
"the",
"event",
"to",
"the",
"ELK",
"beat"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/udphook.go#L67-L100 |
10,623 | gravitational/trace | udphook.go | Levels | func (elk *UDPHook) Levels() []log.Level {
return []log.Level{
log.PanicLevel,
log.FatalLevel,
log.ErrorLevel,
log.WarnLevel,
log.InfoLevel,
log.DebugLevel,
}
} | go | func (elk *UDPHook) Levels() []log.Level {
return []log.Level{
log.PanicLevel,
log.FatalLevel,
log.ErrorLevel,
log.WarnLevel,
log.InfoLevel,
log.DebugLevel,
}
} | [
"func",
"(",
"elk",
"*",
"UDPHook",
")",
"Levels",
"(",
")",
"[",
"]",
"log",
".",
"Level",
"{",
"return",
"[",
"]",
"log",
".",
"Level",
"{",
"log",
".",
"PanicLevel",
",",
"log",
".",
"FatalLevel",
",",
"log",
".",
"ErrorLevel",
",",
"log",
"."... | // Levels returns logging levels supported by logrus | [
"Levels",
"returns",
"logging",
"levels",
"supported",
"by",
"logrus"
] | f30095ced5ff011085d26f160468dcc477607730 | https://github.com/gravitational/trace/blob/f30095ced5ff011085d26f160468dcc477607730/udphook.go#L103-L112 |
10,624 | wvanbergen/kazoo-go | topic_admin.go | CreateTopic | func (kz *Kazoo) CreateTopic(name string, partitionCount int, replicationFactor int, topicConfig map[string]string) error {
topic := kz.Topic(name)
// Official kafka sdk checks if topic exists, then always writes the config unconditionally
// but only writes the partition map if ones does not exist.
exists, err := topic.Exists()
if err != nil {
return err
} else if exists {
return ErrTopicExists
}
brokerList, err := kz.brokerIDList()
if err != nil {
return err
}
partitionList, err := topic.generatePartitionAssignments(brokerList, partitionCount, replicationFactor)
if err != nil {
return err
}
configData, err := topic.marshalConfig(topicConfig)
if err != nil {
return err
}
partitionData, err := topic.marshalPartitions(partitionList)
if err != nil {
return err
}
if err = kz.createOrUpdate(topic.configPath(), configData, false); err != nil {
return err
}
if err = kz.create(topic.metadataPath(), partitionData, false); err != nil {
return err
}
return nil
} | go | func (kz *Kazoo) CreateTopic(name string, partitionCount int, replicationFactor int, topicConfig map[string]string) error {
topic := kz.Topic(name)
// Official kafka sdk checks if topic exists, then always writes the config unconditionally
// but only writes the partition map if ones does not exist.
exists, err := topic.Exists()
if err != nil {
return err
} else if exists {
return ErrTopicExists
}
brokerList, err := kz.brokerIDList()
if err != nil {
return err
}
partitionList, err := topic.generatePartitionAssignments(brokerList, partitionCount, replicationFactor)
if err != nil {
return err
}
configData, err := topic.marshalConfig(topicConfig)
if err != nil {
return err
}
partitionData, err := topic.marshalPartitions(partitionList)
if err != nil {
return err
}
if err = kz.createOrUpdate(topic.configPath(), configData, false); err != nil {
return err
}
if err = kz.create(topic.metadataPath(), partitionData, false); err != nil {
return err
}
return nil
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"CreateTopic",
"(",
"name",
"string",
",",
"partitionCount",
"int",
",",
"replicationFactor",
"int",
",",
"topicConfig",
"map",
"[",
"string",
"]",
"string",
")",
"error",
"{",
"topic",
":=",
"kz",
".",
"Topic",
"(",... | // CreateTopic creates a new kafka topic with the specified parameters and properties | [
"CreateTopic",
"creates",
"a",
"new",
"kafka",
"topic",
"with",
"the",
"specified",
"parameters",
"and",
"properties"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_admin.go#L18-L59 |
10,625 | wvanbergen/kazoo-go | topic_admin.go | DeleteTopic | func (kz *Kazoo) DeleteTopic(name string) error {
node := fmt.Sprintf("%s/admin/delete_topics/%s", kz.conf.Chroot, name)
exists, err := kz.exists(node)
if err != nil {
return err
}
if exists {
return ErrTopicMarkedForDelete
}
if err := kz.create(node, nil, false); err != nil {
return err
}
return nil
} | go | func (kz *Kazoo) DeleteTopic(name string) error {
node := fmt.Sprintf("%s/admin/delete_topics/%s", kz.conf.Chroot, name)
exists, err := kz.exists(node)
if err != nil {
return err
}
if exists {
return ErrTopicMarkedForDelete
}
if err := kz.create(node, nil, false); err != nil {
return err
}
return nil
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"DeleteTopic",
"(",
"name",
"string",
")",
"error",
"{",
"node",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"kz",
".",
"conf",
".",
"Chroot",
",",
"name",
")",
"\n\n",
"exists",
",",
"err",
":=",
"kz"... | // DeleteTopic marks a kafka topic for deletion. Deleting a topic is asynchronous and
// DeleteTopic will return before Kafka actually does the deletion. | [
"DeleteTopic",
"marks",
"a",
"kafka",
"topic",
"for",
"deletion",
".",
"Deleting",
"a",
"topic",
"is",
"asynchronous",
"and",
"DeleteTopic",
"will",
"return",
"before",
"Kafka",
"actually",
"does",
"the",
"deletion",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_admin.go#L63-L78 |
10,626 | wvanbergen/kazoo-go | topic_admin.go | DeleteTopicSync | func (kz *Kazoo) DeleteTopicSync(name string, timeout time.Duration) error {
err := kz.DeleteTopic(name)
if err != nil {
return err
}
topic := kz.Topic(name)
if exists, err := topic.Exists(); err != nil {
return err
} else if !exists {
return nil
}
changes, err := topic.Watch()
if err != nil {
return nil
}
if timeout > 0 {
timer := time.NewTimer(timeout)
defer timer.Stop()
for {
select {
case <-timer.C:
return ErrDeletionTimedOut
case c := <-changes:
if c.Type == zk.EventNodeDeleted {
return nil
}
}
}
} else {
for {
select {
case c := <-changes:
if c.Type == zk.EventNodeDeleted {
return nil
}
}
}
}
} | go | func (kz *Kazoo) DeleteTopicSync(name string, timeout time.Duration) error {
err := kz.DeleteTopic(name)
if err != nil {
return err
}
topic := kz.Topic(name)
if exists, err := topic.Exists(); err != nil {
return err
} else if !exists {
return nil
}
changes, err := topic.Watch()
if err != nil {
return nil
}
if timeout > 0 {
timer := time.NewTimer(timeout)
defer timer.Stop()
for {
select {
case <-timer.C:
return ErrDeletionTimedOut
case c := <-changes:
if c.Type == zk.EventNodeDeleted {
return nil
}
}
}
} else {
for {
select {
case c := <-changes:
if c.Type == zk.EventNodeDeleted {
return nil
}
}
}
}
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"DeleteTopicSync",
"(",
"name",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"error",
"{",
"err",
":=",
"kz",
".",
"DeleteTopic",
"(",
"name",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err... | // DeleteTopicSync marks a kafka topic for deletion and waits until it is deleted
// before returning. | [
"DeleteTopicSync",
"marks",
"a",
"kafka",
"topic",
"for",
"deletion",
"and",
"waits",
"until",
"it",
"is",
"deleted",
"before",
"returning",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_admin.go#L82-L130 |
10,627 | wvanbergen/kazoo-go | kazoo.go | NewKazoo | func NewKazoo(servers []string, conf *Config) (*Kazoo, error) {
if conf == nil {
conf = NewConfig()
}
conn, _, err := zk.Connect(
servers,
conf.Timeout,
func(c *zk.Conn) { c.SetLogger(conf.Logger) },
)
if err != nil {
return nil, err
}
return &Kazoo{conn, conf}, nil
} | go | func NewKazoo(servers []string, conf *Config) (*Kazoo, error) {
if conf == nil {
conf = NewConfig()
}
conn, _, err := zk.Connect(
servers,
conf.Timeout,
func(c *zk.Conn) { c.SetLogger(conf.Logger) },
)
if err != nil {
return nil, err
}
return &Kazoo{conn, conf}, nil
} | [
"func",
"NewKazoo",
"(",
"servers",
"[",
"]",
"string",
",",
"conf",
"*",
"Config",
")",
"(",
"*",
"Kazoo",
",",
"error",
")",
"{",
"if",
"conf",
"==",
"nil",
"{",
"conf",
"=",
"NewConfig",
"(",
")",
"\n",
"}",
"\n\n",
"conn",
",",
"_",
",",
"e... | // NewKazoo creates a new connection instance | [
"NewKazoo",
"creates",
"a",
"new",
"connection",
"instance"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/kazoo.go#L72-L87 |
10,628 | wvanbergen/kazoo-go | kazoo.go | NewKazooFromConnectionString | func NewKazooFromConnectionString(connectionString string, conf *Config) (*Kazoo, error) {
if conf == nil {
conf = NewConfig()
}
nodes, chroot := ParseConnectionString(connectionString)
conf.Chroot = chroot
return NewKazoo(nodes, conf)
} | go | func NewKazooFromConnectionString(connectionString string, conf *Config) (*Kazoo, error) {
if conf == nil {
conf = NewConfig()
}
nodes, chroot := ParseConnectionString(connectionString)
conf.Chroot = chroot
return NewKazoo(nodes, conf)
} | [
"func",
"NewKazooFromConnectionString",
"(",
"connectionString",
"string",
",",
"conf",
"*",
"Config",
")",
"(",
"*",
"Kazoo",
",",
"error",
")",
"{",
"if",
"conf",
"==",
"nil",
"{",
"conf",
"=",
"NewConfig",
"(",
")",
"\n",
"}",
"\n\n",
"nodes",
",",
... | // NewKazooFromConnectionString creates a new connection instance
// based on a zookeeer connection string that can include a chroot. | [
"NewKazooFromConnectionString",
"creates",
"a",
"new",
"connection",
"instance",
"based",
"on",
"a",
"zookeeer",
"connection",
"string",
"that",
"can",
"include",
"a",
"chroot",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/kazoo.go#L91-L99 |
10,629 | wvanbergen/kazoo-go | kazoo.go | Brokers | func (kz *Kazoo) Brokers() (map[int32]string, error) {
root := fmt.Sprintf("%s/brokers/ids", kz.conf.Chroot)
children, _, err := kz.conn.Children(root)
if err != nil {
return nil, err
}
type brokerEntry struct {
Host string `json:"host"`
Port int `json:"port"`
}
result := make(map[int32]string)
for _, child := range children {
brokerID, err := strconv.ParseInt(child, 10, 32)
if err != nil {
return nil, err
}
value, _, err := kz.conn.Get(path.Join(root, child))
if err != nil {
return nil, err
}
var brokerNode brokerEntry
if err := json.Unmarshal(value, &brokerNode); err != nil {
return nil, err
}
result[int32(brokerID)] = fmt.Sprintf("%s:%d", brokerNode.Host, brokerNode.Port)
}
return result, nil
} | go | func (kz *Kazoo) Brokers() (map[int32]string, error) {
root := fmt.Sprintf("%s/brokers/ids", kz.conf.Chroot)
children, _, err := kz.conn.Children(root)
if err != nil {
return nil, err
}
type brokerEntry struct {
Host string `json:"host"`
Port int `json:"port"`
}
result := make(map[int32]string)
for _, child := range children {
brokerID, err := strconv.ParseInt(child, 10, 32)
if err != nil {
return nil, err
}
value, _, err := kz.conn.Get(path.Join(root, child))
if err != nil {
return nil, err
}
var brokerNode brokerEntry
if err := json.Unmarshal(value, &brokerNode); err != nil {
return nil, err
}
result[int32(brokerID)] = fmt.Sprintf("%s:%d", brokerNode.Host, brokerNode.Port)
}
return result, nil
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"Brokers",
"(",
")",
"(",
"map",
"[",
"int32",
"]",
"string",
",",
"error",
")",
"{",
"root",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"kz",
".",
"conf",
".",
"Chroot",
")",
"\n",
"children",
",",... | // Brokers returns a map of all the brokers that make part of the
// Kafka cluster that is registered in Zookeeper. | [
"Brokers",
"returns",
"a",
"map",
"of",
"all",
"the",
"brokers",
"that",
"make",
"part",
"of",
"the",
"Kafka",
"cluster",
"that",
"is",
"registered",
"in",
"Zookeeper",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/kazoo.go#L103-L136 |
10,630 | wvanbergen/kazoo-go | kazoo.go | brokerIDList | func (kz *Kazoo) brokerIDList() ([]int32, error) {
brokers, err := kz.Brokers()
if err != nil {
return nil, err
}
result := make([]int32, 0, len(brokers))
for id := range brokers {
result = append(result, id)
}
// return sorted list to match the offical kafka sdks
sort.Sort(int32Slice(result))
return result, nil
} | go | func (kz *Kazoo) brokerIDList() ([]int32, error) {
brokers, err := kz.Brokers()
if err != nil {
return nil, err
}
result := make([]int32, 0, len(brokers))
for id := range brokers {
result = append(result, id)
}
// return sorted list to match the offical kafka sdks
sort.Sort(int32Slice(result))
return result, nil
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"brokerIDList",
"(",
")",
"(",
"[",
"]",
"int32",
",",
"error",
")",
"{",
"brokers",
",",
"err",
":=",
"kz",
".",
"Brokers",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",... | // BrokerIDList returns a sorted slice of broker ids that can be used for manipulating topics and partitions.`. | [
"BrokerIDList",
"returns",
"a",
"sorted",
"slice",
"of",
"broker",
"ids",
"that",
"can",
"be",
"used",
"for",
"manipulating",
"topics",
"and",
"partitions",
".",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/kazoo.go#L155-L170 |
10,631 | wvanbergen/kazoo-go | kazoo.go | Controller | func (kz *Kazoo) Controller() (int32, error) {
type controllerEntry struct {
BrokerID int32 `json:"brokerid"`
}
node := fmt.Sprintf("%s/controller", kz.conf.Chroot)
data, _, err := kz.conn.Get(node)
if err != nil {
return -1, err
}
var controllerNode controllerEntry
if err := json.Unmarshal(data, &controllerNode); err != nil {
return -1, err
}
return controllerNode.BrokerID, nil
} | go | func (kz *Kazoo) Controller() (int32, error) {
type controllerEntry struct {
BrokerID int32 `json:"brokerid"`
}
node := fmt.Sprintf("%s/controller", kz.conf.Chroot)
data, _, err := kz.conn.Get(node)
if err != nil {
return -1, err
}
var controllerNode controllerEntry
if err := json.Unmarshal(data, &controllerNode); err != nil {
return -1, err
}
return controllerNode.BrokerID, nil
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"Controller",
"(",
")",
"(",
"int32",
",",
"error",
")",
"{",
"type",
"controllerEntry",
"struct",
"{",
"BrokerID",
"int32",
"`json:\"brokerid\"`",
"\n",
"}",
"\n\n",
"node",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
... | // Controller returns what broker is currently acting as controller of the Kafka cluster | [
"Controller",
"returns",
"what",
"broker",
"is",
"currently",
"acting",
"as",
"controller",
"of",
"the",
"Kafka",
"cluster"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/kazoo.go#L173-L190 |
10,632 | wvanbergen/kazoo-go | kazoo.go | deleteRecursive | func (kz *Kazoo) deleteRecursive(node string) (err error) {
children, stat, err := kz.conn.Children(node)
if err == zk.ErrNoNode {
return nil
} else if err != nil {
return
}
for _, child := range children {
if err = kz.deleteRecursive(path.Join(node, child)); err != nil {
return
}
}
return kz.conn.Delete(node, stat.Version)
} | go | func (kz *Kazoo) deleteRecursive(node string) (err error) {
children, stat, err := kz.conn.Children(node)
if err == zk.ErrNoNode {
return nil
} else if err != nil {
return
}
for _, child := range children {
if err = kz.deleteRecursive(path.Join(node, child)); err != nil {
return
}
}
return kz.conn.Delete(node, stat.Version)
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"deleteRecursive",
"(",
"node",
"string",
")",
"(",
"err",
"error",
")",
"{",
"children",
",",
"stat",
",",
"err",
":=",
"kz",
".",
"conn",
".",
"Children",
"(",
"node",
")",
"\n",
"if",
"err",
"==",
"zk",
".... | // DeleteAll deletes a node recursively | [
"DeleteAll",
"deletes",
"a",
"node",
"recursively"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/kazoo.go#L209-L224 |
10,633 | wvanbergen/kazoo-go | kazoo.go | mkdirRecursive | func (kz *Kazoo) mkdirRecursive(node string) (err error) {
parent := path.Dir(node)
if parent != "/" {
if err = kz.mkdirRecursive(parent); err != nil {
return
}
}
exists, _, err := kz.conn.Exists(node)
if err != nil {
return
}
if !exists {
_, err = kz.conn.Create(node, nil, 0, zk.WorldACL(zk.PermAll))
return
}
return
} | go | func (kz *Kazoo) mkdirRecursive(node string) (err error) {
parent := path.Dir(node)
if parent != "/" {
if err = kz.mkdirRecursive(parent); err != nil {
return
}
}
exists, _, err := kz.conn.Exists(node)
if err != nil {
return
}
if !exists {
_, err = kz.conn.Create(node, nil, 0, zk.WorldACL(zk.PermAll))
return
}
return
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"mkdirRecursive",
"(",
"node",
"string",
")",
"(",
"err",
"error",
")",
"{",
"parent",
":=",
"path",
".",
"Dir",
"(",
"node",
")",
"\n",
"if",
"parent",
"!=",
"\"",
"\"",
"{",
"if",
"err",
"=",
"kz",
".",
"... | // MkdirAll creates a directory recursively | [
"MkdirAll",
"creates",
"a",
"directory",
"recursively"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/kazoo.go#L227-L246 |
10,634 | wvanbergen/kazoo-go | kazoo.go | create | func (kz *Kazoo) create(node string, value []byte, ephemeral bool) (err error) {
if err = kz.mkdirRecursive(path.Dir(node)); err != nil {
return
}
flags := int32(0)
if ephemeral {
flags = zk.FlagEphemeral
}
_, err = kz.conn.Create(node, value, flags, zk.WorldACL(zk.PermAll))
return
} | go | func (kz *Kazoo) create(node string, value []byte, ephemeral bool) (err error) {
if err = kz.mkdirRecursive(path.Dir(node)); err != nil {
return
}
flags := int32(0)
if ephemeral {
flags = zk.FlagEphemeral
}
_, err = kz.conn.Create(node, value, flags, zk.WorldACL(zk.PermAll))
return
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"create",
"(",
"node",
"string",
",",
"value",
"[",
"]",
"byte",
",",
"ephemeral",
"bool",
")",
"(",
"err",
"error",
")",
"{",
"if",
"err",
"=",
"kz",
".",
"mkdirRecursive",
"(",
"path",
".",
"Dir",
"(",
"nod... | // Create stores a new value at node. Fails if already set. | [
"Create",
"stores",
"a",
"new",
"value",
"at",
"node",
".",
"Fails",
"if",
"already",
"set",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/kazoo.go#L249-L260 |
10,635 | wvanbergen/kazoo-go | kazoo.go | createOrUpdate | func (kz *Kazoo) createOrUpdate(node string, value []byte, ephemeral bool) (err error) {
if _, err = kz.conn.Set(node, value, -1); err == nil {
return
}
if err == zk.ErrNoNode {
err = kz.create(node, value, ephemeral)
}
return
} | go | func (kz *Kazoo) createOrUpdate(node string, value []byte, ephemeral bool) (err error) {
if _, err = kz.conn.Set(node, value, -1); err == nil {
return
}
if err == zk.ErrNoNode {
err = kz.create(node, value, ephemeral)
}
return
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"createOrUpdate",
"(",
"node",
"string",
",",
"value",
"[",
"]",
"byte",
",",
"ephemeral",
"bool",
")",
"(",
"err",
"error",
")",
"{",
"if",
"_",
",",
"err",
"=",
"kz",
".",
"conn",
".",
"Set",
"(",
"node",
... | // createOrUpdate first attempts to update a node. If the nodes does not exist it will create it. | [
"createOrUpdate",
"first",
"attempts",
"to",
"update",
"a",
"node",
".",
"If",
"the",
"nodes",
"does",
"not",
"exist",
"it",
"will",
"create",
"it",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/kazoo.go#L263-L272 |
10,636 | wvanbergen/kazoo-go | consumergroup.go | Consumergroups | func (kz *Kazoo) Consumergroups() (ConsumergroupList, error) {
root := fmt.Sprintf("%s/consumers", kz.conf.Chroot)
cgs, _, err := kz.conn.Children(root)
if err != nil {
return nil, err
}
result := make(ConsumergroupList, 0, len(cgs))
for _, cg := range cgs {
result = append(result, kz.Consumergroup(cg))
}
return result, nil
} | go | func (kz *Kazoo) Consumergroups() (ConsumergroupList, error) {
root := fmt.Sprintf("%s/consumers", kz.conf.Chroot)
cgs, _, err := kz.conn.Children(root)
if err != nil {
return nil, err
}
result := make(ConsumergroupList, 0, len(cgs))
for _, cg := range cgs {
result = append(result, kz.Consumergroup(cg))
}
return result, nil
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"Consumergroups",
"(",
")",
"(",
"ConsumergroupList",
",",
"error",
")",
"{",
"root",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"kz",
".",
"conf",
".",
"Chroot",
")",
"\n",
"cgs",
",",
"_",
",",
"err... | // Consumergroups returns all the registered consumergroups | [
"Consumergroups",
"returns",
"all",
"the",
"registered",
"consumergroups"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L64-L76 |
10,637 | wvanbergen/kazoo-go | consumergroup.go | Consumergroup | func (kz *Kazoo) Consumergroup(name string) *Consumergroup {
return &Consumergroup{Name: name, kz: kz}
} | go | func (kz *Kazoo) Consumergroup(name string) *Consumergroup {
return &Consumergroup{Name: name, kz: kz}
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"Consumergroup",
"(",
"name",
"string",
")",
"*",
"Consumergroup",
"{",
"return",
"&",
"Consumergroup",
"{",
"Name",
":",
"name",
",",
"kz",
":",
"kz",
"}",
"\n",
"}"
] | // Consumergroup instantiates a new consumergroup. | [
"Consumergroup",
"instantiates",
"a",
"new",
"consumergroup",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L79-L81 |
10,638 | wvanbergen/kazoo-go | consumergroup.go | Exists | func (cg *Consumergroup) Exists() (bool, error) {
return cg.kz.exists(fmt.Sprintf("%s/consumers/%s", cg.kz.conf.Chroot, cg.Name))
} | go | func (cg *Consumergroup) Exists() (bool, error) {
return cg.kz.exists(fmt.Sprintf("%s/consumers/%s", cg.kz.conf.Chroot, cg.Name))
} | [
"func",
"(",
"cg",
"*",
"Consumergroup",
")",
"Exists",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"return",
"cg",
".",
"kz",
".",
"exists",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cg",
".",
"kz",
".",
"conf",
".",
"Chroot",
",",... | // Exists checks whether the consumergroup has been registered in Zookeeper | [
"Exists",
"checks",
"whether",
"the",
"consumergroup",
"has",
"been",
"registered",
"in",
"Zookeeper"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L84-L86 |
10,639 | wvanbergen/kazoo-go | consumergroup.go | Create | func (cg *Consumergroup) Create() error {
return cg.kz.mkdirRecursive(fmt.Sprintf("%s/consumers/%s", cg.kz.conf.Chroot, cg.Name))
} | go | func (cg *Consumergroup) Create() error {
return cg.kz.mkdirRecursive(fmt.Sprintf("%s/consumers/%s", cg.kz.conf.Chroot, cg.Name))
} | [
"func",
"(",
"cg",
"*",
"Consumergroup",
")",
"Create",
"(",
")",
"error",
"{",
"return",
"cg",
".",
"kz",
".",
"mkdirRecursive",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cg",
".",
"kz",
".",
"conf",
".",
"Chroot",
",",
"cg",
".",
"Name... | // Create registers the consumergroup in zookeeper | [
"Create",
"registers",
"the",
"consumergroup",
"in",
"zookeeper"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L89-L91 |
10,640 | wvanbergen/kazoo-go | consumergroup.go | Delete | func (cg *Consumergroup) Delete() error {
if instances, err := cg.Instances(); err != nil {
return err
} else if len(instances) > 0 {
return ErrRunningInstances
}
return cg.kz.deleteRecursive(fmt.Sprintf("%s/consumers/%s", cg.kz.conf.Chroot, cg.Name))
} | go | func (cg *Consumergroup) Delete() error {
if instances, err := cg.Instances(); err != nil {
return err
} else if len(instances) > 0 {
return ErrRunningInstances
}
return cg.kz.deleteRecursive(fmt.Sprintf("%s/consumers/%s", cg.kz.conf.Chroot, cg.Name))
} | [
"func",
"(",
"cg",
"*",
"Consumergroup",
")",
"Delete",
"(",
")",
"error",
"{",
"if",
"instances",
",",
"err",
":=",
"cg",
".",
"Instances",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"if",
"len",
"(",
"instances",
... | // Delete removes the consumergroup from zookeeper | [
"Delete",
"removes",
"the",
"consumergroup",
"from",
"zookeeper"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L94-L102 |
10,641 | wvanbergen/kazoo-go | consumergroup.go | Instances | func (cg *Consumergroup) Instances() (ConsumergroupInstanceList, error) {
root := fmt.Sprintf("%s/consumers/%s/ids", cg.kz.conf.Chroot, cg.Name)
cgis, _, err := cg.kz.conn.Children(root)
if err != nil {
if err == zk.ErrNoNode {
result := make(ConsumergroupInstanceList, 0)
return result, nil
}
return nil, err
}
result := make(ConsumergroupInstanceList, 0, len(cgis))
for _, cgi := range cgis {
result = append(result, cg.Instance(cgi))
}
return result, nil
} | go | func (cg *Consumergroup) Instances() (ConsumergroupInstanceList, error) {
root := fmt.Sprintf("%s/consumers/%s/ids", cg.kz.conf.Chroot, cg.Name)
cgis, _, err := cg.kz.conn.Children(root)
if err != nil {
if err == zk.ErrNoNode {
result := make(ConsumergroupInstanceList, 0)
return result, nil
}
return nil, err
}
result := make(ConsumergroupInstanceList, 0, len(cgis))
for _, cgi := range cgis {
result = append(result, cg.Instance(cgi))
}
return result, nil
} | [
"func",
"(",
"cg",
"*",
"Consumergroup",
")",
"Instances",
"(",
")",
"(",
"ConsumergroupInstanceList",
",",
"error",
")",
"{",
"root",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cg",
".",
"kz",
".",
"conf",
".",
"Chroot",
",",
"cg",
".",
"... | // Instances returns a map of all running instances inside this consumergroup. | [
"Instances",
"returns",
"a",
"map",
"of",
"all",
"running",
"instances",
"inside",
"this",
"consumergroup",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L105-L121 |
10,642 | wvanbergen/kazoo-go | consumergroup.go | WatchInstances | func (cg *Consumergroup) WatchInstances() (ConsumergroupInstanceList, <-chan zk.Event, error) {
node := fmt.Sprintf("%s/consumers/%s/ids", cg.kz.conf.Chroot, cg.Name)
cgis, _, c, err := cg.kz.conn.ChildrenW(node)
if err != nil {
if err != zk.ErrNoNode {
return nil, nil, err
}
if err := cg.kz.mkdirRecursive(node); err != nil {
return nil, nil, err
}
if cgis, _, c, err = cg.kz.conn.ChildrenW(node); err != nil {
return nil, nil, err
}
}
result := make(ConsumergroupInstanceList, 0, len(cgis))
for _, cgi := range cgis {
result = append(result, cg.Instance(cgi))
}
return result, c, nil
} | go | func (cg *Consumergroup) WatchInstances() (ConsumergroupInstanceList, <-chan zk.Event, error) {
node := fmt.Sprintf("%s/consumers/%s/ids", cg.kz.conf.Chroot, cg.Name)
cgis, _, c, err := cg.kz.conn.ChildrenW(node)
if err != nil {
if err != zk.ErrNoNode {
return nil, nil, err
}
if err := cg.kz.mkdirRecursive(node); err != nil {
return nil, nil, err
}
if cgis, _, c, err = cg.kz.conn.ChildrenW(node); err != nil {
return nil, nil, err
}
}
result := make(ConsumergroupInstanceList, 0, len(cgis))
for _, cgi := range cgis {
result = append(result, cg.Instance(cgi))
}
return result, c, nil
} | [
"func",
"(",
"cg",
"*",
"Consumergroup",
")",
"WatchInstances",
"(",
")",
"(",
"ConsumergroupInstanceList",
",",
"<-",
"chan",
"zk",
".",
"Event",
",",
"error",
")",
"{",
"node",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cg",
".",
"kz",
"."... | // WatchInstances returns a ConsumergroupInstanceList, and a channel that will be closed
// as soon the instance list changes. | [
"WatchInstances",
"returns",
"a",
"ConsumergroupInstanceList",
"and",
"a",
"channel",
"that",
"will",
"be",
"closed",
"as",
"soon",
"the",
"instance",
"list",
"changes",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L125-L146 |
10,643 | wvanbergen/kazoo-go | consumergroup.go | NewInstance | func (cg *Consumergroup) NewInstance() *ConsumergroupInstance {
id, err := generateConsumerInstanceID()
if err != nil {
panic(err)
}
return cg.Instance(id)
} | go | func (cg *Consumergroup) NewInstance() *ConsumergroupInstance {
id, err := generateConsumerInstanceID()
if err != nil {
panic(err)
}
return cg.Instance(id)
} | [
"func",
"(",
"cg",
"*",
"Consumergroup",
")",
"NewInstance",
"(",
")",
"*",
"ConsumergroupInstance",
"{",
"id",
",",
"err",
":=",
"generateConsumerInstanceID",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"r... | // NewInstance instantiates a new ConsumergroupInstance inside this consumer group,
// using a newly generated ID. | [
"NewInstance",
"instantiates",
"a",
"new",
"ConsumergroupInstance",
"inside",
"this",
"consumer",
"group",
"using",
"a",
"newly",
"generated",
"ID",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L150-L156 |
10,644 | wvanbergen/kazoo-go | consumergroup.go | Instance | func (cg *Consumergroup) Instance(id string) *ConsumergroupInstance {
return &ConsumergroupInstance{cg: cg, ID: id}
} | go | func (cg *Consumergroup) Instance(id string) *ConsumergroupInstance {
return &ConsumergroupInstance{cg: cg, ID: id}
} | [
"func",
"(",
"cg",
"*",
"Consumergroup",
")",
"Instance",
"(",
"id",
"string",
")",
"*",
"ConsumergroupInstance",
"{",
"return",
"&",
"ConsumergroupInstance",
"{",
"cg",
":",
"cg",
",",
"ID",
":",
"id",
"}",
"\n",
"}"
] | // Instance instantiates a new ConsumergroupInstance inside this consumer group,
// using an existing ID. | [
"Instance",
"instantiates",
"a",
"new",
"ConsumergroupInstance",
"inside",
"this",
"consumer",
"group",
"using",
"an",
"existing",
"ID",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L160-L162 |
10,645 | wvanbergen/kazoo-go | consumergroup.go | PartitionOwner | func (cg *Consumergroup) PartitionOwner(topic string, partition int32) (*ConsumergroupInstance, error) {
node := fmt.Sprintf("%s/consumers/%s/owners/%s/%d", cg.kz.conf.Chroot, cg.Name, topic, partition)
val, _, err := cg.kz.conn.Get(node)
// If the node does not exists, nobody has claimed it.
switch err {
case nil:
return &ConsumergroupInstance{cg: cg, ID: string(val)}, nil
case zk.ErrNoNode:
return nil, nil
default:
return nil, err
}
} | go | func (cg *Consumergroup) PartitionOwner(topic string, partition int32) (*ConsumergroupInstance, error) {
node := fmt.Sprintf("%s/consumers/%s/owners/%s/%d", cg.kz.conf.Chroot, cg.Name, topic, partition)
val, _, err := cg.kz.conn.Get(node)
// If the node does not exists, nobody has claimed it.
switch err {
case nil:
return &ConsumergroupInstance{cg: cg, ID: string(val)}, nil
case zk.ErrNoNode:
return nil, nil
default:
return nil, err
}
} | [
"func",
"(",
"cg",
"*",
"Consumergroup",
")",
"PartitionOwner",
"(",
"topic",
"string",
",",
"partition",
"int32",
")",
"(",
"*",
"ConsumergroupInstance",
",",
"error",
")",
"{",
"node",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cg",
".",
"kz... | // PartitionOwner returns the ConsumergroupInstance that has claimed the given partition.
// This can be nil if nobody has claimed it yet. | [
"PartitionOwner",
"returns",
"the",
"ConsumergroupInstance",
"that",
"has",
"claimed",
"the",
"given",
"partition",
".",
"This",
"can",
"be",
"nil",
"if",
"nobody",
"has",
"claimed",
"it",
"yet",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L166-L179 |
10,646 | wvanbergen/kazoo-go | consumergroup.go | WatchPartitionOwner | func (cg *Consumergroup) WatchPartitionOwner(topic string, partition int32) (*ConsumergroupInstance, <-chan zk.Event, error) {
node := fmt.Sprintf("%s/consumers/%s/owners/%s/%d", cg.kz.conf.Chroot, cg.Name, topic, partition)
instanceID, _, changed, err := cg.kz.conn.GetW(node)
switch err {
case nil:
return &ConsumergroupInstance{cg: cg, ID: string(instanceID)}, changed, nil
case zk.ErrNoNode:
return nil, nil, nil
default:
return nil, nil, err
}
} | go | func (cg *Consumergroup) WatchPartitionOwner(topic string, partition int32) (*ConsumergroupInstance, <-chan zk.Event, error) {
node := fmt.Sprintf("%s/consumers/%s/owners/%s/%d", cg.kz.conf.Chroot, cg.Name, topic, partition)
instanceID, _, changed, err := cg.kz.conn.GetW(node)
switch err {
case nil:
return &ConsumergroupInstance{cg: cg, ID: string(instanceID)}, changed, nil
case zk.ErrNoNode:
return nil, nil, nil
default:
return nil, nil, err
}
} | [
"func",
"(",
"cg",
"*",
"Consumergroup",
")",
"WatchPartitionOwner",
"(",
"topic",
"string",
",",
"partition",
"int32",
")",
"(",
"*",
"ConsumergroupInstance",
",",
"<-",
"chan",
"zk",
".",
"Event",
",",
"error",
")",
"{",
"node",
":=",
"fmt",
".",
"Spri... | // WatchPartitionOwner retrieves what instance is currently owning the partition, and sets a
// Zookeeper watch to be notified of changes. If the partition currently does not have an owner,
// the function returns nil for every return value. In this case is should be safe to claim
// the partition for an instance. | [
"WatchPartitionOwner",
"retrieves",
"what",
"instance",
"is",
"currently",
"owning",
"the",
"partition",
"and",
"sets",
"a",
"Zookeeper",
"watch",
"to",
"be",
"notified",
"of",
"changes",
".",
"If",
"the",
"partition",
"currently",
"does",
"not",
"have",
"an",
... | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L185-L199 |
10,647 | wvanbergen/kazoo-go | consumergroup.go | Registered | func (cgi *ConsumergroupInstance) Registered() (bool, error) {
node := fmt.Sprintf("%s/consumers/%s/ids/%s", cgi.cg.kz.conf.Chroot, cgi.cg.Name, cgi.ID)
return cgi.cg.kz.exists(node)
} | go | func (cgi *ConsumergroupInstance) Registered() (bool, error) {
node := fmt.Sprintf("%s/consumers/%s/ids/%s", cgi.cg.kz.conf.Chroot, cgi.cg.Name, cgi.ID)
return cgi.cg.kz.exists(node)
} | [
"func",
"(",
"cgi",
"*",
"ConsumergroupInstance",
")",
"Registered",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"node",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cgi",
".",
"cg",
".",
"kz",
".",
"conf",
".",
"Chroot",
",",
"cgi",
".... | // Registered checks whether the consumergroup instance is registered in Zookeeper. | [
"Registered",
"checks",
"whether",
"the",
"consumergroup",
"instance",
"is",
"registered",
"in",
"Zookeeper",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L202-L205 |
10,648 | wvanbergen/kazoo-go | consumergroup.go | Registration | func (cgi *ConsumergroupInstance) Registration() (*Registration, error) {
node := fmt.Sprintf("%s/consumers/%s/ids/%s", cgi.cg.kz.conf.Chroot, cgi.cg.Name, cgi.ID)
val, _, err := cgi.cg.kz.conn.Get(node)
if err != nil {
if err == zk.ErrNoNode {
return nil, ErrInstanceNotRegistered
}
return nil, err
}
reg := &Registration{}
if err := json.Unmarshal(val, reg); err != nil {
return nil, err
}
return reg, nil
} | go | func (cgi *ConsumergroupInstance) Registration() (*Registration, error) {
node := fmt.Sprintf("%s/consumers/%s/ids/%s", cgi.cg.kz.conf.Chroot, cgi.cg.Name, cgi.ID)
val, _, err := cgi.cg.kz.conn.Get(node)
if err != nil {
if err == zk.ErrNoNode {
return nil, ErrInstanceNotRegistered
}
return nil, err
}
reg := &Registration{}
if err := json.Unmarshal(val, reg); err != nil {
return nil, err
}
return reg, nil
} | [
"func",
"(",
"cgi",
"*",
"ConsumergroupInstance",
")",
"Registration",
"(",
")",
"(",
"*",
"Registration",
",",
"error",
")",
"{",
"node",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cgi",
".",
"cg",
".",
"kz",
".",
"conf",
".",
"Chroot",
"... | // Registered returns current registration of the consumer group instance. | [
"Registered",
"returns",
"current",
"registration",
"of",
"the",
"consumer",
"group",
"instance",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L208-L223 |
10,649 | wvanbergen/kazoo-go | consumergroup.go | RegisterWithSubscription | func (cgi *ConsumergroupInstance) RegisterWithSubscription(subscriptionJSON []byte) error {
node := fmt.Sprintf("%s/consumers/%s/ids/%s", cgi.cg.kz.conf.Chroot, cgi.cg.Name, cgi.ID)
err := cgi.cg.kz.create(node, subscriptionJSON, true)
if err == zk.ErrNodeExists {
return ErrInstanceAlreadyRegistered
}
return err
} | go | func (cgi *ConsumergroupInstance) RegisterWithSubscription(subscriptionJSON []byte) error {
node := fmt.Sprintf("%s/consumers/%s/ids/%s", cgi.cg.kz.conf.Chroot, cgi.cg.Name, cgi.ID)
err := cgi.cg.kz.create(node, subscriptionJSON, true)
if err == zk.ErrNodeExists {
return ErrInstanceAlreadyRegistered
}
return err
} | [
"func",
"(",
"cgi",
"*",
"ConsumergroupInstance",
")",
"RegisterWithSubscription",
"(",
"subscriptionJSON",
"[",
"]",
"byte",
")",
"error",
"{",
"node",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cgi",
".",
"cg",
".",
"kz",
".",
"conf",
".",
"... | // RegisterSubscription registers the consumer instance in Zookeeper, with its subscription. | [
"RegisterSubscription",
"registers",
"the",
"consumer",
"instance",
"in",
"Zookeeper",
"with",
"its",
"subscription",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L245-L252 |
10,650 | wvanbergen/kazoo-go | consumergroup.go | UpdateRegistration | func (cgi *ConsumergroupInstance) UpdateRegistration(topics []string) error {
subscriptionJSON, err := cgi.marshalSubscription(topics)
if err != nil {
return err
}
node := fmt.Sprintf("%s/consumers/%s/ids/%s", cgi.cg.kz.conf.Chroot, cgi.cg.Name, cgi.ID)
_, stat, err := cgi.cg.kz.conn.Get(node)
if err != nil {
if err == zk.ErrNoNode {
return ErrInstanceNotRegistered
}
return err
}
_, err = cgi.cg.kz.conn.Set(node, subscriptionJSON, stat.Version)
if err == zk.ErrNoNode {
return ErrInstanceNotRegistered
}
return err
} | go | func (cgi *ConsumergroupInstance) UpdateRegistration(topics []string) error {
subscriptionJSON, err := cgi.marshalSubscription(topics)
if err != nil {
return err
}
node := fmt.Sprintf("%s/consumers/%s/ids/%s", cgi.cg.kz.conf.Chroot, cgi.cg.Name, cgi.ID)
_, stat, err := cgi.cg.kz.conn.Get(node)
if err != nil {
if err == zk.ErrNoNode {
return ErrInstanceNotRegistered
}
return err
}
_, err = cgi.cg.kz.conn.Set(node, subscriptionJSON, stat.Version)
if err == zk.ErrNoNode {
return ErrInstanceNotRegistered
}
return err
} | [
"func",
"(",
"cgi",
"*",
"ConsumergroupInstance",
")",
"UpdateRegistration",
"(",
"topics",
"[",
"]",
"string",
")",
"error",
"{",
"subscriptionJSON",
",",
"err",
":=",
"cgi",
".",
"marshalSubscription",
"(",
"topics",
")",
"\n",
"if",
"err",
"!=",
"nil",
... | // UpdateRegistration updates a consumer group member registration. If the
// consumer group member has not been registered yet, then an error is returned. | [
"UpdateRegistration",
"updates",
"a",
"consumer",
"group",
"member",
"registration",
".",
"If",
"the",
"consumer",
"group",
"member",
"has",
"not",
"been",
"registered",
"yet",
"then",
"an",
"error",
"is",
"returned",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L266-L286 |
10,651 | wvanbergen/kazoo-go | consumergroup.go | Deregister | func (cgi *ConsumergroupInstance) Deregister() error {
node := fmt.Sprintf("%s/consumers/%s/ids/%s", cgi.cg.kz.conf.Chroot, cgi.cg.Name, cgi.ID)
exists, stat, err := cgi.cg.kz.conn.Exists(node)
if err != nil {
return err
} else if !exists {
return ErrInstanceNotRegistered
}
err = cgi.cg.kz.conn.Delete(node, stat.Version)
if err == zk.ErrNoNode {
return ErrInstanceNotRegistered
}
return err
} | go | func (cgi *ConsumergroupInstance) Deregister() error {
node := fmt.Sprintf("%s/consumers/%s/ids/%s", cgi.cg.kz.conf.Chroot, cgi.cg.Name, cgi.ID)
exists, stat, err := cgi.cg.kz.conn.Exists(node)
if err != nil {
return err
} else if !exists {
return ErrInstanceNotRegistered
}
err = cgi.cg.kz.conn.Delete(node, stat.Version)
if err == zk.ErrNoNode {
return ErrInstanceNotRegistered
}
return err
} | [
"func",
"(",
"cgi",
"*",
"ConsumergroupInstance",
")",
"Deregister",
"(",
")",
"error",
"{",
"node",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cgi",
".",
"cg",
".",
"kz",
".",
"conf",
".",
"Chroot",
",",
"cgi",
".",
"cg",
".",
"Name",
"... | // Deregister removes the registration of the instance from zookeeper. | [
"Deregister",
"removes",
"the",
"registration",
"of",
"the",
"instance",
"from",
"zookeeper",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L307-L321 |
10,652 | wvanbergen/kazoo-go | consumergroup.go | ReleasePartition | func (cgi *ConsumergroupInstance) ReleasePartition(topic string, partition int32) error {
owner, err := cgi.cg.PartitionOwner(topic, partition)
if err != nil {
return err
}
if owner == nil || owner.ID != cgi.ID {
return ErrPartitionNotClaimed
}
node := fmt.Sprintf("%s/consumers/%s/owners/%s/%d", cgi.cg.kz.conf.Chroot, cgi.cg.Name, topic, partition)
return cgi.cg.kz.conn.Delete(node, 0)
} | go | func (cgi *ConsumergroupInstance) ReleasePartition(topic string, partition int32) error {
owner, err := cgi.cg.PartitionOwner(topic, partition)
if err != nil {
return err
}
if owner == nil || owner.ID != cgi.ID {
return ErrPartitionNotClaimed
}
node := fmt.Sprintf("%s/consumers/%s/owners/%s/%d", cgi.cg.kz.conf.Chroot, cgi.cg.Name, topic, partition)
return cgi.cg.kz.conn.Delete(node, 0)
} | [
"func",
"(",
"cgi",
"*",
"ConsumergroupInstance",
")",
"ReleasePartition",
"(",
"topic",
"string",
",",
"partition",
"int32",
")",
"error",
"{",
"owner",
",",
"err",
":=",
"cgi",
".",
"cg",
".",
"PartitionOwner",
"(",
"topic",
",",
"partition",
")",
"\n",
... | // ReleasePartition releases a claim to a partition. | [
"ReleasePartition",
"releases",
"a",
"claim",
"to",
"a",
"partition",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L351-L362 |
10,653 | wvanbergen/kazoo-go | consumergroup.go | FetchAllOffsets | func (cg *Consumergroup) FetchAllOffsets() (map[string]map[int32]int64, error) {
result := make(map[string]map[int32]int64)
offsetsNode := fmt.Sprintf("%s/consumers/%s/offsets", cg.kz.conf.Chroot, cg.Name)
topics, _, err := cg.kz.conn.Children(offsetsNode)
if err == zk.ErrNoNode {
return result, nil
} else if err != nil {
return nil, err
}
for _, topic := range topics {
result[topic] = make(map[int32]int64)
topicNode := fmt.Sprintf("%s/consumers/%s/offsets/%s", cg.kz.conf.Chroot, cg.Name, topic)
partitions, _, err := cg.kz.conn.Children(topicNode)
if err != nil {
return nil, err
}
for _, partition := range partitions {
partitionNode := fmt.Sprintf("%s/consumers/%s/offsets/%s/%s", cg.kz.conf.Chroot, cg.Name, topic, partition)
val, _, err := cg.kz.conn.Get(partitionNode)
if err != nil {
return nil, err
}
partition, err := strconv.ParseInt(partition, 10, 32)
if err != nil {
return nil, err
}
offset, err := strconv.ParseInt(string(val), 10, 64)
if err != nil {
return nil, err
}
result[topic][int32(partition)] = offset
}
}
return result, nil
} | go | func (cg *Consumergroup) FetchAllOffsets() (map[string]map[int32]int64, error) {
result := make(map[string]map[int32]int64)
offsetsNode := fmt.Sprintf("%s/consumers/%s/offsets", cg.kz.conf.Chroot, cg.Name)
topics, _, err := cg.kz.conn.Children(offsetsNode)
if err == zk.ErrNoNode {
return result, nil
} else if err != nil {
return nil, err
}
for _, topic := range topics {
result[topic] = make(map[int32]int64)
topicNode := fmt.Sprintf("%s/consumers/%s/offsets/%s", cg.kz.conf.Chroot, cg.Name, topic)
partitions, _, err := cg.kz.conn.Children(topicNode)
if err != nil {
return nil, err
}
for _, partition := range partitions {
partitionNode := fmt.Sprintf("%s/consumers/%s/offsets/%s/%s", cg.kz.conf.Chroot, cg.Name, topic, partition)
val, _, err := cg.kz.conn.Get(partitionNode)
if err != nil {
return nil, err
}
partition, err := strconv.ParseInt(partition, 10, 32)
if err != nil {
return nil, err
}
offset, err := strconv.ParseInt(string(val), 10, 64)
if err != nil {
return nil, err
}
result[topic][int32(partition)] = offset
}
}
return result, nil
} | [
"func",
"(",
"cg",
"*",
"Consumergroup",
")",
"FetchAllOffsets",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"int32",
"]",
"int64",
",",
"error",
")",
"{",
"result",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"int32",
"]",
... | // FetchOffset retrieves all the commmitted offsets for a group | [
"FetchOffset",
"retrieves",
"all",
"the",
"commmitted",
"offsets",
"for",
"a",
"group"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L411-L452 |
10,654 | wvanbergen/kazoo-go | consumergroup.go | generateConsumerInstanceID | func generateConsumerInstanceID() (string, error) {
uuid, err := generateUUID()
if err != nil {
return "", err
}
hostname, err := os.Hostname()
if err != nil {
return "", err
}
return fmt.Sprintf("%s:%s", hostname, uuid), nil
} | go | func generateConsumerInstanceID() (string, error) {
uuid, err := generateUUID()
if err != nil {
return "", err
}
hostname, err := os.Hostname()
if err != nil {
return "", err
}
return fmt.Sprintf("%s:%s", hostname, uuid), nil
} | [
"func",
"generateConsumerInstanceID",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"uuid",
",",
"err",
":=",
"generateUUID",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"hostname",
",",
"err... | // generateConsumerInstanceID generates a consumergroup Instance ID
// that is almost certain to be unique. | [
"generateConsumerInstanceID",
"generates",
"a",
"consumergroup",
"Instance",
"ID",
"that",
"is",
"almost",
"certain",
"to",
"be",
"unique",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L508-L520 |
10,655 | wvanbergen/kazoo-go | consumergroup.go | Find | func (cgl ConsumergroupList) Find(name string) *Consumergroup {
for _, cg := range cgl {
if cg.Name == name {
return cg
}
}
return nil
} | go | func (cgl ConsumergroupList) Find(name string) *Consumergroup {
for _, cg := range cgl {
if cg.Name == name {
return cg
}
}
return nil
} | [
"func",
"(",
"cgl",
"ConsumergroupList",
")",
"Find",
"(",
"name",
"string",
")",
"*",
"Consumergroup",
"{",
"for",
"_",
",",
"cg",
":=",
"range",
"cgl",
"{",
"if",
"cg",
".",
"Name",
"==",
"name",
"{",
"return",
"cg",
"\n",
"}",
"\n",
"}",
"\n",
... | // Find returns the consumergroup with the given name if it exists in the list.
// Otherwise it will return `nil`. | [
"Find",
"returns",
"the",
"consumergroup",
"with",
"the",
"given",
"name",
"if",
"it",
"exists",
"in",
"the",
"list",
".",
"Otherwise",
"it",
"will",
"return",
"nil",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L524-L531 |
10,656 | wvanbergen/kazoo-go | consumergroup.go | Find | func (cgil ConsumergroupInstanceList) Find(id string) *ConsumergroupInstance {
for _, cgi := range cgil {
if cgi.ID == id {
return cgi
}
}
return nil
} | go | func (cgil ConsumergroupInstanceList) Find(id string) *ConsumergroupInstance {
for _, cgi := range cgil {
if cgi.ID == id {
return cgi
}
}
return nil
} | [
"func",
"(",
"cgil",
"ConsumergroupInstanceList",
")",
"Find",
"(",
"id",
"string",
")",
"*",
"ConsumergroupInstance",
"{",
"for",
"_",
",",
"cgi",
":=",
"range",
"cgil",
"{",
"if",
"cgi",
".",
"ID",
"==",
"id",
"{",
"return",
"cgi",
"\n",
"}",
"\n",
... | // Find returns the consumergroup instance with the given ID if it exists in the list.
// Otherwise it will return `nil`. | [
"Find",
"returns",
"the",
"consumergroup",
"instance",
"with",
"the",
"given",
"ID",
"if",
"it",
"exists",
"in",
"the",
"list",
".",
"Otherwise",
"it",
"will",
"return",
"nil",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/consumergroup.go#L547-L554 |
10,657 | wvanbergen/kazoo-go | topic_metadata.go | Topics | func (kz *Kazoo) Topics() (TopicList, error) {
root := fmt.Sprintf("%s/brokers/topics", kz.conf.Chroot)
children, _, err := kz.conn.Children(root)
if err != nil {
return nil, err
}
result := make(TopicList, 0, len(children))
for _, name := range children {
result = append(result, kz.Topic(name))
}
return result, nil
} | go | func (kz *Kazoo) Topics() (TopicList, error) {
root := fmt.Sprintf("%s/brokers/topics", kz.conf.Chroot)
children, _, err := kz.conn.Children(root)
if err != nil {
return nil, err
}
result := make(TopicList, 0, len(children))
for _, name := range children {
result = append(result, kz.Topic(name))
}
return result, nil
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"Topics",
"(",
")",
"(",
"TopicList",
",",
"error",
")",
"{",
"root",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"kz",
".",
"conf",
".",
"Chroot",
")",
"\n",
"children",
",",
"_",
",",
"err",
":=",
... | // Topics returns a list of all registered Kafka topics. | [
"Topics",
"returns",
"a",
"list",
"of",
"all",
"registered",
"Kafka",
"topics",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L43-L55 |
10,658 | wvanbergen/kazoo-go | topic_metadata.go | WatchTopics | func (kz *Kazoo) WatchTopics() (TopicList, <-chan zk.Event, error) {
root := fmt.Sprintf("%s/brokers/topics", kz.conf.Chroot)
children, _, c, err := kz.conn.ChildrenW(root)
if err != nil {
return nil, nil, err
}
result := make(TopicList, 0, len(children))
for _, name := range children {
result = append(result, kz.Topic(name))
}
return result, c, nil
} | go | func (kz *Kazoo) WatchTopics() (TopicList, <-chan zk.Event, error) {
root := fmt.Sprintf("%s/brokers/topics", kz.conf.Chroot)
children, _, c, err := kz.conn.ChildrenW(root)
if err != nil {
return nil, nil, err
}
result := make(TopicList, 0, len(children))
for _, name := range children {
result = append(result, kz.Topic(name))
}
return result, c, nil
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"WatchTopics",
"(",
")",
"(",
"TopicList",
",",
"<-",
"chan",
"zk",
".",
"Event",
",",
"error",
")",
"{",
"root",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"kz",
".",
"conf",
".",
"Chroot",
")",
"\... | // WatchTopics returns a list of all registered Kafka topics, and
// watches that list for changes. | [
"WatchTopics",
"returns",
"a",
"list",
"of",
"all",
"registered",
"Kafka",
"topics",
"and",
"watches",
"that",
"list",
"for",
"changes",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L59-L71 |
10,659 | wvanbergen/kazoo-go | topic_metadata.go | Topic | func (kz *Kazoo) Topic(topic string) *Topic {
return &Topic{Name: topic, kz: kz}
} | go | func (kz *Kazoo) Topic(topic string) *Topic {
return &Topic{Name: topic, kz: kz}
} | [
"func",
"(",
"kz",
"*",
"Kazoo",
")",
"Topic",
"(",
"topic",
"string",
")",
"*",
"Topic",
"{",
"return",
"&",
"Topic",
"{",
"Name",
":",
"topic",
",",
"kz",
":",
"kz",
"}",
"\n",
"}"
] | // Topic returns a Topic instance for a given topic name | [
"Topic",
"returns",
"a",
"Topic",
"instance",
"for",
"a",
"given",
"topic",
"name"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L74-L76 |
10,660 | wvanbergen/kazoo-go | topic_metadata.go | Exists | func (t *Topic) Exists() (bool, error) {
return t.kz.exists(t.metadataPath())
} | go | func (t *Topic) Exists() (bool, error) {
return t.kz.exists(t.metadataPath())
} | [
"func",
"(",
"t",
"*",
"Topic",
")",
"Exists",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"return",
"t",
".",
"kz",
".",
"exists",
"(",
"t",
".",
"metadataPath",
"(",
")",
")",
"\n",
"}"
] | // Exists returns true if the topic exists on the Kafka cluster. | [
"Exists",
"returns",
"true",
"if",
"the",
"topic",
"exists",
"on",
"the",
"Kafka",
"cluster",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L79-L81 |
10,661 | wvanbergen/kazoo-go | topic_metadata.go | Partitions | func (t *Topic) Partitions() (PartitionList, error) {
value, _, err := t.kz.conn.Get(t.metadataPath())
if err != nil {
return nil, err
}
return t.parsePartitions(value)
} | go | func (t *Topic) Partitions() (PartitionList, error) {
value, _, err := t.kz.conn.Get(t.metadataPath())
if err != nil {
return nil, err
}
return t.parsePartitions(value)
} | [
"func",
"(",
"t",
"*",
"Topic",
")",
"Partitions",
"(",
")",
"(",
"PartitionList",
",",
"error",
")",
"{",
"value",
",",
"_",
",",
"err",
":=",
"t",
".",
"kz",
".",
"conn",
".",
"Get",
"(",
"t",
".",
"metadataPath",
"(",
")",
")",
"\n",
"if",
... | // Partitions returns a list of all partitions for the topic. | [
"Partitions",
"returns",
"a",
"list",
"of",
"all",
"partitions",
"for",
"the",
"topic",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L84-L91 |
10,662 | wvanbergen/kazoo-go | topic_metadata.go | WatchPartitions | func (t *Topic) WatchPartitions() (PartitionList, <-chan zk.Event, error) {
value, _, c, err := t.kz.conn.GetW(t.metadataPath())
if err != nil {
return nil, nil, err
}
list, err := t.parsePartitions(value)
return list, c, err
} | go | func (t *Topic) WatchPartitions() (PartitionList, <-chan zk.Event, error) {
value, _, c, err := t.kz.conn.GetW(t.metadataPath())
if err != nil {
return nil, nil, err
}
list, err := t.parsePartitions(value)
return list, c, err
} | [
"func",
"(",
"t",
"*",
"Topic",
")",
"WatchPartitions",
"(",
")",
"(",
"PartitionList",
",",
"<-",
"chan",
"zk",
".",
"Event",
",",
"error",
")",
"{",
"value",
",",
"_",
",",
"c",
",",
"err",
":=",
"t",
".",
"kz",
".",
"conn",
".",
"GetW",
"(",... | // WatchPartitions returns a list of all partitions for the topic, and watches the topic for changes. | [
"WatchPartitions",
"returns",
"a",
"list",
"of",
"all",
"partitions",
"for",
"the",
"topic",
"and",
"watches",
"the",
"topic",
"for",
"changes",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L94-L102 |
10,663 | wvanbergen/kazoo-go | topic_metadata.go | Watch | func (t *Topic) Watch() (<-chan zk.Event, error) {
_, _, c, err := t.kz.conn.GetW(t.metadataPath())
if err != nil {
return nil, err
}
return c, err
} | go | func (t *Topic) Watch() (<-chan zk.Event, error) {
_, _, c, err := t.kz.conn.GetW(t.metadataPath())
if err != nil {
return nil, err
}
return c, err
} | [
"func",
"(",
"t",
"*",
"Topic",
")",
"Watch",
"(",
")",
"(",
"<-",
"chan",
"zk",
".",
"Event",
",",
"error",
")",
"{",
"_",
",",
"_",
",",
"c",
",",
"err",
":=",
"t",
".",
"kz",
".",
"conn",
".",
"GetW",
"(",
"t",
".",
"metadataPath",
"(",
... | // Watch watches the topic for changes. | [
"Watch",
"watches",
"the",
"topic",
"for",
"changes",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L105-L112 |
10,664 | wvanbergen/kazoo-go | topic_metadata.go | parsePartitions | func (t *Topic) parsePartitions(value []byte) (PartitionList, error) {
var tm topicMetadata
if err := json.Unmarshal(value, &tm); err != nil {
return nil, err
}
result := make(PartitionList, len(tm.Partitions))
for partitionNumber, replicas := range tm.Partitions {
partitionID, err := strconv.ParseInt(partitionNumber, 10, 32)
if err != nil {
return nil, err
}
replicaIDs := make([]int32, 0, len(replicas))
for _, r := range replicas {
replicaIDs = append(replicaIDs, int32(r))
}
result[partitionID] = t.Partition(int32(partitionID), replicaIDs)
}
return result, nil
} | go | func (t *Topic) parsePartitions(value []byte) (PartitionList, error) {
var tm topicMetadata
if err := json.Unmarshal(value, &tm); err != nil {
return nil, err
}
result := make(PartitionList, len(tm.Partitions))
for partitionNumber, replicas := range tm.Partitions {
partitionID, err := strconv.ParseInt(partitionNumber, 10, 32)
if err != nil {
return nil, err
}
replicaIDs := make([]int32, 0, len(replicas))
for _, r := range replicas {
replicaIDs = append(replicaIDs, int32(r))
}
result[partitionID] = t.Partition(int32(partitionID), replicaIDs)
}
return result, nil
} | [
"func",
"(",
"t",
"*",
"Topic",
")",
"parsePartitions",
"(",
"value",
"[",
"]",
"byte",
")",
"(",
"PartitionList",
",",
"error",
")",
"{",
"var",
"tm",
"topicMetadata",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"value",
",",
"&",
"tm",
... | // parsePartitions parses the JSON representation of the partitions
// that is stored as data on the topic node in Zookeeper. | [
"parsePartitions",
"parses",
"the",
"JSON",
"representation",
"of",
"the",
"partitions",
"that",
"is",
"stored",
"as",
"data",
"on",
"the",
"topic",
"node",
"in",
"Zookeeper",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L125-L146 |
10,665 | wvanbergen/kazoo-go | topic_metadata.go | marshalPartitions | func (t *Topic) marshalPartitions(partitions PartitionList) ([]byte, error) {
tm := topicMetadata{Version: 1, Partitions: make(map[string][]int32, len(partitions))}
for _, part := range partitions {
tm.Partitions[fmt.Sprintf("%d", part.ID)] = part.Replicas
}
return json.Marshal(tm)
} | go | func (t *Topic) marshalPartitions(partitions PartitionList) ([]byte, error) {
tm := topicMetadata{Version: 1, Partitions: make(map[string][]int32, len(partitions))}
for _, part := range partitions {
tm.Partitions[fmt.Sprintf("%d", part.ID)] = part.Replicas
}
return json.Marshal(tm)
} | [
"func",
"(",
"t",
"*",
"Topic",
")",
"marshalPartitions",
"(",
"partitions",
"PartitionList",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"tm",
":=",
"topicMetadata",
"{",
"Version",
":",
"1",
",",
"Partitions",
":",
"make",
"(",
"map",
"[",
... | // marshalPartitions turns a PartitionList into the JSON representation
// to be stored in Zookeeper. | [
"marshalPartitions",
"turns",
"a",
"PartitionList",
"into",
"the",
"JSON",
"representation",
"to",
"be",
"stored",
"in",
"Zookeeper",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L150-L156 |
10,666 | wvanbergen/kazoo-go | topic_metadata.go | generatePartitionAssignments | func (t *Topic) generatePartitionAssignments(brokers []int32, partitionCount int, replicationFactor int) (PartitionList, error) {
if partitionCount <= 0 {
return nil, ErrInvalidPartitionCount
}
if replicationFactor <= 0 || len(brokers) < replicationFactor {
return nil, ErrInvalidReplicationFactor
}
result := make(PartitionList, partitionCount)
brokerCount := len(brokers)
brokerIdx := rand.Intn(brokerCount)
for p := 0; p < partitionCount; p++ {
partition := &Partition{topic: t, ID: int32(p), Replicas: make([]int32, replicationFactor)}
brokerIndices := rand.Perm(len(brokers))[0:replicationFactor]
for r := 0; r < replicationFactor; r++ {
partition.Replicas[r] = brokers[brokerIndices[r]]
}
result[p] = partition
brokerIdx = (brokerIdx + 1) % brokerCount
}
return result, nil
} | go | func (t *Topic) generatePartitionAssignments(brokers []int32, partitionCount int, replicationFactor int) (PartitionList, error) {
if partitionCount <= 0 {
return nil, ErrInvalidPartitionCount
}
if replicationFactor <= 0 || len(brokers) < replicationFactor {
return nil, ErrInvalidReplicationFactor
}
result := make(PartitionList, partitionCount)
brokerCount := len(brokers)
brokerIdx := rand.Intn(brokerCount)
for p := 0; p < partitionCount; p++ {
partition := &Partition{topic: t, ID: int32(p), Replicas: make([]int32, replicationFactor)}
brokerIndices := rand.Perm(len(brokers))[0:replicationFactor]
for r := 0; r < replicationFactor; r++ {
partition.Replicas[r] = brokers[brokerIndices[r]]
}
result[p] = partition
brokerIdx = (brokerIdx + 1) % brokerCount
}
return result, nil
} | [
"func",
"(",
"t",
"*",
"Topic",
")",
"generatePartitionAssignments",
"(",
"brokers",
"[",
"]",
"int32",
",",
"partitionCount",
"int",
",",
"replicationFactor",
"int",
")",
"(",
"PartitionList",
",",
"error",
")",
"{",
"if",
"partitionCount",
"<=",
"0",
"{",
... | // generatePartitionAssignments creates a partition list for a topic. The primary replica for
// each partition is assigned in a round-robin fashion starting at a random broker.
// Additional replicas are assigned to subsequent brokers to ensure there is no overlap | [
"generatePartitionAssignments",
"creates",
"a",
"partition",
"list",
"for",
"a",
"topic",
".",
"The",
"primary",
"replica",
"for",
"each",
"partition",
"is",
"assigned",
"in",
"a",
"round",
"-",
"robin",
"fashion",
"starting",
"at",
"a",
"random",
"broker",
".... | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L161-L188 |
10,667 | wvanbergen/kazoo-go | topic_metadata.go | validatePartitionAssignments | func (t *Topic) validatePartitionAssignments(brokers []int32, assignment PartitionList) error {
if len(assignment) == 0 {
return ErrInvalidPartitionCount
}
// get the first replica count to compare against. Every partition should have the same.
var replicaCount int
for _, part := range assignment {
replicaCount = len(part.Replicas)
break
}
if replicaCount == 0 {
return ErrInvalidReplicationFactor
}
// ensure all ids are unique and sequential
maxPartitionID := int32(-1)
partitionIDmap := make(map[int32]struct{}, len(assignment))
for _, part := range assignment {
if part == nil {
continue
}
if maxPartitionID < part.ID {
maxPartitionID = part.ID
}
partitionIDmap[part.ID] = struct{}{}
// all partitions require the same replica count
if len(part.Replicas) != replicaCount {
return ErrInvalidReplicaCount
}
rset := make(map[int32]struct{}, replicaCount)
for _, r := range part.Replicas {
// replica must be assigned to a valid broker
found := false
for _, b := range brokers {
if r == b {
found = true
break
}
}
if !found {
return ErrInvalidBroker
}
rset[r] = struct{}{}
}
// broker assignments for a partition must be unique
if len(rset) != replicaCount {
return ErrReplicaBrokerOverlap
}
}
// ensure all partitions accounted for
if int(maxPartitionID) != len(assignment)-1 {
return ErrMissingPartitionID
}
// ensure no duplicate ids
if len(partitionIDmap) != len(assignment) {
return ErrDuplicatePartitionID
}
return nil
} | go | func (t *Topic) validatePartitionAssignments(brokers []int32, assignment PartitionList) error {
if len(assignment) == 0 {
return ErrInvalidPartitionCount
}
// get the first replica count to compare against. Every partition should have the same.
var replicaCount int
for _, part := range assignment {
replicaCount = len(part.Replicas)
break
}
if replicaCount == 0 {
return ErrInvalidReplicationFactor
}
// ensure all ids are unique and sequential
maxPartitionID := int32(-1)
partitionIDmap := make(map[int32]struct{}, len(assignment))
for _, part := range assignment {
if part == nil {
continue
}
if maxPartitionID < part.ID {
maxPartitionID = part.ID
}
partitionIDmap[part.ID] = struct{}{}
// all partitions require the same replica count
if len(part.Replicas) != replicaCount {
return ErrInvalidReplicaCount
}
rset := make(map[int32]struct{}, replicaCount)
for _, r := range part.Replicas {
// replica must be assigned to a valid broker
found := false
for _, b := range brokers {
if r == b {
found = true
break
}
}
if !found {
return ErrInvalidBroker
}
rset[r] = struct{}{}
}
// broker assignments for a partition must be unique
if len(rset) != replicaCount {
return ErrReplicaBrokerOverlap
}
}
// ensure all partitions accounted for
if int(maxPartitionID) != len(assignment)-1 {
return ErrMissingPartitionID
}
// ensure no duplicate ids
if len(partitionIDmap) != len(assignment) {
return ErrDuplicatePartitionID
}
return nil
} | [
"func",
"(",
"t",
"*",
"Topic",
")",
"validatePartitionAssignments",
"(",
"brokers",
"[",
"]",
"int32",
",",
"assignment",
"PartitionList",
")",
"error",
"{",
"if",
"len",
"(",
"assignment",
")",
"==",
"0",
"{",
"return",
"ErrInvalidPartitionCount",
"\n",
"}... | // validatePartitionAssignments ensures that all partitions are assigned to valid brokers,
// have the same number of replicas, and each replica is assigned to a unique broker | [
"validatePartitionAssignments",
"ensures",
"that",
"all",
"partitions",
"are",
"assigned",
"to",
"valid",
"brokers",
"have",
"the",
"same",
"number",
"of",
"replicas",
"and",
"each",
"replica",
"is",
"assigned",
"to",
"a",
"unique",
"broker"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L192-L257 |
10,668 | wvanbergen/kazoo-go | topic_metadata.go | Partition | func (t *Topic) Partition(id int32, replicas []int32) *Partition {
return &Partition{ID: id, Replicas: replicas, topic: t}
} | go | func (t *Topic) Partition(id int32, replicas []int32) *Partition {
return &Partition{ID: id, Replicas: replicas, topic: t}
} | [
"func",
"(",
"t",
"*",
"Topic",
")",
"Partition",
"(",
"id",
"int32",
",",
"replicas",
"[",
"]",
"int32",
")",
"*",
"Partition",
"{",
"return",
"&",
"Partition",
"{",
"ID",
":",
"id",
",",
"Replicas",
":",
"replicas",
",",
"topic",
":",
"t",
"}",
... | // Partition returns a Partition instance for the topic. | [
"Partition",
"returns",
"a",
"Partition",
"instance",
"for",
"the",
"topic",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L260-L262 |
10,669 | wvanbergen/kazoo-go | topic_metadata.go | configPath | func (t *Topic) configPath() string {
return fmt.Sprintf("%s/config/topics/%s", t.kz.conf.Chroot, t.Name)
} | go | func (t *Topic) configPath() string {
return fmt.Sprintf("%s/config/topics/%s", t.kz.conf.Chroot, t.Name)
} | [
"func",
"(",
"t",
"*",
"Topic",
")",
"configPath",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
".",
"kz",
".",
"conf",
".",
"Chroot",
",",
"t",
".",
"Name",
")",
"\n",
"}"
] | // getConfigPath returns the zk node path for a topic's config | [
"getConfigPath",
"returns",
"the",
"zk",
"node",
"path",
"for",
"a",
"topic",
"s",
"config"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L270-L272 |
10,670 | wvanbergen/kazoo-go | topic_metadata.go | parseConfig | func (t *Topic) parseConfig(data []byte) (map[string]string, error) {
var cfg topicConfig
if err := json.Unmarshal(data, &cfg); err != nil {
return nil, err
}
return cfg.ConfigMap, nil
} | go | func (t *Topic) parseConfig(data []byte) (map[string]string, error) {
var cfg topicConfig
if err := json.Unmarshal(data, &cfg); err != nil {
return nil, err
}
return cfg.ConfigMap, nil
} | [
"func",
"(",
"t",
"*",
"Topic",
")",
"parseConfig",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"var",
"cfg",
"topicConfig",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
... | // parseConfig parses the json representation of a topic config
// and returns the configuration values | [
"parseConfig",
"parses",
"the",
"json",
"representation",
"of",
"a",
"topic",
"config",
"and",
"returns",
"the",
"configuration",
"values"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L276-L282 |
10,671 | wvanbergen/kazoo-go | topic_metadata.go | marshalConfig | func (t *Topic) marshalConfig(data map[string]string) ([]byte, error) {
cfg := topicConfig{Version: 1, ConfigMap: data}
if cfg.ConfigMap == nil {
cfg.ConfigMap = make(map[string]string)
}
return json.Marshal(&cfg)
} | go | func (t *Topic) marshalConfig(data map[string]string) ([]byte, error) {
cfg := topicConfig{Version: 1, ConfigMap: data}
if cfg.ConfigMap == nil {
cfg.ConfigMap = make(map[string]string)
}
return json.Marshal(&cfg)
} | [
"func",
"(",
"t",
"*",
"Topic",
")",
"marshalConfig",
"(",
"data",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cfg",
":=",
"topicConfig",
"{",
"Version",
":",
"1",
",",
"ConfigMap",
":",
"data",
"}",
... | // marshalConfig turns a config map into the json representation
// needed for Zookeeper | [
"marshalConfig",
"turns",
"a",
"config",
"map",
"into",
"the",
"json",
"representation",
"needed",
"for",
"Zookeeper"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L286-L292 |
10,672 | wvanbergen/kazoo-go | topic_metadata.go | Config | func (t *Topic) Config() (map[string]string, error) {
value, _, err := t.kz.conn.Get(t.configPath())
if err != nil {
return nil, err
}
return t.parseConfig(value)
} | go | func (t *Topic) Config() (map[string]string, error) {
value, _, err := t.kz.conn.Get(t.configPath())
if err != nil {
return nil, err
}
return t.parseConfig(value)
} | [
"func",
"(",
"t",
"*",
"Topic",
")",
"Config",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"value",
",",
"_",
",",
"err",
":=",
"t",
".",
"kz",
".",
"conn",
".",
"Get",
"(",
"t",
".",
"configPath",
"(",
")",
... | // Config returns topic-level configuration settings as a map. | [
"Config",
"returns",
"topic",
"-",
"level",
"configuration",
"settings",
"as",
"a",
"map",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L295-L302 |
10,673 | wvanbergen/kazoo-go | topic_metadata.go | Leader | func (p *Partition) Leader() (int32, error) {
if state, err := p.state(); err != nil {
return -1, err
} else {
return state.Leader, nil
}
} | go | func (p *Partition) Leader() (int32, error) {
if state, err := p.state(); err != nil {
return -1, err
} else {
return state.Leader, nil
}
} | [
"func",
"(",
"p",
"*",
"Partition",
")",
"Leader",
"(",
")",
"(",
"int32",
",",
"error",
")",
"{",
"if",
"state",
",",
"err",
":=",
"p",
".",
"state",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"err",
"\n",
"}",
"else",
... | // Leader returns the broker ID of the broker that is currently the leader for the partition. | [
"Leader",
"returns",
"the",
"broker",
"ID",
"of",
"the",
"broker",
"that",
"is",
"currently",
"the",
"leader",
"for",
"the",
"partition",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L324-L330 |
10,674 | wvanbergen/kazoo-go | topic_metadata.go | ISR | func (p *Partition) ISR() ([]int32, error) {
if state, err := p.state(); err != nil {
return nil, err
} else {
return state.ISR, nil
}
} | go | func (p *Partition) ISR() ([]int32, error) {
if state, err := p.state(); err != nil {
return nil, err
} else {
return state.ISR, nil
}
} | [
"func",
"(",
"p",
"*",
"Partition",
")",
"ISR",
"(",
")",
"(",
"[",
"]",
"int32",
",",
"error",
")",
"{",
"if",
"state",
",",
"err",
":=",
"p",
".",
"state",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"e... | // ISR returns the broker IDs of the current in-sync replica set for the partition | [
"ISR",
"returns",
"the",
"broker",
"IDs",
"of",
"the",
"current",
"in",
"-",
"sync",
"replica",
"set",
"for",
"the",
"partition"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L333-L339 |
10,675 | wvanbergen/kazoo-go | topic_metadata.go | state | func (p *Partition) state() (partitionState, error) {
var state partitionState
node := fmt.Sprintf("%s/brokers/topics/%s/partitions/%d/state", p.topic.kz.conf.Chroot, p.topic.Name, p.ID)
value, _, err := p.topic.kz.conn.Get(node)
if err != nil {
return state, err
}
if err := json.Unmarshal(value, &state); err != nil {
return state, err
}
return state, nil
} | go | func (p *Partition) state() (partitionState, error) {
var state partitionState
node := fmt.Sprintf("%s/brokers/topics/%s/partitions/%d/state", p.topic.kz.conf.Chroot, p.topic.Name, p.ID)
value, _, err := p.topic.kz.conn.Get(node)
if err != nil {
return state, err
}
if err := json.Unmarshal(value, &state); err != nil {
return state, err
}
return state, nil
} | [
"func",
"(",
"p",
"*",
"Partition",
")",
"state",
"(",
")",
"(",
"partitionState",
",",
"error",
")",
"{",
"var",
"state",
"partitionState",
"\n",
"node",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
".",
"topic",
".",
"kz",
".",
"conf",... | // state retrieves and parses the partition State | [
"state",
"retrieves",
"and",
"parses",
"the",
"partition",
"State"
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L365-L378 |
10,676 | wvanbergen/kazoo-go | topic_metadata.go | Find | func (tl TopicList) Find(name string) *Topic {
for _, topic := range tl {
if topic.Name == name {
return topic
}
}
return nil
} | go | func (tl TopicList) Find(name string) *Topic {
for _, topic := range tl {
if topic.Name == name {
return topic
}
}
return nil
} | [
"func",
"(",
"tl",
"TopicList",
")",
"Find",
"(",
"name",
"string",
")",
"*",
"Topic",
"{",
"for",
"_",
",",
"topic",
":=",
"range",
"tl",
"{",
"if",
"topic",
".",
"Name",
"==",
"name",
"{",
"return",
"topic",
"\n",
"}",
"\n",
"}",
"\n",
"return"... | // Find returns the topic with the given name if it exists in the topic list,
// and will return `nil` otherwise. | [
"Find",
"returns",
"the",
"topic",
"with",
"the",
"given",
"name",
"if",
"it",
"exists",
"in",
"the",
"topic",
"list",
"and",
"will",
"return",
"nil",
"otherwise",
"."
] | f72d8611297a7cf105da904c04198ad701a60101 | https://github.com/wvanbergen/kazoo-go/blob/f72d8611297a7cf105da904c04198ad701a60101/topic_metadata.go#L382-L389 |
10,677 | go-chef/chef | reader.go | JSONReader | func JSONReader(v interface{}) (r io.Reader, err error) {
buf := new(bytes.Buffer)
err = json.NewEncoder(buf).Encode(v)
r = bytes.NewReader(buf.Bytes())
return
} | go | func JSONReader(v interface{}) (r io.Reader, err error) {
buf := new(bytes.Buffer)
err = json.NewEncoder(buf).Encode(v)
r = bytes.NewReader(buf.Bytes())
return
} | [
"func",
"JSONReader",
"(",
"v",
"interface",
"{",
"}",
")",
"(",
"r",
"io",
".",
"Reader",
",",
"err",
"error",
")",
"{",
"buf",
":=",
"new",
"(",
"bytes",
".",
"Buffer",
")",
"\n",
"err",
"=",
"json",
".",
"NewEncoder",
"(",
"buf",
")",
".",
"... | // JSONReader handles arbitrary types and synthesizes a streaming encoder for them. | [
"JSONReader",
"handles",
"arbitrary",
"types",
"and",
"synthesizes",
"a",
"streaming",
"encoder",
"for",
"them",
"."
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/reader.go#L10-L15 |
10,678 | go-chef/chef | authentication.go | privateEncrypt | func privateEncrypt(key *rsa.PrivateKey, data []byte) (enc []byte, err error) {
k := (key.N.BitLen() + 7) / 8
tLen := len(data)
// rfc2313, section 8:
// The length of the data D shall not be more than k-11 octets
if tLen > k-11 {
err = errors.New("Data too long")
return
}
em := make([]byte, k)
em[1] = 1
for i := 2; i < k-tLen-1; i++ {
em[i] = 0xff
}
copy(em[k-tLen:k], data)
c := new(big.Int).SetBytes(em)
if c.Cmp(key.N) > 0 {
err = nil
return
}
var m *big.Int
var ir *big.Int
if key.Precomputed.Dp == nil {
m = new(big.Int).Exp(c, key.D, key.N)
} else {
// We have the precalculated values needed for the CRT.
m = new(big.Int).Exp(c, key.Precomputed.Dp, key.Primes[0])
m2 := new(big.Int).Exp(c, key.Precomputed.Dq, key.Primes[1])
m.Sub(m, m2)
if m.Sign() < 0 {
m.Add(m, key.Primes[0])
}
m.Mul(m, key.Precomputed.Qinv)
m.Mod(m, key.Primes[0])
m.Mul(m, key.Primes[1])
m.Add(m, m2)
for i, values := range key.Precomputed.CRTValues {
prime := key.Primes[2+i]
m2.Exp(c, values.Exp, prime)
m2.Sub(m2, m)
m2.Mul(m2, values.Coeff)
m2.Mod(m2, prime)
if m2.Sign() < 0 {
m2.Add(m2, prime)
}
m2.Mul(m2, values.R)
m.Add(m, m2)
}
}
if ir != nil {
// Unblind.
m.Mul(m, ir)
m.Mod(m, key.N)
}
enc = m.Bytes()
return
} | go | func privateEncrypt(key *rsa.PrivateKey, data []byte) (enc []byte, err error) {
k := (key.N.BitLen() + 7) / 8
tLen := len(data)
// rfc2313, section 8:
// The length of the data D shall not be more than k-11 octets
if tLen > k-11 {
err = errors.New("Data too long")
return
}
em := make([]byte, k)
em[1] = 1
for i := 2; i < k-tLen-1; i++ {
em[i] = 0xff
}
copy(em[k-tLen:k], data)
c := new(big.Int).SetBytes(em)
if c.Cmp(key.N) > 0 {
err = nil
return
}
var m *big.Int
var ir *big.Int
if key.Precomputed.Dp == nil {
m = new(big.Int).Exp(c, key.D, key.N)
} else {
// We have the precalculated values needed for the CRT.
m = new(big.Int).Exp(c, key.Precomputed.Dp, key.Primes[0])
m2 := new(big.Int).Exp(c, key.Precomputed.Dq, key.Primes[1])
m.Sub(m, m2)
if m.Sign() < 0 {
m.Add(m, key.Primes[0])
}
m.Mul(m, key.Precomputed.Qinv)
m.Mod(m, key.Primes[0])
m.Mul(m, key.Primes[1])
m.Add(m, m2)
for i, values := range key.Precomputed.CRTValues {
prime := key.Primes[2+i]
m2.Exp(c, values.Exp, prime)
m2.Sub(m2, m)
m2.Mul(m2, values.Coeff)
m2.Mod(m2, prime)
if m2.Sign() < 0 {
m2.Add(m2, prime)
}
m2.Mul(m2, values.R)
m.Add(m, m2)
}
}
if ir != nil {
// Unblind.
m.Mul(m, ir)
m.Mod(m, key.N)
}
enc = m.Bytes()
return
} | [
"func",
"privateEncrypt",
"(",
"key",
"*",
"rsa",
".",
"PrivateKey",
",",
"data",
"[",
"]",
"byte",
")",
"(",
"enc",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"k",
":=",
"(",
"key",
".",
"N",
".",
"BitLen",
"(",
")",
"+",
"7",
")",
"/"... | // privateEncrypt implements OpenSSL's RSA_private_encrypt function | [
"privateEncrypt",
"implements",
"OpenSSL",
"s",
"RSA_private_encrypt",
"function"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/authentication.go#L23-L82 |
10,679 | go-chef/chef | authentication.go | HashStr | func HashStr(toHash string) string {
h := sha1.New()
io.WriteString(h, toHash)
hashed := base64.StdEncoding.EncodeToString(h.Sum(nil))
return hashed
} | go | func HashStr(toHash string) string {
h := sha1.New()
io.WriteString(h, toHash)
hashed := base64.StdEncoding.EncodeToString(h.Sum(nil))
return hashed
} | [
"func",
"HashStr",
"(",
"toHash",
"string",
")",
"string",
"{",
"h",
":=",
"sha1",
".",
"New",
"(",
")",
"\n",
"io",
".",
"WriteString",
"(",
"h",
",",
"toHash",
")",
"\n",
"hashed",
":=",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"h"... | // HashStr returns the base64 encoded SHA1 sum of the toHash string | [
"HashStr",
"returns",
"the",
"base64",
"encoded",
"SHA1",
"sum",
"of",
"the",
"toHash",
"string"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/authentication.go#L85-L90 |
10,680 | go-chef/chef | authentication.go | Base64BlockEncode | func Base64BlockEncode(content []byte, limit int) []string {
resultString := base64.StdEncoding.EncodeToString(content)
var resultSlice []string
index := 0
var maxLengthPerSlice int
// No limit
if limit == 0 {
maxLengthPerSlice = len(resultString)
} else {
maxLengthPerSlice = limit
}
// Iterate through the encoded string storing
// a max of <limit> per slice item
for i := 0; i < len(resultString)/maxLengthPerSlice; i++ {
resultSlice = append(resultSlice, resultString[index:index+maxLengthPerSlice])
index += maxLengthPerSlice
}
// Add remaining chunk to the end of the slice
if len(resultString)%maxLengthPerSlice != 0 {
resultSlice = append(resultSlice, resultString[index:])
}
return resultSlice
} | go | func Base64BlockEncode(content []byte, limit int) []string {
resultString := base64.StdEncoding.EncodeToString(content)
var resultSlice []string
index := 0
var maxLengthPerSlice int
// No limit
if limit == 0 {
maxLengthPerSlice = len(resultString)
} else {
maxLengthPerSlice = limit
}
// Iterate through the encoded string storing
// a max of <limit> per slice item
for i := 0; i < len(resultString)/maxLengthPerSlice; i++ {
resultSlice = append(resultSlice, resultString[index:index+maxLengthPerSlice])
index += maxLengthPerSlice
}
// Add remaining chunk to the end of the slice
if len(resultString)%maxLengthPerSlice != 0 {
resultSlice = append(resultSlice, resultString[index:])
}
return resultSlice
} | [
"func",
"Base64BlockEncode",
"(",
"content",
"[",
"]",
"byte",
",",
"limit",
"int",
")",
"[",
"]",
"string",
"{",
"resultString",
":=",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"content",
")",
"\n",
"var",
"resultSlice",
"[",
"]",
"string"... | // Base64BlockEncode takes a byte slice and breaks it up into a
// slice of base64 encoded strings | [
"Base64BlockEncode",
"takes",
"a",
"byte",
"slice",
"and",
"breaks",
"it",
"up",
"into",
"a",
"slice",
"of",
"base64",
"encoded",
"strings"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/authentication.go#L94-L122 |
10,681 | go-chef/chef | examples/sandboxes/sandboxes.go | random_data | func random_data(size int) (b []byte) {
b = make([]byte, size)
rand.Read(b)
return
} | go | func random_data(size int) (b []byte) {
b = make([]byte, size)
rand.Read(b)
return
} | [
"func",
"random_data",
"(",
"size",
"int",
")",
"(",
"b",
"[",
"]",
"byte",
")",
"{",
"b",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"size",
")",
"\n",
"rand",
".",
"Read",
"(",
"b",
")",
"\n",
"return",
"\n",
"}"
] | //random_data makes random byte slice for building junk sandbox data | [
"random_data",
"makes",
"random",
"byte",
"slice",
"for",
"building",
"junk",
"sandbox",
"data"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/examples/sandboxes/sandboxes.go#L18-L22 |
10,682 | go-chef/chef | client.go | String | func (c ApiClientListResult) String() (out string) {
for k, v := range c {
out += fmt.Sprintf("%s => %s\n", k, v)
}
return out
} | go | func (c ApiClientListResult) String() (out string) {
for k, v := range c {
out += fmt.Sprintf("%s => %s\n", k, v)
}
return out
} | [
"func",
"(",
"c",
"ApiClientListResult",
")",
"String",
"(",
")",
"(",
"out",
"string",
")",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"c",
"{",
"out",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"k",
",",
"v",
")",
"\n",
"}",
"... | // String makes ApiClientListResult implement the string result | [
"String",
"makes",
"ApiClientListResult",
"implement",
"the",
"string",
"result"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/client.go#L50-L55 |
10,683 | go-chef/chef | node.go | NewNode | func NewNode(name string) (node Node) {
node = Node{
Name: name,
Environment: "_default",
ChefType: "node",
JsonClass: "Chef::Node",
}
return
} | go | func NewNode(name string) (node Node) {
node = Node{
Name: name,
Environment: "_default",
ChefType: "node",
JsonClass: "Chef::Node",
}
return
} | [
"func",
"NewNode",
"(",
"name",
"string",
")",
"(",
"node",
"Node",
")",
"{",
"node",
"=",
"Node",
"{",
"Name",
":",
"name",
",",
"Environment",
":",
"\"",
"\"",
",",
"ChefType",
":",
"\"",
"\"",
",",
"JsonClass",
":",
"\"",
"\"",
",",
"}",
"\n",... | // NewNode is the Node constructor method | [
"NewNode",
"is",
"the",
"Node",
"constructor",
"method"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/node.go#L29-L37 |
10,684 | go-chef/chef | http.go | Buffer | func (body *Body) Buffer() *bytes.Buffer {
var b bytes.Buffer
if body.Reader == nil {
return &b
}
b.ReadFrom(body.Reader)
_, err := body.Reader.(io.Seeker).Seek(0, 0)
if err != nil {
log.Fatal(err)
}
return &b
} | go | func (body *Body) Buffer() *bytes.Buffer {
var b bytes.Buffer
if body.Reader == nil {
return &b
}
b.ReadFrom(body.Reader)
_, err := body.Reader.(io.Seeker).Seek(0, 0)
if err != nil {
log.Fatal(err)
}
return &b
} | [
"func",
"(",
"body",
"*",
"Body",
")",
"Buffer",
"(",
")",
"*",
"bytes",
".",
"Buffer",
"{",
"var",
"b",
"bytes",
".",
"Buffer",
"\n",
"if",
"body",
".",
"Reader",
"==",
"nil",
"{",
"return",
"&",
"b",
"\n",
"}",
"\n\n",
"b",
".",
"ReadFrom",
"... | // Buffer creates a byte.Buffer copy from a io.Reader resets read on reader to 0,0 | [
"Buffer",
"creates",
"a",
"byte",
".",
"Buffer",
"copy",
"from",
"a",
"io",
".",
"Reader",
"resets",
"read",
"on",
"reader",
"to",
"0",
"0"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/http.go#L82-L94 |
10,685 | go-chef/chef | http.go | Hash | func (body *Body) Hash() (h string) {
b := body.Buffer()
// empty buffs should return a empty string
if b.Len() == 0 {
h = HashStr("")
}
h = HashStr(b.String())
return
} | go | func (body *Body) Hash() (h string) {
b := body.Buffer()
// empty buffs should return a empty string
if b.Len() == 0 {
h = HashStr("")
}
h = HashStr(b.String())
return
} | [
"func",
"(",
"body",
"*",
"Body",
")",
"Hash",
"(",
")",
"(",
"h",
"string",
")",
"{",
"b",
":=",
"body",
".",
"Buffer",
"(",
")",
"\n",
"// empty buffs should return a empty string",
"if",
"b",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"h",
"=",
"Hash... | // Hash calculates the body content hash | [
"Hash",
"calculates",
"the",
"body",
"content",
"hash"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/http.go#L97-L105 |
10,686 | go-chef/chef | http.go | NewClient | func NewClient(cfg *Config) (*Client, error) {
pk, err := PrivateKeyFromString([]byte(cfg.Key))
if err != nil {
return nil, err
}
baseUrl, _ := url.Parse(cfg.BaseURL)
tr := &http.Transport{
Proxy: http.ProxyFromEnvironment,
Dial: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
}).Dial,
TLSClientConfig: &tls.Config{InsecureSkipVerify: cfg.SkipSSL},
TLSHandshakeTimeout: 10 * time.Second,
}
c := &Client{
Auth: &AuthConfig{
PrivateKey: pk,
ClientName: cfg.Name,
},
client: &http.Client{
Transport: tr,
Timeout: cfg.Timeout * time.Second,
},
BaseURL: baseUrl,
}
c.ACLs = &ACLService{client: c}
c.Clients = &ApiClientService{client: c}
c.Cookbooks = &CookbookService{client: c}
c.DataBags = &DataBagService{client: c}
c.Environments = &EnvironmentService{client: c}
c.Nodes = &NodeService{client: c}
c.Principals = &PrincipalService{client: c}
c.Roles = &RoleService{client: c}
c.Sandboxes = &SandboxService{client: c}
c.Search = &SearchService{client: c}
return c, nil
} | go | func NewClient(cfg *Config) (*Client, error) {
pk, err := PrivateKeyFromString([]byte(cfg.Key))
if err != nil {
return nil, err
}
baseUrl, _ := url.Parse(cfg.BaseURL)
tr := &http.Transport{
Proxy: http.ProxyFromEnvironment,
Dial: (&net.Dialer{
Timeout: 30 * time.Second,
KeepAlive: 30 * time.Second,
}).Dial,
TLSClientConfig: &tls.Config{InsecureSkipVerify: cfg.SkipSSL},
TLSHandshakeTimeout: 10 * time.Second,
}
c := &Client{
Auth: &AuthConfig{
PrivateKey: pk,
ClientName: cfg.Name,
},
client: &http.Client{
Transport: tr,
Timeout: cfg.Timeout * time.Second,
},
BaseURL: baseUrl,
}
c.ACLs = &ACLService{client: c}
c.Clients = &ApiClientService{client: c}
c.Cookbooks = &CookbookService{client: c}
c.DataBags = &DataBagService{client: c}
c.Environments = &EnvironmentService{client: c}
c.Nodes = &NodeService{client: c}
c.Principals = &PrincipalService{client: c}
c.Roles = &RoleService{client: c}
c.Sandboxes = &SandboxService{client: c}
c.Search = &SearchService{client: c}
return c, nil
} | [
"func",
"NewClient",
"(",
"cfg",
"*",
"Config",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"pk",
",",
"err",
":=",
"PrivateKeyFromString",
"(",
"[",
"]",
"byte",
"(",
"cfg",
".",
"Key",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return... | // NewClient is the client generator used to instantiate a client for talking to a chef-server
// It is a simple constructor for the Client struct intended as a easy interface for issuing
// signed requests | [
"NewClient",
"is",
"the",
"client",
"generator",
"used",
"to",
"instantiate",
"a",
"client",
"for",
"talking",
"to",
"a",
"chef",
"-",
"server",
"It",
"is",
"a",
"simple",
"constructor",
"for",
"the",
"Client",
"struct",
"intended",
"as",
"a",
"easy",
"int... | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/http.go#L124-L164 |
10,687 | go-chef/chef | http.go | magicRequestDecoder | func (c *Client) magicRequestDecoder(method, path string, body io.Reader, v interface{}) error {
req, err := c.NewRequest(method, path, body)
if err != nil {
return err
}
debug("Request: %+v \n", req)
res, err := c.Do(req, v)
if res != nil {
defer res.Body.Close()
}
debug("Response: %+v \n", res)
if err != nil {
return err
}
return err
} | go | func (c *Client) magicRequestDecoder(method, path string, body io.Reader, v interface{}) error {
req, err := c.NewRequest(method, path, body)
if err != nil {
return err
}
debug("Request: %+v \n", req)
res, err := c.Do(req, v)
if res != nil {
defer res.Body.Close()
}
debug("Response: %+v \n", res)
if err != nil {
return err
}
return err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"magicRequestDecoder",
"(",
"method",
",",
"path",
"string",
",",
"body",
"io",
".",
"Reader",
",",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"req",
",",
"err",
":=",
"c",
".",
"NewRequest",
"(",
"method",
... | // magicRequestDecoder performs a request on an endpoint, and decodes the response into the passed in Type | [
"magicRequestDecoder",
"performs",
"a",
"request",
"on",
"an",
"endpoint",
"and",
"decodes",
"the",
"response",
"into",
"the",
"passed",
"in",
"Type"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/http.go#L167-L183 |
10,688 | go-chef/chef | http.go | NewRequest | func (c *Client) NewRequest(method string, requestUrl string, body io.Reader) (*http.Request, error) {
relativeUrl, err := url.Parse(requestUrl)
if err != nil {
return nil, err
}
u := c.BaseURL.ResolveReference(relativeUrl)
// NewRequest uses a new value object of body
req, err := http.NewRequest(method, u.String(), body)
if err != nil {
return nil, err
}
// parse and encode Querystring Values
values := req.URL.Query()
req.URL.RawQuery = values.Encode()
debug("Encoded url %+v", u)
myBody := &Body{body}
if body != nil {
// Detect Content-type
req.Header.Set("Content-Type", myBody.ContentType())
}
// Calculate the body hash
req.Header.Set("X-Ops-Content-Hash", myBody.Hash())
// don't have to check this works, signRequest only emits error when signing hash is not valid, and we baked that in
c.Auth.SignRequest(req)
return req, nil
} | go | func (c *Client) NewRequest(method string, requestUrl string, body io.Reader) (*http.Request, error) {
relativeUrl, err := url.Parse(requestUrl)
if err != nil {
return nil, err
}
u := c.BaseURL.ResolveReference(relativeUrl)
// NewRequest uses a new value object of body
req, err := http.NewRequest(method, u.String(), body)
if err != nil {
return nil, err
}
// parse and encode Querystring Values
values := req.URL.Query()
req.URL.RawQuery = values.Encode()
debug("Encoded url %+v", u)
myBody := &Body{body}
if body != nil {
// Detect Content-type
req.Header.Set("Content-Type", myBody.ContentType())
}
// Calculate the body hash
req.Header.Set("X-Ops-Content-Hash", myBody.Hash())
// don't have to check this works, signRequest only emits error when signing hash is not valid, and we baked that in
c.Auth.SignRequest(req)
return req, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"NewRequest",
"(",
"method",
"string",
",",
"requestUrl",
"string",
",",
"body",
"io",
".",
"Reader",
")",
"(",
"*",
"http",
".",
"Request",
",",
"error",
")",
"{",
"relativeUrl",
",",
"err",
":=",
"url",
".",
... | // NewRequest returns a signed request suitable for the chef server | [
"NewRequest",
"returns",
"a",
"signed",
"request",
"suitable",
"for",
"the",
"chef",
"server"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/http.go#L186-L217 |
10,689 | go-chef/chef | http.go | CheckResponse | func CheckResponse(r *http.Response) error {
if c := r.StatusCode; 200 <= c && c <= 299 {
return nil
}
errorResponse := &ErrorResponse{Response: r}
data, err := ioutil.ReadAll(r.Body)
if err == nil && data != nil {
json.Unmarshal(data, errorResponse)
}
return errorResponse
} | go | func CheckResponse(r *http.Response) error {
if c := r.StatusCode; 200 <= c && c <= 299 {
return nil
}
errorResponse := &ErrorResponse{Response: r}
data, err := ioutil.ReadAll(r.Body)
if err == nil && data != nil {
json.Unmarshal(data, errorResponse)
}
return errorResponse
} | [
"func",
"CheckResponse",
"(",
"r",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"if",
"c",
":=",
"r",
".",
"StatusCode",
";",
"200",
"<=",
"c",
"&&",
"c",
"<=",
"299",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"errorResponse",
":=",
"&",
"ErrorRes... | // CheckResponse receives a pointer to a http.Response and generates an Error via unmarshalling | [
"CheckResponse",
"receives",
"a",
"pointer",
"to",
"a",
"http",
".",
"Response",
"and",
"generates",
"an",
"Error",
"via",
"unmarshalling"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/http.go#L220-L230 |
10,690 | go-chef/chef | http.go | Do | func (c *Client) Do(req *http.Request, v interface{}) (*http.Response, error) {
res, err := c.client.Do(req)
if err != nil {
return nil, err
}
// BUG(fujin) tightly coupled
err = CheckResponse(res) // <--
if err != nil {
return res, err
}
if v != nil {
if w, ok := v.(io.Writer); ok {
io.Copy(w, res.Body)
} else {
err = json.NewDecoder(res.Body).Decode(v)
if err != nil {
return res, err
}
}
}
return res, nil
} | go | func (c *Client) Do(req *http.Request, v interface{}) (*http.Response, error) {
res, err := c.client.Do(req)
if err != nil {
return nil, err
}
// BUG(fujin) tightly coupled
err = CheckResponse(res) // <--
if err != nil {
return res, err
}
if v != nil {
if w, ok := v.(io.Writer); ok {
io.Copy(w, res.Body)
} else {
err = json.NewDecoder(res.Body).Decode(v)
if err != nil {
return res, err
}
}
}
return res, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Do",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"v",
"interface",
"{",
"}",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"c",
".",
"client",
".",
"Do",
"(",... | // Do is used either internally via our magic request shite or a user may use it | [
"Do",
"is",
"used",
"either",
"internally",
"via",
"our",
"magic",
"request",
"shite",
"or",
"a",
"user",
"may",
"use",
"it"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/http.go#L233-L256 |
10,691 | go-chef/chef | http.go | SignRequest | func (ac AuthConfig) SignRequest(request *http.Request) error {
// sanitize the path for the chef-server
// chef-server doesn't support '//' in the Hash Path.
var endpoint string
if request.URL.Path != "" {
endpoint = path.Clean(request.URL.Path)
request.URL.Path = endpoint
} else {
endpoint = request.URL.Path
}
vals := map[string]string{
"Method": request.Method,
"Hashed Path": HashStr(endpoint),
"Accept": "application/json",
"X-Chef-Version": ChefVersion,
"X-Ops-Timestamp": time.Now().UTC().Format(time.RFC3339),
"X-Ops-UserId": ac.ClientName,
"X-Ops-Sign": "algorithm=sha1;version=1.0",
"X-Ops-Content-Hash": request.Header.Get("X-Ops-Content-Hash"),
}
for _, key := range []string{"Method", "Accept", "X-Chef-Version", "X-Ops-Timestamp", "X-Ops-UserId", "X-Ops-Sign"} {
request.Header.Set(key, vals[key])
}
// To validate the signature it seems to be very particular
var content string
for _, key := range []string{"Method", "Hashed Path", "X-Ops-Content-Hash", "X-Ops-Timestamp", "X-Ops-UserId"} {
content += fmt.Sprintf("%s:%s\n", key, vals[key])
}
content = strings.TrimSuffix(content, "\n")
// generate signed string of headers
// Since we've gone through additional validation steps above,
// we shouldn't get an error at this point
signature, err := GenerateSignature(ac.PrivateKey, content)
if err != nil {
return err
}
// TODO: THIS IS CHEF PROTOCOL SPECIFIC
// Signature is made up of n 60 length chunks
base64sig := Base64BlockEncode(signature, 60)
// roll over the auth slice and add the apropriate header
for index, value := range base64sig {
request.Header.Set(fmt.Sprintf("X-Ops-Authorization-%d", index+1), string(value))
}
return nil
} | go | func (ac AuthConfig) SignRequest(request *http.Request) error {
// sanitize the path for the chef-server
// chef-server doesn't support '//' in the Hash Path.
var endpoint string
if request.URL.Path != "" {
endpoint = path.Clean(request.URL.Path)
request.URL.Path = endpoint
} else {
endpoint = request.URL.Path
}
vals := map[string]string{
"Method": request.Method,
"Hashed Path": HashStr(endpoint),
"Accept": "application/json",
"X-Chef-Version": ChefVersion,
"X-Ops-Timestamp": time.Now().UTC().Format(time.RFC3339),
"X-Ops-UserId": ac.ClientName,
"X-Ops-Sign": "algorithm=sha1;version=1.0",
"X-Ops-Content-Hash": request.Header.Get("X-Ops-Content-Hash"),
}
for _, key := range []string{"Method", "Accept", "X-Chef-Version", "X-Ops-Timestamp", "X-Ops-UserId", "X-Ops-Sign"} {
request.Header.Set(key, vals[key])
}
// To validate the signature it seems to be very particular
var content string
for _, key := range []string{"Method", "Hashed Path", "X-Ops-Content-Hash", "X-Ops-Timestamp", "X-Ops-UserId"} {
content += fmt.Sprintf("%s:%s\n", key, vals[key])
}
content = strings.TrimSuffix(content, "\n")
// generate signed string of headers
// Since we've gone through additional validation steps above,
// we shouldn't get an error at this point
signature, err := GenerateSignature(ac.PrivateKey, content)
if err != nil {
return err
}
// TODO: THIS IS CHEF PROTOCOL SPECIFIC
// Signature is made up of n 60 length chunks
base64sig := Base64BlockEncode(signature, 60)
// roll over the auth slice and add the apropriate header
for index, value := range base64sig {
request.Header.Set(fmt.Sprintf("X-Ops-Authorization-%d", index+1), string(value))
}
return nil
} | [
"func",
"(",
"ac",
"AuthConfig",
")",
"SignRequest",
"(",
"request",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"// sanitize the path for the chef-server",
"// chef-server doesn't support '//' in the Hash Path.",
"var",
"endpoint",
"string",
"\n",
"if",
"request",
... | // SignRequest modifies headers of an http.Request | [
"SignRequest",
"modifies",
"headers",
"of",
"an",
"http",
".",
"Request"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/http.go#L259-L309 |
10,692 | go-chef/chef | http.go | PrivateKeyFromString | func PrivateKeyFromString(key []byte) (*rsa.PrivateKey, error) {
block, _ := pem.Decode(key)
if block == nil {
return nil, fmt.Errorf("private key block size invalid")
}
rsaKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
if err != nil {
return nil, err
}
return rsaKey, nil
} | go | func PrivateKeyFromString(key []byte) (*rsa.PrivateKey, error) {
block, _ := pem.Decode(key)
if block == nil {
return nil, fmt.Errorf("private key block size invalid")
}
rsaKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
if err != nil {
return nil, err
}
return rsaKey, nil
} | [
"func",
"PrivateKeyFromString",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"*",
"rsa",
".",
"PrivateKey",
",",
"error",
")",
"{",
"block",
",",
"_",
":=",
"pem",
".",
"Decode",
"(",
"key",
")",
"\n",
"if",
"block",
"==",
"nil",
"{",
"return",
"nil",
... | // PrivateKeyFromString parses an RSA private key from a string | [
"PrivateKeyFromString",
"parses",
"an",
"RSA",
"private",
"key",
"from",
"a",
"string"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/http.go#L312-L322 |
10,693 | go-chef/chef | search.go | String | func (q SearchQuery) String() string {
return fmt.Sprintf("%s?q=%s&rows=%d&sort=%s&start=%d", q.Index, q.Query, q.Rows, q.SortBy, q.Start)
} | go | func (q SearchQuery) String() string {
return fmt.Sprintf("%s?q=%s&rows=%d&sort=%s&start=%d", q.Index, q.Query, q.Rows, q.SortBy, q.Start)
} | [
"func",
"(",
"q",
"SearchQuery",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"q",
".",
"Index",
",",
"q",
".",
"Query",
",",
"q",
".",
"Rows",
",",
"q",
".",
"SortBy",
",",
"q",
".",
"Start",
... | // String implements the Stringer Interface for the SearchQuery | [
"String",
"implements",
"the",
"Stringer",
"Interface",
"for",
"the",
"SearchQuery"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/search.go#L32-L34 |
10,694 | go-chef/chef | search.go | Do | func (q SearchQuery) Do(client *Client) (res SearchResult, err error) {
fullUrl := fmt.Sprintf("search/%s", q)
err = client.magicRequestDecoder("GET", fullUrl, nil, &res)
return
} | go | func (q SearchQuery) Do(client *Client) (res SearchResult, err error) {
fullUrl := fmt.Sprintf("search/%s", q)
err = client.magicRequestDecoder("GET", fullUrl, nil, &res)
return
} | [
"func",
"(",
"q",
"SearchQuery",
")",
"Do",
"(",
"client",
"*",
"Client",
")",
"(",
"res",
"SearchResult",
",",
"err",
"error",
")",
"{",
"fullUrl",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"q",
")",
"\n",
"err",
"=",
"client",
".",
"ma... | // Do will execute the search query on the client | [
"Do",
"will",
"execute",
"the",
"search",
"query",
"on",
"the",
"client"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/search.go#L44-L48 |
10,695 | go-chef/chef | search.go | DoPartial | func (q SearchQuery) DoPartial(client *Client, params map[string]interface{}) (res SearchResult, err error) {
fullUrl := fmt.Sprintf("search/%s", q)
body, err := JSONReader(params)
if err != nil {
debug("Problem encoding params for body", err.Error())
return
}
err = client.magicRequestDecoder("POST", fullUrl, body, &res)
return
} | go | func (q SearchQuery) DoPartial(client *Client, params map[string]interface{}) (res SearchResult, err error) {
fullUrl := fmt.Sprintf("search/%s", q)
body, err := JSONReader(params)
if err != nil {
debug("Problem encoding params for body", err.Error())
return
}
err = client.magicRequestDecoder("POST", fullUrl, body, &res)
return
} | [
"func",
"(",
"q",
"SearchQuery",
")",
"DoPartial",
"(",
"client",
"*",
"Client",
",",
"params",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"res",
"SearchResult",
",",
"err",
"error",
")",
"{",
"fullUrl",
":=",
"fmt",
".",
"Sprintf",
... | // DoPartial will execute the search query on the client with partal mapping | [
"DoPartial",
"will",
"execute",
"the",
"search",
"query",
"on",
"the",
"client",
"with",
"partal",
"mapping"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/search.go#L51-L62 |
10,696 | go-chef/chef | search.go | NewQuery | func (e SearchService) NewQuery(idx, statement string) (query SearchQuery, err error) {
// validate statement
if !strings.Contains(statement, ":") {
err = errors.New("statement is malformed")
return
}
query = SearchQuery{
Index: idx,
Query: statement,
// These are the defaults in chef: https://github.com/opscode/chef/blob/master/lib/chef/search/query.rb#L102-L105
SortBy: "X_CHEF_id_CHEF_X asc",
Start: 0,
Rows: 1000,
}
return
} | go | func (e SearchService) NewQuery(idx, statement string) (query SearchQuery, err error) {
// validate statement
if !strings.Contains(statement, ":") {
err = errors.New("statement is malformed")
return
}
query = SearchQuery{
Index: idx,
Query: statement,
// These are the defaults in chef: https://github.com/opscode/chef/blob/master/lib/chef/search/query.rb#L102-L105
SortBy: "X_CHEF_id_CHEF_X asc",
Start: 0,
Rows: 1000,
}
return
} | [
"func",
"(",
"e",
"SearchService",
")",
"NewQuery",
"(",
"idx",
",",
"statement",
"string",
")",
"(",
"query",
"SearchQuery",
",",
"err",
"error",
")",
"{",
"// validate statement",
"if",
"!",
"strings",
".",
"Contains",
"(",
"statement",
",",
"\"",
"\"",
... | // NewSearch is a constructor for a SearchQuery struct. This is used by other search service methods to perform search requests on the server | [
"NewSearch",
"is",
"a",
"constructor",
"for",
"a",
"SearchQuery",
"struct",
".",
"This",
"is",
"used",
"by",
"other",
"search",
"service",
"methods",
"to",
"perform",
"search",
"requests",
"on",
"the",
"server"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/search.go#L65-L82 |
10,697 | go-chef/chef | search.go | PartialExec | func (e SearchService) PartialExec(idx, statement string, params map[string]interface{}) (res SearchResult, err error) {
query := SearchQuery{
Index: idx,
Query: statement,
// These are the defaults in chef: https://github.com/opscode/chef/blob/master/lib/chef/search/query.rb#L102-L105
SortBy: "X_CHEF_id_CHEF_X asc",
Start: 0,
Rows: 1000,
}
fullUrl := fmt.Sprintf("search/%s", query)
body, err := JSONReader(params)
if err != nil {
debug("Problem encoding params for body")
return
}
err = e.client.magicRequestDecoder("POST", fullUrl, body, &res)
return
} | go | func (e SearchService) PartialExec(idx, statement string, params map[string]interface{}) (res SearchResult, err error) {
query := SearchQuery{
Index: idx,
Query: statement,
// These are the defaults in chef: https://github.com/opscode/chef/blob/master/lib/chef/search/query.rb#L102-L105
SortBy: "X_CHEF_id_CHEF_X asc",
Start: 0,
Rows: 1000,
}
fullUrl := fmt.Sprintf("search/%s", query)
body, err := JSONReader(params)
if err != nil {
debug("Problem encoding params for body")
return
}
err = e.client.magicRequestDecoder("POST", fullUrl, body, &res)
return
} | [
"func",
"(",
"e",
"SearchService",
")",
"PartialExec",
"(",
"idx",
",",
"statement",
"string",
",",
"params",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"(",
"res",
"SearchResult",
",",
"err",
"error",
")",
"{",
"query",
":=",
"SearchQuery",
... | // PartialExec Executes a partial search based on passed in params and the query. | [
"PartialExec",
"Executes",
"a",
"partial",
"search",
"based",
"on",
"passed",
"in",
"params",
"and",
"the",
"query",
"."
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/search.go#L120-L140 |
10,698 | go-chef/chef | sandbox.go | Put | func (s SandboxService) Put(id string) (box Sandbox, err error) {
answer := make(map[string]bool)
answer["is_completed"] = true
body, err := JSONReader(answer)
if id == "" {
return box, fmt.Errorf("must supply sandbox id to PUT request.")
}
err = s.client.magicRequestDecoder("PUT", "/sandboxes/"+id, body, &box)
return
} | go | func (s SandboxService) Put(id string) (box Sandbox, err error) {
answer := make(map[string]bool)
answer["is_completed"] = true
body, err := JSONReader(answer)
if id == "" {
return box, fmt.Errorf("must supply sandbox id to PUT request.")
}
err = s.client.magicRequestDecoder("PUT", "/sandboxes/"+id, body, &box)
return
} | [
"func",
"(",
"s",
"SandboxService",
")",
"Put",
"(",
"id",
"string",
")",
"(",
"box",
"Sandbox",
",",
"err",
"error",
")",
"{",
"answer",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"answer",
"[",
"\"",
"\"",
"]",
"=",
"true"... | // Put is used to commit a sandbox ID to the chef server. To singal that the sandox you have Posted is now uploaded. | [
"Put",
"is",
"used",
"to",
"commit",
"a",
"sandbox",
"ID",
"to",
"the",
"chef",
"server",
".",
"To",
"singal",
"that",
"the",
"sandox",
"you",
"have",
"Posted",
"is",
"now",
"uploaded",
"."
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/sandbox.go#L59-L70 |
10,699 | go-chef/chef | cookbook.go | String | func (c CookbookListResult) String() (out string) {
for k, v := range c {
out += fmt.Sprintf("%s => %s\n", k, v.Url)
for _, i := range v.Versions {
out += fmt.Sprintf(" * %s\n", i.Version)
}
}
return out
} | go | func (c CookbookListResult) String() (out string) {
for k, v := range c {
out += fmt.Sprintf("%s => %s\n", k, v.Url)
for _, i := range v.Versions {
out += fmt.Sprintf(" * %s\n", i.Version)
}
}
return out
} | [
"func",
"(",
"c",
"CookbookListResult",
")",
"String",
"(",
")",
"(",
"out",
"string",
")",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"c",
"{",
"out",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"k",
",",
"v",
".",
"Url",
")",
"... | // String makes CookbookListResult implement the string result | [
"String",
"makes",
"CookbookListResult",
"implement",
"the",
"string",
"result"
] | cfd55cf96411cfa6ea658a3904fbcb8e40843e68 | https://github.com/go-chef/chef/blob/cfd55cf96411cfa6ea658a3904fbcb8e40843e68/cookbook.go#L81-L89 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.