id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
30,100 | 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",
"(",
")",
... | // 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 |
30,101 | 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
}
ret... | 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
}
ret... | [
"func",
"(",
"b",
"*",
"Box",
")",
"Resolve",
"(",
"key",
"string",
")",
"(",
"file",
".",
"File",
",",
"error",
")",
"{",
"key",
"=",
"strings",
".",
"TrimPrefix",
"(",
"key",
",",
"\"",
"\"",
")",
"\n\n",
"var",
"r",
"resolver",
".",
"Resolver"... | // 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 |
30,102 | 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.Di... | 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.Di... | [
"func",
"NewFromRoots",
"(",
"roots",
"[",
"]",
"string",
",",
"opts",
"*",
"RootsOptions",
")",
"(",
"*",
"Parser",
",",
"error",
")",
"{",
"if",
"opts",
"==",
"nil",
"{",
"opts",
"=",
"&",
"RootsOptions",
"{",
"}",
"\n",
"}",
"\n\n",
"if",
"len",... | // 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 |
30,103 | 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 |
30,104 | 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 * ti... | 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 * ti... | [
"func",
"(",
"k",
"*",
"Kite",
")",
"RegisterHTTPForever",
"(",
"kiteURL",
"*",
"url",
".",
"URL",
")",
"{",
"// Create the httpBackoffRegister that RegisterHTTPForever will",
"// use to backoff repeated register attempts.",
"httpRegisterBackOff",
":=",
"backoff",
".",
"New... | // 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",
"initializ... | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/heartbeat.go#L90-L116 |
30,105 | 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",
"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 |
30,106 | 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",
".",
... | // Call the received function. | [
"Call",
"the",
"received",
"function",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/dnode/callback.go#L18-L23 |
30,107 | 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 {... | 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 {... | [
"func",
"ParseCallbacks",
"(",
"msg",
"*",
"Message",
",",
"sender",
"func",
"(",
"id",
"uint64",
",",
"args",
"[",
"]",
"interface",
"{",
"}",
")",
"error",
")",
"error",
"{",
"// Parse callbacks field and create callback functions.",
"for",
"methodID",
",",
... | // 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 |
30,108 | 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",
... | // 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 |
30,109 | 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",
",",
"e... | // 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 |
30,110 | 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",
"(",
... | // 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 |
30,111 | 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",
":=... | // 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 |
30,112 | 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: "genericE... | 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: "genericE... | [
"func",
"createError",
"(",
"req",
"*",
"Request",
",",
"r",
"interface",
"{",
"}",
")",
"*",
"Error",
"{",
"if",
"r",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"var",
"kiteErr",
"*",
"Error",
"\n",
"switch",
"err",
":=",
"r",
".",
"(... | // 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 |
30,113 | 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",
"(",
"st... | // 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 |
30,114 | 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.... | 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.... | [
"func",
"(",
"p",
"*",
"Proxy",
")",
"ListenAndServe",
"(",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"p",
".",
"listener",
",",
"err",
"=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"net",
".",
"JoinHostPort",
"(",
"p",
".",
"Kite",
".",... | // 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 |
30,115 | 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
... | 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
... | [
"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",
",",
"_",
",",
... | // 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 |
30,116 | 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... | 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... | [
"func",
"memoryStats",
"(",
")",
"(",
"*",
"memory",
",",
"error",
")",
"{",
"mstat",
":=",
"struct",
"{",
"size",
"uint32",
"\n",
"_",
"uint32",
"\n",
"totalPhys",
"uint64",
"\n",
"availPhys",
"uint64",
"\n",
"_",
"[",
"5",
"]",
"uint64",
"\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 |
30,117 | 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",
".",
"is... | // 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 |
30,118 | 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",
"cas... | // 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 |
30,119 | 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",
":",
"r... | // 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 |
30,120 | 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-separate... | 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-separate... | [
"func",
"(",
"s",
"*",
"Scrubber",
")",
"fields",
"(",
"rv",
"reflect",
".",
"Value",
",",
"path",
"Path",
",",
"callbacks",
"map",
"[",
"string",
"]",
"Path",
")",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"rv",
".",
"NumField",
"(",
")",
";"... | // 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 |
30,121 | 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.ToL... | 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.ToL... | [
"func",
"(",
"s",
"*",
"Scrubber",
")",
"methods",
"(",
"rv",
"reflect",
".",
"Value",
",",
"path",
"Path",
",",
"callbacks",
"map",
"[",
"string",
"]",
"Path",
")",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"rv",
".",
"NumMethod",
"(",
")",
"... | // 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 |
30,122 | 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
clie... | 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
clie... | [
"func",
"(",
"k",
"*",
"Kite",
")",
"SetupKontrolClient",
"(",
")",
"error",
"{",
"if",
"k",
".",
"kontrol",
".",
"Client",
"!=",
"nil",
"{",
"return",
"nil",
"// already prepared",
"\n",
"}",
"\n\n",
"if",
"k",
".",
"Config",
".",
"KontrolURL",
"==",
... | // 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",
"whenev... | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrolclient.go#L53-L102 |
30,123 | 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(&tk... | 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(&tk... | [
"func",
"(",
"k",
"*",
"Kite",
")",
"GetToken",
"(",
"kite",
"*",
"protocol",
".",
"Kite",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"k",
".",
"SetupKontrolClient",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\""... | // 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 |
30,124 | 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.T... | 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.T... | [
"func",
"(",
"k",
"*",
"Kite",
")",
"GetTokenForce",
"(",
"kite",
"*",
"protocol",
".",
"Kite",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"k",
".",
"SetupKontrolClient",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
... | // 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 |
30,125 | 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 ... | 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 ... | [
"func",
"(",
"k",
"*",
"Kite",
")",
"GetKey",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"err",
":=",
"k",
".",
"SetupKontrolClient",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\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",
... | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrolclient.go#L254-L277 |
30,126 | 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",
".",... | // 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 |
30,127 | 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 |
30,128 | 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",
"... | // 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... | [
"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",
"... | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrolclient.go#L398-L406 |
30,129 | 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.
... | 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.
... | [
"func",
"(",
"k",
"*",
"Kite",
")",
"RegisterToProxy",
"(",
"registerURL",
"*",
"url",
".",
"URL",
",",
"query",
"*",
"protocol",
".",
"KontrolQuery",
")",
"{",
"go",
"k",
".",
"RegisterForever",
"(",
"nil",
")",
"\n\n",
"for",
"{",
"var",
"proxyKite",... | // 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",
"terminati... | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrolclient.go#L412-L463 |
30,130 | 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()
}... | 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()
}... | [
"func",
"(",
"k",
"*",
"Kite",
")",
"registerToProxyKite",
"(",
"c",
"*",
"Client",
",",
"kiteURL",
"*",
"url",
".",
"URL",
")",
"(",
"*",
"url",
".",
"URL",
",",
"error",
")",
"{",
"err",
":=",
"c",
".",
"Dial",
"(",
")",
"\n",
"if",
"err",
... | // 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 |
30,131 | 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:... | 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:... | [
"func",
"(",
"k",
"*",
"Kite",
")",
"TellKontrolWithTimeout",
"(",
"method",
"string",
",",
"timeout",
"time",
".",
"Duration",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"(",
"result",
"*",
"dnode",
".",
"Partial",
",",
"err",
"error",
")",
"{",
... | // 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 |
30,132 | 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... | // 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 |
30,133 | 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",
... | // 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 |
30,134 | 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",
... | // 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 |
30,135 | 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"... | // 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 |
30,136 | 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)
... | 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)
... | [
"func",
"DialWebsocket",
"(",
"uri",
"string",
",",
"cfg",
"*",
"config",
".",
"Config",
")",
"(",
"*",
"WebsocketSession",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"uri",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
... | // 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 |
30,137 | 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... | 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... | [
"func",
"(",
"w",
"*",
"WebsocketSession",
")",
"Recv",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"// Return previously received messages if there is any.",
"if",
"len",
"(",
"w",
".",
"messages",
")",
">",
"0",
"{",
"msg",
":=",
"w",
".",
"messages... | // 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 |
30,138 | 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",
"... | // 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 |
30,139 | 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",
".",
"Clos... | // 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 |
30,140 | 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",
"}",
"\... | // 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 |
30,141 | 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 |
30,142 | 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 |
30,143 | 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",
")",
")",... | // 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 |
30,144 | 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",
"{",... | // 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 |
30,145 | 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 c... | // 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 |
30,146 | 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.di... | 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.di... | [
"func",
"(",
"c",
"*",
"Client",
")",
"run",
"(",
")",
"{",
"err",
":=",
"c",
".",
"readLoop",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"LocalKite",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"err",
")",
"\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 |
30,147 | 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 pro... | 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 pro... | [
"func",
"(",
"c",
"*",
"Client",
")",
"readLoop",
"(",
")",
"error",
"{",
"for",
"{",
"p",
",",
"err",
":=",
"c",
".",
"receiveData",
"(",
")",
"\n\n",
"c",
".",
"LocalKite",
".",
"Log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"p",
",",
"err",
")... | // 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 |
30,148 | 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 ... | 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 ... | [
"func",
"(",
"c",
"*",
"Client",
")",
"receiveData",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"type",
"recv",
"struct",
"{",
"msg",
"[",
"]",
"byte",
"\n",
"err",
"error",
"\n",
"}",
"\n\n",
"session",
":=",
"c",
".",
"getSession"... | // receiveData reads a message from session. | [
"receiveData",
"reads",
"a",
"message",
"from",
"session",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L460-L484 |
30,149 | 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 []inte... | 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 []inte... | [
"func",
"(",
"c",
"*",
"Client",
")",
"processMessage",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"msg",
"*",
"dnode",
".",
"Message",
",",
"fn",
"interface",
"{",
"}",
",",
"err",
"error",
")",
"{",
"// Call error handler.",
"defer",
"func",
"(",
")"... | // 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 |
30,150 | 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.er... | 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.er... | [
"func",
"(",
"c",
"*",
"Client",
")",
"sendHub",
"(",
")",
"{",
"defer",
"c",
".",
"wg",
".",
"Done",
"(",
")",
"\n\n",
"for",
"{",
"select",
"{",
"case",
"msg",
":=",
"<-",
"c",
".",
"send",
":",
"c",
".",
"LocalKite",
".",
"Log",
".",
"Debu... | // 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 |
30,151 | 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",
... | // 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 |
30,152 | 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",
")",... | // 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 |
30,153 | 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",
"... | // 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 |
30,154 | 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",
"... | // 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 |
30,155 | 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",
".",
"onConnectHa... | // callOnConnectHandlers runs the registered connect handlers. | [
"callOnConnectHandlers",
"runs",
"the",
"registered",
"connect",
"handlers",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L642-L652 |
30,156 | 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",
".",
"onDiscon... | // callOnDisconnectHandlers runs the registered disconnect handlers. | [
"callOnDisconnectHandlers",
"runs",
"the",
"registered",
"disconnect",
"handlers",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L655-L665 |
30,157 | 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",
".",
"onToken... | // 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 |
30,158 | 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",
... | // 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 |
30,159 | 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",
... | // 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 |
30,160 | 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 |
30,161 | 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 ui... | 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 ui... | [
"func",
"(",
"c",
"*",
"Client",
")",
"sendMethod",
"(",
"method",
"string",
",",
"args",
"[",
"]",
"interface",
"{",
"}",
",",
"timeout",
"time",
".",
"Duration",
",",
"responseChan",
"chan",
"*",
"response",
")",
"{",
"// To clean the sent callback after r... | // 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 |
30,162 | 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)
}
}()
// ... | 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)
}
}()
// ... | [
"func",
"(",
"c",
"*",
"Client",
")",
"marshalAndSend",
"(",
"method",
"interface",
"{",
"}",
",",
"arguments",
"[",
"]",
"interface",
"{",
"}",
")",
"(",
"callbacks",
"map",
"[",
"string",
"]",
"dnode",
".",
"Path",
",",
"errC",
"<-",
"chan",
"error... | // 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 |
30,163 | 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... | 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... | [
"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",
"cal... | // 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 |
30,164 | 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].... | 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].... | [
"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",
",",
"e... | // 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 |
30,165 | 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... | 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... | [
"func",
"(",
"k",
"*",
"Kite",
")",
"Run",
"(",
")",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"fmt",
".",
"Println",
"(",
"k",
".",
"Kite",
"(",
")",
".",
"Version",
")",
"\n",
"os",
".",
"Exit",
"(",
"... | // 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 |
30,166 | 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.Sto... | 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.Sto... | [
"func",
"(",
"k",
"*",
"Kite",
")",
"Close",
"(",
")",
"{",
"k",
".",
"Log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n\n",
"k",
".",
"kontrol",
".",
"Lock",
"(",
")",
"\n",
"if",
"k",
".",
"kontrol",
"!=",
"nil",
"&&",
"k",
".",
"kontrol",
"."... | // 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 |
30,167 | 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... | 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... | [
"func",
"(",
"k",
"*",
"Kite",
")",
"listenAndServe",
"(",
")",
"error",
"{",
"// create a new one if there doesn't exist",
"l",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"k",
".",
"Addr",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"... | // 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 |
30,168 | 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",
".",
"No... | // 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 calle... | [
"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",
"call... | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/onceevery/onceevery.go#L28-L44 |
30,169 | 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... | 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... | [
"func",
"sysctlbyname",
"(",
"name",
"string",
",",
"data",
"interface",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"val",
",",
"err",
":=",
"syscall",
".",
"Sysctl",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
... | // generic Sysctl buffer unmarshalling | [
"generic",
"Sysctl",
"buffer",
"unmarshalling"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/systeminfo/systeminfo_darwin.go#L79-L95 |
30,170 | 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",... | // 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 |
30,171 | 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",
"... | // 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 |
30,172 | 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 ... | 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 ... | [
"func",
"Write",
"(",
"kiteKey",
"string",
")",
"error",
"{",
"keyPath",
",",
"err",
":=",
"kiteKeyPath",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"os",
".",
"MkdirAll",
"(",
"filepath",
".",
"D... | // 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 |
30,173 | 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",
".",
"ParseWi... | // 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 |
30,174 | 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",
"\... | // 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 |
30,175 | 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 = clai... | 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 = clai... | [
"func",
"(",
"e",
"*",
"Extractor",
")",
"Extract",
"(",
"token",
"*",
"jwt",
".",
"Token",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"e",
".",
"Token",
"=",
"token",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"token",
".",
"Method",
".... | // 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 |
30,176 | koding/kite | kontrol/kontrol.go | registerSelf | func (k *Kontrol) registerSelf() {
value := &kontrolprotocol.RegisterValue{
URL: k.Kite.Config.KontrolURL,
}
// change if the user wants something different
if k.RegisterURL != "" {
value.URL = k.RegisterURL
}
keyPair, err := k.KeyPair()
if err != nil {
if err != errNoSelfKeyPair {
k.log.Error("%s", e... | go | func (k *Kontrol) registerSelf() {
value := &kontrolprotocol.RegisterValue{
URL: k.Kite.Config.KontrolURL,
}
// change if the user wants something different
if k.RegisterURL != "" {
value.URL = k.RegisterURL
}
keyPair, err := k.KeyPair()
if err != nil {
if err != errNoSelfKeyPair {
k.log.Error("%s", e... | [
"func",
"(",
"k",
"*",
"Kontrol",
")",
"registerSelf",
"(",
")",
"{",
"value",
":=",
"&",
"kontrolprotocol",
".",
"RegisterValue",
"{",
"URL",
":",
"k",
".",
"Kite",
".",
"Config",
".",
"KontrolURL",
",",
"}",
"\n\n",
"// change if the user wants something d... | // registerSelf adds Kontrol itself to the storage as a kite. | [
"registerSelf",
"adds",
"Kontrol",
"itself",
"to",
"the",
"storage",
"as",
"a",
"kite",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/kontrol.go#L390-L451 |
30,177 | koding/kite | kontrol/kontrol.go | KeyPair | func (k *Kontrol) KeyPair() (pair *KeyPair, err error) {
if k.selfKeyPair != nil {
return k.selfKeyPair, nil
}
kiteKey := k.Kite.KiteKey()
if kiteKey == "" || len(k.lastPublic) == 0 {
return nil, errNoSelfKeyPair
}
keyIndex := -1
me := new(multiError)
for i := range k.lastPublic {
ri := len(k.lastPub... | go | func (k *Kontrol) KeyPair() (pair *KeyPair, err error) {
if k.selfKeyPair != nil {
return k.selfKeyPair, nil
}
kiteKey := k.Kite.KiteKey()
if kiteKey == "" || len(k.lastPublic) == 0 {
return nil, errNoSelfKeyPair
}
keyIndex := -1
me := new(multiError)
for i := range k.lastPublic {
ri := len(k.lastPub... | [
"func",
"(",
"k",
"*",
"Kontrol",
")",
"KeyPair",
"(",
")",
"(",
"pair",
"*",
"KeyPair",
",",
"err",
"error",
")",
"{",
"if",
"k",
".",
"selfKeyPair",
"!=",
"nil",
"{",
"return",
"k",
".",
"selfKeyPair",
",",
"nil",
"\n",
"}",
"\n\n",
"kiteKey",
... | // KeyPair looks up a key pair that was used to sign Kontrol's kite key.
//
// The value is cached on first call of the function. | [
"KeyPair",
"looks",
"up",
"a",
"key",
"pair",
"that",
"was",
"used",
"to",
"sign",
"Kontrol",
"s",
"kite",
"key",
".",
"The",
"value",
"is",
"cached",
"on",
"first",
"call",
"of",
"the",
"function",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/kontrol.go#L456-L502 |
30,178 | koding/kite | kontrol/kontrol.go | cacheToken | func (k *Kontrol) cacheToken(key, signed string) {
if ct, ok := k.tokenCache[key]; ok {
ct.timer.Stop()
}
k.tokenCache[key] = cachedToken{
signed: signed,
timer: time.AfterFunc(k.tokenTTL()-k.tokenLeeway(), func() {
k.tokenCacheMu.Lock()
delete(k.tokenCache, key)
k.tokenCacheMu.Unlock()
}),
}
} | go | func (k *Kontrol) cacheToken(key, signed string) {
if ct, ok := k.tokenCache[key]; ok {
ct.timer.Stop()
}
k.tokenCache[key] = cachedToken{
signed: signed,
timer: time.AfterFunc(k.tokenTTL()-k.tokenLeeway(), func() {
k.tokenCacheMu.Lock()
delete(k.tokenCache, key)
k.tokenCacheMu.Unlock()
}),
}
} | [
"func",
"(",
"k",
"*",
"Kontrol",
")",
"cacheToken",
"(",
"key",
",",
"signed",
"string",
")",
"{",
"if",
"ct",
",",
"ok",
":=",
"k",
".",
"tokenCache",
"[",
"key",
"]",
";",
"ok",
"{",
"ct",
".",
"timer",
".",
"Stop",
"(",
")",
"\n",
"}",
"\... | // cacheToken cached the signed token under the given key.
//
// It also ensures the token is invalidated after its expiration time.
//
// If the token was already exists in the cache, it will be
// overwritten with a new value. | [
"cacheToken",
"cached",
"the",
"signed",
"token",
"under",
"the",
"given",
"key",
".",
"It",
"also",
"ensures",
"the",
"token",
"is",
"invalidated",
"after",
"its",
"expiration",
"time",
".",
"If",
"the",
"token",
"was",
"already",
"exists",
"in",
"the",
"... | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/kontrol.go#L543-L556 |
30,179 | koding/kite | dnode/partial.go | UnmarshalJSON | func (p *Partial) UnmarshalJSON(data []byte) error {
if p == nil {
return errors.New("json.Partial: UnmarshalJSON on nil pointer")
}
p.Raw = make([]byte, len(data))
copy(p.Raw, data)
return nil
} | go | func (p *Partial) UnmarshalJSON(data []byte) error {
if p == nil {
return errors.New("json.Partial: UnmarshalJSON on nil pointer")
}
p.Raw = make([]byte, len(data))
copy(p.Raw, data)
return nil
} | [
"func",
"(",
"p",
"*",
"Partial",
")",
"UnmarshalJSON",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"p",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"p",
".",
"Raw",
"=",
"make",
"(",
... | // UnmarshalJSON puts the data into Partial.Raw. | [
"UnmarshalJSON",
"puts",
"the",
"data",
"into",
"Partial",
".",
"Raw",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/dnode/partial.go#L22-L30 |
30,180 | koding/kite | dnode/partial.go | SliceOfLength | func (p *Partial) SliceOfLength(length int) (a []*Partial, err error) {
err = p.Unmarshal(&a)
if err != nil {
return
}
if len(a) != length {
err = errors.New("Invalid array length")
}
return
} | go | func (p *Partial) SliceOfLength(length int) (a []*Partial, err error) {
err = p.Unmarshal(&a)
if err != nil {
return
}
if len(a) != length {
err = errors.New("Invalid array length")
}
return
} | [
"func",
"(",
"p",
"*",
"Partial",
")",
"SliceOfLength",
"(",
"length",
"int",
")",
"(",
"a",
"[",
"]",
"*",
"Partial",
",",
"err",
"error",
")",
"{",
"err",
"=",
"p",
".",
"Unmarshal",
"(",
"&",
"a",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
... | // SliceOfLength is a helper method to unmarshal a JSON Array with specified length. | [
"SliceOfLength",
"is",
"a",
"helper",
"method",
"to",
"unmarshal",
"a",
"JSON",
"Array",
"with",
"specified",
"length",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/dnode/partial.go#L70-L81 |
30,181 | koding/kite | dnode/partial.go | Map | func (p *Partial) Map() (m map[string]*Partial, err error) {
err = p.Unmarshal(&m)
return
} | go | func (p *Partial) Map() (m map[string]*Partial, err error) {
err = p.Unmarshal(&m)
return
} | [
"func",
"(",
"p",
"*",
"Partial",
")",
"Map",
"(",
")",
"(",
"m",
"map",
"[",
"string",
"]",
"*",
"Partial",
",",
"err",
"error",
")",
"{",
"err",
"=",
"p",
".",
"Unmarshal",
"(",
"&",
"m",
")",
"\n",
"return",
"\n",
"}"
] | // Map is a helper method to unmarshal to a JSON Object. | [
"Map",
"is",
"a",
"helper",
"method",
"to",
"unmarshal",
"to",
"a",
"JSON",
"Object",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/dnode/partial.go#L84-L87 |
30,182 | koding/kite | dnode/partial.go | String | func (p *Partial) String() (s string, err error) {
err = p.Unmarshal(&s)
return
} | go | func (p *Partial) String() (s string, err error) {
err = p.Unmarshal(&s)
return
} | [
"func",
"(",
"p",
"*",
"Partial",
")",
"String",
"(",
")",
"(",
"s",
"string",
",",
"err",
"error",
")",
"{",
"err",
"=",
"p",
".",
"Unmarshal",
"(",
"&",
"s",
")",
"\n",
"return",
"\n",
"}"
] | // String is a helper to unmarshal a JSON String. | [
"String",
"is",
"a",
"helper",
"to",
"unmarshal",
"a",
"JSON",
"String",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/dnode/partial.go#L90-L93 |
30,183 | koding/kite | dnode/partial.go | Float64 | func (p *Partial) Float64() (f float64, err error) {
err = p.Unmarshal(&f)
return
} | go | func (p *Partial) Float64() (f float64, err error) {
err = p.Unmarshal(&f)
return
} | [
"func",
"(",
"p",
"*",
"Partial",
")",
"Float64",
"(",
")",
"(",
"f",
"float64",
",",
"err",
"error",
")",
"{",
"err",
"=",
"p",
".",
"Unmarshal",
"(",
"&",
"f",
")",
"\n",
"return",
"\n",
"}"
] | // Float64 is a helper to unmarshal a JSON Number. | [
"Float64",
"is",
"a",
"helper",
"to",
"unmarshal",
"a",
"JSON",
"Number",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/dnode/partial.go#L96-L99 |
30,184 | koding/kite | dnode/partial.go | Bool | func (p *Partial) Bool() (b bool, err error) {
err = p.Unmarshal(&b)
return
} | go | func (p *Partial) Bool() (b bool, err error) {
err = p.Unmarshal(&b)
return
} | [
"func",
"(",
"p",
"*",
"Partial",
")",
"Bool",
"(",
")",
"(",
"b",
"bool",
",",
"err",
"error",
")",
"{",
"err",
"=",
"p",
".",
"Unmarshal",
"(",
"&",
"b",
")",
"\n",
"return",
"\n",
"}"
] | // Bool is a helper to unmarshal a JSON Boolean. | [
"Bool",
"is",
"a",
"helper",
"to",
"unmarshal",
"a",
"JSON",
"Boolean",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/dnode/partial.go#L102-L105 |
30,185 | koding/kite | dnode/partial.go | Function | func (p *Partial) Function() (f Function, err error) {
err = p.Unmarshal(&f)
return
} | go | func (p *Partial) Function() (f Function, err error) {
err = p.Unmarshal(&f)
return
} | [
"func",
"(",
"p",
"*",
"Partial",
")",
"Function",
"(",
")",
"(",
"f",
"Function",
",",
"err",
"error",
")",
"{",
"err",
"=",
"p",
".",
"Unmarshal",
"(",
"&",
"f",
")",
"\n",
"return",
"\n",
"}"
] | // Function is a helper to unmarshal a callback function. | [
"Function",
"is",
"a",
"helper",
"to",
"unmarshal",
"a",
"callback",
"function",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/dnode/partial.go#L108-L111 |
30,186 | koding/kite | kontrol/etcd.go | validateKiteKey | func validateKiteKey(k *protocol.Kite) error {
fields := k.Query().Fields()
// Validate fields.
for k, v := range fields {
if v == "" {
return fmt.Errorf("Empty Kite field: %s", k)
}
if strings.ContainsRune(v, '/') {
return fmt.Errorf("Field \"%s\" must not contain '/'", k)
}
}
return nil
} | go | func validateKiteKey(k *protocol.Kite) error {
fields := k.Query().Fields()
// Validate fields.
for k, v := range fields {
if v == "" {
return fmt.Errorf("Empty Kite field: %s", k)
}
if strings.ContainsRune(v, '/') {
return fmt.Errorf("Field \"%s\" must not contain '/'", k)
}
}
return nil
} | [
"func",
"validateKiteKey",
"(",
"k",
"*",
"protocol",
".",
"Kite",
")",
"error",
"{",
"fields",
":=",
"k",
".",
"Query",
"(",
")",
".",
"Fields",
"(",
")",
"\n\n",
"// Validate fields.",
"for",
"k",
",",
"v",
":=",
"range",
"fields",
"{",
"if",
"v",
... | // validateKiteKey returns a string representing the kite uniquely
// that is suitable to use as a key for etcd. | [
"validateKiteKey",
"returns",
"a",
"string",
"representing",
"the",
"kite",
"uniquely",
"that",
"is",
"suitable",
"to",
"use",
"as",
"a",
"key",
"for",
"etcd",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/etcd.go#L300-L314 |
30,187 | koding/kite | kontrol/etcd.go | onlyIDQuery | func onlyIDQuery(q *protocol.KontrolQuery) bool {
fields := q.Fields()
// check if any other key exist, if yes return a false
for _, k := range keyOrder {
v := fields[k]
if k != "id" && v != "" {
return false
}
}
// now all other keys are empty, check finally for our ID
if fields["id"] != "" {
return... | go | func onlyIDQuery(q *protocol.KontrolQuery) bool {
fields := q.Fields()
// check if any other key exist, if yes return a false
for _, k := range keyOrder {
v := fields[k]
if k != "id" && v != "" {
return false
}
}
// now all other keys are empty, check finally for our ID
if fields["id"] != "" {
return... | [
"func",
"onlyIDQuery",
"(",
"q",
"*",
"protocol",
".",
"KontrolQuery",
")",
"bool",
"{",
"fields",
":=",
"q",
".",
"Fields",
"(",
")",
"\n\n",
"// check if any other key exist, if yes return a false",
"for",
"_",
",",
"k",
":=",
"range",
"keyOrder",
"{",
"v",
... | // onlyIDQuery returns true if the query contains only a non-empty ID and all
// others keys are empty | [
"onlyIDQuery",
"returns",
"true",
"if",
"the",
"query",
"contains",
"only",
"a",
"non",
"-",
"empty",
"ID",
"and",
"all",
"others",
"keys",
"are",
"empty"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/etcd.go#L318-L336 |
30,188 | koding/kite | kontrol/etcd.go | GetQueryKey | func GetQueryKey(q *protocol.KontrolQuery) (string, error) {
fields := q.Fields()
if q.Username == "" {
return "", errors.New("Empty username field")
}
// Validate query and build key.
path := "/"
empty := false // encountered with empty field?
empytField := "" // for error log
// http://golang.org/doc/... | go | func GetQueryKey(q *protocol.KontrolQuery) (string, error) {
fields := q.Fields()
if q.Username == "" {
return "", errors.New("Empty username field")
}
// Validate query and build key.
path := "/"
empty := false // encountered with empty field?
empytField := "" // for error log
// http://golang.org/doc/... | [
"func",
"GetQueryKey",
"(",
"q",
"*",
"protocol",
".",
"KontrolQuery",
")",
"(",
"string",
",",
"error",
")",
"{",
"fields",
":=",
"q",
".",
"Fields",
"(",
")",
"\n\n",
"if",
"q",
".",
"Username",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
... | // getQueryKey returns the etcd key for the query. | [
"getQueryKey",
"returns",
"the",
"etcd",
"key",
"for",
"the",
"query",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/etcd.go#L339-L372 |
30,189 | koding/kite | kite.go | New | func New(name, version string) *Kite {
return NewWithConfig(name, version, config.New())
} | go | func New(name, version string) *Kite {
return NewWithConfig(name, version, config.New())
} | [
"func",
"New",
"(",
"name",
",",
"version",
"string",
")",
"*",
"Kite",
"{",
"return",
"NewWithConfig",
"(",
"name",
",",
"version",
",",
"config",
".",
"New",
"(",
")",
")",
"\n",
"}"
] | // New creates, initializes and then returns a new Kite instance.
//
// Version must be in 3-digit semantic form.
//
// Name is important that it's also used to be searched by others. | [
"New",
"creates",
"initializes",
"and",
"then",
"returns",
"a",
"new",
"Kite",
"instance",
".",
"Version",
"must",
"be",
"in",
"3",
"-",
"digit",
"semantic",
"form",
".",
"Name",
"is",
"important",
"that",
"it",
"s",
"also",
"used",
"to",
"be",
"searched... | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L163-L165 |
30,190 | koding/kite | kite.go | NewWithConfig | func NewWithConfig(name, version string, cfg *config.Config) *Kite {
if name == "" {
panic("kite: name cannot be empty")
}
if digits := strings.Split(version, "."); len(digits) != 3 {
panic("kite: version must be 3-digits semantic version")
}
kiteID := uuid.Must(uuid.NewV4())
l, setlevel := newLogger(name)... | go | func NewWithConfig(name, version string, cfg *config.Config) *Kite {
if name == "" {
panic("kite: name cannot be empty")
}
if digits := strings.Split(version, "."); len(digits) != 3 {
panic("kite: version must be 3-digits semantic version")
}
kiteID := uuid.Must(uuid.NewV4())
l, setlevel := newLogger(name)... | [
"func",
"NewWithConfig",
"(",
"name",
",",
"version",
"string",
",",
"cfg",
"*",
"config",
".",
"Config",
")",
"*",
"Kite",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"digits",
":=",
"strings",... | // NewWithConfig builds a new kite value for the given configuration. | [
"NewWithConfig",
"builds",
"a",
"new",
"kite",
"value",
"for",
"the",
"given",
"configuration",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L168-L229 |
30,191 | koding/kite | kite.go | Kite | func (k *Kite) Kite() *protocol.Kite {
return &protocol.Kite{
Username: k.Config.Username,
Environment: k.Config.Environment,
Name: k.name,
Version: k.version,
Region: k.Config.Region,
Hostname: hostname,
ID: k.Id,
}
} | go | func (k *Kite) Kite() *protocol.Kite {
return &protocol.Kite{
Username: k.Config.Username,
Environment: k.Config.Environment,
Name: k.name,
Version: k.version,
Region: k.Config.Region,
Hostname: hostname,
ID: k.Id,
}
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"Kite",
"(",
")",
"*",
"protocol",
".",
"Kite",
"{",
"return",
"&",
"protocol",
".",
"Kite",
"{",
"Username",
":",
"k",
".",
"Config",
".",
"Username",
",",
"Environment",
":",
"k",
".",
"Config",
".",
"Environme... | // Kite returns the definition of the kite. | [
"Kite",
"returns",
"the",
"definition",
"of",
"the",
"kite",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L232-L242 |
30,192 | koding/kite | kite.go | KiteKey | func (k *Kite) KiteKey() string {
k.configMu.RLock()
defer k.configMu.RUnlock()
return k.Config.KiteKey
} | go | func (k *Kite) KiteKey() string {
k.configMu.RLock()
defer k.configMu.RUnlock()
return k.Config.KiteKey
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"KiteKey",
"(",
")",
"string",
"{",
"k",
".",
"configMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"k",
".",
"configMu",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"k",
".",
"Config",
".",
"KiteKey",
"\n",
"}"
] | // KiteKey gives a kite key used to authenticate to kontrol and other kites. | [
"KiteKey",
"gives",
"a",
"kite",
"key",
"used",
"to",
"authenticate",
"to",
"kontrol",
"and",
"other",
"kites",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L245-L250 |
30,193 | koding/kite | kite.go | KontrolKey | func (k *Kite) KontrolKey() *rsa.PublicKey {
k.configMu.RLock()
defer k.configMu.RUnlock()
return k.kontrolKey
} | go | func (k *Kite) KontrolKey() *rsa.PublicKey {
k.configMu.RLock()
defer k.configMu.RUnlock()
return k.kontrolKey
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"KontrolKey",
"(",
")",
"*",
"rsa",
".",
"PublicKey",
"{",
"k",
".",
"configMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"k",
".",
"configMu",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"k",
".",
"kontrolKey",
... | // KontrolKey gives a Kontrol's public key.
//
// The value is taken form kite key's kontrolKey claim. | [
"KontrolKey",
"gives",
"a",
"Kontrol",
"s",
"public",
"key",
".",
"The",
"value",
"is",
"taken",
"form",
"kite",
"key",
"s",
"kontrolKey",
"claim",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L255-L260 |
30,194 | koding/kite | kite.go | HandleHTTP | func (k *Kite) HandleHTTP(pattern string, handler http.Handler) {
k.muxer.Handle(pattern, handler)
} | go | func (k *Kite) HandleHTTP(pattern string, handler http.Handler) {
k.muxer.Handle(pattern, handler)
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"HandleHTTP",
"(",
"pattern",
"string",
",",
"handler",
"http",
".",
"Handler",
")",
"{",
"k",
".",
"muxer",
".",
"Handle",
"(",
"pattern",
",",
"handler",
")",
"\n",
"}"
] | // HandleHTTP registers the HTTP handler for the given pattern into the
// underlying HTTP muxer. | [
"HandleHTTP",
"registers",
"the",
"HTTP",
"handler",
"for",
"the",
"given",
"pattern",
"into",
"the",
"underlying",
"HTTP",
"muxer",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L264-L266 |
30,195 | koding/kite | kite.go | HandleHTTPFunc | func (k *Kite) HandleHTTPFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) {
k.muxer.HandleFunc(pattern, handler)
} | go | func (k *Kite) HandleHTTPFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) {
k.muxer.HandleFunc(pattern, handler)
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"HandleHTTPFunc",
"(",
"pattern",
"string",
",",
"handler",
"func",
"(",
"http",
".",
"ResponseWriter",
",",
"*",
"http",
".",
"Request",
")",
")",
"{",
"k",
".",
"muxer",
".",
"HandleFunc",
"(",
"pattern",
",",
"h... | // HandleHTTPFunc registers the HTTP handler for the given pattern into the
// underlying HTTP muxer. | [
"HandleHTTPFunc",
"registers",
"the",
"HTTP",
"handler",
"for",
"the",
"given",
"pattern",
"into",
"the",
"underlying",
"HTTP",
"muxer",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L270-L272 |
30,196 | koding/kite | kite.go | ServeHTTP | func (k *Kite) ServeHTTP(w http.ResponseWriter, req *http.Request) {
k.muxer.ServeHTTP(w, req)
} | go | func (k *Kite) ServeHTTP(w http.ResponseWriter, req *http.Request) {
k.muxer.ServeHTTP(w, req)
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"ServeHTTP",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"k",
".",
"muxer",
".",
"ServeHTTP",
"(",
"w",
",",
"req",
")",
"\n",
"}"
] | // ServeHTTP helps Kite to satisfy the http.Handler interface. So kite can be
// used as a standard http server. | [
"ServeHTTP",
"helps",
"Kite",
"to",
"satisfy",
"the",
"http",
".",
"Handler",
"interface",
".",
"So",
"kite",
"can",
"be",
"used",
"as",
"a",
"standard",
"http",
"server",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L276-L278 |
30,197 | koding/kite | kite.go | OnConnect | func (k *Kite) OnConnect(handler func(*Client)) {
k.handlersMu.Lock()
k.onConnectHandlers = append(k.onConnectHandlers, handler)
k.handlersMu.Unlock()
} | go | func (k *Kite) OnConnect(handler func(*Client)) {
k.handlersMu.Lock()
k.onConnectHandlers = append(k.onConnectHandlers, handler)
k.handlersMu.Unlock()
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"OnConnect",
"(",
"handler",
"func",
"(",
"*",
"Client",
")",
")",
"{",
"k",
".",
"handlersMu",
".",
"Lock",
"(",
")",
"\n",
"k",
".",
"onConnectHandlers",
"=",
"append",
"(",
"k",
".",
"onConnectHandlers",
",",
... | // OnConnect registers a callbacks which is called when a Kite connects
// to the k Kite. | [
"OnConnect",
"registers",
"a",
"callbacks",
"which",
"is",
"called",
"when",
"a",
"Kite",
"connects",
"to",
"the",
"k",
"Kite",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L304-L308 |
30,198 | koding/kite | kite.go | OnFirstRequest | func (k *Kite) OnFirstRequest(handler func(*Client)) {
k.handlersMu.Lock()
k.onFirstRequestHandlers = append(k.onFirstRequestHandlers, handler)
k.handlersMu.Unlock()
} | go | func (k *Kite) OnFirstRequest(handler func(*Client)) {
k.handlersMu.Lock()
k.onFirstRequestHandlers = append(k.onFirstRequestHandlers, handler)
k.handlersMu.Unlock()
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"OnFirstRequest",
"(",
"handler",
"func",
"(",
"*",
"Client",
")",
")",
"{",
"k",
".",
"handlersMu",
".",
"Lock",
"(",
")",
"\n",
"k",
".",
"onFirstRequestHandlers",
"=",
"append",
"(",
"k",
".",
"onFirstRequestHandl... | // OnFirstRequest registers a function to run when we receive first request
// from other Kite. | [
"OnFirstRequest",
"registers",
"a",
"function",
"to",
"run",
"when",
"we",
"receive",
"first",
"request",
"from",
"other",
"Kite",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L312-L316 |
30,199 | koding/kite | kite.go | OnDisconnect | func (k *Kite) OnDisconnect(handler func(*Client)) {
k.handlersMu.Lock()
k.onDisconnectHandlers = append(k.onDisconnectHandlers, handler)
k.handlersMu.Unlock()
} | go | func (k *Kite) OnDisconnect(handler func(*Client)) {
k.handlersMu.Lock()
k.onDisconnectHandlers = append(k.onDisconnectHandlers, handler)
k.handlersMu.Unlock()
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"OnDisconnect",
"(",
"handler",
"func",
"(",
"*",
"Client",
")",
")",
"{",
"k",
".",
"handlersMu",
".",
"Lock",
"(",
")",
"\n",
"k",
".",
"onDisconnectHandlers",
"=",
"append",
"(",
"k",
".",
"onDisconnectHandlers",
... | // OnDisconnect registers a function to run when a connected Kite is disconnected. | [
"OnDisconnect",
"registers",
"a",
"function",
"to",
"run",
"when",
"a",
"connected",
"Kite",
"is",
"disconnected",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L319-L323 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.