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
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
gobuffalo/packr | v2/pointer.go | Resolve | func (p Pointer) Resolve(box string, path string) (file.File, error) {
plog.Debug(p, "Resolve", "box", box, "path", path, "forward-box", p.ForwardBox, "forward-path", p.ForwardPath)
b, err := findBox(p.ForwardBox)
if err != nil {
return nil, err
}
f, err := b.Resolve(p.ForwardPath)
if err != nil {
return f, errors.WithStack(errors.Wrap(err, path))
}
plog.Debug(p, "Resolve", "box", box, "path", path, "file", f)
return file.NewFileR(path, f)
} | go | func (p Pointer) Resolve(box string, path string) (file.File, error) {
plog.Debug(p, "Resolve", "box", box, "path", path, "forward-box", p.ForwardBox, "forward-path", p.ForwardPath)
b, err := findBox(p.ForwardBox)
if err != nil {
return nil, err
}
f, err := b.Resolve(p.ForwardPath)
if err != nil {
return f, errors.WithStack(errors.Wrap(err, path))
}
plog.Debug(p, "Resolve", "box", box, "path", path, "file", f)
return file.NewFileR(path, f)
} | [
"func",
"(",
"p",
"Pointer",
")",
"Resolve",
"(",
"box",
"string",
",",
"path",
"string",
")",
"(",
"file",
".",
"File",
",",
"error",
")",
"{",
"plog",
".",
"Debug",
"(",
"p",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"box",
",",
"\"",
"\"",
",",
"path",
",",
"\"",
"\"",
",",
"p",
".",
"ForwardBox",
",",
"\"",
"\"",
",",
"p",
".",
"ForwardPath",
")",
"\n",
"b",
",",
"err",
":=",
"findBox",
"(",
"p",
".",
"ForwardBox",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"f",
",",
"err",
":=",
"b",
".",
"Resolve",
"(",
"p",
".",
"ForwardPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"f",
",",
"errors",
".",
"WithStack",
"(",
"errors",
".",
"Wrap",
"(",
"err",
",",
"path",
")",
")",
"\n",
"}",
"\n",
"plog",
".",
"Debug",
"(",
"p",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"box",
",",
"\"",
"\"",
",",
"path",
",",
"\"",
"\"",
",",
"f",
")",
"\n",
"return",
"file",
".",
"NewFileR",
"(",
"path",
",",
"f",
")",
"\n",
"}"
] | // Resolve attempts to find the file in the specific box
// with the specified key | [
"Resolve",
"attempts",
"to",
"find",
"the",
"file",
"in",
"the",
"specific",
"box",
"with",
"the",
"specified",
"key"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/pointer.go#L21-L33 | train |
gobuffalo/packr | v2/jam/parser/parser.go | Run | func (p *Parser) Run() (Boxes, error) {
var boxes Boxes
for _, pros := range p.Prospects {
plog.Debug(p, "Run", "parsing", pros.Name())
v := NewVisitor(pros)
pbr, err := v.Run()
if err != nil {
return boxes, err
}
for _, b := range pbr {
plog.Debug(p, "Run", "file", pros.Name(), "box", b.Name)
boxes = append(boxes, b)
}
}
pwd, _ := os.Getwd()
sort.Slice(boxes, func(a, b int) bool {
b1 := boxes[a]
return !strings.HasPrefix(b1.AbsPath, pwd)
})
return boxes, nil
} | go | func (p *Parser) Run() (Boxes, error) {
var boxes Boxes
for _, pros := range p.Prospects {
plog.Debug(p, "Run", "parsing", pros.Name())
v := NewVisitor(pros)
pbr, err := v.Run()
if err != nil {
return boxes, err
}
for _, b := range pbr {
plog.Debug(p, "Run", "file", pros.Name(), "box", b.Name)
boxes = append(boxes, b)
}
}
pwd, _ := os.Getwd()
sort.Slice(boxes, func(a, b int) bool {
b1 := boxes[a]
return !strings.HasPrefix(b1.AbsPath, pwd)
})
return boxes, nil
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"Run",
"(",
")",
"(",
"Boxes",
",",
"error",
")",
"{",
"var",
"boxes",
"Boxes",
"\n",
"for",
"_",
",",
"pros",
":=",
"range",
"p",
".",
"Prospects",
"{",
"plog",
".",
"Debug",
"(",
"p",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"pros",
".",
"Name",
"(",
")",
")",
"\n",
"v",
":=",
"NewVisitor",
"(",
"pros",
")",
"\n",
"pbr",
",",
"err",
":=",
"v",
".",
"Run",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"boxes",
",",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"b",
":=",
"range",
"pbr",
"{",
"plog",
".",
"Debug",
"(",
"p",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"pros",
".",
"Name",
"(",
")",
",",
"\"",
"\"",
",",
"b",
".",
"Name",
")",
"\n",
"boxes",
"=",
"append",
"(",
"boxes",
",",
"b",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"pwd",
",",
"_",
":=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"sort",
".",
"Slice",
"(",
"boxes",
",",
"func",
"(",
"a",
",",
"b",
"int",
")",
"bool",
"{",
"b1",
":=",
"boxes",
"[",
"a",
"]",
"\n",
"return",
"!",
"strings",
".",
"HasPrefix",
"(",
"b1",
".",
"AbsPath",
",",
"pwd",
")",
"\n",
"}",
")",
"\n",
"return",
"boxes",
",",
"nil",
"\n",
"}"
] | // Run the parser and run any boxes found | [
"Run",
"the",
"parser",
"and",
"run",
"any",
"boxes",
"found"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/jam/parser/parser.go#L18-L39 | train |
gobuffalo/packr | packr.go | PackBytes | func PackBytes(box string, name string, bb []byte) {
gil.Lock()
defer gil.Unlock()
if _, ok := data[box]; !ok {
data[box] = map[string][]byte{}
}
data[box][name] = bb
} | go | func PackBytes(box string, name string, bb []byte) {
gil.Lock()
defer gil.Unlock()
if _, ok := data[box]; !ok {
data[box] = map[string][]byte{}
}
data[box][name] = bb
} | [
"func",
"PackBytes",
"(",
"box",
"string",
",",
"name",
"string",
",",
"bb",
"[",
"]",
"byte",
")",
"{",
"gil",
".",
"Lock",
"(",
")",
"\n",
"defer",
"gil",
".",
"Unlock",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"data",
"[",
"box",
"]",
";",
"!",
"ok",
"{",
"data",
"[",
"box",
"]",
"=",
"map",
"[",
"string",
"]",
"[",
"]",
"byte",
"{",
"}",
"\n",
"}",
"\n",
"data",
"[",
"box",
"]",
"[",
"name",
"]",
"=",
"bb",
"\n",
"}"
] | // PackBytes packs bytes for a file into a box. | [
"PackBytes",
"packs",
"bytes",
"for",
"a",
"file",
"into",
"a",
"box",
"."
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/packr.go#L16-L23 | train |
gobuffalo/packr | packr.go | PackBytesGzip | func PackBytesGzip(box string, name string, bb []byte) error {
var buf bytes.Buffer
w := gzip.NewWriter(&buf)
_, err := w.Write(bb)
if err != nil {
return err
}
err = w.Close()
if err != nil {
return err
}
PackBytes(box, name, buf.Bytes())
return nil
} | go | func PackBytesGzip(box string, name string, bb []byte) error {
var buf bytes.Buffer
w := gzip.NewWriter(&buf)
_, err := w.Write(bb)
if err != nil {
return err
}
err = w.Close()
if err != nil {
return err
}
PackBytes(box, name, buf.Bytes())
return nil
} | [
"func",
"PackBytesGzip",
"(",
"box",
"string",
",",
"name",
"string",
",",
"bb",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"w",
":=",
"gzip",
".",
"NewWriter",
"(",
"&",
"buf",
")",
"\n",
"_",
",",
"err",
":=",
"w",
".",
"Write",
"(",
"bb",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"w",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"PackBytes",
"(",
"box",
",",
"name",
",",
"buf",
".",
"Bytes",
"(",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // PackBytesGzip packets the gzipped compressed bytes into a box. | [
"PackBytesGzip",
"packets",
"the",
"gzipped",
"compressed",
"bytes",
"into",
"a",
"box",
"."
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/packr.go#L26-L39 | train |
gobuffalo/packr | packr.go | PackJSONBytes | func PackJSONBytes(box string, name string, jbb string) error {
var bb []byte
err := json.Unmarshal([]byte(jbb), &bb)
if err != nil {
return err
}
PackBytes(box, name, bb)
return nil
} | go | func PackJSONBytes(box string, name string, jbb string) error {
var bb []byte
err := json.Unmarshal([]byte(jbb), &bb)
if err != nil {
return err
}
PackBytes(box, name, bb)
return nil
} | [
"func",
"PackJSONBytes",
"(",
"box",
"string",
",",
"name",
"string",
",",
"jbb",
"string",
")",
"error",
"{",
"var",
"bb",
"[",
"]",
"byte",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"jbb",
")",
",",
"&",
"bb",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"PackBytes",
"(",
"box",
",",
"name",
",",
"bb",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // PackJSONBytes packs JSON encoded bytes for a file into a box. | [
"PackJSONBytes",
"packs",
"JSON",
"encoded",
"bytes",
"for",
"a",
"file",
"into",
"a",
"box",
"."
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/packr.go#L42-L50 | train |
gobuffalo/packr | packr.go | UnpackBytes | func UnpackBytes(box string) {
gil.Lock()
defer gil.Unlock()
delete(data, box)
} | go | func UnpackBytes(box string) {
gil.Lock()
defer gil.Unlock()
delete(data, box)
} | [
"func",
"UnpackBytes",
"(",
"box",
"string",
")",
"{",
"gil",
".",
"Lock",
"(",
")",
"\n",
"defer",
"gil",
".",
"Unlock",
"(",
")",
"\n",
"delete",
"(",
"data",
",",
"box",
")",
"\n",
"}"
] | // UnpackBytes unpacks bytes for specific box. | [
"UnpackBytes",
"unpacks",
"bytes",
"for",
"specific",
"box",
"."
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/packr.go#L53-L57 | train |
gobuffalo/packr | v2/file/resolver/encoding/hex/hex.go | DecodeString | func DecodeString(s string) ([]byte, error) {
src := []byte(s)
// We can use the source slice itself as the destination
// because the decode loop increments by one and then the 'seen' byte is not used anymore.
n, err := Decode(src, src)
return src[:n], err
} | go | func DecodeString(s string) ([]byte, error) {
src := []byte(s)
// We can use the source slice itself as the destination
// because the decode loop increments by one and then the 'seen' byte is not used anymore.
n, err := Decode(src, src)
return src[:n], err
} | [
"func",
"DecodeString",
"(",
"s",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"src",
":=",
"[",
"]",
"byte",
"(",
"s",
")",
"\n",
"// We can use the source slice itself as the destination",
"// because the decode loop increments by one and then the 'seen' byte is not used anymore.",
"n",
",",
"err",
":=",
"Decode",
"(",
"src",
",",
"src",
")",
"\n",
"return",
"src",
"[",
":",
"n",
"]",
",",
"err",
"\n",
"}"
] | // DecodeString returns the bytes represented by the hexadecimal string s.
//
// DecodeString expects that src contains only hexadecimal
// characters and that src has even length.
// If the input is malformed, DecodeString returns
// the bytes decoded before the error. | [
"DecodeString",
"returns",
"the",
"bytes",
"represented",
"by",
"the",
"hexadecimal",
"string",
"s",
".",
"DecodeString",
"expects",
"that",
"src",
"contains",
"only",
"hexadecimal",
"characters",
"and",
"that",
"src",
"has",
"even",
"length",
".",
"If",
"the",
"input",
"is",
"malformed",
"DecodeString",
"returns",
"the",
"bytes",
"decoded",
"before",
"the",
"error",
"."
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/file/resolver/encoding/hex/hex.go#L108-L114 | train |
gobuffalo/packr | v2/file/resolver/encoding/hex/hex.go | Dump | func Dump(data []byte) string {
var buf bytes.Buffer
dumper := Dumper(&buf)
dumper.Write(data)
dumper.Close()
return buf.String()
} | go | func Dump(data []byte) string {
var buf bytes.Buffer
dumper := Dumper(&buf)
dumper.Write(data)
dumper.Close()
return buf.String()
} | [
"func",
"Dump",
"(",
"data",
"[",
"]",
"byte",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"dumper",
":=",
"Dumper",
"(",
"&",
"buf",
")",
"\n",
"dumper",
".",
"Write",
"(",
"data",
")",
"\n",
"dumper",
".",
"Close",
"(",
")",
"\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] | // Dump returns a string that contains a hex dump of the given data. The format
// of the hex dump matches the output of `hexdump -C` on the command line. | [
"Dump",
"returns",
"a",
"string",
"that",
"contains",
"a",
"hex",
"dump",
"of",
"the",
"given",
"data",
".",
"The",
"format",
"of",
"the",
"hex",
"dump",
"matches",
"the",
"output",
"of",
"hexdump",
"-",
"C",
"on",
"the",
"command",
"line",
"."
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/file/resolver/encoding/hex/hex.go#L118-L124 | train |
gobuffalo/packr | v2/resolvers_map.go | Load | func (m *resolversMap) Load(key string) (resolver.Resolver, bool) {
i, ok := m.data.Load(key)
if !ok {
return nil, false
}
s, ok := i.(resolver.Resolver)
return s, ok
} | go | func (m *resolversMap) Load(key string) (resolver.Resolver, bool) {
i, ok := m.data.Load(key)
if !ok {
return nil, false
}
s, ok := i.(resolver.Resolver)
return s, ok
} | [
"func",
"(",
"m",
"*",
"resolversMap",
")",
"Load",
"(",
"key",
"string",
")",
"(",
"resolver",
".",
"Resolver",
",",
"bool",
")",
"{",
"i",
",",
"ok",
":=",
"m",
".",
"data",
".",
"Load",
"(",
"key",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"false",
"\n",
"}",
"\n",
"s",
",",
"ok",
":=",
"i",
".",
"(",
"resolver",
".",
"Resolver",
")",
"\n",
"return",
"s",
",",
"ok",
"\n",
"}"
] | // Load the key from the map.
// Returns resolver.Resolver or bool.
// A false return indicates either the key was not found
// or the value is not of type resolver.Resolver | [
"Load",
"the",
"key",
"from",
"the",
"map",
".",
"Returns",
"resolver",
".",
"Resolver",
"or",
"bool",
".",
"A",
"false",
"return",
"indicates",
"either",
"the",
"key",
"was",
"not",
"found",
"or",
"the",
"value",
"is",
"not",
"of",
"type",
"resolver",
".",
"Resolver"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/resolvers_map.go#L29-L36 | train |
gobuffalo/packr | v2/resolvers_map.go | Range | func (m *resolversMap) Range(f func(key string, value resolver.Resolver) bool) {
m.data.Range(func(k, v interface{}) bool {
key, ok := k.(string)
if !ok {
return false
}
value, ok := v.(resolver.Resolver)
if !ok {
return false
}
return f(key, value)
})
} | go | func (m *resolversMap) Range(f func(key string, value resolver.Resolver) bool) {
m.data.Range(func(k, v interface{}) bool {
key, ok := k.(string)
if !ok {
return false
}
value, ok := v.(resolver.Resolver)
if !ok {
return false
}
return f(key, value)
})
} | [
"func",
"(",
"m",
"*",
"resolversMap",
")",
"Range",
"(",
"f",
"func",
"(",
"key",
"string",
",",
"value",
"resolver",
".",
"Resolver",
")",
"bool",
")",
"{",
"m",
".",
"data",
".",
"Range",
"(",
"func",
"(",
"k",
",",
"v",
"interface",
"{",
"}",
")",
"bool",
"{",
"key",
",",
"ok",
":=",
"k",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"value",
",",
"ok",
":=",
"v",
".",
"(",
"resolver",
".",
"Resolver",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"f",
"(",
"key",
",",
"value",
")",
"\n",
"}",
")",
"\n",
"}"
] | // Range over the resolver.Resolver values in the map | [
"Range",
"over",
"the",
"resolver",
".",
"Resolver",
"values",
"in",
"the",
"map"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/resolvers_map.go#L47-L59 | train |
gobuffalo/packr | v2/resolvers_map.go | Store | func (m *resolversMap) Store(key string, value resolver.Resolver) {
m.data.Store(key, value)
} | go | func (m *resolversMap) Store(key string, value resolver.Resolver) {
m.data.Store(key, value)
} | [
"func",
"(",
"m",
"*",
"resolversMap",
")",
"Store",
"(",
"key",
"string",
",",
"value",
"resolver",
".",
"Resolver",
")",
"{",
"m",
".",
"data",
".",
"Store",
"(",
"key",
",",
"value",
")",
"\n",
"}"
] | // Store a resolver.Resolver in the map | [
"Store",
"a",
"resolver",
".",
"Resolver",
"in",
"the",
"map"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/resolvers_map.go#L62-L64 | train |
gobuffalo/packr | v2/deprecated.go | PackBytes | func PackBytes(box string, name string, bb []byte) {
b := NewBox(box)
d := resolver.NewInMemory(map[string]file.File{})
f, err := file.NewFile(name, bb)
if err != nil {
panic(err)
}
if err := d.Pack(name, f); err != nil {
panic(err)
}
b.SetResolver(name, d)
} | go | func PackBytes(box string, name string, bb []byte) {
b := NewBox(box)
d := resolver.NewInMemory(map[string]file.File{})
f, err := file.NewFile(name, bb)
if err != nil {
panic(err)
}
if err := d.Pack(name, f); err != nil {
panic(err)
}
b.SetResolver(name, d)
} | [
"func",
"PackBytes",
"(",
"box",
"string",
",",
"name",
"string",
",",
"bb",
"[",
"]",
"byte",
")",
"{",
"b",
":=",
"NewBox",
"(",
"box",
")",
"\n",
"d",
":=",
"resolver",
".",
"NewInMemory",
"(",
"map",
"[",
"string",
"]",
"file",
".",
"File",
"{",
"}",
")",
"\n",
"f",
",",
"err",
":=",
"file",
".",
"NewFile",
"(",
"name",
",",
"bb",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"d",
".",
"Pack",
"(",
"name",
",",
"f",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"b",
".",
"SetResolver",
"(",
"name",
",",
"d",
")",
"\n",
"}"
] | // PackBytes packs bytes for a file into a box.
// Deprecated | [
"PackBytes",
"packs",
"bytes",
"for",
"a",
"file",
"into",
"a",
"box",
".",
"Deprecated"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/deprecated.go#L23-L34 | train |
gobuffalo/packr | v2/deprecated.go | PackBytesGzip | func PackBytesGzip(box string, name string, bb []byte) error {
// TODO: this function never did what it was supposed to do!
PackBytes(box, name, bb)
return nil
} | go | func PackBytesGzip(box string, name string, bb []byte) error {
// TODO: this function never did what it was supposed to do!
PackBytes(box, name, bb)
return nil
} | [
"func",
"PackBytesGzip",
"(",
"box",
"string",
",",
"name",
"string",
",",
"bb",
"[",
"]",
"byte",
")",
"error",
"{",
"// TODO: this function never did what it was supposed to do!",
"PackBytes",
"(",
"box",
",",
"name",
",",
"bb",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // PackBytesGzip packets the gzipped compressed bytes into a box.
// Deprecated | [
"PackBytesGzip",
"packets",
"the",
"gzipped",
"compressed",
"bytes",
"into",
"a",
"box",
".",
"Deprecated"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/deprecated.go#L38-L42 | train |
gobuffalo/packr | v2/deprecated.go | String | func (b *Box) String(name string) string {
oncer.Deprecate(0, "github.com/gobuffalo/packr/v2#Box.String", "Use github.com/gobuffalo/packr/v2#Box.FindString instead.")
return string(b.Bytes(name))
} | go | func (b *Box) String(name string) string {
oncer.Deprecate(0, "github.com/gobuffalo/packr/v2#Box.String", "Use github.com/gobuffalo/packr/v2#Box.FindString instead.")
return string(b.Bytes(name))
} | [
"func",
"(",
"b",
"*",
"Box",
")",
"String",
"(",
"name",
"string",
")",
"string",
"{",
"oncer",
".",
"Deprecate",
"(",
"0",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"return",
"string",
"(",
"b",
".",
"Bytes",
"(",
"name",
")",
")",
"\n",
"}"
] | // String is deprecated. Use FindString instead | [
"String",
"is",
"deprecated",
".",
"Use",
"FindString",
"instead"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/deprecated.go#L70-L73 | train |
gobuffalo/packr | v2/deprecated.go | MustString | func (b *Box) MustString(name string) (string, error) {
oncer.Deprecate(0, "github.com/gobuffalo/packr/v2#Box.MustString", "Use github.com/gobuffalo/packr/v2#Box.FindString instead.")
return b.FindString(name)
} | go | func (b *Box) MustString(name string) (string, error) {
oncer.Deprecate(0, "github.com/gobuffalo/packr/v2#Box.MustString", "Use github.com/gobuffalo/packr/v2#Box.FindString instead.")
return b.FindString(name)
} | [
"func",
"(",
"b",
"*",
"Box",
")",
"MustString",
"(",
"name",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"oncer",
".",
"Deprecate",
"(",
"0",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"return",
"b",
".",
"FindString",
"(",
"name",
")",
"\n",
"}"
] | // MustString is deprecated. Use FindString instead | [
"MustString",
"is",
"deprecated",
".",
"Use",
"FindString",
"instead"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/deprecated.go#L76-L79 | train |
gobuffalo/packr | v2/dirs_map.go | Delete | func (m *dirsMap) Delete(key string) {
m.data.Delete(m.normalizeKey(key))
} | go | func (m *dirsMap) Delete(key string) {
m.data.Delete(m.normalizeKey(key))
} | [
"func",
"(",
"m",
"*",
"dirsMap",
")",
"Delete",
"(",
"key",
"string",
")",
"{",
"m",
".",
"data",
".",
"Delete",
"(",
"m",
".",
"normalizeKey",
"(",
"key",
")",
")",
"\n",
"}"
] | // Delete the key from the map | [
"Delete",
"the",
"key",
"from",
"the",
"map"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/dirs_map.go#L20-L22 | train |
gobuffalo/packr | v2/dirs_map.go | Load | func (m *dirsMap) Load(key string) (bool, bool) {
i, ok := m.data.Load(m.normalizeKey(key))
if !ok {
return false, false
}
s, ok := i.(bool)
return s, ok
} | go | func (m *dirsMap) Load(key string) (bool, bool) {
i, ok := m.data.Load(m.normalizeKey(key))
if !ok {
return false, false
}
s, ok := i.(bool)
return s, ok
} | [
"func",
"(",
"m",
"*",
"dirsMap",
")",
"Load",
"(",
"key",
"string",
")",
"(",
"bool",
",",
"bool",
")",
"{",
"i",
",",
"ok",
":=",
"m",
".",
"data",
".",
"Load",
"(",
"m",
".",
"normalizeKey",
"(",
"key",
")",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
",",
"false",
"\n",
"}",
"\n",
"s",
",",
"ok",
":=",
"i",
".",
"(",
"bool",
")",
"\n",
"return",
"s",
",",
"ok",
"\n",
"}"
] | // Load the key from the map.
// Returns bool or bool.
// A false return indicates either the key was not found
// or the value is not of type bool | [
"Load",
"the",
"key",
"from",
"the",
"map",
".",
"Returns",
"bool",
"or",
"bool",
".",
"A",
"false",
"return",
"indicates",
"either",
"the",
"key",
"was",
"not",
"found",
"or",
"the",
"value",
"is",
"not",
"of",
"type",
"bool"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/dirs_map.go#L28-L35 | train |
gobuffalo/packr | v2/dirs_map.go | Store | func (m *dirsMap) Store(key string, value bool) {
d := m.normalizeKey(key)
m.data.Store(d, value)
m.data.Store(strings.TrimPrefix(d, "/"), value)
} | go | func (m *dirsMap) Store(key string, value bool) {
d := m.normalizeKey(key)
m.data.Store(d, value)
m.data.Store(strings.TrimPrefix(d, "/"), value)
} | [
"func",
"(",
"m",
"*",
"dirsMap",
")",
"Store",
"(",
"key",
"string",
",",
"value",
"bool",
")",
"{",
"d",
":=",
"m",
".",
"normalizeKey",
"(",
"key",
")",
"\n",
"m",
".",
"data",
".",
"Store",
"(",
"d",
",",
"value",
")",
"\n",
"m",
".",
"data",
".",
"Store",
"(",
"strings",
".",
"TrimPrefix",
"(",
"d",
",",
"\"",
"\"",
")",
",",
"value",
")",
"\n",
"}"
] | // Store a bool in the map | [
"Store",
"a",
"bool",
"in",
"the",
"map"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/dirs_map.go#L61-L65 | train |
gobuffalo/packr | v2/packr2/cmd/fix/runner.go | Run | func Run() error {
fmt.Printf("! This updater will attempt to update your application to packr version: %s\n", packr.Version)
if !ask("Do you wish to continue?") {
fmt.Println("~~~ cancelling update ~~~")
return nil
}
r := &Runner{
Warnings: []string{},
}
defer func() {
if len(r.Warnings) == 0 {
return
}
fmt.Println("\n\n----------------------------")
fmt.Printf("!!! (%d) Warnings Were Found !!!\n\n", len(r.Warnings))
for _, w := range r.Warnings {
fmt.Printf("[WARNING]: %s\n", w)
}
}()
for _, c := range checks {
if err := c(r); err != nil {
return err
}
}
return nil
} | go | func Run() error {
fmt.Printf("! This updater will attempt to update your application to packr version: %s\n", packr.Version)
if !ask("Do you wish to continue?") {
fmt.Println("~~~ cancelling update ~~~")
return nil
}
r := &Runner{
Warnings: []string{},
}
defer func() {
if len(r.Warnings) == 0 {
return
}
fmt.Println("\n\n----------------------------")
fmt.Printf("!!! (%d) Warnings Were Found !!!\n\n", len(r.Warnings))
for _, w := range r.Warnings {
fmt.Printf("[WARNING]: %s\n", w)
}
}()
for _, c := range checks {
if err := c(r); err != nil {
return err
}
}
return nil
} | [
"func",
"Run",
"(",
")",
"error",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"packr",
".",
"Version",
")",
"\n",
"if",
"!",
"ask",
"(",
"\"",
"\"",
")",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"r",
":=",
"&",
"Runner",
"{",
"Warnings",
":",
"[",
"]",
"string",
"{",
"}",
",",
"}",
"\n\n",
"defer",
"func",
"(",
")",
"{",
"if",
"len",
"(",
"r",
".",
"Warnings",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n\n",
"fmt",
".",
"Println",
"(",
"\"",
"\\n",
"\\n",
"\"",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"len",
"(",
"r",
".",
"Warnings",
")",
")",
"\n",
"for",
"_",
",",
"w",
":=",
"range",
"r",
".",
"Warnings",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"w",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"for",
"_",
",",
"c",
":=",
"range",
"checks",
"{",
"if",
"err",
":=",
"c",
"(",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Run all compatible checks | [
"Run",
"all",
"compatible",
"checks"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/packr2/cmd/fix/runner.go#L18-L47 | train |
gobuffalo/packr | v2/box.go | New | func New(name string, path string) *Box {
plog.Debug("packr", "New", "name", name, "path", path)
b, _ := findBox(name)
if b != nil {
return b
}
b = construct(name, path)
plog.Debug(b, "New", "Box", b, "ResolutionDir", b.ResolutionDir)
b, err := placeBox(b)
if err != nil {
panic(err)
}
return b
} | go | func New(name string, path string) *Box {
plog.Debug("packr", "New", "name", name, "path", path)
b, _ := findBox(name)
if b != nil {
return b
}
b = construct(name, path)
plog.Debug(b, "New", "Box", b, "ResolutionDir", b.ResolutionDir)
b, err := placeBox(b)
if err != nil {
panic(err)
}
return b
} | [
"func",
"New",
"(",
"name",
"string",
",",
"path",
"string",
")",
"*",
"Box",
"{",
"plog",
".",
"Debug",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"name",
",",
"\"",
"\"",
",",
"path",
")",
"\n",
"b",
",",
"_",
":=",
"findBox",
"(",
"name",
")",
"\n",
"if",
"b",
"!=",
"nil",
"{",
"return",
"b",
"\n",
"}",
"\n\n",
"b",
"=",
"construct",
"(",
"name",
",",
"path",
")",
"\n",
"plog",
".",
"Debug",
"(",
"b",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"b",
",",
"\"",
"\"",
",",
"b",
".",
"ResolutionDir",
")",
"\n",
"b",
",",
"err",
":=",
"placeBox",
"(",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"b",
"\n",
"}"
] | // New returns a new Box with the name of the box
// and the path of the box. | [
"New",
"returns",
"a",
"new",
"Box",
"with",
"the",
"name",
"of",
"the",
"box",
"and",
"the",
"path",
"of",
"the",
"box",
"."
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/box.go#L51-L66 | train |
gobuffalo/packr | v2/box.go | SetResolver | func (b *Box) SetResolver(file string, res resolver.Resolver) {
d := filepath.Dir(file)
b.dirs.Store(d, true)
plog.Debug(b, "SetResolver", "file", file, "resolver", fmt.Sprintf("%T", res))
b.resolvers.Store(resolver.Key(file), res)
} | go | func (b *Box) SetResolver(file string, res resolver.Resolver) {
d := filepath.Dir(file)
b.dirs.Store(d, true)
plog.Debug(b, "SetResolver", "file", file, "resolver", fmt.Sprintf("%T", res))
b.resolvers.Store(resolver.Key(file), res)
} | [
"func",
"(",
"b",
"*",
"Box",
")",
"SetResolver",
"(",
"file",
"string",
",",
"res",
"resolver",
".",
"Resolver",
")",
"{",
"d",
":=",
"filepath",
".",
"Dir",
"(",
"file",
")",
"\n",
"b",
".",
"dirs",
".",
"Store",
"(",
"d",
",",
"true",
")",
"\n",
"plog",
".",
"Debug",
"(",
"b",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"file",
",",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"res",
")",
")",
"\n",
"b",
".",
"resolvers",
".",
"Store",
"(",
"resolver",
".",
"Key",
"(",
"file",
")",
",",
"res",
")",
"\n",
"}"
] | // SetResolver allows for the use of a custom resolver for
// the specified file | [
"SetResolver",
"allows",
"for",
"the",
"use",
"of",
"a",
"custom",
"resolver",
"for",
"the",
"specified",
"file"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/box.go#L77-L82 | train |
gobuffalo/packr | v2/box.go | AddString | func (b *Box) AddString(path string, t string) error {
return b.AddBytes(path, []byte(t))
} | go | func (b *Box) AddString(path string, t string) error {
return b.AddBytes(path, []byte(t))
} | [
"func",
"(",
"b",
"*",
"Box",
")",
"AddString",
"(",
"path",
"string",
",",
"t",
"string",
")",
"error",
"{",
"return",
"b",
".",
"AddBytes",
"(",
"path",
",",
"[",
"]",
"byte",
"(",
"t",
")",
")",
"\n",
"}"
] | // AddString converts t to a byteslice and delegates to AddBytes to add to b.data | [
"AddString",
"converts",
"t",
"to",
"a",
"byteslice",
"and",
"delegates",
"to",
"AddBytes",
"to",
"add",
"to",
"b",
".",
"data"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/box.go#L85-L87 | train |
gobuffalo/packr | v2/box.go | AddBytes | func (b *Box) AddBytes(path string, t []byte) error {
m := map[string]file.File{}
f, err := file.NewFile(path, t)
if err != nil {
return err
}
m[resolver.Key(path)] = f
res := resolver.NewInMemory(m)
b.SetResolver(path, res)
return nil
} | go | func (b *Box) AddBytes(path string, t []byte) error {
m := map[string]file.File{}
f, err := file.NewFile(path, t)
if err != nil {
return err
}
m[resolver.Key(path)] = f
res := resolver.NewInMemory(m)
b.SetResolver(path, res)
return nil
} | [
"func",
"(",
"b",
"*",
"Box",
")",
"AddBytes",
"(",
"path",
"string",
",",
"t",
"[",
"]",
"byte",
")",
"error",
"{",
"m",
":=",
"map",
"[",
"string",
"]",
"file",
".",
"File",
"{",
"}",
"\n",
"f",
",",
"err",
":=",
"file",
".",
"NewFile",
"(",
"path",
",",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"m",
"[",
"resolver",
".",
"Key",
"(",
"path",
")",
"]",
"=",
"f",
"\n",
"res",
":=",
"resolver",
".",
"NewInMemory",
"(",
"m",
")",
"\n",
"b",
".",
"SetResolver",
"(",
"path",
",",
"res",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // AddBytes sets t in b.data by the given path | [
"AddBytes",
"sets",
"t",
"in",
"b",
".",
"data",
"by",
"the",
"given",
"path"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/box.go#L90-L100 | train |
gobuffalo/packr | v2/box.go | FindString | func (b *Box) FindString(name string) (string, error) {
bb, err := b.Find(name)
return string(bb), err
} | go | func (b *Box) FindString(name string) (string, error) {
bb, err := b.Find(name)
return string(bb), err
} | [
"func",
"(",
"b",
"*",
"Box",
")",
"FindString",
"(",
"name",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"bb",
",",
"err",
":=",
"b",
".",
"Find",
"(",
"name",
")",
"\n",
"return",
"string",
"(",
"bb",
")",
",",
"err",
"\n",
"}"
] | // FindString returns either the string of the requested
// file or an error if it can not be found. | [
"FindString",
"returns",
"either",
"the",
"string",
"of",
"the",
"requested",
"file",
"or",
"an",
"error",
"if",
"it",
"can",
"not",
"be",
"found",
"."
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/box.go#L104-L107 | train |
gobuffalo/packr | v2/box.go | HasDir | func (b *Box) HasDir(name string) bool {
oncer.Do("packr2/box/HasDir"+b.Name, func() {
for _, f := range b.List() {
for d := filepath.Dir(f); d != "."; d = filepath.Dir(d) {
b.dirs.Store(d, true)
}
}
})
if name == "/" {
return b.Has("index.html")
}
_, ok := b.dirs.Load(name)
return ok
} | go | func (b *Box) HasDir(name string) bool {
oncer.Do("packr2/box/HasDir"+b.Name, func() {
for _, f := range b.List() {
for d := filepath.Dir(f); d != "."; d = filepath.Dir(d) {
b.dirs.Store(d, true)
}
}
})
if name == "/" {
return b.Has("index.html")
}
_, ok := b.dirs.Load(name)
return ok
} | [
"func",
"(",
"b",
"*",
"Box",
")",
"HasDir",
"(",
"name",
"string",
")",
"bool",
"{",
"oncer",
".",
"Do",
"(",
"\"",
"\"",
"+",
"b",
".",
"Name",
",",
"func",
"(",
")",
"{",
"for",
"_",
",",
"f",
":=",
"range",
"b",
".",
"List",
"(",
")",
"{",
"for",
"d",
":=",
"filepath",
".",
"Dir",
"(",
"f",
")",
";",
"d",
"!=",
"\"",
"\"",
";",
"d",
"=",
"filepath",
".",
"Dir",
"(",
"d",
")",
"{",
"b",
".",
"dirs",
".",
"Store",
"(",
"d",
",",
"true",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
")",
"\n",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"b",
".",
"Has",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"_",
",",
"ok",
":=",
"b",
".",
"dirs",
".",
"Load",
"(",
"name",
")",
"\n",
"return",
"ok",
"\n",
"}"
] | // HasDir returns true if the directory exists in the box | [
"HasDir",
"returns",
"true",
"if",
"the",
"directory",
"exists",
"in",
"the",
"box"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/box.go#L128-L141 | train |
gobuffalo/packr | v2/box.go | Resolve | func (b *Box) Resolve(key string) (file.File, error) {
key = strings.TrimPrefix(key, "/")
var r resolver.Resolver
b.resolvers.Range(func(k string, vr resolver.Resolver) bool {
lk := strings.ToLower(resolver.Key(k))
lkey := strings.ToLower(resolver.Key(key))
if lk == lkey {
r = vr
return false
}
return true
})
if r == nil {
r = b.DefaultResolver
if r == nil {
r = resolver.DefaultResolver
if r == nil {
return nil, errors.New("resolver.DefaultResolver is nil")
}
}
}
plog.Debug(r, "Resolve", "box", b.Name, "key", key)
f, err := r.Resolve(b.Name, key)
if err != nil {
z := filepath.Join(resolver.OsPath(b.ResolutionDir), resolver.OsPath(key))
f, err = r.Resolve(b.Name, z)
if err != nil {
plog.Debug(r, "Resolve", "box", b.Name, "key", z, "err", err)
return f, err
}
b, err := ioutil.ReadAll(f)
if err != nil {
return f, err
}
f, err = file.NewFile(key, b)
if err != nil {
return f, err
}
}
plog.Debug(r, "Resolve", "box", b.Name, "key", key, "file", f.Name())
return f, nil
} | go | func (b *Box) Resolve(key string) (file.File, error) {
key = strings.TrimPrefix(key, "/")
var r resolver.Resolver
b.resolvers.Range(func(k string, vr resolver.Resolver) bool {
lk := strings.ToLower(resolver.Key(k))
lkey := strings.ToLower(resolver.Key(key))
if lk == lkey {
r = vr
return false
}
return true
})
if r == nil {
r = b.DefaultResolver
if r == nil {
r = resolver.DefaultResolver
if r == nil {
return nil, errors.New("resolver.DefaultResolver is nil")
}
}
}
plog.Debug(r, "Resolve", "box", b.Name, "key", key)
f, err := r.Resolve(b.Name, key)
if err != nil {
z := filepath.Join(resolver.OsPath(b.ResolutionDir), resolver.OsPath(key))
f, err = r.Resolve(b.Name, z)
if err != nil {
plog.Debug(r, "Resolve", "box", b.Name, "key", z, "err", err)
return f, err
}
b, err := ioutil.ReadAll(f)
if err != nil {
return f, err
}
f, err = file.NewFile(key, b)
if err != nil {
return f, err
}
}
plog.Debug(r, "Resolve", "box", b.Name, "key", key, "file", f.Name())
return f, nil
} | [
"func",
"(",
"b",
"*",
"Box",
")",
"Resolve",
"(",
"key",
"string",
")",
"(",
"file",
".",
"File",
",",
"error",
")",
"{",
"key",
"=",
"strings",
".",
"TrimPrefix",
"(",
"key",
",",
"\"",
"\"",
")",
"\n\n",
"var",
"r",
"resolver",
".",
"Resolver",
"\n\n",
"b",
".",
"resolvers",
".",
"Range",
"(",
"func",
"(",
"k",
"string",
",",
"vr",
"resolver",
".",
"Resolver",
")",
"bool",
"{",
"lk",
":=",
"strings",
".",
"ToLower",
"(",
"resolver",
".",
"Key",
"(",
"k",
")",
")",
"\n",
"lkey",
":=",
"strings",
".",
"ToLower",
"(",
"resolver",
".",
"Key",
"(",
"key",
")",
")",
"\n",
"if",
"lk",
"==",
"lkey",
"{",
"r",
"=",
"vr",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}",
")",
"\n\n",
"if",
"r",
"==",
"nil",
"{",
"r",
"=",
"b",
".",
"DefaultResolver",
"\n",
"if",
"r",
"==",
"nil",
"{",
"r",
"=",
"resolver",
".",
"DefaultResolver",
"\n",
"if",
"r",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"plog",
".",
"Debug",
"(",
"r",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"b",
".",
"Name",
",",
"\"",
"\"",
",",
"key",
")",
"\n\n",
"f",
",",
"err",
":=",
"r",
".",
"Resolve",
"(",
"b",
".",
"Name",
",",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"z",
":=",
"filepath",
".",
"Join",
"(",
"resolver",
".",
"OsPath",
"(",
"b",
".",
"ResolutionDir",
")",
",",
"resolver",
".",
"OsPath",
"(",
"key",
")",
")",
"\n",
"f",
",",
"err",
"=",
"r",
".",
"Resolve",
"(",
"b",
".",
"Name",
",",
"z",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"plog",
".",
"Debug",
"(",
"r",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"b",
".",
"Name",
",",
"\"",
"\"",
",",
"z",
",",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"f",
",",
"err",
"\n",
"}",
"\n",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"f",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"f",
",",
"err",
"\n",
"}",
"\n",
"f",
",",
"err",
"=",
"file",
".",
"NewFile",
"(",
"key",
",",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"f",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"plog",
".",
"Debug",
"(",
"r",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"b",
".",
"Name",
",",
"\"",
"\"",
",",
"key",
",",
"\"",
"\"",
",",
"f",
".",
"Name",
"(",
")",
")",
"\n",
"return",
"f",
",",
"nil",
"\n",
"}"
] | // Resolve will attempt to find the file in the box,
// returning an error if the find can not be found. | [
"Resolve",
"will",
"attempt",
"to",
"find",
"the",
"file",
"in",
"the",
"box",
"returning",
"an",
"error",
"if",
"the",
"find",
"can",
"not",
"be",
"found",
"."
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/box.go#L191-L236 | train |
gobuffalo/packr | v2/jam/parser/roots.go | NewFromRoots | func NewFromRoots(roots []string, opts *RootsOptions) (*Parser, error) {
if opts == nil {
opts = &RootsOptions{}
}
if len(roots) == 0 {
pwd, _ := os.Getwd()
roots = append(roots, pwd)
}
p := New()
plog.Debug(p, "NewFromRoots", "roots", roots, "options", opts)
callback := func(path string, de *godirwalk.Dirent) error {
if IsProspect(path, opts.Ignores...) {
if de.IsDir() {
return nil
}
roots = append(roots, path)
return nil
}
if de.IsDir() {
return filepath.SkipDir
}
return nil
}
wopts := &godirwalk.Options{
FollowSymbolicLinks: true,
Callback: callback,
}
for _, root := range roots {
plog.Debug(p, "NewFromRoots", "walking", root)
err := godirwalk.Walk(root, wopts)
if err != nil {
return p, err
}
}
dd := map[string]string{}
fd := &finder{id: time.Now()}
for _, r := range roots {
var names []string
if opts.IgnoreImports {
names, _ = fd.findAllGoFiles(r)
} else {
names, _ = fd.findAllGoFilesImports(r)
}
for _, n := range names {
if IsProspect(n) {
plog.Debug(p, "NewFromRoots", "mapping", n)
dd[n] = n
}
}
}
for path := range dd {
plog.Debug(p, "NewFromRoots", "reading file", path)
b, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
p.Prospects = append(p.Prospects, NewFile(path, bytes.NewReader(b)))
}
plog.Debug(p, "NewFromRoots", "found prospects", len(p.Prospects))
return p, nil
} | go | func NewFromRoots(roots []string, opts *RootsOptions) (*Parser, error) {
if opts == nil {
opts = &RootsOptions{}
}
if len(roots) == 0 {
pwd, _ := os.Getwd()
roots = append(roots, pwd)
}
p := New()
plog.Debug(p, "NewFromRoots", "roots", roots, "options", opts)
callback := func(path string, de *godirwalk.Dirent) error {
if IsProspect(path, opts.Ignores...) {
if de.IsDir() {
return nil
}
roots = append(roots, path)
return nil
}
if de.IsDir() {
return filepath.SkipDir
}
return nil
}
wopts := &godirwalk.Options{
FollowSymbolicLinks: true,
Callback: callback,
}
for _, root := range roots {
plog.Debug(p, "NewFromRoots", "walking", root)
err := godirwalk.Walk(root, wopts)
if err != nil {
return p, err
}
}
dd := map[string]string{}
fd := &finder{id: time.Now()}
for _, r := range roots {
var names []string
if opts.IgnoreImports {
names, _ = fd.findAllGoFiles(r)
} else {
names, _ = fd.findAllGoFilesImports(r)
}
for _, n := range names {
if IsProspect(n) {
plog.Debug(p, "NewFromRoots", "mapping", n)
dd[n] = n
}
}
}
for path := range dd {
plog.Debug(p, "NewFromRoots", "reading file", path)
b, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
p.Prospects = append(p.Prospects, NewFile(path, bytes.NewReader(b)))
}
plog.Debug(p, "NewFromRoots", "found prospects", len(p.Prospects))
return p, nil
} | [
"func",
"NewFromRoots",
"(",
"roots",
"[",
"]",
"string",
",",
"opts",
"*",
"RootsOptions",
")",
"(",
"*",
"Parser",
",",
"error",
")",
"{",
"if",
"opts",
"==",
"nil",
"{",
"opts",
"=",
"&",
"RootsOptions",
"{",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"roots",
")",
"==",
"0",
"{",
"pwd",
",",
"_",
":=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"roots",
"=",
"append",
"(",
"roots",
",",
"pwd",
")",
"\n",
"}",
"\n",
"p",
":=",
"New",
"(",
")",
"\n",
"plog",
".",
"Debug",
"(",
"p",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"roots",
",",
"\"",
"\"",
",",
"opts",
")",
"\n",
"callback",
":=",
"func",
"(",
"path",
"string",
",",
"de",
"*",
"godirwalk",
".",
"Dirent",
")",
"error",
"{",
"if",
"IsProspect",
"(",
"path",
",",
"opts",
".",
"Ignores",
"...",
")",
"{",
"if",
"de",
".",
"IsDir",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"roots",
"=",
"append",
"(",
"roots",
",",
"path",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"de",
".",
"IsDir",
"(",
")",
"{",
"return",
"filepath",
".",
"SkipDir",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"wopts",
":=",
"&",
"godirwalk",
".",
"Options",
"{",
"FollowSymbolicLinks",
":",
"true",
",",
"Callback",
":",
"callback",
",",
"}",
"\n",
"for",
"_",
",",
"root",
":=",
"range",
"roots",
"{",
"plog",
".",
"Debug",
"(",
"p",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"root",
")",
"\n",
"err",
":=",
"godirwalk",
".",
"Walk",
"(",
"root",
",",
"wopts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"p",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"dd",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"fd",
":=",
"&",
"finder",
"{",
"id",
":",
"time",
".",
"Now",
"(",
")",
"}",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"roots",
"{",
"var",
"names",
"[",
"]",
"string",
"\n",
"if",
"opts",
".",
"IgnoreImports",
"{",
"names",
",",
"_",
"=",
"fd",
".",
"findAllGoFiles",
"(",
"r",
")",
"\n",
"}",
"else",
"{",
"names",
",",
"_",
"=",
"fd",
".",
"findAllGoFilesImports",
"(",
"r",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"names",
"{",
"if",
"IsProspect",
"(",
"n",
")",
"{",
"plog",
".",
"Debug",
"(",
"p",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"n",
")",
"\n",
"dd",
"[",
"n",
"]",
"=",
"n",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"path",
":=",
"range",
"dd",
"{",
"plog",
".",
"Debug",
"(",
"p",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"path",
")",
"\n",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"p",
".",
"Prospects",
"=",
"append",
"(",
"p",
".",
"Prospects",
",",
"NewFile",
"(",
"path",
",",
"bytes",
".",
"NewReader",
"(",
"b",
")",
")",
")",
"\n",
"}",
"\n",
"plog",
".",
"Debug",
"(",
"p",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"len",
"(",
"p",
".",
"Prospects",
")",
")",
"\n",
"return",
"p",
",",
"nil",
"\n",
"}"
] | // NewFromRoots scans the file roots provided and returns a
// new Parser containing the prospects | [
"NewFromRoots",
"scans",
"the",
"file",
"roots",
"provided",
"and",
"returns",
"a",
"new",
"Parser",
"containing",
"the",
"prospects"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/jam/parser/roots.go#L27-L89 | train |
gobuffalo/packr | v2/file/file.go | NewFile | func NewFile(name string, b []byte) (File, error) {
return packd.NewFile(name, bytes.NewReader(b))
} | go | func NewFile(name string, b []byte) (File, error) {
return packd.NewFile(name, bytes.NewReader(b))
} | [
"func",
"NewFile",
"(",
"name",
"string",
",",
"b",
"[",
"]",
"byte",
")",
"(",
"File",
",",
"error",
")",
"{",
"return",
"packd",
".",
"NewFile",
"(",
"name",
",",
"bytes",
".",
"NewReader",
"(",
"b",
")",
")",
"\n",
"}"
] | // NewFile returns a virtual File implementation | [
"NewFile",
"returns",
"a",
"virtual",
"File",
"implementation"
] | 9819ef1571983a956c49475cb0524d8a4971620f | https://github.com/gobuffalo/packr/blob/9819ef1571983a956c49475cb0524d8a4971620f/v2/file/file.go#L21-L23 | train |
koding/kite | heartbeat.go | RegisterHTTPForever | func (k *Kite) RegisterHTTPForever(kiteURL *url.URL) {
// Create the httpBackoffRegister that RegisterHTTPForever will
// use to backoff repeated register attempts.
httpRegisterBackOff := backoff.NewExponentialBackOff()
httpRegisterBackOff.InitialInterval = 30 * time.Second
httpRegisterBackOff.MaxInterval = 5 * time.Minute
httpRegisterBackOff.Multiplier = 1.7
httpRegisterBackOff.MaxElapsedTime = 0
register := func() error {
_, err := k.RegisterHTTP(kiteURL)
if err != nil {
k.Log.Error("Cannot register to Kontrol: %s Will retry after %d seconds",
err,
httpRegisterBackOff.NextBackOff()/time.Second)
return err
}
return nil
}
// this will retry register forever
err := backoff.Retry(register, httpRegisterBackOff)
if err != nil {
k.Log.Error("BackOff stopped retrying with Error '%s'", err)
}
} | go | func (k *Kite) RegisterHTTPForever(kiteURL *url.URL) {
// Create the httpBackoffRegister that RegisterHTTPForever will
// use to backoff repeated register attempts.
httpRegisterBackOff := backoff.NewExponentialBackOff()
httpRegisterBackOff.InitialInterval = 30 * time.Second
httpRegisterBackOff.MaxInterval = 5 * time.Minute
httpRegisterBackOff.Multiplier = 1.7
httpRegisterBackOff.MaxElapsedTime = 0
register := func() error {
_, err := k.RegisterHTTP(kiteURL)
if err != nil {
k.Log.Error("Cannot register to Kontrol: %s Will retry after %d seconds",
err,
httpRegisterBackOff.NextBackOff()/time.Second)
return err
}
return nil
}
// this will retry register forever
err := backoff.Retry(register, httpRegisterBackOff)
if err != nil {
k.Log.Error("BackOff stopped retrying with Error '%s'", err)
}
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"RegisterHTTPForever",
"(",
"kiteURL",
"*",
"url",
".",
"URL",
")",
"{",
"// Create the httpBackoffRegister that RegisterHTTPForever will",
"// use to backoff repeated register attempts.",
"httpRegisterBackOff",
":=",
"backoff",
".",
"NewExponentialBackOff",
"(",
")",
"\n",
"httpRegisterBackOff",
".",
"InitialInterval",
"=",
"30",
"*",
"time",
".",
"Second",
"\n",
"httpRegisterBackOff",
".",
"MaxInterval",
"=",
"5",
"*",
"time",
".",
"Minute",
"\n",
"httpRegisterBackOff",
".",
"Multiplier",
"=",
"1.7",
"\n",
"httpRegisterBackOff",
".",
"MaxElapsedTime",
"=",
"0",
"\n\n",
"register",
":=",
"func",
"(",
")",
"error",
"{",
"_",
",",
"err",
":=",
"k",
".",
"RegisterHTTP",
"(",
"kiteURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"k",
".",
"Log",
".",
"Error",
"(",
"\"",
"\"",
",",
"err",
",",
"httpRegisterBackOff",
".",
"NextBackOff",
"(",
")",
"/",
"time",
".",
"Second",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"// this will retry register forever",
"err",
":=",
"backoff",
".",
"Retry",
"(",
"register",
",",
"httpRegisterBackOff",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"k",
".",
"Log",
".",
"Error",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // RegisterHTTPForever is just like RegisterHTTP however it first tries to
// register forever until a response from kontrol is received. It's useful to
// use it during app initializations. After the registration a reconnect is
// automatically handled inside the RegisterHTTP method. | [
"RegisterHTTPForever",
"is",
"just",
"like",
"RegisterHTTP",
"however",
"it",
"first",
"tries",
"to",
"register",
"forever",
"until",
"a",
"response",
"from",
"kontrol",
"is",
"received",
".",
"It",
"s",
"useful",
"to",
"use",
"it",
"during",
"app",
"initializations",
".",
"After",
"the",
"registration",
"a",
"reconnect",
"is",
"automatically",
"handled",
"inside",
"the",
"RegisterHTTP",
"method",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/heartbeat.go#L90-L116 | train |
koding/kite | heartbeat.go | handleHeartbeat | func (k *Kite) handleHeartbeat(r *Request) (interface{}, error) {
req, err := newHeartbeatReq(r)
if err != nil {
return nil, err
}
k.heartbeatC <- req
return nil, req.ping()
} | go | func (k *Kite) handleHeartbeat(r *Request) (interface{}, error) {
req, err := newHeartbeatReq(r)
if err != nil {
return nil, err
}
k.heartbeatC <- req
return nil, req.ping()
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"handleHeartbeat",
"(",
"r",
"*",
"Request",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"newHeartbeatReq",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"k",
".",
"heartbeatC",
"<-",
"req",
"\n\n",
"return",
"nil",
",",
"req",
".",
"ping",
"(",
")",
"\n",
"}"
] | // handleHeartbeat pings the callback with the given interval seconds. | [
"handleHeartbeat",
"pings",
"the",
"callback",
"with",
"the",
"given",
"interval",
"seconds",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/heartbeat.go#L246-L255 | train |
koding/kite | dnode/callback.go | Call | func (f Function) Call(args ...interface{}) error {
if !f.IsValid() {
return errors.New("invalid function")
}
return f.Caller.Call(args...)
} | go | func (f Function) Call(args ...interface{}) error {
if !f.IsValid() {
return errors.New("invalid function")
}
return f.Caller.Call(args...)
} | [
"func",
"(",
"f",
"Function",
")",
"Call",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"!",
"f",
".",
"IsValid",
"(",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"f",
".",
"Caller",
".",
"Call",
"(",
"args",
"...",
")",
"\n",
"}"
] | // Call the received function. | [
"Call",
"the",
"received",
"function",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/dnode/callback.go#L18-L23 | train |
koding/kite | dnode/callback.go | ParseCallbacks | func ParseCallbacks(msg *Message, sender func(id uint64, args []interface{}) error) error {
// Parse callbacks field and create callback functions.
for methodID, path := range msg.Callbacks {
id, err := strconv.ParseUint(methodID, 10, 64)
if err != nil {
return err
}
f := func(args ...interface{}) error { return sender(id, args) }
spec := CallbackSpec{path, Function{functionReceived(f)}}
msg.Arguments.CallbackSpecs = append(msg.Arguments.CallbackSpecs, spec)
}
return nil
} | go | func ParseCallbacks(msg *Message, sender func(id uint64, args []interface{}) error) error {
// Parse callbacks field and create callback functions.
for methodID, path := range msg.Callbacks {
id, err := strconv.ParseUint(methodID, 10, 64)
if err != nil {
return err
}
f := func(args ...interface{}) error { return sender(id, args) }
spec := CallbackSpec{path, Function{functionReceived(f)}}
msg.Arguments.CallbackSpecs = append(msg.Arguments.CallbackSpecs, spec)
}
return nil
} | [
"func",
"ParseCallbacks",
"(",
"msg",
"*",
"Message",
",",
"sender",
"func",
"(",
"id",
"uint64",
",",
"args",
"[",
"]",
"interface",
"{",
"}",
")",
"error",
")",
"error",
"{",
"// Parse callbacks field and create callback functions.",
"for",
"methodID",
",",
"path",
":=",
"range",
"msg",
".",
"Callbacks",
"{",
"id",
",",
"err",
":=",
"strconv",
".",
"ParseUint",
"(",
"methodID",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"f",
":=",
"func",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"sender",
"(",
"id",
",",
"args",
")",
"}",
"\n",
"spec",
":=",
"CallbackSpec",
"{",
"path",
",",
"Function",
"{",
"functionReceived",
"(",
"f",
")",
"}",
"}",
"\n",
"msg",
".",
"Arguments",
".",
"CallbackSpecs",
"=",
"append",
"(",
"msg",
".",
"Arguments",
".",
"CallbackSpecs",
",",
"spec",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // parseCallbacks parses the message's "callbacks" field and prepares
// callback functions in "arguments" field. | [
"parseCallbacks",
"parses",
"the",
"message",
"s",
"callbacks",
"field",
"and",
"prepares",
"callback",
"functions",
"in",
"arguments",
"field",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/dnode/callback.go#L78-L92 | train |
koding/kite | kontrol/node.go | Flatten | func (n *Node) Flatten() []*Node {
nodes := make([]*Node, 0)
for _, node := range n.Node.Nodes {
if node.Dir {
nodes = append(nodes, NewNode(node).Flatten()...)
continue
}
nodes = append(nodes, NewNode(node))
}
return nodes
} | go | func (n *Node) Flatten() []*Node {
nodes := make([]*Node, 0)
for _, node := range n.Node.Nodes {
if node.Dir {
nodes = append(nodes, NewNode(node).Flatten()...)
continue
}
nodes = append(nodes, NewNode(node))
}
return nodes
} | [
"func",
"(",
"n",
"*",
"Node",
")",
"Flatten",
"(",
")",
"[",
"]",
"*",
"Node",
"{",
"nodes",
":=",
"make",
"(",
"[",
"]",
"*",
"Node",
",",
"0",
")",
"\n",
"for",
"_",
",",
"node",
":=",
"range",
"n",
".",
"Node",
".",
"Nodes",
"{",
"if",
"node",
".",
"Dir",
"{",
"nodes",
"=",
"append",
"(",
"nodes",
",",
"NewNode",
"(",
"node",
")",
".",
"Flatten",
"(",
")",
"...",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"nodes",
"=",
"append",
"(",
"nodes",
",",
"NewNode",
"(",
"node",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nodes",
"\n",
"}"
] | // Flatten converts the recursive etcd directory structure to a flat one that
// contains all kontrolNodes | [
"Flatten",
"converts",
"the",
"recursive",
"etcd",
"directory",
"structure",
"to",
"a",
"flat",
"one",
"that",
"contains",
"all",
"kontrolNodes"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/node.go#L33-L45 | train |
koding/kite | kontrol/node.go | Kite | func (n *Node) Kite() (*protocol.KiteWithToken, error) {
kite, err := n.KiteFromKey()
if err != nil {
return nil, err
}
val, err := n.Value()
if err != nil {
return nil, err
}
return &protocol.KiteWithToken{
Kite: *kite,
URL: val.URL,
KeyID: val.KeyID,
}, nil
} | go | func (n *Node) Kite() (*protocol.KiteWithToken, error) {
kite, err := n.KiteFromKey()
if err != nil {
return nil, err
}
val, err := n.Value()
if err != nil {
return nil, err
}
return &protocol.KiteWithToken{
Kite: *kite,
URL: val.URL,
KeyID: val.KeyID,
}, nil
} | [
"func",
"(",
"n",
"*",
"Node",
")",
"Kite",
"(",
")",
"(",
"*",
"protocol",
".",
"KiteWithToken",
",",
"error",
")",
"{",
"kite",
",",
"err",
":=",
"n",
".",
"KiteFromKey",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"val",
",",
"err",
":=",
"n",
".",
"Value",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"protocol",
".",
"KiteWithToken",
"{",
"Kite",
":",
"*",
"kite",
",",
"URL",
":",
"val",
".",
"URL",
",",
"KeyID",
":",
"val",
".",
"KeyID",
",",
"}",
",",
"nil",
"\n",
"}"
] | // Kite returns a single kite gathered from the key and the value for the
// current node. | [
"Kite",
"returns",
"a",
"single",
"kite",
"gathered",
"from",
"the",
"key",
"and",
"the",
"value",
"for",
"the",
"current",
"node",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/node.go#L49-L65 | train |
koding/kite | kontrol/node.go | Value | func (n *Node) Value() (kontrolprotocol.RegisterValue, error) {
var rv kontrolprotocol.RegisterValue
err := json.Unmarshal([]byte(n.Node.Value), &rv)
return rv, err
} | go | func (n *Node) Value() (kontrolprotocol.RegisterValue, error) {
var rv kontrolprotocol.RegisterValue
err := json.Unmarshal([]byte(n.Node.Value), &rv)
return rv, err
} | [
"func",
"(",
"n",
"*",
"Node",
")",
"Value",
"(",
")",
"(",
"kontrolprotocol",
".",
"RegisterValue",
",",
"error",
")",
"{",
"var",
"rv",
"kontrolprotocol",
".",
"RegisterValue",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"n",
".",
"Node",
".",
"Value",
")",
",",
"&",
"rv",
")",
"\n",
"return",
"rv",
",",
"err",
"\n",
"}"
] | // Value returns the value associated with the current node. | [
"Value",
"returns",
"the",
"value",
"associated",
"with",
"the",
"current",
"node",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/node.go#L88-L92 | train |
koding/kite | kontrol/node.go | Kites | func (n *Node) Kites() (Kites, error) {
// Get all nodes recursively.
nodes := n.Flatten()
// Convert etcd nodes to kites.
var err error
kites := make(Kites, len(nodes))
for i, n := range nodes {
kites[i], err = n.Kite()
if err != nil {
return nil, err
}
}
return kites, nil
} | go | func (n *Node) Kites() (Kites, error) {
// Get all nodes recursively.
nodes := n.Flatten()
// Convert etcd nodes to kites.
var err error
kites := make(Kites, len(nodes))
for i, n := range nodes {
kites[i], err = n.Kite()
if err != nil {
return nil, err
}
}
return kites, nil
} | [
"func",
"(",
"n",
"*",
"Node",
")",
"Kites",
"(",
")",
"(",
"Kites",
",",
"error",
")",
"{",
"// Get all nodes recursively.",
"nodes",
":=",
"n",
".",
"Flatten",
"(",
")",
"\n\n",
"// Convert etcd nodes to kites.",
"var",
"err",
"error",
"\n",
"kites",
":=",
"make",
"(",
"Kites",
",",
"len",
"(",
"nodes",
")",
")",
"\n",
"for",
"i",
",",
"n",
":=",
"range",
"nodes",
"{",
"kites",
"[",
"i",
"]",
",",
"err",
"=",
"n",
".",
"Kite",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"kites",
",",
"nil",
"\n",
"}"
] | // Kites returns a list of kites that are gathered by collecting recursively
// all nodes under the current node. | [
"Kites",
"returns",
"a",
"list",
"of",
"kites",
"that",
"are",
"gathered",
"by",
"collecting",
"recursively",
"all",
"nodes",
"under",
"the",
"current",
"node",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/node.go#L96-L111 | train |
koding/kite | errors.go | createError | func createError(req *Request, r interface{}) *Error {
if r == nil {
return nil
}
var kiteErr *Error
switch err := r.(type) {
case *Error:
kiteErr = err
case *dnode.ArgumentError:
kiteErr = &Error{
Type: "argumentError",
Message: err.Error(),
}
default:
kiteErr = &Error{
Type: "genericError",
Message: fmt.Sprint(r),
}
}
if kiteErr.RequestID == "" && req != nil {
kiteErr.RequestID = req.ID
}
return kiteErr
} | go | func createError(req *Request, r interface{}) *Error {
if r == nil {
return nil
}
var kiteErr *Error
switch err := r.(type) {
case *Error:
kiteErr = err
case *dnode.ArgumentError:
kiteErr = &Error{
Type: "argumentError",
Message: err.Error(),
}
default:
kiteErr = &Error{
Type: "genericError",
Message: fmt.Sprint(r),
}
}
if kiteErr.RequestID == "" && req != nil {
kiteErr.RequestID = req.ID
}
return kiteErr
} | [
"func",
"createError",
"(",
"req",
"*",
"Request",
",",
"r",
"interface",
"{",
"}",
")",
"*",
"Error",
"{",
"if",
"r",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"var",
"kiteErr",
"*",
"Error",
"\n",
"switch",
"err",
":=",
"r",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Error",
":",
"kiteErr",
"=",
"err",
"\n",
"case",
"*",
"dnode",
".",
"ArgumentError",
":",
"kiteErr",
"=",
"&",
"Error",
"{",
"Type",
":",
"\"",
"\"",
",",
"Message",
":",
"err",
".",
"Error",
"(",
")",
",",
"}",
"\n",
"default",
":",
"kiteErr",
"=",
"&",
"Error",
"{",
"Type",
":",
"\"",
"\"",
",",
"Message",
":",
"fmt",
".",
"Sprint",
"(",
"r",
")",
",",
"}",
"\n",
"}",
"\n\n",
"if",
"kiteErr",
".",
"RequestID",
"==",
"\"",
"\"",
"&&",
"req",
"!=",
"nil",
"{",
"kiteErr",
".",
"RequestID",
"=",
"req",
".",
"ID",
"\n",
"}",
"\n\n",
"return",
"kiteErr",
"\n",
"}"
] | // createError creates a new kite.Error for the given r variable | [
"createError",
"creates",
"a",
"new",
"kite",
".",
"Error",
"for",
"the",
"given",
"r",
"variable"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/errors.go#L41-L67 | train |
koding/kite | reverseproxy/reverseproxy.go | isWebsocket | func isWebsocket(req *http.Request) bool {
if strings.ToLower(req.Header.Get("Upgrade")) != "websocket" ||
!strings.Contains(strings.ToLower(req.Header.Get("Connection")), "upgrade") {
return false
}
return true
} | go | func isWebsocket(req *http.Request) bool {
if strings.ToLower(req.Header.Get("Upgrade")) != "websocket" ||
!strings.Contains(strings.ToLower(req.Header.Get("Connection")), "upgrade") {
return false
}
return true
} | [
"func",
"isWebsocket",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"bool",
"{",
"if",
"strings",
".",
"ToLower",
"(",
"req",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
")",
"!=",
"\"",
"\"",
"||",
"!",
"strings",
".",
"Contains",
"(",
"strings",
".",
"ToLower",
"(",
"req",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
")",
",",
"\"",
"\"",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // isWebsocket checks wether the incoming request is a part of websocket
// handshake | [
"isWebsocket",
"checks",
"wether",
"the",
"incoming",
"request",
"is",
"a",
"part",
"of",
"websocket",
"handshake"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/reverseproxy/reverseproxy.go#L109-L115 | train |
koding/kite | reverseproxy/reverseproxy.go | ListenAndServe | func (p *Proxy) ListenAndServe() error {
var err error
p.listener, err = net.Listen("tcp4",
net.JoinHostPort(p.Kite.Config.IP, strconv.Itoa(p.Kite.Config.Port)))
if err != nil {
return err
}
p.Kite.Log.Info("Listening on: %s", p.listener.Addr().String())
close(p.readyC)
server := http.Server{
Handler: p.mux,
}
defer close(p.closeC)
return server.Serve(p.listener)
} | go | func (p *Proxy) ListenAndServe() error {
var err error
p.listener, err = net.Listen("tcp4",
net.JoinHostPort(p.Kite.Config.IP, strconv.Itoa(p.Kite.Config.Port)))
if err != nil {
return err
}
p.Kite.Log.Info("Listening on: %s", p.listener.Addr().String())
close(p.readyC)
server := http.Server{
Handler: p.mux,
}
defer close(p.closeC)
return server.Serve(p.listener)
} | [
"func",
"(",
"p",
"*",
"Proxy",
")",
"ListenAndServe",
"(",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"p",
".",
"listener",
",",
"err",
"=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"net",
".",
"JoinHostPort",
"(",
"p",
".",
"Kite",
".",
"Config",
".",
"IP",
",",
"strconv",
".",
"Itoa",
"(",
"p",
".",
"Kite",
".",
"Config",
".",
"Port",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"p",
".",
"Kite",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
",",
"p",
".",
"listener",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
")",
"\n\n",
"close",
"(",
"p",
".",
"readyC",
")",
"\n\n",
"server",
":=",
"http",
".",
"Server",
"{",
"Handler",
":",
"p",
".",
"mux",
",",
"}",
"\n\n",
"defer",
"close",
"(",
"p",
".",
"closeC",
")",
"\n",
"return",
"server",
".",
"Serve",
"(",
"p",
".",
"listener",
")",
"\n",
"}"
] | // ListenAndServe listens on the TCP network address addr and then calls Serve
// with handler to handle requests on incoming connections. | [
"ListenAndServe",
"listens",
"on",
"the",
"TCP",
"network",
"address",
"addr",
"and",
"then",
"calls",
"Serve",
"with",
"handler",
"to",
"handle",
"requests",
"on",
"incoming",
"connections",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/reverseproxy/reverseproxy.go#L195-L212 | train |
koding/kite | systeminfo/systeminfo_windows.go | diskStats | func diskStats() (*disk, error) {
var (
freeBytes uint64 = 0
totalBytes uint64 = 0
)
// windows sets return value to 0 when function fails.
ret, _, err := procGetDiskFreeSpaceExW.Call(
0,
uintptr(unsafe.Pointer(&freeBytes)),
uintptr(unsafe.Pointer(&totalBytes)),
0,
)
if ret == 0 {
return nil, err
}
// diskStats functions from other platforms return disk usage in kiB.
return &disk{
Usage: (totalBytes - freeBytes) / 1024,
Total: totalBytes / 1024,
}, nil
} | go | func diskStats() (*disk, error) {
var (
freeBytes uint64 = 0
totalBytes uint64 = 0
)
// windows sets return value to 0 when function fails.
ret, _, err := procGetDiskFreeSpaceExW.Call(
0,
uintptr(unsafe.Pointer(&freeBytes)),
uintptr(unsafe.Pointer(&totalBytes)),
0,
)
if ret == 0 {
return nil, err
}
// diskStats functions from other platforms return disk usage in kiB.
return &disk{
Usage: (totalBytes - freeBytes) / 1024,
Total: totalBytes / 1024,
}, nil
} | [
"func",
"diskStats",
"(",
")",
"(",
"*",
"disk",
",",
"error",
")",
"{",
"var",
"(",
"freeBytes",
"uint64",
"=",
"0",
"\n",
"totalBytes",
"uint64",
"=",
"0",
"\n",
")",
"\n\n",
"// windows sets return value to 0 when function fails.",
"ret",
",",
"_",
",",
"err",
":=",
"procGetDiskFreeSpaceExW",
".",
"Call",
"(",
"0",
",",
"uintptr",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"freeBytes",
")",
")",
",",
"uintptr",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"totalBytes",
")",
")",
",",
"0",
",",
")",
"\n",
"if",
"ret",
"==",
"0",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// diskStats functions from other platforms return disk usage in kiB.",
"return",
"&",
"disk",
"{",
"Usage",
":",
"(",
"totalBytes",
"-",
"freeBytes",
")",
"/",
"1024",
",",
"Total",
":",
"totalBytes",
"/",
"1024",
",",
"}",
",",
"nil",
"\n",
"}"
] | // diskStats returns information about the amount of space that is available on
// a current disk volume for the user who calls this function. | [
"diskStats",
"returns",
"information",
"about",
"the",
"amount",
"of",
"space",
"that",
"is",
"available",
"on",
"a",
"current",
"disk",
"volume",
"for",
"the",
"user",
"who",
"calls",
"this",
"function",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/systeminfo/systeminfo_windows.go#L17-L39 | train |
koding/kite | systeminfo/systeminfo_windows.go | memoryStats | func memoryStats() (*memory, error) {
mstat := struct {
size uint32
_ uint32
totalPhys uint64
availPhys uint64
_ [5]uint64
}{}
// windows sets return value to 0 when function fails.
mstat.size = uint32(unsafe.Sizeof(mstat))
ret, _, err := procGlobalMemoryStatusEx.Call(uintptr(unsafe.Pointer(&mstat)))
if ret == 0 {
return nil, err
}
// memoryStats functions from other platforms return memory usage in bytes.
return &memory{
Usage: mstat.totalPhys - mstat.availPhys,
Total: mstat.totalPhys,
}, nil
} | go | func memoryStats() (*memory, error) {
mstat := struct {
size uint32
_ uint32
totalPhys uint64
availPhys uint64
_ [5]uint64
}{}
// windows sets return value to 0 when function fails.
mstat.size = uint32(unsafe.Sizeof(mstat))
ret, _, err := procGlobalMemoryStatusEx.Call(uintptr(unsafe.Pointer(&mstat)))
if ret == 0 {
return nil, err
}
// memoryStats functions from other platforms return memory usage in bytes.
return &memory{
Usage: mstat.totalPhys - mstat.availPhys,
Total: mstat.totalPhys,
}, nil
} | [
"func",
"memoryStats",
"(",
")",
"(",
"*",
"memory",
",",
"error",
")",
"{",
"mstat",
":=",
"struct",
"{",
"size",
"uint32",
"\n",
"_",
"uint32",
"\n",
"totalPhys",
"uint64",
"\n",
"availPhys",
"uint64",
"\n",
"_",
"[",
"5",
"]",
"uint64",
"\n",
"}",
"{",
"}",
"\n\n",
"// windows sets return value to 0 when function fails.",
"mstat",
".",
"size",
"=",
"uint32",
"(",
"unsafe",
".",
"Sizeof",
"(",
"mstat",
")",
")",
"\n",
"ret",
",",
"_",
",",
"err",
":=",
"procGlobalMemoryStatusEx",
".",
"Call",
"(",
"uintptr",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"mstat",
")",
")",
")",
"\n",
"if",
"ret",
"==",
"0",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// memoryStats functions from other platforms return memory usage in bytes.",
"return",
"&",
"memory",
"{",
"Usage",
":",
"mstat",
".",
"totalPhys",
"-",
"mstat",
".",
"availPhys",
",",
"Total",
":",
"mstat",
".",
"totalPhys",
",",
"}",
",",
"nil",
"\n\n",
"}"
] | // memoryStatus retrieves information about the system's current usage of
// physical memory. | [
"memoryStatus",
"retrieves",
"information",
"about",
"the",
"system",
"s",
"current",
"usage",
"of",
"physical",
"memory",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/systeminfo/systeminfo_windows.go#L43-L65 | train |
koding/kite | protocol/webrtc.go | ParsePayload | func (w *WebRTCSignalMessage) ParsePayload() (*Payload, error) {
w.mu.Lock()
defer w.mu.Unlock()
if w.isParsed {
return w.parsedPayload, nil
}
payload := &Payload{}
if err := json.Unmarshal(w.Payload, payload); err != nil {
return nil, err
}
w.parsedPayload = payload
return payload, nil
} | go | func (w *WebRTCSignalMessage) ParsePayload() (*Payload, error) {
w.mu.Lock()
defer w.mu.Unlock()
if w.isParsed {
return w.parsedPayload, nil
}
payload := &Payload{}
if err := json.Unmarshal(w.Payload, payload); err != nil {
return nil, err
}
w.parsedPayload = payload
return payload, nil
} | [
"func",
"(",
"w",
"*",
"WebRTCSignalMessage",
")",
"ParsePayload",
"(",
")",
"(",
"*",
"Payload",
",",
"error",
")",
"{",
"w",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"w",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"w",
".",
"isParsed",
"{",
"return",
"w",
".",
"parsedPayload",
",",
"nil",
"\n",
"}",
"\n\n",
"payload",
":=",
"&",
"Payload",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"w",
".",
"Payload",
",",
"payload",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"w",
".",
"parsedPayload",
"=",
"payload",
"\n",
"return",
"payload",
",",
"nil",
"\n",
"}"
] | // ParsePayload parses the payload if it is not parsed previously. This method
// can be called concurrently. | [
"ParsePayload",
"parses",
"the",
"payload",
"if",
"it",
"is",
"not",
"parsed",
"previously",
".",
"This",
"method",
"can",
"be",
"called",
"concurrently",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/protocol/webrtc.go#L50-L65 | train |
koding/kite | logger.go | getLogLevel | func getLogLevel() Level {
switch strings.ToUpper(os.Getenv("KITE_LOG_LEVEL")) {
case "DEBUG":
return DEBUG
case "WARNING":
return WARNING
case "ERROR":
return ERROR
case "FATAL":
return FATAL
default:
return INFO
}
} | go | func getLogLevel() Level {
switch strings.ToUpper(os.Getenv("KITE_LOG_LEVEL")) {
case "DEBUG":
return DEBUG
case "WARNING":
return WARNING
case "ERROR":
return ERROR
case "FATAL":
return FATAL
default:
return INFO
}
} | [
"func",
"getLogLevel",
"(",
")",
"Level",
"{",
"switch",
"strings",
".",
"ToUpper",
"(",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
")",
"{",
"case",
"\"",
"\"",
":",
"return",
"DEBUG",
"\n",
"case",
"\"",
"\"",
":",
"return",
"WARNING",
"\n",
"case",
"\"",
"\"",
":",
"return",
"ERROR",
"\n",
"case",
"\"",
"\"",
":",
"return",
"FATAL",
"\n",
"default",
":",
"return",
"INFO",
"\n",
"}",
"\n",
"}"
] | // getLogLevel returns the logging level defined via the KITE_LOG_LEVEL
// environment. It returns Info by default if no environment variable
// is set. | [
"getLogLevel",
"returns",
"the",
"logging",
"level",
"defined",
"via",
"the",
"KITE_LOG_LEVEL",
"environment",
".",
"It",
"returns",
"Info",
"by",
"default",
"if",
"no",
"environment",
"variable",
"is",
"set",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/logger.go#L46-L59 | train |
koding/kite | logger.go | convertLevel | func convertLevel(l Level) logging.Level {
switch l {
case DEBUG:
return logging.DEBUG
case WARNING:
return logging.WARNING
case ERROR:
return logging.ERROR
case FATAL:
return logging.CRITICAL
default:
return logging.INFO
}
} | go | func convertLevel(l Level) logging.Level {
switch l {
case DEBUG:
return logging.DEBUG
case WARNING:
return logging.WARNING
case ERROR:
return logging.ERROR
case FATAL:
return logging.CRITICAL
default:
return logging.INFO
}
} | [
"func",
"convertLevel",
"(",
"l",
"Level",
")",
"logging",
".",
"Level",
"{",
"switch",
"l",
"{",
"case",
"DEBUG",
":",
"return",
"logging",
".",
"DEBUG",
"\n",
"case",
"WARNING",
":",
"return",
"logging",
".",
"WARNING",
"\n",
"case",
"ERROR",
":",
"return",
"logging",
".",
"ERROR",
"\n",
"case",
"FATAL",
":",
"return",
"logging",
".",
"CRITICAL",
"\n",
"default",
":",
"return",
"logging",
".",
"INFO",
"\n",
"}",
"\n",
"}"
] | // convertLevel converts a kite level into logging level | [
"convertLevel",
"converts",
"a",
"kite",
"level",
"into",
"logging",
"level"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/logger.go#L62-L75 | train |
koding/kite | dnode/scrub.go | fields | func (s *Scrubber) fields(rv reflect.Value, path Path, callbacks map[string]Path) {
for i := 0; i < rv.NumField(); i++ {
sf := rv.Type().Field(i)
if sf.PkgPath != "" && !sf.Anonymous { // unexported.
continue
}
// dnode uses JSON package tags for field naming so we need to
// discard their comma-separated options.
tag := sf.Tag.Get("json")
if idx := strings.Index(tag, ","); idx != -1 {
tag = tag[:idx]
}
if tag == "-" {
continue
}
// do not collect callbacks for "-" tagged fields.
if skip := sf.Tag.Get("dnode"); skip == "-" {
continue
}
var name = tag
if name == "" {
name = sf.Name
}
if sf.Anonymous {
s.collect(rv.Field(i), path, callbacks)
} else {
s.collect(rv.Field(i), append(path, name), callbacks)
}
}
} | go | func (s *Scrubber) fields(rv reflect.Value, path Path, callbacks map[string]Path) {
for i := 0; i < rv.NumField(); i++ {
sf := rv.Type().Field(i)
if sf.PkgPath != "" && !sf.Anonymous { // unexported.
continue
}
// dnode uses JSON package tags for field naming so we need to
// discard their comma-separated options.
tag := sf.Tag.Get("json")
if idx := strings.Index(tag, ","); idx != -1 {
tag = tag[:idx]
}
if tag == "-" {
continue
}
// do not collect callbacks for "-" tagged fields.
if skip := sf.Tag.Get("dnode"); skip == "-" {
continue
}
var name = tag
if name == "" {
name = sf.Name
}
if sf.Anonymous {
s.collect(rv.Field(i), path, callbacks)
} else {
s.collect(rv.Field(i), append(path, name), callbacks)
}
}
} | [
"func",
"(",
"s",
"*",
"Scrubber",
")",
"fields",
"(",
"rv",
"reflect",
".",
"Value",
",",
"path",
"Path",
",",
"callbacks",
"map",
"[",
"string",
"]",
"Path",
")",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"rv",
".",
"NumField",
"(",
")",
";",
"i",
"++",
"{",
"sf",
":=",
"rv",
".",
"Type",
"(",
")",
".",
"Field",
"(",
"i",
")",
"\n",
"if",
"sf",
".",
"PkgPath",
"!=",
"\"",
"\"",
"&&",
"!",
"sf",
".",
"Anonymous",
"{",
"// unexported.",
"continue",
"\n",
"}",
"\n\n",
"// dnode uses JSON package tags for field naming so we need to",
"// discard their comma-separated options.",
"tag",
":=",
"sf",
".",
"Tag",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"if",
"idx",
":=",
"strings",
".",
"Index",
"(",
"tag",
",",
"\"",
"\"",
")",
";",
"idx",
"!=",
"-",
"1",
"{",
"tag",
"=",
"tag",
"[",
":",
"idx",
"]",
"\n",
"}",
"\n",
"if",
"tag",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n",
"// do not collect callbacks for \"-\" tagged fields.",
"if",
"skip",
":=",
"sf",
".",
"Tag",
".",
"Get",
"(",
"\"",
"\"",
")",
";",
"skip",
"==",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n\n",
"var",
"name",
"=",
"tag",
"\n",
"if",
"name",
"==",
"\"",
"\"",
"{",
"name",
"=",
"sf",
".",
"Name",
"\n",
"}",
"\n\n",
"if",
"sf",
".",
"Anonymous",
"{",
"s",
".",
"collect",
"(",
"rv",
".",
"Field",
"(",
"i",
")",
",",
"path",
",",
"callbacks",
")",
"\n",
"}",
"else",
"{",
"s",
".",
"collect",
"(",
"rv",
".",
"Field",
"(",
"i",
")",
",",
"append",
"(",
"path",
",",
"name",
")",
",",
"callbacks",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // fields walks over a structure and scrubs its fields. | [
"fields",
"walks",
"over",
"a",
"structure",
"and",
"scrubs",
"its",
"fields",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/dnode/scrub.go#L71-L103 | train |
koding/kite | dnode/scrub.go | methods | func (s *Scrubber) methods(rv reflect.Value, path Path, callbacks map[string]Path) {
for i := 0; i < rv.NumMethod(); i++ {
if rv.Type().Method(i).PkgPath == "" { // exported
cb, ok := rv.Method(i).Interface().(func(*Partial))
if !ok {
continue
}
name := rv.Type().Method(i).Name
name = strings.ToLower(name[0:1]) + name[1:]
s.register(cb, append(path, name), callbacks)
}
}
} | go | func (s *Scrubber) methods(rv reflect.Value, path Path, callbacks map[string]Path) {
for i := 0; i < rv.NumMethod(); i++ {
if rv.Type().Method(i).PkgPath == "" { // exported
cb, ok := rv.Method(i).Interface().(func(*Partial))
if !ok {
continue
}
name := rv.Type().Method(i).Name
name = strings.ToLower(name[0:1]) + name[1:]
s.register(cb, append(path, name), callbacks)
}
}
} | [
"func",
"(",
"s",
"*",
"Scrubber",
")",
"methods",
"(",
"rv",
"reflect",
".",
"Value",
",",
"path",
"Path",
",",
"callbacks",
"map",
"[",
"string",
"]",
"Path",
")",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"rv",
".",
"NumMethod",
"(",
")",
";",
"i",
"++",
"{",
"if",
"rv",
".",
"Type",
"(",
")",
".",
"Method",
"(",
"i",
")",
".",
"PkgPath",
"==",
"\"",
"\"",
"{",
"// exported",
"cb",
",",
"ok",
":=",
"rv",
".",
"Method",
"(",
"i",
")",
".",
"Interface",
"(",
")",
".",
"(",
"func",
"(",
"*",
"Partial",
")",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n\n",
"name",
":=",
"rv",
".",
"Type",
"(",
")",
".",
"Method",
"(",
"i",
")",
".",
"Name",
"\n",
"name",
"=",
"strings",
".",
"ToLower",
"(",
"name",
"[",
"0",
":",
"1",
"]",
")",
"+",
"name",
"[",
"1",
":",
"]",
"\n",
"s",
".",
"register",
"(",
"cb",
",",
"append",
"(",
"path",
",",
"name",
")",
",",
"callbacks",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // methods walks over a structure and scrubs its exported methods. | [
"methods",
"walks",
"over",
"a",
"structure",
"and",
"scrubs",
"its",
"exported",
"methods",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/dnode/scrub.go#L106-L119 | train |
koding/kite | kontrolclient.go | SetupKontrolClient | func (k *Kite) SetupKontrolClient() error {
if k.kontrol.Client != nil {
return nil // already prepared
}
if k.Config.KontrolURL == "" {
return errors.New("no kontrol URL given in config")
}
client := k.NewClient(k.Config.KontrolURL)
client.Kite = protocol.Kite{Name: "kontrol"} // for logging purposes
client.Auth = &Auth{
Type: "kiteKey",
Key: k.KiteKey(),
}
k.kontrol.Lock()
k.kontrol.Client = client
k.kontrol.Unlock()
k.kontrol.OnConnect(func() {
k.Log.Info("Connected to Kontrol")
k.Log.Debug("Connected to Kontrol with session %q", client.session.ID())
// try to re-register on connect
k.kontrol.Lock()
if k.kontrol.lastRegisteredURL != nil {
select {
case k.kontrol.registerChan <- k.kontrol.lastRegisteredURL:
default:
}
}
k.kontrol.Unlock()
// signal all other methods that are listening on this channel, that we
// are connected to kontrol.
k.kontrol.onceConnected.Do(func() { close(k.kontrol.readyConnected) })
})
k.kontrol.OnDisconnect(func() {
k.Log.Warning("Disconnected from Kontrol.")
})
// non blocking, is going to reconnect if the connection goes down.
if _, err := k.kontrol.DialForever(); err != nil {
return err
}
return nil
} | go | func (k *Kite) SetupKontrolClient() error {
if k.kontrol.Client != nil {
return nil // already prepared
}
if k.Config.KontrolURL == "" {
return errors.New("no kontrol URL given in config")
}
client := k.NewClient(k.Config.KontrolURL)
client.Kite = protocol.Kite{Name: "kontrol"} // for logging purposes
client.Auth = &Auth{
Type: "kiteKey",
Key: k.KiteKey(),
}
k.kontrol.Lock()
k.kontrol.Client = client
k.kontrol.Unlock()
k.kontrol.OnConnect(func() {
k.Log.Info("Connected to Kontrol")
k.Log.Debug("Connected to Kontrol with session %q", client.session.ID())
// try to re-register on connect
k.kontrol.Lock()
if k.kontrol.lastRegisteredURL != nil {
select {
case k.kontrol.registerChan <- k.kontrol.lastRegisteredURL:
default:
}
}
k.kontrol.Unlock()
// signal all other methods that are listening on this channel, that we
// are connected to kontrol.
k.kontrol.onceConnected.Do(func() { close(k.kontrol.readyConnected) })
})
k.kontrol.OnDisconnect(func() {
k.Log.Warning("Disconnected from Kontrol.")
})
// non blocking, is going to reconnect if the connection goes down.
if _, err := k.kontrol.DialForever(); err != nil {
return err
}
return nil
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"SetupKontrolClient",
"(",
")",
"error",
"{",
"if",
"k",
".",
"kontrol",
".",
"Client",
"!=",
"nil",
"{",
"return",
"nil",
"// already prepared",
"\n",
"}",
"\n\n",
"if",
"k",
".",
"Config",
".",
"KontrolURL",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"client",
":=",
"k",
".",
"NewClient",
"(",
"k",
".",
"Config",
".",
"KontrolURL",
")",
"\n",
"client",
".",
"Kite",
"=",
"protocol",
".",
"Kite",
"{",
"Name",
":",
"\"",
"\"",
"}",
"// for logging purposes",
"\n",
"client",
".",
"Auth",
"=",
"&",
"Auth",
"{",
"Type",
":",
"\"",
"\"",
",",
"Key",
":",
"k",
".",
"KiteKey",
"(",
")",
",",
"}",
"\n\n",
"k",
".",
"kontrol",
".",
"Lock",
"(",
")",
"\n",
"k",
".",
"kontrol",
".",
"Client",
"=",
"client",
"\n",
"k",
".",
"kontrol",
".",
"Unlock",
"(",
")",
"\n\n",
"k",
".",
"kontrol",
".",
"OnConnect",
"(",
"func",
"(",
")",
"{",
"k",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"k",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"client",
".",
"session",
".",
"ID",
"(",
")",
")",
"\n\n",
"// try to re-register on connect",
"k",
".",
"kontrol",
".",
"Lock",
"(",
")",
"\n",
"if",
"k",
".",
"kontrol",
".",
"lastRegisteredURL",
"!=",
"nil",
"{",
"select",
"{",
"case",
"k",
".",
"kontrol",
".",
"registerChan",
"<-",
"k",
".",
"kontrol",
".",
"lastRegisteredURL",
":",
"default",
":",
"}",
"\n",
"}",
"\n",
"k",
".",
"kontrol",
".",
"Unlock",
"(",
")",
"\n\n",
"// signal all other methods that are listening on this channel, that we",
"// are connected to kontrol.",
"k",
".",
"kontrol",
".",
"onceConnected",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"close",
"(",
"k",
".",
"kontrol",
".",
"readyConnected",
")",
"}",
")",
"\n",
"}",
")",
"\n\n",
"k",
".",
"kontrol",
".",
"OnDisconnect",
"(",
"func",
"(",
")",
"{",
"k",
".",
"Log",
".",
"Warning",
"(",
"\"",
"\"",
")",
"\n",
"}",
")",
"\n\n",
"// non blocking, is going to reconnect if the connection goes down.",
"if",
"_",
",",
"err",
":=",
"k",
".",
"kontrol",
".",
"DialForever",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // SetupKontrolClient setups and prepares a the kontrol instance. It connects
// to kontrol and reconnects again if there is any disconnections. This method
// is called internally whenever a kontrol client specific action is taking.
// However if you wish to connect earlier you may call this method. | [
"SetupKontrolClient",
"setups",
"and",
"prepares",
"a",
"the",
"kontrol",
"instance",
".",
"It",
"connects",
"to",
"kontrol",
"and",
"reconnects",
"again",
"if",
"there",
"is",
"any",
"disconnections",
".",
"This",
"method",
"is",
"called",
"internally",
"whenever",
"a",
"kontrol",
"client",
"specific",
"action",
"is",
"taking",
".",
"However",
"if",
"you",
"wish",
"to",
"connect",
"earlier",
"you",
"may",
"call",
"this",
"method",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrolclient.go#L53-L102 | train |
koding/kite | kontrolclient.go | GetToken | func (k *Kite) GetToken(kite *protocol.Kite) (string, error) {
if err := k.SetupKontrolClient(); err != nil {
return "", err
}
<-k.kontrol.readyConnected
result, err := k.kontrol.TellWithTimeout("getToken", k.Config.Timeout, kite)
if err != nil {
return "", err
}
var tkn string
err = result.Unmarshal(&tkn)
if err != nil {
return "", err
}
return tkn, nil
} | go | func (k *Kite) GetToken(kite *protocol.Kite) (string, error) {
if err := k.SetupKontrolClient(); err != nil {
return "", err
}
<-k.kontrol.readyConnected
result, err := k.kontrol.TellWithTimeout("getToken", k.Config.Timeout, kite)
if err != nil {
return "", err
}
var tkn string
err = result.Unmarshal(&tkn)
if err != nil {
return "", err
}
return tkn, nil
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"GetToken",
"(",
"kite",
"*",
"protocol",
".",
"Kite",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"k",
".",
"SetupKontrolClient",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"<-",
"k",
".",
"kontrol",
".",
"readyConnected",
"\n\n",
"result",
",",
"err",
":=",
"k",
".",
"kontrol",
".",
"TellWithTimeout",
"(",
"\"",
"\"",
",",
"k",
".",
"Config",
".",
"Timeout",
",",
"kite",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"tkn",
"string",
"\n",
"err",
"=",
"result",
".",
"Unmarshal",
"(",
"&",
"tkn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"tkn",
",",
"nil",
"\n",
"}"
] | // GetToken is used to get a token for a single Kite.
//
// In case of calling GetToken multiple times, it usually
// returns the same token until it expires on Kontrol side. | [
"GetToken",
"is",
"used",
"to",
"get",
"a",
"token",
"for",
"a",
"single",
"Kite",
".",
"In",
"case",
"of",
"calling",
"GetToken",
"multiple",
"times",
"it",
"usually",
"returns",
"the",
"same",
"token",
"until",
"it",
"expires",
"on",
"Kontrol",
"side",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrolclient.go#L187-L206 | train |
koding/kite | kontrolclient.go | GetTokenForce | func (k *Kite) GetTokenForce(kite *protocol.Kite) (string, error) {
if err := k.SetupKontrolClient(); err != nil {
return "", err
}
<-k.kontrol.readyConnected
args := &protocol.GetTokenArgs{
KontrolQuery: *kite.Query(),
Force: true,
}
result, err := k.kontrol.TellWithTimeout("getToken", k.Config.Timeout, args)
if err != nil {
return "", err
}
var tkn string
err = result.Unmarshal(&tkn)
if err != nil {
return "", err
}
return tkn, nil
} | go | func (k *Kite) GetTokenForce(kite *protocol.Kite) (string, error) {
if err := k.SetupKontrolClient(); err != nil {
return "", err
}
<-k.kontrol.readyConnected
args := &protocol.GetTokenArgs{
KontrolQuery: *kite.Query(),
Force: true,
}
result, err := k.kontrol.TellWithTimeout("getToken", k.Config.Timeout, args)
if err != nil {
return "", err
}
var tkn string
err = result.Unmarshal(&tkn)
if err != nil {
return "", err
}
return tkn, nil
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"GetTokenForce",
"(",
"kite",
"*",
"protocol",
".",
"Kite",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"k",
".",
"SetupKontrolClient",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"<-",
"k",
".",
"kontrol",
".",
"readyConnected",
"\n\n",
"args",
":=",
"&",
"protocol",
".",
"GetTokenArgs",
"{",
"KontrolQuery",
":",
"*",
"kite",
".",
"Query",
"(",
")",
",",
"Force",
":",
"true",
",",
"}",
"\n\n",
"result",
",",
"err",
":=",
"k",
".",
"kontrol",
".",
"TellWithTimeout",
"(",
"\"",
"\"",
",",
"k",
".",
"Config",
".",
"Timeout",
",",
"args",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"tkn",
"string",
"\n",
"err",
"=",
"result",
".",
"Unmarshal",
"(",
"&",
"tkn",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"tkn",
",",
"nil",
"\n",
"}"
] | // GetTokenForce is used to obtain a new token for the given kite.
//
// It always returns a new token and forces a Kontrol to
// forget about any previous ones. | [
"GetTokenForce",
"is",
"used",
"to",
"obtain",
"a",
"new",
"token",
"for",
"the",
"given",
"kite",
".",
"It",
"always",
"returns",
"a",
"new",
"token",
"and",
"forces",
"a",
"Kontrol",
"to",
"forget",
"about",
"any",
"previous",
"ones",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrolclient.go#L224-L248 | train |
koding/kite | kontrolclient.go | GetKey | func (k *Kite) GetKey() (string, error) {
if err := k.SetupKontrolClient(); err != nil {
return "", err
}
<-k.kontrol.readyConnected
result, err := k.kontrol.TellWithTimeout("getKey", k.Config.Timeout)
if err != nil {
return "", err
}
var key string
err = result.Unmarshal(&key)
if err != nil {
return "", err
}
k.configMu.Lock()
k.Config.KontrolKey = key
k.configMu.Unlock()
return key, nil
} | go | func (k *Kite) GetKey() (string, error) {
if err := k.SetupKontrolClient(); err != nil {
return "", err
}
<-k.kontrol.readyConnected
result, err := k.kontrol.TellWithTimeout("getKey", k.Config.Timeout)
if err != nil {
return "", err
}
var key string
err = result.Unmarshal(&key)
if err != nil {
return "", err
}
k.configMu.Lock()
k.Config.KontrolKey = key
k.configMu.Unlock()
return key, nil
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"GetKey",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"k",
".",
"SetupKontrolClient",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"<-",
"k",
".",
"kontrol",
".",
"readyConnected",
"\n\n",
"result",
",",
"err",
":=",
"k",
".",
"kontrol",
".",
"TellWithTimeout",
"(",
"\"",
"\"",
",",
"k",
".",
"Config",
".",
"Timeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"key",
"string",
"\n",
"err",
"=",
"result",
".",
"Unmarshal",
"(",
"&",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"k",
".",
"configMu",
".",
"Lock",
"(",
")",
"\n",
"k",
".",
"Config",
".",
"KontrolKey",
"=",
"key",
"\n",
"k",
".",
"configMu",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"key",
",",
"nil",
"\n",
"}"
] | // GetKey is used to get a new public key from kontrol if the current one is
// invalidated. The key is also replaced in memory and every request is going
// to use it. This means even if kite.key contains the old key, the kite itself
// uses the new one. | [
"GetKey",
"is",
"used",
"to",
"get",
"a",
"new",
"public",
"key",
"from",
"kontrol",
"if",
"the",
"current",
"one",
"is",
"invalidated",
".",
"The",
"key",
"is",
"also",
"replaced",
"in",
"memory",
"and",
"every",
"request",
"is",
"going",
"to",
"use",
"it",
".",
"This",
"means",
"even",
"if",
"kite",
".",
"key",
"contains",
"the",
"old",
"key",
"the",
"kite",
"itself",
"uses",
"the",
"new",
"one",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrolclient.go#L254-L277 | train |
koding/kite | kontrolclient.go | NewKeyRenewer | func (k *Kite) NewKeyRenewer(interval time.Duration) {
ticker := time.NewTicker(interval)
for range ticker.C {
_, err := k.GetKey()
if err != nil {
k.Log.Warning("Key renew failed: %s", err)
}
}
} | go | func (k *Kite) NewKeyRenewer(interval time.Duration) {
ticker := time.NewTicker(interval)
for range ticker.C {
_, err := k.GetKey()
if err != nil {
k.Log.Warning("Key renew failed: %s", err)
}
}
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"NewKeyRenewer",
"(",
"interval",
"time",
".",
"Duration",
")",
"{",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"interval",
")",
"\n",
"for",
"range",
"ticker",
".",
"C",
"{",
"_",
",",
"err",
":=",
"k",
".",
"GetKey",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"k",
".",
"Log",
".",
"Warning",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // NewKeyRenewer renews the internal key every given interval | [
"NewKeyRenewer",
"renews",
"the",
"internal",
"key",
"every",
"given",
"interval"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrolclient.go#L280-L288 | train |
koding/kite | kontrolclient.go | signalReady | func (k *Kite) signalReady() {
k.kontrol.onceRegistered.Do(func() { close(k.kontrol.readyRegistered) })
} | go | func (k *Kite) signalReady() {
k.kontrol.onceRegistered.Do(func() { close(k.kontrol.readyRegistered) })
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"signalReady",
"(",
")",
"{",
"k",
".",
"kontrol",
".",
"onceRegistered",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"close",
"(",
"k",
".",
"kontrol",
".",
"readyRegistered",
")",
"}",
")",
"\n",
"}"
] | // signalReady is an internal method to notify that a successful registration
// is done. | [
"signalReady",
"is",
"an",
"internal",
"method",
"to",
"notify",
"that",
"a",
"successful",
"registration",
"is",
"done",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrolclient.go#L298-L300 | train |
koding/kite | kontrolclient.go | RegisterToTunnel | func (k *Kite) RegisterToTunnel() {
query := &protocol.KontrolQuery{
Username: k.Config.KontrolUser,
Environment: k.Config.Environment,
Name: "tunnelproxy",
}
k.RegisterToProxy(nil, query)
} | go | func (k *Kite) RegisterToTunnel() {
query := &protocol.KontrolQuery{
Username: k.Config.KontrolUser,
Environment: k.Config.Environment,
Name: "tunnelproxy",
}
k.RegisterToProxy(nil, query)
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"RegisterToTunnel",
"(",
")",
"{",
"query",
":=",
"&",
"protocol",
".",
"KontrolQuery",
"{",
"Username",
":",
"k",
".",
"Config",
".",
"KontrolUser",
",",
"Environment",
":",
"k",
".",
"Config",
".",
"Environment",
",",
"Name",
":",
"\"",
"\"",
",",
"}",
"\n\n",
"k",
".",
"RegisterToProxy",
"(",
"nil",
",",
"query",
")",
"\n",
"}"
] | // RegisterToTunnel finds a tunnel proxy kite by asking kontrol then registers
// itself on proxy. On error, retries forever. On every successful
// registration, it sends the proxied URL to the registerChan channel. There is
// no register URL needed because the Tunnel Proxy automatically gets the IP
// from tunneling. This is a blocking function. | [
"RegisterToTunnel",
"finds",
"a",
"tunnel",
"proxy",
"kite",
"by",
"asking",
"kontrol",
"then",
"registers",
"itself",
"on",
"proxy",
".",
"On",
"error",
"retries",
"forever",
".",
"On",
"every",
"successful",
"registration",
"it",
"sends",
"the",
"proxied",
"URL",
"to",
"the",
"registerChan",
"channel",
".",
"There",
"is",
"no",
"register",
"URL",
"needed",
"because",
"the",
"Tunnel",
"Proxy",
"automatically",
"gets",
"the",
"IP",
"from",
"tunneling",
".",
"This",
"is",
"a",
"blocking",
"function",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrolclient.go#L398-L406 | train |
koding/kite | kontrolclient.go | RegisterToProxy | func (k *Kite) RegisterToProxy(registerURL *url.URL, query *protocol.KontrolQuery) {
go k.RegisterForever(nil)
for {
var proxyKite *Client
// The proxy kite to connect can be overridden with the
// environmental variable "KITE_PROXY_URL". If it is not set
// we will ask Kontrol for available Proxy kites.
// As an authentication informain kiteKey method will be used,
// so be careful when using this feature.
kiteProxyURL := os.Getenv("KITE_PROXY_URL")
if kiteProxyURL != "" {
proxyKite = k.NewClient(kiteProxyURL)
proxyKite.Auth = &Auth{
Type: "kiteKey",
Key: k.KiteKey(),
}
} else {
kites, err := k.GetKites(query)
if err != nil {
k.Log.Error("Cannot get Proxy kites from Kontrol: %s", err.Error())
time.Sleep(proxyRetryDuration)
continue
}
// If more than one one Proxy Kite is available pick one randomly.
// It does not matter which one we connect.
proxyKite = kites[rand.Int()%len(kites)]
}
// Notify us on disconnect
disconnect := make(chan bool, 1)
proxyKite.OnDisconnect(func() {
select {
case disconnect <- true:
default:
}
})
proxyURL, err := k.registerToProxyKite(proxyKite, registerURL)
if err != nil {
time.Sleep(proxyRetryDuration)
continue
}
k.kontrol.registerChan <- proxyURL
// Block until disconnect from Proxy Kite.
<-disconnect
}
} | go | func (k *Kite) RegisterToProxy(registerURL *url.URL, query *protocol.KontrolQuery) {
go k.RegisterForever(nil)
for {
var proxyKite *Client
// The proxy kite to connect can be overridden with the
// environmental variable "KITE_PROXY_URL". If it is not set
// we will ask Kontrol for available Proxy kites.
// As an authentication informain kiteKey method will be used,
// so be careful when using this feature.
kiteProxyURL := os.Getenv("KITE_PROXY_URL")
if kiteProxyURL != "" {
proxyKite = k.NewClient(kiteProxyURL)
proxyKite.Auth = &Auth{
Type: "kiteKey",
Key: k.KiteKey(),
}
} else {
kites, err := k.GetKites(query)
if err != nil {
k.Log.Error("Cannot get Proxy kites from Kontrol: %s", err.Error())
time.Sleep(proxyRetryDuration)
continue
}
// If more than one one Proxy Kite is available pick one randomly.
// It does not matter which one we connect.
proxyKite = kites[rand.Int()%len(kites)]
}
// Notify us on disconnect
disconnect := make(chan bool, 1)
proxyKite.OnDisconnect(func() {
select {
case disconnect <- true:
default:
}
})
proxyURL, err := k.registerToProxyKite(proxyKite, registerURL)
if err != nil {
time.Sleep(proxyRetryDuration)
continue
}
k.kontrol.registerChan <- proxyURL
// Block until disconnect from Proxy Kite.
<-disconnect
}
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"RegisterToProxy",
"(",
"registerURL",
"*",
"url",
".",
"URL",
",",
"query",
"*",
"protocol",
".",
"KontrolQuery",
")",
"{",
"go",
"k",
".",
"RegisterForever",
"(",
"nil",
")",
"\n\n",
"for",
"{",
"var",
"proxyKite",
"*",
"Client",
"\n\n",
"// The proxy kite to connect can be overridden with the",
"// environmental variable \"KITE_PROXY_URL\". If it is not set",
"// we will ask Kontrol for available Proxy kites.",
"// As an authentication informain kiteKey method will be used,",
"// so be careful when using this feature.",
"kiteProxyURL",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"kiteProxyURL",
"!=",
"\"",
"\"",
"{",
"proxyKite",
"=",
"k",
".",
"NewClient",
"(",
"kiteProxyURL",
")",
"\n",
"proxyKite",
".",
"Auth",
"=",
"&",
"Auth",
"{",
"Type",
":",
"\"",
"\"",
",",
"Key",
":",
"k",
".",
"KiteKey",
"(",
")",
",",
"}",
"\n",
"}",
"else",
"{",
"kites",
",",
"err",
":=",
"k",
".",
"GetKites",
"(",
"query",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"k",
".",
"Log",
".",
"Error",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"time",
".",
"Sleep",
"(",
"proxyRetryDuration",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"// If more than one one Proxy Kite is available pick one randomly.",
"// It does not matter which one we connect.",
"proxyKite",
"=",
"kites",
"[",
"rand",
".",
"Int",
"(",
")",
"%",
"len",
"(",
"kites",
")",
"]",
"\n",
"}",
"\n\n",
"// Notify us on disconnect",
"disconnect",
":=",
"make",
"(",
"chan",
"bool",
",",
"1",
")",
"\n",
"proxyKite",
".",
"OnDisconnect",
"(",
"func",
"(",
")",
"{",
"select",
"{",
"case",
"disconnect",
"<-",
"true",
":",
"default",
":",
"}",
"\n",
"}",
")",
"\n\n",
"proxyURL",
",",
"err",
":=",
"k",
".",
"registerToProxyKite",
"(",
"proxyKite",
",",
"registerURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"time",
".",
"Sleep",
"(",
"proxyRetryDuration",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"k",
".",
"kontrol",
".",
"registerChan",
"<-",
"proxyURL",
"\n\n",
"// Block until disconnect from Proxy Kite.",
"<-",
"disconnect",
"\n",
"}",
"\n",
"}"
] | // RegisterToProxy is just like RegisterForever but registers the given URL
// to kontrol over a kite-proxy. A Kiteproxy is a reverseproxy that can be used
// for SSL termination or handling hundreds of kites behind a single. This is a
// blocking function. | [
"RegisterToProxy",
"is",
"just",
"like",
"RegisterForever",
"but",
"registers",
"the",
"given",
"URL",
"to",
"kontrol",
"over",
"a",
"kite",
"-",
"proxy",
".",
"A",
"Kiteproxy",
"is",
"a",
"reverseproxy",
"that",
"can",
"be",
"used",
"for",
"SSL",
"termination",
"or",
"handling",
"hundreds",
"of",
"kites",
"behind",
"a",
"single",
".",
"This",
"is",
"a",
"blocking",
"function",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrolclient.go#L412-L463 | train |
koding/kite | kontrolclient.go | registerToProxyKite | func (k *Kite) registerToProxyKite(c *Client, kiteURL *url.URL) (*url.URL, error) {
err := c.Dial()
if err != nil {
k.Log.Error("Cannot connect to Proxy kite: %s", err.Error())
return nil, err
}
// Disconnect from Proxy Kite if error happens while registering.
defer func() {
if err != nil {
c.Close()
}
}()
// do not panic if we call Tell method below
if kiteURL == nil {
kiteURL = &url.URL{}
}
// this could be tunnelproxy or reverseproxy. Tunnelproxy doesn't need an
// URL however Reverseproxy needs one.
result, err := c.TellWithTimeout("register", k.Config.Timeout, kiteURL.String())
if err != nil {
k.Log.Error("Proxy register error: %s", err.Error())
return nil, err
}
proxyURL, err := result.String()
if err != nil {
k.Log.Error("Proxy register result error: %s", err.Error())
return nil, err
}
parsed, err := url.Parse(proxyURL)
if err != nil {
k.Log.Error("Cannot parse Proxy URL: %s", err.Error())
return nil, err
}
return parsed, nil
} | go | func (k *Kite) registerToProxyKite(c *Client, kiteURL *url.URL) (*url.URL, error) {
err := c.Dial()
if err != nil {
k.Log.Error("Cannot connect to Proxy kite: %s", err.Error())
return nil, err
}
// Disconnect from Proxy Kite if error happens while registering.
defer func() {
if err != nil {
c.Close()
}
}()
// do not panic if we call Tell method below
if kiteURL == nil {
kiteURL = &url.URL{}
}
// this could be tunnelproxy or reverseproxy. Tunnelproxy doesn't need an
// URL however Reverseproxy needs one.
result, err := c.TellWithTimeout("register", k.Config.Timeout, kiteURL.String())
if err != nil {
k.Log.Error("Proxy register error: %s", err.Error())
return nil, err
}
proxyURL, err := result.String()
if err != nil {
k.Log.Error("Proxy register result error: %s", err.Error())
return nil, err
}
parsed, err := url.Parse(proxyURL)
if err != nil {
k.Log.Error("Cannot parse Proxy URL: %s", err.Error())
return nil, err
}
return parsed, nil
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"registerToProxyKite",
"(",
"c",
"*",
"Client",
",",
"kiteURL",
"*",
"url",
".",
"URL",
")",
"(",
"*",
"url",
".",
"URL",
",",
"error",
")",
"{",
"err",
":=",
"c",
".",
"Dial",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"k",
".",
"Log",
".",
"Error",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Disconnect from Proxy Kite if error happens while registering.",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"// do not panic if we call Tell method below",
"if",
"kiteURL",
"==",
"nil",
"{",
"kiteURL",
"=",
"&",
"url",
".",
"URL",
"{",
"}",
"\n",
"}",
"\n\n",
"// this could be tunnelproxy or reverseproxy. Tunnelproxy doesn't need an",
"// URL however Reverseproxy needs one.",
"result",
",",
"err",
":=",
"c",
".",
"TellWithTimeout",
"(",
"\"",
"\"",
",",
"k",
".",
"Config",
".",
"Timeout",
",",
"kiteURL",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"k",
".",
"Log",
".",
"Error",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"proxyURL",
",",
"err",
":=",
"result",
".",
"String",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"k",
".",
"Log",
".",
"Error",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"parsed",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"proxyURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"k",
".",
"Log",
".",
"Error",
"(",
"\"",
"\"",
",",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"parsed",
",",
"nil",
"\n",
"}"
] | // registerToProxyKite dials the proxy kite and calls register method then
// returns the reverse-proxy URL. | [
"registerToProxyKite",
"dials",
"the",
"proxy",
"kite",
"and",
"calls",
"register",
"method",
"then",
"returns",
"the",
"reverse",
"-",
"proxy",
"URL",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrolclient.go#L467-L507 | train |
koding/kite | kontrolclient.go | TellKontrolWithTimeout | func (k *Kite) TellKontrolWithTimeout(method string, timeout time.Duration, args ...interface{}) (result *dnode.Partial, err error) {
if err := k.SetupKontrolClient(); err != nil {
return nil, err
}
// Wait for readyConnect, or timeout
select {
case <-time.After(k.Config.Timeout):
return nil, &Error{
Type: "timeout",
Message: fmt.Sprintf(
"Timed out registering to kontrol for %s method after %s",
method, k.Config.Timeout,
),
}
case <-k.kontrol.readyConnected:
}
return k.kontrol.TellWithTimeout(method, timeout, args...)
} | go | func (k *Kite) TellKontrolWithTimeout(method string, timeout time.Duration, args ...interface{}) (result *dnode.Partial, err error) {
if err := k.SetupKontrolClient(); err != nil {
return nil, err
}
// Wait for readyConnect, or timeout
select {
case <-time.After(k.Config.Timeout):
return nil, &Error{
Type: "timeout",
Message: fmt.Sprintf(
"Timed out registering to kontrol for %s method after %s",
method, k.Config.Timeout,
),
}
case <-k.kontrol.readyConnected:
}
return k.kontrol.TellWithTimeout(method, timeout, args...)
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"TellKontrolWithTimeout",
"(",
"method",
"string",
",",
"timeout",
"time",
".",
"Duration",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"(",
"result",
"*",
"dnode",
".",
"Partial",
",",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"k",
".",
"SetupKontrolClient",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Wait for readyConnect, or timeout",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"k",
".",
"Config",
".",
"Timeout",
")",
":",
"return",
"nil",
",",
"&",
"Error",
"{",
"Type",
":",
"\"",
"\"",
",",
"Message",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"method",
",",
"k",
".",
"Config",
".",
"Timeout",
",",
")",
",",
"}",
"\n",
"case",
"<-",
"k",
".",
"kontrol",
".",
"readyConnected",
":",
"}",
"\n\n",
"return",
"k",
".",
"kontrol",
".",
"TellWithTimeout",
"(",
"method",
",",
"timeout",
",",
"args",
"...",
")",
"\n",
"}"
] | // TellKontrolWithTimeout is a lower level function for communicating directly with
// kontrol. Like GetKites and GetToken, this automatically sets up and connects to
// kontrol as needed. | [
"TellKontrolWithTimeout",
"is",
"a",
"lower",
"level",
"function",
"for",
"communicating",
"directly",
"with",
"kontrol",
".",
"Like",
"GetKites",
"and",
"GetToken",
"this",
"automatically",
"sets",
"up",
"and",
"connects",
"to",
"kontrol",
"as",
"needed",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrolclient.go#L512-L531 | train |
koding/kite | kontrol/idlock.go | Get | func (i *IdLock) Get(id string) sync.Locker {
i.locksMu.Lock()
defer i.locksMu.Unlock()
var l sync.Locker
var ok bool
l, ok = i.locks[id]
if !ok {
l = &sync.Mutex{}
i.locks[id] = l
}
return l
} | go | func (i *IdLock) Get(id string) sync.Locker {
i.locksMu.Lock()
defer i.locksMu.Unlock()
var l sync.Locker
var ok bool
l, ok = i.locks[id]
if !ok {
l = &sync.Mutex{}
i.locks[id] = l
}
return l
} | [
"func",
"(",
"i",
"*",
"IdLock",
")",
"Get",
"(",
"id",
"string",
")",
"sync",
".",
"Locker",
"{",
"i",
".",
"locksMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"i",
".",
"locksMu",
".",
"Unlock",
"(",
")",
"\n\n",
"var",
"l",
"sync",
".",
"Locker",
"\n",
"var",
"ok",
"bool",
"\n\n",
"l",
",",
"ok",
"=",
"i",
".",
"locks",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"l",
"=",
"&",
"sync",
".",
"Mutex",
"{",
"}",
"\n",
"i",
".",
"locks",
"[",
"id",
"]",
"=",
"l",
"\n",
"}",
"\n\n",
"return",
"l",
"\n",
"}"
] | // Get returns a lock that is bound to a specific id. | [
"Get",
"returns",
"a",
"lock",
"that",
"is",
"bound",
"to",
"a",
"specific",
"id",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/idlock.go#L19-L33 | train |
koding/kite | kitectl/command/list.go | BinPath | func (k *InstalledKite) BinPath() string {
return filepath.Join(k.Domain, k.User, k.Repo, k.Version, "bin", strings.TrimSuffix(k.Repo, ".kite"))
} | go | func (k *InstalledKite) BinPath() string {
return filepath.Join(k.Domain, k.User, k.Repo, k.Version, "bin", strings.TrimSuffix(k.Repo, ".kite"))
} | [
"func",
"(",
"k",
"*",
"InstalledKite",
")",
"BinPath",
"(",
")",
"string",
"{",
"return",
"filepath",
".",
"Join",
"(",
"k",
".",
"Domain",
",",
"k",
".",
"User",
",",
"k",
".",
"Repo",
",",
"k",
".",
"Version",
",",
"\"",
"\"",
",",
"strings",
".",
"TrimSuffix",
"(",
"k",
".",
"Repo",
",",
"\"",
"\"",
")",
")",
"\n",
"}"
] | // BinPath returns the path of the executable binary file. | [
"BinPath",
"returns",
"the",
"path",
"of",
"the",
"executable",
"binary",
"file",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitectl/command/list.go#L134-L136 | train |
koding/kite | sockjsclient/sockjsclient.go | Error | func (err *ErrSession) Error() string {
if err.Err == nil {
return fmt.Sprintf("%s (%s)", stateTexts[err.State], err.Type)
}
return fmt.Sprintf("%s: %s (%s)", stateTexts[err.State], err.Err, err.Type)
} | go | func (err *ErrSession) Error() string {
if err.Err == nil {
return fmt.Sprintf("%s (%s)", stateTexts[err.State], err.Type)
}
return fmt.Sprintf("%s: %s (%s)", stateTexts[err.State], err.Err, err.Type)
} | [
"func",
"(",
"err",
"*",
"ErrSession",
")",
"Error",
"(",
")",
"string",
"{",
"if",
"err",
".",
"Err",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"stateTexts",
"[",
"err",
".",
"State",
"]",
",",
"err",
".",
"Type",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"stateTexts",
"[",
"err",
".",
"State",
"]",
",",
"err",
".",
"Err",
",",
"err",
".",
"Type",
")",
"\n",
"}"
] | // Error implements the buildin error interface. | [
"Error",
"implements",
"the",
"buildin",
"error",
"interface",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/sockjsclient/sockjsclient.go#L51-L56 | train |
koding/kite | sockjsclient/sockjsclient.go | IsSessionClosed | func IsSessionClosed(err error) bool {
switch err {
case ErrSessionClosed, sockjs.ErrSessionNotOpen, websocket.ErrCloseSent:
return true
}
if e, ok := err.(*ErrSession); ok && e.State > sockjs.SessionActive {
return true
}
_, ok := err.(*websocket.CloseError)
return ok
} | go | func IsSessionClosed(err error) bool {
switch err {
case ErrSessionClosed, sockjs.ErrSessionNotOpen, websocket.ErrCloseSent:
return true
}
if e, ok := err.(*ErrSession); ok && e.State > sockjs.SessionActive {
return true
}
_, ok := err.(*websocket.CloseError)
return ok
} | [
"func",
"IsSessionClosed",
"(",
"err",
"error",
")",
"bool",
"{",
"switch",
"err",
"{",
"case",
"ErrSessionClosed",
",",
"sockjs",
".",
"ErrSessionNotOpen",
",",
"websocket",
".",
"ErrCloseSent",
":",
"return",
"true",
"\n",
"}",
"\n",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"ErrSession",
")",
";",
"ok",
"&&",
"e",
".",
"State",
">",
"sockjs",
".",
"SessionActive",
"{",
"return",
"true",
"\n",
"}",
"\n",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"websocket",
".",
"CloseError",
")",
"\n",
"return",
"ok",
"\n",
"}"
] | // IsSessionClosed tests whether given error is caused
// by a closed session. | [
"IsSessionClosed",
"tests",
"whether",
"given",
"error",
"is",
"caused",
"by",
"a",
"closed",
"session",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/sockjsclient/sockjsclient.go#L60-L70 | train |
koding/kite | sockjsclient/sockjsclient.go | DialWebsocket | func DialWebsocket(uri string, cfg *config.Config) (*WebsocketSession, error) {
u, err := url.Parse(uri)
if err != nil {
return nil, err
}
h := http.Header{
"Origin": {u.Scheme + "://" + u.Host},
}
serverID := threeDigits()
sessionID := utils.RandomString(20)
u = makeWebsocketURL(u, serverID, sessionID)
conn, _, err := cfg.Websocket.Dial(u.String(), h)
if err != nil {
return nil, err
}
session := NewWebsocketSession(conn)
session.id = sessionID
session.req = &http.Request{
URL: u,
Header: h,
}
return session, nil
} | go | func DialWebsocket(uri string, cfg *config.Config) (*WebsocketSession, error) {
u, err := url.Parse(uri)
if err != nil {
return nil, err
}
h := http.Header{
"Origin": {u.Scheme + "://" + u.Host},
}
serverID := threeDigits()
sessionID := utils.RandomString(20)
u = makeWebsocketURL(u, serverID, sessionID)
conn, _, err := cfg.Websocket.Dial(u.String(), h)
if err != nil {
return nil, err
}
session := NewWebsocketSession(conn)
session.id = sessionID
session.req = &http.Request{
URL: u,
Header: h,
}
return session, nil
} | [
"func",
"DialWebsocket",
"(",
"uri",
"string",
",",
"cfg",
"*",
"config",
".",
"Config",
")",
"(",
"*",
"WebsocketSession",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"uri",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"h",
":=",
"http",
".",
"Header",
"{",
"\"",
"\"",
":",
"{",
"u",
".",
"Scheme",
"+",
"\"",
"\"",
"+",
"u",
".",
"Host",
"}",
",",
"}",
"\n\n",
"serverID",
":=",
"threeDigits",
"(",
")",
"\n",
"sessionID",
":=",
"utils",
".",
"RandomString",
"(",
"20",
")",
"\n\n",
"u",
"=",
"makeWebsocketURL",
"(",
"u",
",",
"serverID",
",",
"sessionID",
")",
"\n\n",
"conn",
",",
"_",
",",
"err",
":=",
"cfg",
".",
"Websocket",
".",
"Dial",
"(",
"u",
".",
"String",
"(",
")",
",",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"session",
":=",
"NewWebsocketSession",
"(",
"conn",
")",
"\n",
"session",
".",
"id",
"=",
"sessionID",
"\n",
"session",
".",
"req",
"=",
"&",
"http",
".",
"Request",
"{",
"URL",
":",
"u",
",",
"Header",
":",
"h",
",",
"}",
"\n\n",
"return",
"session",
",",
"nil",
"\n",
"}"
] | // DialWebsocket establishes a SockJS session over a websocket connection.
//
// Requires cfg.Websocket to be a valid client. | [
"DialWebsocket",
"establishes",
"a",
"SockJS",
"session",
"over",
"a",
"websocket",
"connection",
".",
"Requires",
"cfg",
".",
"Websocket",
"to",
"be",
"a",
"valid",
"client",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/sockjsclient/sockjsclient.go#L136-L164 | train |
koding/kite | sockjsclient/sockjsclient.go | Recv | func (w *WebsocketSession) Recv() (string, error) {
// Return previously received messages if there is any.
if len(w.messages) > 0 {
msg := w.messages[0]
w.messages = w.messages[1:]
return msg, nil
}
read_frame:
if atomic.LoadInt32(&w.closed) == 1 {
return "", ErrSessionClosed
}
// Read one SockJS frame.
_, buf, err := w.conn.ReadMessage()
if err != nil {
return "", err
}
if len(buf) == 0 {
return "", errors.New("unexpected empty message")
}
frameType := buf[0]
data := buf[1:]
switch frameType {
case 'o':
w.setState(sockjs.SessionActive)
goto read_frame
case 'a':
var messages []string
err = json.Unmarshal(data, &messages)
if err != nil {
return "", err
}
w.messages = append(w.messages, messages...)
case 'm':
var message string
err = json.Unmarshal(data, &message)
if err != nil {
return "", err
}
w.messages = append(w.messages, message)
case 'c':
w.setState(sockjs.SessionClosed)
return "", ErrSessionClosed
case 'h':
// TODO handle heartbeat
goto read_frame
default:
return "", errors.New("invalid frame type")
}
// Return first message in slice.
if len(w.messages) == 0 {
return "", errors.New("no message")
}
msg := w.messages[0]
w.messages = w.messages[1:]
return msg, nil
} | go | func (w *WebsocketSession) Recv() (string, error) {
// Return previously received messages if there is any.
if len(w.messages) > 0 {
msg := w.messages[0]
w.messages = w.messages[1:]
return msg, nil
}
read_frame:
if atomic.LoadInt32(&w.closed) == 1 {
return "", ErrSessionClosed
}
// Read one SockJS frame.
_, buf, err := w.conn.ReadMessage()
if err != nil {
return "", err
}
if len(buf) == 0 {
return "", errors.New("unexpected empty message")
}
frameType := buf[0]
data := buf[1:]
switch frameType {
case 'o':
w.setState(sockjs.SessionActive)
goto read_frame
case 'a':
var messages []string
err = json.Unmarshal(data, &messages)
if err != nil {
return "", err
}
w.messages = append(w.messages, messages...)
case 'm':
var message string
err = json.Unmarshal(data, &message)
if err != nil {
return "", err
}
w.messages = append(w.messages, message)
case 'c':
w.setState(sockjs.SessionClosed)
return "", ErrSessionClosed
case 'h':
// TODO handle heartbeat
goto read_frame
default:
return "", errors.New("invalid frame type")
}
// Return first message in slice.
if len(w.messages) == 0 {
return "", errors.New("no message")
}
msg := w.messages[0]
w.messages = w.messages[1:]
return msg, nil
} | [
"func",
"(",
"w",
"*",
"WebsocketSession",
")",
"Recv",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"// Return previously received messages if there is any.",
"if",
"len",
"(",
"w",
".",
"messages",
")",
">",
"0",
"{",
"msg",
":=",
"w",
".",
"messages",
"[",
"0",
"]",
"\n",
"w",
".",
"messages",
"=",
"w",
".",
"messages",
"[",
"1",
":",
"]",
"\n",
"return",
"msg",
",",
"nil",
"\n",
"}",
"\n\n",
"read_frame",
":",
"if",
"atomic",
".",
"LoadInt32",
"(",
"&",
"w",
".",
"closed",
")",
"==",
"1",
"{",
"return",
"\"",
"\"",
",",
"ErrSessionClosed",
"\n",
"}",
"\n\n",
"// Read one SockJS frame.",
"_",
",",
"buf",
",",
"err",
":=",
"w",
".",
"conn",
".",
"ReadMessage",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"buf",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"frameType",
":=",
"buf",
"[",
"0",
"]",
"\n",
"data",
":=",
"buf",
"[",
"1",
":",
"]",
"\n\n",
"switch",
"frameType",
"{",
"case",
"'o'",
":",
"w",
".",
"setState",
"(",
"sockjs",
".",
"SessionActive",
")",
"\n",
"goto",
"read_frame",
"\n",
"case",
"'a'",
":",
"var",
"messages",
"[",
"]",
"string",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"messages",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"w",
".",
"messages",
"=",
"append",
"(",
"w",
".",
"messages",
",",
"messages",
"...",
")",
"\n",
"case",
"'m'",
":",
"var",
"message",
"string",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"message",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"w",
".",
"messages",
"=",
"append",
"(",
"w",
".",
"messages",
",",
"message",
")",
"\n",
"case",
"'c'",
":",
"w",
".",
"setState",
"(",
"sockjs",
".",
"SessionClosed",
")",
"\n",
"return",
"\"",
"\"",
",",
"ErrSessionClosed",
"\n",
"case",
"'h'",
":",
"// TODO handle heartbeat",
"goto",
"read_frame",
"\n",
"default",
":",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Return first message in slice.",
"if",
"len",
"(",
"w",
".",
"messages",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"msg",
":=",
"w",
".",
"messages",
"[",
"0",
"]",
"\n",
"w",
".",
"messages",
"=",
"w",
".",
"messages",
"[",
"1",
":",
"]",
"\n",
"return",
"msg",
",",
"nil",
"\n",
"}"
] | // Recv reads one text frame from session. | [
"Recv",
"reads",
"one",
"text",
"frame",
"from",
"session",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/sockjsclient/sockjsclient.go#L198-L259 | train |
koding/kite | sockjsclient/sockjsclient.go | Send | func (w *WebsocketSession) Send(str string) error {
if atomic.LoadInt32(&w.closed) == 1 {
return ErrSessionClosed
}
w.mu.Lock()
defer w.mu.Unlock()
b, _ := json.Marshal([]string{str})
return w.conn.WriteMessage(websocket.TextMessage, b)
} | go | func (w *WebsocketSession) Send(str string) error {
if atomic.LoadInt32(&w.closed) == 1 {
return ErrSessionClosed
}
w.mu.Lock()
defer w.mu.Unlock()
b, _ := json.Marshal([]string{str})
return w.conn.WriteMessage(websocket.TextMessage, b)
} | [
"func",
"(",
"w",
"*",
"WebsocketSession",
")",
"Send",
"(",
"str",
"string",
")",
"error",
"{",
"if",
"atomic",
".",
"LoadInt32",
"(",
"&",
"w",
".",
"closed",
")",
"==",
"1",
"{",
"return",
"ErrSessionClosed",
"\n",
"}",
"\n\n",
"w",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"w",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"b",
",",
"_",
":=",
"json",
".",
"Marshal",
"(",
"[",
"]",
"string",
"{",
"str",
"}",
")",
"\n",
"return",
"w",
".",
"conn",
".",
"WriteMessage",
"(",
"websocket",
".",
"TextMessage",
",",
"b",
")",
"\n",
"}"
] | // Send sends one text frame to session | [
"Send",
"sends",
"one",
"text",
"frame",
"to",
"session"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/sockjsclient/sockjsclient.go#L262-L272 | train |
koding/kite | sockjsclient/sockjsclient.go | Close | func (w *WebsocketSession) Close(uint32, string) error {
if atomic.CompareAndSwapInt32(&w.closed, 0, 1) {
return w.conn.Close()
}
return ErrSessionClosed
} | go | func (w *WebsocketSession) Close(uint32, string) error {
if atomic.CompareAndSwapInt32(&w.closed, 0, 1) {
return w.conn.Close()
}
return ErrSessionClosed
} | [
"func",
"(",
"w",
"*",
"WebsocketSession",
")",
"Close",
"(",
"uint32",
",",
"string",
")",
"error",
"{",
"if",
"atomic",
".",
"CompareAndSwapInt32",
"(",
"&",
"w",
".",
"closed",
",",
"0",
",",
"1",
")",
"{",
"return",
"w",
".",
"conn",
".",
"Close",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"ErrSessionClosed",
"\n",
"}"
] | // Close closes the session with provided code and reason. | [
"Close",
"closes",
"the",
"session",
"with",
"provided",
"code",
"and",
"reason",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/sockjsclient/sockjsclient.go#L275-L281 | train |
koding/kite | kitectl/command/uninstall.go | isInstalled | func isInstalled(fullKiteName string) (bool, error) {
bundlePath, err := getBundlePath(fullKiteName)
if err != nil {
return false, err
}
return exists(bundlePath)
} | go | func isInstalled(fullKiteName string) (bool, error) {
bundlePath, err := getBundlePath(fullKiteName)
if err != nil {
return false, err
}
return exists(bundlePath)
} | [
"func",
"isInstalled",
"(",
"fullKiteName",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"bundlePath",
",",
"err",
":=",
"getBundlePath",
"(",
"fullKiteName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"return",
"exists",
"(",
"bundlePath",
")",
"\n",
"}"
] | // isInstalled returns true if the kite is installed. | [
"isInstalled",
"returns",
"true",
"if",
"the",
"kite",
"is",
"installed",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitectl/command/uninstall.go#L83-L89 | train |
koding/kite | kontrol/keypair.go | NewCachedStorage | func NewCachedStorage(backend KeyPairStorage, cache KeyPairStorage) *CachedStorage {
return &CachedStorage{
cache: cache,
backend: backend,
}
} | go | func NewCachedStorage(backend KeyPairStorage, cache KeyPairStorage) *CachedStorage {
return &CachedStorage{
cache: cache,
backend: backend,
}
} | [
"func",
"NewCachedStorage",
"(",
"backend",
"KeyPairStorage",
",",
"cache",
"KeyPairStorage",
")",
"*",
"CachedStorage",
"{",
"return",
"&",
"CachedStorage",
"{",
"cache",
":",
"cache",
",",
"backend",
":",
"backend",
",",
"}",
"\n",
"}"
] | // NewCachedStorage creates a new CachedStorage | [
"NewCachedStorage",
"creates",
"a",
"new",
"CachedStorage"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/keypair.go#L150-L155 | train |
koding/kite | kontrol/kites.go | Attach | func (k Kites) Attach(token string) {
for _, kite := range k {
kite.Token = token
}
} | go | func (k Kites) Attach(token string) {
for _, kite := range k {
kite.Token = token
}
} | [
"func",
"(",
"k",
"Kites",
")",
"Attach",
"(",
"token",
"string",
")",
"{",
"for",
"_",
",",
"kite",
":=",
"range",
"k",
"{",
"kite",
".",
"Token",
"=",
"token",
"\n",
"}",
"\n",
"}"
] | // Attach attaches the given token to each kite. It replaces any previous
// token. | [
"Attach",
"attaches",
"the",
"given",
"token",
"to",
"each",
"kite",
".",
"It",
"replaces",
"any",
"previous",
"token",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/kites.go#L16-L20 | train |
koding/kite | kontrol/kites.go | Shuffle | func (k *Kites) Shuffle() {
shuffled := make(Kites, len(*k))
for i, v := range rand.Perm(len(*k)) {
shuffled[v] = (*k)[i]
}
*k = shuffled
} | go | func (k *Kites) Shuffle() {
shuffled := make(Kites, len(*k))
for i, v := range rand.Perm(len(*k)) {
shuffled[v] = (*k)[i]
}
*k = shuffled
} | [
"func",
"(",
"k",
"*",
"Kites",
")",
"Shuffle",
"(",
")",
"{",
"shuffled",
":=",
"make",
"(",
"Kites",
",",
"len",
"(",
"*",
"k",
")",
")",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"rand",
".",
"Perm",
"(",
"len",
"(",
"*",
"k",
")",
")",
"{",
"shuffled",
"[",
"v",
"]",
"=",
"(",
"*",
"k",
")",
"[",
"i",
"]",
"\n",
"}",
"\n\n",
"*",
"k",
"=",
"shuffled",
"\n",
"}"
] | // Shuffle shuffles the order of the kites. This is useful if you want send
// back a randomized list of kites. | [
"Shuffle",
"shuffles",
"the",
"order",
"of",
"the",
"kites",
".",
"This",
"is",
"useful",
"if",
"you",
"want",
"send",
"back",
"a",
"randomized",
"list",
"of",
"kites",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/kites.go#L24-L31 | train |
koding/kite | kontrol/kites.go | Filter | func (k *Kites) Filter(constraint version.Constraints, keyRest string) {
filtered := make(Kites, 0)
for _, kite := range *k {
if isValid(&kite.Kite, constraint, keyRest) {
filtered = append(filtered, kite)
}
}
*k = filtered
} | go | func (k *Kites) Filter(constraint version.Constraints, keyRest string) {
filtered := make(Kites, 0)
for _, kite := range *k {
if isValid(&kite.Kite, constraint, keyRest) {
filtered = append(filtered, kite)
}
}
*k = filtered
} | [
"func",
"(",
"k",
"*",
"Kites",
")",
"Filter",
"(",
"constraint",
"version",
".",
"Constraints",
",",
"keyRest",
"string",
")",
"{",
"filtered",
":=",
"make",
"(",
"Kites",
",",
"0",
")",
"\n",
"for",
"_",
",",
"kite",
":=",
"range",
"*",
"k",
"{",
"if",
"isValid",
"(",
"&",
"kite",
".",
"Kite",
",",
"constraint",
",",
"keyRest",
")",
"{",
"filtered",
"=",
"append",
"(",
"filtered",
",",
"kite",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"*",
"k",
"=",
"filtered",
"\n",
"}"
] | // Filter filters out kites with the given constraints | [
"Filter",
"filters",
"out",
"kites",
"with",
"the",
"given",
"constraints"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/kites.go#L34-L43 | train |
koding/kite | client.go | DialForever | func (c *Client) DialForever() (connected chan bool, err error) {
c.Reconnect = true
connected = make(chan bool, 1) // This will be closed on first connection.
go c.dialForever(connected)
return
} | go | func (c *Client) DialForever() (connected chan bool, err error) {
c.Reconnect = true
connected = make(chan bool, 1) // This will be closed on first connection.
go c.dialForever(connected)
return
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DialForever",
"(",
")",
"(",
"connected",
"chan",
"bool",
",",
"err",
"error",
")",
"{",
"c",
".",
"Reconnect",
"=",
"true",
"\n",
"connected",
"=",
"make",
"(",
"chan",
"bool",
",",
"1",
")",
"// This will be closed on first connection.",
"\n",
"go",
"c",
".",
"dialForever",
"(",
"connected",
")",
"\n",
"return",
"\n",
"}"
] | // Dial connects to the remote Kite. If it can't connect, it retries
// indefinitely. It returns a channel to check if it's connected or not. | [
"Dial",
"connects",
"to",
"the",
"remote",
"Kite",
".",
"If",
"it",
"can",
"t",
"connect",
"it",
"retries",
"indefinitely",
".",
"It",
"returns",
"a",
"channel",
"to",
"check",
"if",
"it",
"s",
"connected",
"or",
"not",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L256-L261 | train |
koding/kite | client.go | run | func (c *Client) run() {
err := c.readLoop()
if err != nil {
c.LocalKite.Log.Debug("readloop err: %s", err)
}
// falls here when connection disconnects
c.callOnDisconnectHandlers()
// let others know that the client has disconnected
c.disconnectMu.Lock()
if c.disconnect != nil {
close(c.disconnect)
c.disconnect = nil
}
c.disconnectMu.Unlock()
if c.reconnect() {
// we override it so it doesn't get selected next time. Because we are
// redialing, so after redial if a new method is called, the disconnect
// channel is being read and the local "disconnect" message will be the
// final response. This shouldn't be happen for redials.
c.disconnectMu.Lock()
c.disconnect = make(chan struct{}, 1)
c.disconnectMu.Unlock()
go c.dialForever(nil)
}
} | go | func (c *Client) run() {
err := c.readLoop()
if err != nil {
c.LocalKite.Log.Debug("readloop err: %s", err)
}
// falls here when connection disconnects
c.callOnDisconnectHandlers()
// let others know that the client has disconnected
c.disconnectMu.Lock()
if c.disconnect != nil {
close(c.disconnect)
c.disconnect = nil
}
c.disconnectMu.Unlock()
if c.reconnect() {
// we override it so it doesn't get selected next time. Because we are
// redialing, so after redial if a new method is called, the disconnect
// channel is being read and the local "disconnect" message will be the
// final response. This shouldn't be happen for redials.
c.disconnectMu.Lock()
c.disconnect = make(chan struct{}, 1)
c.disconnectMu.Unlock()
go c.dialForever(nil)
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"run",
"(",
")",
"{",
"err",
":=",
"c",
".",
"readLoop",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"LocalKite",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// falls here when connection disconnects",
"c",
".",
"callOnDisconnectHandlers",
"(",
")",
"\n\n",
"// let others know that the client has disconnected",
"c",
".",
"disconnectMu",
".",
"Lock",
"(",
")",
"\n",
"if",
"c",
".",
"disconnect",
"!=",
"nil",
"{",
"close",
"(",
"c",
".",
"disconnect",
")",
"\n",
"c",
".",
"disconnect",
"=",
"nil",
"\n",
"}",
"\n",
"c",
".",
"disconnectMu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"c",
".",
"reconnect",
"(",
")",
"{",
"// we override it so it doesn't get selected next time. Because we are",
"// redialing, so after redial if a new method is called, the disconnect",
"// channel is being read and the local \"disconnect\" message will be the",
"// final response. This shouldn't be happen for redials.",
"c",
".",
"disconnectMu",
".",
"Lock",
"(",
")",
"\n",
"c",
".",
"disconnect",
"=",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"1",
")",
"\n",
"c",
".",
"disconnectMu",
".",
"Unlock",
"(",
")",
"\n",
"go",
"c",
".",
"dialForever",
"(",
"nil",
")",
"\n",
"}",
"\n",
"}"
] | // run consumes incoming dnode messages. Reconnects if necessary. | [
"run",
"consumes",
"incoming",
"dnode",
"messages",
".",
"Reconnects",
"if",
"necessary",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L388-L415 | train |
koding/kite | client.go | readLoop | func (c *Client) readLoop() error {
for {
p, err := c.receiveData()
c.LocalKite.Log.Debug("readloop received: %s %v", p, err)
if err != nil {
return err
}
msg, fn, err := c.processMessage(p)
if err != nil {
if _, ok := err.(dnode.CallbackNotFoundError); !ok {
c.LocalKite.Log.Warning("error processing message err: %s message: %s", err, msg)
}
}
switch v := fn.(type) {
case *Method: // invoke method
if c.Concurrent {
go c.runMethod(v, msg.Arguments)
} else {
c.runMethod(v, msg.Arguments)
}
case func(*dnode.Partial): // invoke callback
if c.Concurrent && c.ConcurrentCallbacks {
go c.runCallback(v, msg.Arguments)
} else {
c.runCallback(v, msg.Arguments)
}
}
}
} | go | func (c *Client) readLoop() error {
for {
p, err := c.receiveData()
c.LocalKite.Log.Debug("readloop received: %s %v", p, err)
if err != nil {
return err
}
msg, fn, err := c.processMessage(p)
if err != nil {
if _, ok := err.(dnode.CallbackNotFoundError); !ok {
c.LocalKite.Log.Warning("error processing message err: %s message: %s", err, msg)
}
}
switch v := fn.(type) {
case *Method: // invoke method
if c.Concurrent {
go c.runMethod(v, msg.Arguments)
} else {
c.runMethod(v, msg.Arguments)
}
case func(*dnode.Partial): // invoke callback
if c.Concurrent && c.ConcurrentCallbacks {
go c.runCallback(v, msg.Arguments)
} else {
c.runCallback(v, msg.Arguments)
}
}
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"readLoop",
"(",
")",
"error",
"{",
"for",
"{",
"p",
",",
"err",
":=",
"c",
".",
"receiveData",
"(",
")",
"\n\n",
"c",
".",
"LocalKite",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"p",
",",
"err",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"msg",
",",
"fn",
",",
"err",
":=",
"c",
".",
"processMessage",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"dnode",
".",
"CallbackNotFoundError",
")",
";",
"!",
"ok",
"{",
"c",
".",
"LocalKite",
".",
"Log",
".",
"Warning",
"(",
"\"",
"\"",
",",
"err",
",",
"msg",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"switch",
"v",
":=",
"fn",
".",
"(",
"type",
")",
"{",
"case",
"*",
"Method",
":",
"// invoke method",
"if",
"c",
".",
"Concurrent",
"{",
"go",
"c",
".",
"runMethod",
"(",
"v",
",",
"msg",
".",
"Arguments",
")",
"\n",
"}",
"else",
"{",
"c",
".",
"runMethod",
"(",
"v",
",",
"msg",
".",
"Arguments",
")",
"\n",
"}",
"\n",
"case",
"func",
"(",
"*",
"dnode",
".",
"Partial",
")",
":",
"// invoke callback",
"if",
"c",
".",
"Concurrent",
"&&",
"c",
".",
"ConcurrentCallbacks",
"{",
"go",
"c",
".",
"runCallback",
"(",
"v",
",",
"msg",
".",
"Arguments",
")",
"\n",
"}",
"else",
"{",
"c",
".",
"runCallback",
"(",
"v",
",",
"msg",
".",
"Arguments",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // readLoop reads a message from websocket and processes it. | [
"readLoop",
"reads",
"a",
"message",
"from",
"websocket",
"and",
"processes",
"it",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L425-L457 | train |
koding/kite | client.go | receiveData | func (c *Client) receiveData() ([]byte, error) {
type recv struct {
msg []byte
err error
}
session := c.getSession()
if session == nil {
return nil, errors.New("not connected")
}
done := make(chan recv, 1)
go func() {
msg, err := session.Recv()
done <- recv{[]byte(msg), err}
}()
select {
case r := <-done:
return r.msg, r.err
case err := <-c.interrupt:
return nil, err
}
} | go | func (c *Client) receiveData() ([]byte, error) {
type recv struct {
msg []byte
err error
}
session := c.getSession()
if session == nil {
return nil, errors.New("not connected")
}
done := make(chan recv, 1)
go func() {
msg, err := session.Recv()
done <- recv{[]byte(msg), err}
}()
select {
case r := <-done:
return r.msg, r.err
case err := <-c.interrupt:
return nil, err
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"receiveData",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"type",
"recv",
"struct",
"{",
"msg",
"[",
"]",
"byte",
"\n",
"err",
"error",
"\n",
"}",
"\n\n",
"session",
":=",
"c",
".",
"getSession",
"(",
")",
"\n",
"if",
"session",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"done",
":=",
"make",
"(",
"chan",
"recv",
",",
"1",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"msg",
",",
"err",
":=",
"session",
".",
"Recv",
"(",
")",
"\n",
"done",
"<-",
"recv",
"{",
"[",
"]",
"byte",
"(",
"msg",
")",
",",
"err",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"select",
"{",
"case",
"r",
":=",
"<-",
"done",
":",
"return",
"r",
".",
"msg",
",",
"r",
".",
"err",
"\n",
"case",
"err",
":=",
"<-",
"c",
".",
"interrupt",
":",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}"
] | // receiveData reads a message from session. | [
"receiveData",
"reads",
"a",
"message",
"from",
"session",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L460-L484 | train |
koding/kite | client.go | processMessage | func (c *Client) processMessage(data []byte) (msg *dnode.Message, fn interface{}, err error) {
// Call error handler.
defer func() {
if err != nil {
onError(err)
}
}()
msg = &dnode.Message{}
if err = json.Unmarshal(data, &msg); err != nil {
return nil, nil, err
}
sender := func(id uint64, args []interface{}) error {
// do not name the error variable to "err" here, it's a trap for
// shadowing variables
_, _, e := c.marshalAndSend(id, args)
return e
}
// Replace function placeholders with real functions.
if err := dnode.ParseCallbacks(msg, sender); err != nil {
return nil, nil, err
}
// Find the handler function. Method may be string or integer.
switch method := msg.Method.(type) {
case float64:
id := uint64(method)
callback := c.scrubber.GetCallback(id)
if callback == nil {
err = dnode.CallbackNotFoundError{
ID: id,
Args: msg.Arguments,
}
return nil, nil, err
}
return msg, callback, nil
case string:
m, ok := c.LocalKite.handlers[method]
if !ok {
err = dnode.MethodNotFoundError{
Method: method,
Args: msg.Arguments,
}
return nil, nil, err
}
return msg, m, nil
default:
return nil, nil, fmt.Errorf("Method is not string or integer: %+v (%T)", msg.Method, msg.Method)
}
} | go | func (c *Client) processMessage(data []byte) (msg *dnode.Message, fn interface{}, err error) {
// Call error handler.
defer func() {
if err != nil {
onError(err)
}
}()
msg = &dnode.Message{}
if err = json.Unmarshal(data, &msg); err != nil {
return nil, nil, err
}
sender := func(id uint64, args []interface{}) error {
// do not name the error variable to "err" here, it's a trap for
// shadowing variables
_, _, e := c.marshalAndSend(id, args)
return e
}
// Replace function placeholders with real functions.
if err := dnode.ParseCallbacks(msg, sender); err != nil {
return nil, nil, err
}
// Find the handler function. Method may be string or integer.
switch method := msg.Method.(type) {
case float64:
id := uint64(method)
callback := c.scrubber.GetCallback(id)
if callback == nil {
err = dnode.CallbackNotFoundError{
ID: id,
Args: msg.Arguments,
}
return nil, nil, err
}
return msg, callback, nil
case string:
m, ok := c.LocalKite.handlers[method]
if !ok {
err = dnode.MethodNotFoundError{
Method: method,
Args: msg.Arguments,
}
return nil, nil, err
}
return msg, m, nil
default:
return nil, nil, fmt.Errorf("Method is not string or integer: %+v (%T)", msg.Method, msg.Method)
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processMessage",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"msg",
"*",
"dnode",
".",
"Message",
",",
"fn",
"interface",
"{",
"}",
",",
"err",
"error",
")",
"{",
"// Call error handler.",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"onError",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"msg",
"=",
"&",
"dnode",
".",
"Message",
"{",
"}",
"\n\n",
"if",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"msg",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"sender",
":=",
"func",
"(",
"id",
"uint64",
",",
"args",
"[",
"]",
"interface",
"{",
"}",
")",
"error",
"{",
"// do not name the error variable to \"err\" here, it's a trap for",
"// shadowing variables",
"_",
",",
"_",
",",
"e",
":=",
"c",
".",
"marshalAndSend",
"(",
"id",
",",
"args",
")",
"\n",
"return",
"e",
"\n",
"}",
"\n\n",
"// Replace function placeholders with real functions.",
"if",
"err",
":=",
"dnode",
".",
"ParseCallbacks",
"(",
"msg",
",",
"sender",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Find the handler function. Method may be string or integer.",
"switch",
"method",
":=",
"msg",
".",
"Method",
".",
"(",
"type",
")",
"{",
"case",
"float64",
":",
"id",
":=",
"uint64",
"(",
"method",
")",
"\n",
"callback",
":=",
"c",
".",
"scrubber",
".",
"GetCallback",
"(",
"id",
")",
"\n",
"if",
"callback",
"==",
"nil",
"{",
"err",
"=",
"dnode",
".",
"CallbackNotFoundError",
"{",
"ID",
":",
"id",
",",
"Args",
":",
"msg",
".",
"Arguments",
",",
"}",
"\n",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"msg",
",",
"callback",
",",
"nil",
"\n",
"case",
"string",
":",
"m",
",",
"ok",
":=",
"c",
".",
"LocalKite",
".",
"handlers",
"[",
"method",
"]",
"\n",
"if",
"!",
"ok",
"{",
"err",
"=",
"dnode",
".",
"MethodNotFoundError",
"{",
"Method",
":",
"method",
",",
"Args",
":",
"msg",
".",
"Arguments",
",",
"}",
"\n",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"msg",
",",
"m",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"msg",
".",
"Method",
",",
"msg",
".",
"Method",
")",
"\n",
"}",
"\n",
"}"
] | // processMessage processes a single message and calls a handler or callback. | [
"processMessage",
"processes",
"a",
"single",
"message",
"and",
"calls",
"a",
"handler",
"or",
"callback",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L487-L541 | train |
koding/kite | client.go | sendHub | func (c *Client) sendHub() {
defer c.wg.Done()
for {
select {
case msg := <-c.send:
c.LocalKite.Log.Debug("sending: %s", msg)
session := c.getSession()
if session == nil {
c.LocalKite.Log.Error("not connected")
continue
}
err := session.Send(string(msg.p))
if err != nil {
if msg.errC != nil {
msg.errC <- err
}
if sockjsclient.IsSessionClosed(err) {
// The readloop may already be interrupted, thus the non-blocking send.
select {
case c.interrupt <- err:
default:
}
c.LocalKite.Log.Error("error sending to %s: %s", session.ID(), err)
return
}
}
case <-c.closeChan:
c.LocalKite.Log.Debug("Send hub is closed")
return
}
}
} | go | func (c *Client) sendHub() {
defer c.wg.Done()
for {
select {
case msg := <-c.send:
c.LocalKite.Log.Debug("sending: %s", msg)
session := c.getSession()
if session == nil {
c.LocalKite.Log.Error("not connected")
continue
}
err := session.Send(string(msg.p))
if err != nil {
if msg.errC != nil {
msg.errC <- err
}
if sockjsclient.IsSessionClosed(err) {
// The readloop may already be interrupted, thus the non-blocking send.
select {
case c.interrupt <- err:
default:
}
c.LocalKite.Log.Error("error sending to %s: %s", session.ID(), err)
return
}
}
case <-c.closeChan:
c.LocalKite.Log.Debug("Send hub is closed")
return
}
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"sendHub",
"(",
")",
"{",
"defer",
"c",
".",
"wg",
".",
"Done",
"(",
")",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"msg",
":=",
"<-",
"c",
".",
"send",
":",
"c",
".",
"LocalKite",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"msg",
")",
"\n",
"session",
":=",
"c",
".",
"getSession",
"(",
")",
"\n",
"if",
"session",
"==",
"nil",
"{",
"c",
".",
"LocalKite",
".",
"Log",
".",
"Error",
"(",
"\"",
"\"",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"err",
":=",
"session",
".",
"Send",
"(",
"string",
"(",
"msg",
".",
"p",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"msg",
".",
"errC",
"!=",
"nil",
"{",
"msg",
".",
"errC",
"<-",
"err",
"\n",
"}",
"\n\n",
"if",
"sockjsclient",
".",
"IsSessionClosed",
"(",
"err",
")",
"{",
"// The readloop may already be interrupted, thus the non-blocking send.",
"select",
"{",
"case",
"c",
".",
"interrupt",
"<-",
"err",
":",
"default",
":",
"}",
"\n\n",
"c",
".",
"LocalKite",
".",
"Log",
".",
"Error",
"(",
"\"",
"\"",
",",
"session",
".",
"ID",
"(",
")",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"case",
"<-",
"c",
".",
"closeChan",
":",
"c",
".",
"LocalKite",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // sendhub sends the msg received from the send channel to the remote client | [
"sendhub",
"sends",
"the",
"msg",
"received",
"from",
"the",
"send",
"channel",
"to",
"the",
"remote",
"client"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L572-L607 | train |
koding/kite | client.go | OnConnect | func (c *Client) OnConnect(handler func()) {
c.m.Lock()
c.onConnectHandlers = append(c.onConnectHandlers, handler)
c.m.Unlock()
} | go | func (c *Client) OnConnect(handler func()) {
c.m.Lock()
c.onConnectHandlers = append(c.onConnectHandlers, handler)
c.m.Unlock()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"OnConnect",
"(",
"handler",
"func",
"(",
")",
")",
"{",
"c",
".",
"m",
".",
"Lock",
"(",
")",
"\n",
"c",
".",
"onConnectHandlers",
"=",
"append",
"(",
"c",
".",
"onConnectHandlers",
",",
"handler",
")",
"\n",
"c",
".",
"m",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // OnConnect adds a callback which is called when client connects
// to a remote kite. | [
"OnConnect",
"adds",
"a",
"callback",
"which",
"is",
"called",
"when",
"client",
"connects",
"to",
"a",
"remote",
"kite",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L611-L615 | train |
koding/kite | client.go | OnDisconnect | func (c *Client) OnDisconnect(handler func()) {
c.m.Lock()
c.onDisconnectHandlers = append(c.onDisconnectHandlers, handler)
c.m.Unlock()
} | go | func (c *Client) OnDisconnect(handler func()) {
c.m.Lock()
c.onDisconnectHandlers = append(c.onDisconnectHandlers, handler)
c.m.Unlock()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"OnDisconnect",
"(",
"handler",
"func",
"(",
")",
")",
"{",
"c",
".",
"m",
".",
"Lock",
"(",
")",
"\n",
"c",
".",
"onDisconnectHandlers",
"=",
"append",
"(",
"c",
".",
"onDisconnectHandlers",
",",
"handler",
")",
"\n",
"c",
".",
"m",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // OnDisconnect adds a callback which is called when client disconnects
// from a remote kite. | [
"OnDisconnect",
"adds",
"a",
"callback",
"which",
"is",
"called",
"when",
"client",
"disconnects",
"from",
"a",
"remote",
"kite",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L619-L623 | train |
koding/kite | client.go | OnTokenExpire | func (c *Client) OnTokenExpire(handler func()) {
c.m.Lock()
c.onTokenExpireHandlers = append(c.onTokenExpireHandlers, handler)
c.m.Unlock()
} | go | func (c *Client) OnTokenExpire(handler func()) {
c.m.Lock()
c.onTokenExpireHandlers = append(c.onTokenExpireHandlers, handler)
c.m.Unlock()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"OnTokenExpire",
"(",
"handler",
"func",
"(",
")",
")",
"{",
"c",
".",
"m",
".",
"Lock",
"(",
")",
"\n",
"c",
".",
"onTokenExpireHandlers",
"=",
"append",
"(",
"c",
".",
"onTokenExpireHandlers",
",",
"handler",
")",
"\n",
"c",
".",
"m",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // OnTokenExpire adds a callback which is called when client receives
// token-is-expired error from a remote kite. | [
"OnTokenExpire",
"adds",
"a",
"callback",
"which",
"is",
"called",
"when",
"client",
"receives",
"token",
"-",
"is",
"-",
"expired",
"error",
"from",
"a",
"remote",
"kite",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L627-L631 | train |
koding/kite | client.go | OnTokenRenew | func (c *Client) OnTokenRenew(handler func(token string)) {
c.m.Lock()
c.onTokenRenewHandlers = append(c.onTokenRenewHandlers, handler)
c.m.Unlock()
} | go | func (c *Client) OnTokenRenew(handler func(token string)) {
c.m.Lock()
c.onTokenRenewHandlers = append(c.onTokenRenewHandlers, handler)
c.m.Unlock()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"OnTokenRenew",
"(",
"handler",
"func",
"(",
"token",
"string",
")",
")",
"{",
"c",
".",
"m",
".",
"Lock",
"(",
")",
"\n",
"c",
".",
"onTokenRenewHandlers",
"=",
"append",
"(",
"c",
".",
"onTokenRenewHandlers",
",",
"handler",
")",
"\n",
"c",
".",
"m",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // OnTokenRenew adds a callback which is called when client successfully
// renews its token. | [
"OnTokenRenew",
"adds",
"a",
"callback",
"which",
"is",
"called",
"when",
"client",
"successfully",
"renews",
"its",
"token",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L635-L639 | train |
koding/kite | client.go | callOnConnectHandlers | func (c *Client) callOnConnectHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onConnectHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | go | func (c *Client) callOnConnectHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onConnectHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"callOnConnectHandlers",
"(",
")",
"{",
"c",
".",
"m",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"m",
".",
"RUnlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"handler",
":=",
"range",
"c",
".",
"onConnectHandlers",
"{",
"func",
"(",
")",
"{",
"defer",
"nopRecover",
"(",
")",
"\n",
"handler",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // callOnConnectHandlers runs the registered connect handlers. | [
"callOnConnectHandlers",
"runs",
"the",
"registered",
"connect",
"handlers",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L642-L652 | train |
koding/kite | client.go | callOnDisconnectHandlers | func (c *Client) callOnDisconnectHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onDisconnectHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | go | func (c *Client) callOnDisconnectHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onDisconnectHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"callOnDisconnectHandlers",
"(",
")",
"{",
"c",
".",
"m",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"m",
".",
"RUnlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"handler",
":=",
"range",
"c",
".",
"onDisconnectHandlers",
"{",
"func",
"(",
")",
"{",
"defer",
"nopRecover",
"(",
")",
"\n",
"handler",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // callOnDisconnectHandlers runs the registered disconnect handlers. | [
"callOnDisconnectHandlers",
"runs",
"the",
"registered",
"disconnect",
"handlers",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L655-L665 | train |
koding/kite | client.go | callOnTokenExpireHandlers | func (c *Client) callOnTokenExpireHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onTokenExpireHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | go | func (c *Client) callOnTokenExpireHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onTokenExpireHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"callOnTokenExpireHandlers",
"(",
")",
"{",
"c",
".",
"m",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"m",
".",
"RUnlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"handler",
":=",
"range",
"c",
".",
"onTokenExpireHandlers",
"{",
"func",
"(",
")",
"{",
"defer",
"nopRecover",
"(",
")",
"\n",
"handler",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // callOnTokenExpireHandlers calls registered functions when an error
// from remote kite is received that token used is expired. | [
"callOnTokenExpireHandlers",
"calls",
"registered",
"functions",
"when",
"an",
"error",
"from",
"remote",
"kite",
"is",
"received",
"that",
"token",
"used",
"is",
"expired",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L669-L679 | train |
koding/kite | client.go | callOnTokenRenewHandlers | func (c *Client) callOnTokenRenewHandlers(token string) {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onTokenRenewHandlers {
func() {
defer nopRecover()
handler(token)
}()
}
} | go | func (c *Client) callOnTokenRenewHandlers(token string) {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onTokenRenewHandlers {
func() {
defer nopRecover()
handler(token)
}()
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"callOnTokenRenewHandlers",
"(",
"token",
"string",
")",
"{",
"c",
".",
"m",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"m",
".",
"RUnlock",
"(",
")",
"\n\n",
"for",
"_",
",",
"handler",
":=",
"range",
"c",
".",
"onTokenRenewHandlers",
"{",
"func",
"(",
")",
"{",
"defer",
"nopRecover",
"(",
")",
"\n",
"handler",
"(",
"token",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // callOnTokenRenewHandlers calls all registered functions when
// we successfully obtain new token from kontrol. | [
"callOnTokenRenewHandlers",
"calls",
"all",
"registered",
"functions",
"when",
"we",
"successfully",
"obtain",
"new",
"token",
"from",
"kontrol",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L683-L693 | train |
koding/kite | client.go | Tell | func (c *Client) Tell(method string, args ...interface{}) (result *dnode.Partial, err error) {
return c.TellWithTimeout(method, 0, args...)
} | go | func (c *Client) Tell(method string, args ...interface{}) (result *dnode.Partial, err error) {
return c.TellWithTimeout(method, 0, args...)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Tell",
"(",
"method",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"(",
"result",
"*",
"dnode",
".",
"Partial",
",",
"err",
"error",
")",
"{",
"return",
"c",
".",
"TellWithTimeout",
"(",
"method",
",",
"0",
",",
"args",
"...",
")",
"\n",
"}"
] | // Tell makes a blocking method call to the server.
// Waits until the callback function is called by the other side and
// returns the result and the error. | [
"Tell",
"makes",
"a",
"blocking",
"method",
"call",
"to",
"the",
"server",
".",
"Waits",
"until",
"the",
"callback",
"function",
"is",
"called",
"by",
"the",
"other",
"side",
"and",
"returns",
"the",
"result",
"and",
"the",
"error",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L710-L712 | train |
koding/kite | client.go | Go | func (c *Client) Go(method string, args ...interface{}) chan *response {
return c.GoWithTimeout(method, 0, args...)
} | go | func (c *Client) Go(method string, args ...interface{}) chan *response {
return c.GoWithTimeout(method, 0, args...)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Go",
"(",
"method",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"chan",
"*",
"response",
"{",
"return",
"c",
".",
"GoWithTimeout",
"(",
"method",
",",
"0",
",",
"args",
"...",
")",
"\n",
"}"
] | // Go makes an unblocking method call to the server.
// It returns a channel that the caller can wait on it to get the response. | [
"Go",
"makes",
"an",
"unblocking",
"method",
"call",
"to",
"the",
"server",
".",
"It",
"returns",
"a",
"channel",
"that",
"the",
"caller",
"can",
"wait",
"on",
"it",
"to",
"get",
"the",
"response",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L734-L736 | train |
koding/kite | client.go | sendMethod | func (c *Client) sendMethod(method string, args []interface{}, timeout time.Duration, responseChan chan *response) {
// To clean the sent callback after response is received.
// Send/Receive in a channel to prevent race condition because
// the callback is run in a separate goroutine.
removeCallback := make(chan uint64, 1)
// When a callback is called it will send the response to this channel.
doneChan := make(chan *response, 1)
cb := c.makeResponseCallback(doneChan, removeCallback, method, args)
args = c.wrapMethodArgs(args, cb)
callbacks, errC, err := c.marshalAndSend(method, args)
if err != nil {
responseChan <- &response{
Result: nil,
Err: &Error{
Type: "sendError",
Message: err.Error(),
},
}
return
}
// nil value of afterTimeout means no timeout, it will not selected in
// select statement
var afterTimeout <-chan time.Time
if timeout > 0 {
afterTimeout = time.After(timeout)
}
// Waits until the response has came or the connection has disconnected.
go func() {
c.disconnectMu.Lock()
defer c.disconnectMu.Unlock()
select {
case resp := <-doneChan:
if e, ok := resp.Err.(*Error); ok {
if e.Type == "authenticationError" && strings.Contains(e.Message, "token is expired") {
c.callOnTokenExpireHandlers()
}
}
responseChan <- resp
case <-c.disconnect:
responseChan <- &response{
nil,
&Error{
Type: "disconnect",
Message: "Remote kite has disconnected",
},
}
case err := <-errC:
if err != nil {
responseChan <- &response{
nil,
&Error{
Type: "sendError",
Message: err.Error(),
},
}
}
case <-afterTimeout:
responseChan <- &response{
nil,
&Error{
Type: "timeout",
Message: fmt.Sprintf("No response to %q method in %s", method, timeout),
},
}
// Remove the callback function from the map so we do not
// consume memory for unused callbacks.
if id, ok := <-removeCallback; ok {
c.scrubber.RemoveCallback(id)
}
}
}()
sendCallbackID(callbacks, removeCallback)
} | go | func (c *Client) sendMethod(method string, args []interface{}, timeout time.Duration, responseChan chan *response) {
// To clean the sent callback after response is received.
// Send/Receive in a channel to prevent race condition because
// the callback is run in a separate goroutine.
removeCallback := make(chan uint64, 1)
// When a callback is called it will send the response to this channel.
doneChan := make(chan *response, 1)
cb := c.makeResponseCallback(doneChan, removeCallback, method, args)
args = c.wrapMethodArgs(args, cb)
callbacks, errC, err := c.marshalAndSend(method, args)
if err != nil {
responseChan <- &response{
Result: nil,
Err: &Error{
Type: "sendError",
Message: err.Error(),
},
}
return
}
// nil value of afterTimeout means no timeout, it will not selected in
// select statement
var afterTimeout <-chan time.Time
if timeout > 0 {
afterTimeout = time.After(timeout)
}
// Waits until the response has came or the connection has disconnected.
go func() {
c.disconnectMu.Lock()
defer c.disconnectMu.Unlock()
select {
case resp := <-doneChan:
if e, ok := resp.Err.(*Error); ok {
if e.Type == "authenticationError" && strings.Contains(e.Message, "token is expired") {
c.callOnTokenExpireHandlers()
}
}
responseChan <- resp
case <-c.disconnect:
responseChan <- &response{
nil,
&Error{
Type: "disconnect",
Message: "Remote kite has disconnected",
},
}
case err := <-errC:
if err != nil {
responseChan <- &response{
nil,
&Error{
Type: "sendError",
Message: err.Error(),
},
}
}
case <-afterTimeout:
responseChan <- &response{
nil,
&Error{
Type: "timeout",
Message: fmt.Sprintf("No response to %q method in %s", method, timeout),
},
}
// Remove the callback function from the map so we do not
// consume memory for unused callbacks.
if id, ok := <-removeCallback; ok {
c.scrubber.RemoveCallback(id)
}
}
}()
sendCallbackID(callbacks, removeCallback)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"sendMethod",
"(",
"method",
"string",
",",
"args",
"[",
"]",
"interface",
"{",
"}",
",",
"timeout",
"time",
".",
"Duration",
",",
"responseChan",
"chan",
"*",
"response",
")",
"{",
"// To clean the sent callback after response is received.",
"// Send/Receive in a channel to prevent race condition because",
"// the callback is run in a separate goroutine.",
"removeCallback",
":=",
"make",
"(",
"chan",
"uint64",
",",
"1",
")",
"\n\n",
"// When a callback is called it will send the response to this channel.",
"doneChan",
":=",
"make",
"(",
"chan",
"*",
"response",
",",
"1",
")",
"\n\n",
"cb",
":=",
"c",
".",
"makeResponseCallback",
"(",
"doneChan",
",",
"removeCallback",
",",
"method",
",",
"args",
")",
"\n",
"args",
"=",
"c",
".",
"wrapMethodArgs",
"(",
"args",
",",
"cb",
")",
"\n\n",
"callbacks",
",",
"errC",
",",
"err",
":=",
"c",
".",
"marshalAndSend",
"(",
"method",
",",
"args",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"responseChan",
"<-",
"&",
"response",
"{",
"Result",
":",
"nil",
",",
"Err",
":",
"&",
"Error",
"{",
"Type",
":",
"\"",
"\"",
",",
"Message",
":",
"err",
".",
"Error",
"(",
")",
",",
"}",
",",
"}",
"\n",
"return",
"\n",
"}",
"\n\n",
"// nil value of afterTimeout means no timeout, it will not selected in",
"// select statement",
"var",
"afterTimeout",
"<-",
"chan",
"time",
".",
"Time",
"\n",
"if",
"timeout",
">",
"0",
"{",
"afterTimeout",
"=",
"time",
".",
"After",
"(",
"timeout",
")",
"\n",
"}",
"\n\n",
"// Waits until the response has came or the connection has disconnected.",
"go",
"func",
"(",
")",
"{",
"c",
".",
"disconnectMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"disconnectMu",
".",
"Unlock",
"(",
")",
"\n\n",
"select",
"{",
"case",
"resp",
":=",
"<-",
"doneChan",
":",
"if",
"e",
",",
"ok",
":=",
"resp",
".",
"Err",
".",
"(",
"*",
"Error",
")",
";",
"ok",
"{",
"if",
"e",
".",
"Type",
"==",
"\"",
"\"",
"&&",
"strings",
".",
"Contains",
"(",
"e",
".",
"Message",
",",
"\"",
"\"",
")",
"{",
"c",
".",
"callOnTokenExpireHandlers",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"responseChan",
"<-",
"resp",
"\n",
"case",
"<-",
"c",
".",
"disconnect",
":",
"responseChan",
"<-",
"&",
"response",
"{",
"nil",
",",
"&",
"Error",
"{",
"Type",
":",
"\"",
"\"",
",",
"Message",
":",
"\"",
"\"",
",",
"}",
",",
"}",
"\n",
"case",
"err",
":=",
"<-",
"errC",
":",
"if",
"err",
"!=",
"nil",
"{",
"responseChan",
"<-",
"&",
"response",
"{",
"nil",
",",
"&",
"Error",
"{",
"Type",
":",
"\"",
"\"",
",",
"Message",
":",
"err",
".",
"Error",
"(",
")",
",",
"}",
",",
"}",
"\n",
"}",
"\n",
"case",
"<-",
"afterTimeout",
":",
"responseChan",
"<-",
"&",
"response",
"{",
"nil",
",",
"&",
"Error",
"{",
"Type",
":",
"\"",
"\"",
",",
"Message",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"method",
",",
"timeout",
")",
",",
"}",
",",
"}",
"\n\n",
"// Remove the callback function from the map so we do not",
"// consume memory for unused callbacks.",
"if",
"id",
",",
"ok",
":=",
"<-",
"removeCallback",
";",
"ok",
"{",
"c",
".",
"scrubber",
".",
"RemoveCallback",
"(",
"id",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"sendCallbackID",
"(",
"callbacks",
",",
"removeCallback",
")",
"\n",
"}"
] | // sendMethod wraps the arguments, adds a response callback,
// marshals the message and send it over the wire. | [
"sendMethod",
"wraps",
"the",
"arguments",
"adds",
"a",
"response",
"callback",
"marshals",
"the",
"message",
"and",
"send",
"it",
"over",
"the",
"wire",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L753-L834 | train |
koding/kite | client.go | marshalAndSend | func (c *Client) marshalAndSend(method interface{}, arguments []interface{}) (callbacks map[string]dnode.Path, errC <-chan error, err error) {
// scrub trough the arguments and save any callbacks.
callbacks = c.scrubber.Scrub(arguments)
defer func() {
if err != nil {
c.removeCallbacks(callbacks)
}
}()
// Do not encode empty arguments as "null", make it "[]".
if arguments == nil {
arguments = make([]interface{}, 0)
}
rawArgs, err := json.Marshal(arguments)
if err != nil {
return nil, nil, err
}
msg := dnode.Message{
Method: method,
Arguments: &dnode.Partial{Raw: rawArgs},
Callbacks: callbacks,
}
p, err := json.Marshal(msg)
if err != nil {
return nil, nil, err
}
select {
case <-c.closeChan:
return nil, nil, errors.New("can't send, client is closed")
default:
if c.getSession() == nil {
return nil, nil, errors.New("can't send, session is not established yet")
}
errC := make(chan error, 1)
c.send <- &message{
p: p,
errC: errC,
}
return callbacks, errC, nil
}
} | go | func (c *Client) marshalAndSend(method interface{}, arguments []interface{}) (callbacks map[string]dnode.Path, errC <-chan error, err error) {
// scrub trough the arguments and save any callbacks.
callbacks = c.scrubber.Scrub(arguments)
defer func() {
if err != nil {
c.removeCallbacks(callbacks)
}
}()
// Do not encode empty arguments as "null", make it "[]".
if arguments == nil {
arguments = make([]interface{}, 0)
}
rawArgs, err := json.Marshal(arguments)
if err != nil {
return nil, nil, err
}
msg := dnode.Message{
Method: method,
Arguments: &dnode.Partial{Raw: rawArgs},
Callbacks: callbacks,
}
p, err := json.Marshal(msg)
if err != nil {
return nil, nil, err
}
select {
case <-c.closeChan:
return nil, nil, errors.New("can't send, client is closed")
default:
if c.getSession() == nil {
return nil, nil, errors.New("can't send, session is not established yet")
}
errC := make(chan error, 1)
c.send <- &message{
p: p,
errC: errC,
}
return callbacks, errC, nil
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"marshalAndSend",
"(",
"method",
"interface",
"{",
"}",
",",
"arguments",
"[",
"]",
"interface",
"{",
"}",
")",
"(",
"callbacks",
"map",
"[",
"string",
"]",
"dnode",
".",
"Path",
",",
"errC",
"<-",
"chan",
"error",
",",
"err",
"error",
")",
"{",
"// scrub trough the arguments and save any callbacks.",
"callbacks",
"=",
"c",
".",
"scrubber",
".",
"Scrub",
"(",
"arguments",
")",
"\n\n",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"removeCallbacks",
"(",
"callbacks",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"// Do not encode empty arguments as \"null\", make it \"[]\".",
"if",
"arguments",
"==",
"nil",
"{",
"arguments",
"=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"0",
")",
"\n",
"}",
"\n\n",
"rawArgs",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"arguments",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"msg",
":=",
"dnode",
".",
"Message",
"{",
"Method",
":",
"method",
",",
"Arguments",
":",
"&",
"dnode",
".",
"Partial",
"{",
"Raw",
":",
"rawArgs",
"}",
",",
"Callbacks",
":",
"callbacks",
",",
"}",
"\n\n",
"p",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"msg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"select",
"{",
"case",
"<-",
"c",
".",
"closeChan",
":",
"return",
"nil",
",",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"default",
":",
"if",
"c",
".",
"getSession",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"errC",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n\n",
"c",
".",
"send",
"<-",
"&",
"message",
"{",
"p",
":",
"p",
",",
"errC",
":",
"errC",
",",
"}",
"\n\n",
"return",
"callbacks",
",",
"errC",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // marshalAndSend takes a method and arguments, scrubs the arguments to create
// a dnode message, marshals the message to JSON and sends it over the wire. | [
"marshalAndSend",
"takes",
"a",
"method",
"and",
"arguments",
"scrubs",
"the",
"arguments",
"to",
"create",
"a",
"dnode",
"message",
"marshals",
"the",
"message",
"to",
"JSON",
"and",
"sends",
"it",
"over",
"the",
"wire",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L838-L886 | train |
koding/kite | client.go | sendCallbackID | func sendCallbackID(callbacks map[string]dnode.Path, ch chan<- uint64) {
// TODO fix finding of responseCallback in dnode message when removing callback
for id, path := range callbacks {
if len(path) != 2 {
continue
}
p0, ok := path[0].(string)
if !ok {
continue
}
p1, ok := path[1].(string)
if !ok {
continue
}
if p0 != "0" || p1 != "responseCallback" {
continue
}
i, _ := strconv.ParseUint(id, 10, 64)
ch <- i
return
}
close(ch)
} | go | func sendCallbackID(callbacks map[string]dnode.Path, ch chan<- uint64) {
// TODO fix finding of responseCallback in dnode message when removing callback
for id, path := range callbacks {
if len(path) != 2 {
continue
}
p0, ok := path[0].(string)
if !ok {
continue
}
p1, ok := path[1].(string)
if !ok {
continue
}
if p0 != "0" || p1 != "responseCallback" {
continue
}
i, _ := strconv.ParseUint(id, 10, 64)
ch <- i
return
}
close(ch)
} | [
"func",
"sendCallbackID",
"(",
"callbacks",
"map",
"[",
"string",
"]",
"dnode",
".",
"Path",
",",
"ch",
"chan",
"<-",
"uint64",
")",
"{",
"// TODO fix finding of responseCallback in dnode message when removing callback",
"for",
"id",
",",
"path",
":=",
"range",
"callbacks",
"{",
"if",
"len",
"(",
"path",
")",
"!=",
"2",
"{",
"continue",
"\n",
"}",
"\n",
"p0",
",",
"ok",
":=",
"path",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"p1",
",",
"ok",
":=",
"path",
"[",
"1",
"]",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"p0",
"!=",
"\"",
"\"",
"||",
"p1",
"!=",
"\"",
"\"",
"{",
"continue",
"\n",
"}",
"\n",
"i",
",",
"_",
":=",
"strconv",
".",
"ParseUint",
"(",
"id",
",",
"10",
",",
"64",
")",
"\n",
"ch",
"<-",
"i",
"\n",
"return",
"\n",
"}",
"\n",
"close",
"(",
"ch",
")",
"\n",
"}"
] | // sendCallbackID send the callback number to be deleted after response is received. | [
"sendCallbackID",
"send",
"the",
"callback",
"number",
"to",
"be",
"deleted",
"after",
"response",
"is",
"received",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L922-L944 | train |
koding/kite | client.go | onError | func onError(err error) {
// TODO do not marshal options again here
switch e := err.(type) {
case dnode.MethodNotFoundError: // Tell the requester "method is not found".
args, err2 := e.Args.Slice()
if err2 != nil {
return
}
if len(args) < 1 {
return
}
var options callOptions
if err := args[0].Unmarshal(&options); err != nil {
return
}
if options.ResponseCallback.Caller != nil {
response := Response{
Result: nil,
Error: &Error{
Type: "methodNotFound",
Message: err.Error(),
},
}
options.ResponseCallback.Call(response)
}
}
} | go | func onError(err error) {
// TODO do not marshal options again here
switch e := err.(type) {
case dnode.MethodNotFoundError: // Tell the requester "method is not found".
args, err2 := e.Args.Slice()
if err2 != nil {
return
}
if len(args) < 1 {
return
}
var options callOptions
if err := args[0].Unmarshal(&options); err != nil {
return
}
if options.ResponseCallback.Caller != nil {
response := Response{
Result: nil,
Error: &Error{
Type: "methodNotFound",
Message: err.Error(),
},
}
options.ResponseCallback.Call(response)
}
}
} | [
"func",
"onError",
"(",
"err",
"error",
")",
"{",
"// TODO do not marshal options again here",
"switch",
"e",
":=",
"err",
".",
"(",
"type",
")",
"{",
"case",
"dnode",
".",
"MethodNotFoundError",
":",
"// Tell the requester \"method is not found\".",
"args",
",",
"err2",
":=",
"e",
".",
"Args",
".",
"Slice",
"(",
")",
"\n",
"if",
"err2",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"args",
")",
"<",
"1",
"{",
"return",
"\n",
"}",
"\n\n",
"var",
"options",
"callOptions",
"\n",
"if",
"err",
":=",
"args",
"[",
"0",
"]",
".",
"Unmarshal",
"(",
"&",
"options",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"options",
".",
"ResponseCallback",
".",
"Caller",
"!=",
"nil",
"{",
"response",
":=",
"Response",
"{",
"Result",
":",
"nil",
",",
"Error",
":",
"&",
"Error",
"{",
"Type",
":",
"\"",
"\"",
",",
"Message",
":",
"err",
".",
"Error",
"(",
")",
",",
"}",
",",
"}",
"\n",
"options",
".",
"ResponseCallback",
".",
"Call",
"(",
"response",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // onError is called when an error happened in a method handler. | [
"onError",
"is",
"called",
"when",
"an",
"error",
"happened",
"in",
"a",
"method",
"handler",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L1003-L1032 | train |
koding/kite | server.go | Run | func (k *Kite) Run() {
if os.Getenv("KITE_VERSION") != "" {
fmt.Println(k.Kite().Version)
os.Exit(0)
}
// An error string equivalent to net.errClosing for using with http.Serve()
// during a graceful exit. Needed to declare here again because it is not
// exported by "net" package.
const errClosing = "use of closed network connection"
err := k.listenAndServe()
if err != nil {
if strings.Contains(err.Error(), errClosing) {
// The server is closed by Close() method
k.Log.Info("Kite server is closed.")
return
}
k.Log.Fatal(err.Error())
}
} | go | func (k *Kite) Run() {
if os.Getenv("KITE_VERSION") != "" {
fmt.Println(k.Kite().Version)
os.Exit(0)
}
// An error string equivalent to net.errClosing for using with http.Serve()
// during a graceful exit. Needed to declare here again because it is not
// exported by "net" package.
const errClosing = "use of closed network connection"
err := k.listenAndServe()
if err != nil {
if strings.Contains(err.Error(), errClosing) {
// The server is closed by Close() method
k.Log.Info("Kite server is closed.")
return
}
k.Log.Fatal(err.Error())
}
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"Run",
"(",
")",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"fmt",
".",
"Println",
"(",
"k",
".",
"Kite",
"(",
")",
".",
"Version",
")",
"\n",
"os",
".",
"Exit",
"(",
"0",
")",
"\n",
"}",
"\n\n",
"// An error string equivalent to net.errClosing for using with http.Serve()",
"// during a graceful exit. Needed to declare here again because it is not",
"// exported by \"net\" package.",
"const",
"errClosing",
"=",
"\"",
"\"",
"\n\n",
"err",
":=",
"k",
".",
"listenAndServe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"strings",
".",
"Contains",
"(",
"err",
".",
"Error",
"(",
")",
",",
"errClosing",
")",
"{",
"// The server is closed by Close() method",
"k",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"k",
".",
"Log",
".",
"Fatal",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] | // Run is a blocking method. It runs the kite server and then accepts requests
// asynchronously. It supports graceful restart via SIGUSR2. | [
"Run",
"is",
"a",
"blocking",
"method",
".",
"It",
"runs",
"the",
"kite",
"server",
"and",
"then",
"accepts",
"requests",
"asynchronously",
".",
"It",
"supports",
"graceful",
"restart",
"via",
"SIGUSR2",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/server.go#L18-L38 | train |
koding/kite | server.go | Close | func (k *Kite) Close() {
k.Log.Info("Closing kite...")
k.kontrol.Lock()
if k.kontrol != nil && k.kontrol.Client != nil {
k.kontrol.Close()
}
k.kontrol.Unlock()
if k.listener != nil {
k.listener.Close()
k.listener = nil
}
k.mu.Lock()
cache := k.verifyCache
k.mu.Unlock()
if cache != nil {
cache.StopGC()
}
} | go | func (k *Kite) Close() {
k.Log.Info("Closing kite...")
k.kontrol.Lock()
if k.kontrol != nil && k.kontrol.Client != nil {
k.kontrol.Close()
}
k.kontrol.Unlock()
if k.listener != nil {
k.listener.Close()
k.listener = nil
}
k.mu.Lock()
cache := k.verifyCache
k.mu.Unlock()
if cache != nil {
cache.StopGC()
}
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"Close",
"(",
")",
"{",
"k",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"k",
".",
"kontrol",
".",
"Lock",
"(",
")",
"\n",
"if",
"k",
".",
"kontrol",
"!=",
"nil",
"&&",
"k",
".",
"kontrol",
".",
"Client",
"!=",
"nil",
"{",
"k",
".",
"kontrol",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"k",
".",
"kontrol",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"k",
".",
"listener",
"!=",
"nil",
"{",
"k",
".",
"listener",
".",
"Close",
"(",
")",
"\n",
"k",
".",
"listener",
"=",
"nil",
"\n",
"}",
"\n\n",
"k",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"cache",
":=",
"k",
".",
"verifyCache",
"\n",
"k",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"cache",
"!=",
"nil",
"{",
"cache",
".",
"StopGC",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Close stops the server and the kontrol client instance. | [
"Close",
"stops",
"the",
"server",
"and",
"the",
"kontrol",
"client",
"instance",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/server.go#L41-L62 | train |
koding/kite | server.go | listenAndServe | func (k *Kite) listenAndServe() error {
// create a new one if there doesn't exist
l, err := net.Listen("tcp4", k.Addr())
if err != nil {
return err
}
k.Log.Info("New listening: %s", l.Addr())
if k.TLSConfig != nil {
if k.TLSConfig.NextProtos == nil {
k.TLSConfig.NextProtos = []string{"http/1.1"}
}
l = tls.NewListener(l, k.TLSConfig)
}
k.listener = newGracefulListener(l)
// listener is ready, notify waiters.
close(k.readyC)
defer close(k.closeC) // serving is finished, notify waiters.
k.Log.Info("Serving...")
return k.serve(k.listener, k)
} | go | func (k *Kite) listenAndServe() error {
// create a new one if there doesn't exist
l, err := net.Listen("tcp4", k.Addr())
if err != nil {
return err
}
k.Log.Info("New listening: %s", l.Addr())
if k.TLSConfig != nil {
if k.TLSConfig.NextProtos == nil {
k.TLSConfig.NextProtos = []string{"http/1.1"}
}
l = tls.NewListener(l, k.TLSConfig)
}
k.listener = newGracefulListener(l)
// listener is ready, notify waiters.
close(k.readyC)
defer close(k.closeC) // serving is finished, notify waiters.
k.Log.Info("Serving...")
return k.serve(k.listener, k)
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"listenAndServe",
"(",
")",
"error",
"{",
"// create a new one if there doesn't exist",
"l",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"k",
".",
"Addr",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"k",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
",",
"l",
".",
"Addr",
"(",
")",
")",
"\n\n",
"if",
"k",
".",
"TLSConfig",
"!=",
"nil",
"{",
"if",
"k",
".",
"TLSConfig",
".",
"NextProtos",
"==",
"nil",
"{",
"k",
".",
"TLSConfig",
".",
"NextProtos",
"=",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
"\n",
"}",
"\n",
"l",
"=",
"tls",
".",
"NewListener",
"(",
"l",
",",
"k",
".",
"TLSConfig",
")",
"\n",
"}",
"\n\n",
"k",
".",
"listener",
"=",
"newGracefulListener",
"(",
"l",
")",
"\n\n",
"// listener is ready, notify waiters.",
"close",
"(",
"k",
".",
"readyC",
")",
"\n\n",
"defer",
"close",
"(",
"k",
".",
"closeC",
")",
"// serving is finished, notify waiters.",
"\n",
"k",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"return",
"k",
".",
"serve",
"(",
"k",
".",
"listener",
",",
"k",
")",
"\n",
"}"
] | // listenAndServe listens on the TCP network address k.URL.Host and then
// calls Serve to handle requests on incoming connectionk. | [
"listenAndServe",
"listens",
"on",
"the",
"TCP",
"network",
"address",
"k",
".",
"URL",
".",
"Host",
"and",
"then",
"calls",
"Serve",
"to",
"handle",
"requests",
"on",
"incoming",
"connectionk",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/server.go#L70-L95 | train |
koding/kite | kontrol/onceevery/onceevery.go | Do | func (o *OnceEvery) Do(f func()) {
if f == nil {
panic("passed function is nil")
}
o.mu.Lock()
now := time.Now()
ok := o.last.Add(o.Interval).Before(now)
if ok {
o.last = now
}
o.mu.Unlock()
if ok {
f()
}
} | go | func (o *OnceEvery) Do(f func()) {
if f == nil {
panic("passed function is nil")
}
o.mu.Lock()
now := time.Now()
ok := o.last.Add(o.Interval).Before(now)
if ok {
o.last = now
}
o.mu.Unlock()
if ok {
f()
}
} | [
"func",
"(",
"o",
"*",
"OnceEvery",
")",
"Do",
"(",
"f",
"func",
"(",
")",
")",
"{",
"if",
"f",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"o",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"now",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"ok",
":=",
"o",
".",
"last",
".",
"Add",
"(",
"o",
".",
"Interval",
")",
".",
"Before",
"(",
"now",
")",
"\n",
"if",
"ok",
"{",
"o",
".",
"last",
"=",
"now",
"\n",
"}",
"\n",
"o",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"ok",
"{",
"f",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Do calls the function f if and only if Do hits the given periodic interval.
// In other words Do can be called multiple times during the interval but it
// gets called only once if it hits the interval tick. So if the interval is
// 10 seconds, and a total of 100 calls are made during this period, f will
// be called it every 10 seconds. | [
"Do",
"calls",
"the",
"function",
"f",
"if",
"and",
"only",
"if",
"Do",
"hits",
"the",
"given",
"periodic",
"interval",
".",
"In",
"other",
"words",
"Do",
"can",
"be",
"called",
"multiple",
"times",
"during",
"the",
"interval",
"but",
"it",
"gets",
"called",
"only",
"once",
"if",
"it",
"hits",
"the",
"interval",
"tick",
".",
"So",
"if",
"the",
"interval",
"is",
"10",
"seconds",
"and",
"a",
"total",
"of",
"100",
"calls",
"are",
"made",
"during",
"this",
"period",
"f",
"will",
"be",
"called",
"it",
"every",
"10",
"seconds",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/onceevery/onceevery.go#L28-L44 | train |
koding/kite | systeminfo/systeminfo_darwin.go | sysctlbyname | func sysctlbyname(name string, data interface{}) (err error) {
val, err := syscall.Sysctl(name)
if err != nil {
return err
}
buf := []byte(val)
switch v := data.(type) {
case *uint64:
*v = *(*uint64)(unsafe.Pointer(&buf[0]))
return
}
bbuf := bytes.NewBuffer([]byte(val))
return binary.Read(bbuf, binary.LittleEndian, data)
} | go | func sysctlbyname(name string, data interface{}) (err error) {
val, err := syscall.Sysctl(name)
if err != nil {
return err
}
buf := []byte(val)
switch v := data.(type) {
case *uint64:
*v = *(*uint64)(unsafe.Pointer(&buf[0]))
return
}
bbuf := bytes.NewBuffer([]byte(val))
return binary.Read(bbuf, binary.LittleEndian, data)
} | [
"func",
"sysctlbyname",
"(",
"name",
"string",
",",
"data",
"interface",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"val",
",",
"err",
":=",
"syscall",
".",
"Sysctl",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"buf",
":=",
"[",
"]",
"byte",
"(",
"val",
")",
"\n\n",
"switch",
"v",
":=",
"data",
".",
"(",
"type",
")",
"{",
"case",
"*",
"uint64",
":",
"*",
"v",
"=",
"*",
"(",
"*",
"uint64",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"buf",
"[",
"0",
"]",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"bbuf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"[",
"]",
"byte",
"(",
"val",
")",
")",
"\n",
"return",
"binary",
".",
"Read",
"(",
"bbuf",
",",
"binary",
".",
"LittleEndian",
",",
"data",
")",
"\n",
"}"
] | // generic Sysctl buffer unmarshalling | [
"generic",
"Sysctl",
"buffer",
"unmarshalling"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/systeminfo/systeminfo_darwin.go#L79-L95 | train |
koding/kite | kitekey/kitekey.go | KiteHome | func KiteHome() (string, error) {
kiteHome := os.Getenv("KITE_HOME")
if kiteHome != "" {
return kiteHome, nil
}
usr, err := user.Current()
if err != nil {
return "", err
}
return filepath.Join(usr.HomeDir, kiteDirName), nil
} | go | func KiteHome() (string, error) {
kiteHome := os.Getenv("KITE_HOME")
if kiteHome != "" {
return kiteHome, nil
}
usr, err := user.Current()
if err != nil {
return "", err
}
return filepath.Join(usr.HomeDir, kiteDirName), nil
} | [
"func",
"KiteHome",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"kiteHome",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"kiteHome",
"!=",
"\"",
"\"",
"{",
"return",
"kiteHome",
",",
"nil",
"\n",
"}",
"\n",
"usr",
",",
"err",
":=",
"user",
".",
"Current",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"filepath",
".",
"Join",
"(",
"usr",
".",
"HomeDir",
",",
"kiteDirName",
")",
",",
"nil",
"\n",
"}"
] | // KiteHome returns the home path of Kite directory.
// The returned value can be overridden by setting KITE_HOME environment variable. | [
"KiteHome",
"returns",
"the",
"home",
"path",
"of",
"Kite",
"directory",
".",
"The",
"returned",
"value",
"can",
"be",
"overridden",
"by",
"setting",
"KITE_HOME",
"environment",
"variable",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitekey/kitekey.go#L31-L41 | train |
koding/kite | kitekey/kitekey.go | Read | func Read() (string, error) {
keyPath, err := kiteKeyPath()
if err != nil {
return "", err
}
data, err := ioutil.ReadFile(keyPath)
if err != nil {
return "", err
}
return strings.TrimSpace(string(data)), nil
} | go | func Read() (string, error) {
keyPath, err := kiteKeyPath()
if err != nil {
return "", err
}
data, err := ioutil.ReadFile(keyPath)
if err != nil {
return "", err
}
return strings.TrimSpace(string(data)), nil
} | [
"func",
"Read",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"keyPath",
",",
"err",
":=",
"kiteKeyPath",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"keyPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"strings",
".",
"TrimSpace",
"(",
"string",
"(",
"data",
")",
")",
",",
"nil",
"\n",
"}"
] | // Read the contents of the kite.key file. | [
"Read",
"the",
"contents",
"of",
"the",
"kite",
".",
"key",
"file",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitekey/kitekey.go#L52-L62 | train |
koding/kite | kitekey/kitekey.go | Write | func Write(kiteKey string) error {
keyPath, err := kiteKeyPath()
if err != nil {
return err
}
err = os.MkdirAll(filepath.Dir(keyPath), 0700)
if err != nil {
return err
}
// Need to remove the previous key first because we can't write over
// when previous file's mode is 0400.
os.Remove(keyPath)
return ioutil.WriteFile(keyPath, []byte(kiteKey), 0400)
} | go | func Write(kiteKey string) error {
keyPath, err := kiteKeyPath()
if err != nil {
return err
}
err = os.MkdirAll(filepath.Dir(keyPath), 0700)
if err != nil {
return err
}
// Need to remove the previous key first because we can't write over
// when previous file's mode is 0400.
os.Remove(keyPath)
return ioutil.WriteFile(keyPath, []byte(kiteKey), 0400)
} | [
"func",
"Write",
"(",
"kiteKey",
"string",
")",
"error",
"{",
"keyPath",
",",
"err",
":=",
"kiteKeyPath",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"os",
".",
"MkdirAll",
"(",
"filepath",
".",
"Dir",
"(",
"keyPath",
")",
",",
"0700",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Need to remove the previous key first because we can't write over",
"// when previous file's mode is 0400.",
"os",
".",
"Remove",
"(",
"keyPath",
")",
"\n\n",
"return",
"ioutil",
".",
"WriteFile",
"(",
"keyPath",
",",
"[",
"]",
"byte",
"(",
"kiteKey",
")",
",",
"0400",
")",
"\n",
"}"
] | // Write over the kite.key file. | [
"Write",
"over",
"the",
"kite",
".",
"key",
"file",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitekey/kitekey.go#L65-L81 | train |
koding/kite | kitekey/kitekey.go | Parse | func Parse() (*jwt.Token, error) {
kiteKey, err := Read()
if err != nil {
return nil, err
}
return jwt.ParseWithClaims(kiteKey, &KiteClaims{}, GetKontrolKey)
} | go | func Parse() (*jwt.Token, error) {
kiteKey, err := Read()
if err != nil {
return nil, err
}
return jwt.ParseWithClaims(kiteKey, &KiteClaims{}, GetKontrolKey)
} | [
"func",
"Parse",
"(",
")",
"(",
"*",
"jwt",
".",
"Token",
",",
"error",
")",
"{",
"kiteKey",
",",
"err",
":=",
"Read",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"jwt",
".",
"ParseWithClaims",
"(",
"kiteKey",
",",
"&",
"KiteClaims",
"{",
"}",
",",
"GetKontrolKey",
")",
"\n",
"}"
] | // Parse the kite.key file and return it as JWT token. | [
"Parse",
"the",
"kite",
".",
"key",
"file",
"and",
"return",
"it",
"as",
"JWT",
"token",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitekey/kitekey.go#L84-L91 | train |
koding/kite | kitekey/kitekey.go | ParseFile | func ParseFile(file string) (*jwt.Token, error) {
kiteKey, err := ioutil.ReadFile(file)
if err != nil {
return nil, err
}
return jwt.ParseWithClaims(string(bytes.TrimSpace(kiteKey)), &KiteClaims{}, GetKontrolKey)
} | go | func ParseFile(file string) (*jwt.Token, error) {
kiteKey, err := ioutil.ReadFile(file)
if err != nil {
return nil, err
}
return jwt.ParseWithClaims(string(bytes.TrimSpace(kiteKey)), &KiteClaims{}, GetKontrolKey)
} | [
"func",
"ParseFile",
"(",
"file",
"string",
")",
"(",
"*",
"jwt",
".",
"Token",
",",
"error",
")",
"{",
"kiteKey",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"jwt",
".",
"ParseWithClaims",
"(",
"string",
"(",
"bytes",
".",
"TrimSpace",
"(",
"kiteKey",
")",
")",
",",
"&",
"KiteClaims",
"{",
"}",
",",
"GetKontrolKey",
")",
"\n",
"}"
] | // ParseFile reads the given kite key file and parses it as a JWT token. | [
"ParseFile",
"reads",
"the",
"given",
"kite",
"key",
"file",
"and",
"parses",
"it",
"as",
"a",
"JWT",
"token",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitekey/kitekey.go#L94-L101 | train |
koding/kite | kitekey/kitekey.go | Extract | func (e *Extractor) Extract(token *jwt.Token) (interface{}, error) {
e.Token = token
if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
return nil, errors.New("invalid signing method")
}
claims, ok := token.Claims.(*KiteClaims)
if !ok {
return nil, fmt.Errorf("no kontrol key found")
}
e.Claims = claims
return jwt.ParseRSAPublicKeyFromPEM([]byte(claims.KontrolKey))
} | go | func (e *Extractor) Extract(token *jwt.Token) (interface{}, error) {
e.Token = token
if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
return nil, errors.New("invalid signing method")
}
claims, ok := token.Claims.(*KiteClaims)
if !ok {
return nil, fmt.Errorf("no kontrol key found")
}
e.Claims = claims
return jwt.ParseRSAPublicKeyFromPEM([]byte(claims.KontrolKey))
} | [
"func",
"(",
"e",
"*",
"Extractor",
")",
"Extract",
"(",
"token",
"*",
"jwt",
".",
"Token",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"e",
".",
"Token",
"=",
"token",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"token",
".",
"Method",
".",
"(",
"*",
"jwt",
".",
"SigningMethodRSA",
")",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"claims",
",",
"ok",
":=",
"token",
".",
"Claims",
".",
"(",
"*",
"KiteClaims",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"e",
".",
"Claims",
"=",
"claims",
"\n\n",
"return",
"jwt",
".",
"ParseRSAPublicKeyFromPEM",
"(",
"[",
"]",
"byte",
"(",
"claims",
".",
"KontrolKey",
")",
")",
"\n",
"}"
] | // Extract is a keyFunc argument for jwt.Parse function. | [
"Extract",
"is",
"a",
"keyFunc",
"argument",
"for",
"jwt",
".",
"Parse",
"function",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitekey/kitekey.go#L110-L125 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.