repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
koding/kite | client.go | OnTokenRenew | func (c *Client) OnTokenRenew(handler func(token string)) {
c.m.Lock()
c.onTokenRenewHandlers = append(c.onTokenRenewHandlers, handler)
c.m.Unlock()
} | go | func (c *Client) OnTokenRenew(handler func(token string)) {
c.m.Lock()
c.onTokenRenewHandlers = append(c.onTokenRenewHandlers, handler)
c.m.Unlock()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"OnTokenRenew",
"(",
"handler",
"func",
"(",
"token",
"string",
")",
")",
"{",
"c",
".",
"m",
".",
"Lock",
"(",
")",
"\n",
"c",
".",
"onTokenRenewHandlers",
"=",
"append",
"(",
"c",
".",
"onTokenRenewHandlers",
",",
"handler",
")",
"\n",
"c",
".",
"m",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // OnTokenRenew adds a callback which is called when client successfully
// renews its token. | [
"OnTokenRenew",
"adds",
"a",
"callback",
"which",
"is",
"called",
"when",
"client",
"successfully",
"renews",
"its",
"token",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L635-L639 | train |
koding/kite | client.go | callOnConnectHandlers | func (c *Client) callOnConnectHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onConnectHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | go | func (c *Client) callOnConnectHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onConnectHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"callOnConnectHandlers",
"(",
")",
"{",
"c",
".",
"m",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"m",
".",
"RUnlock",
"(",
")",
"\n",
"for",
"_",
",",
"handler",
":=",
"range",
"c",
".",
"onConnectHandlers",
"{",
"func",
"(",
")",
"{",
"defer",
"nopRecover",
"(",
")",
"\n",
"handler",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // callOnConnectHandlers runs the registered connect handlers. | [
"callOnConnectHandlers",
"runs",
"the",
"registered",
"connect",
"handlers",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L642-L652 | train |
koding/kite | client.go | callOnDisconnectHandlers | func (c *Client) callOnDisconnectHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onDisconnectHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | go | func (c *Client) callOnDisconnectHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onDisconnectHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"callOnDisconnectHandlers",
"(",
")",
"{",
"c",
".",
"m",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"m",
".",
"RUnlock",
"(",
")",
"\n",
"for",
"_",
",",
"handler",
":=",
"range",
"c",
".",
"onDisconnectHandlers",
"{",
"func",
"(",
")",
"{",
"defer",
"nopRecover",
"(",
")",
"\n",
"handler",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // callOnDisconnectHandlers runs the registered disconnect handlers. | [
"callOnDisconnectHandlers",
"runs",
"the",
"registered",
"disconnect",
"handlers",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L655-L665 | train |
koding/kite | client.go | callOnTokenExpireHandlers | func (c *Client) callOnTokenExpireHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onTokenExpireHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | go | func (c *Client) callOnTokenExpireHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onTokenExpireHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"callOnTokenExpireHandlers",
"(",
")",
"{",
"c",
".",
"m",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"m",
".",
"RUnlock",
"(",
")",
"\n",
"for",
"_",
",",
"handler",
":=",
"range",
"c",
".",
"onTokenExpireHandlers",
"{",
"func",
"(",
")",
"{",
"defer",
"nopRecover",
"(",
")",
"\n",
"handler",
"(",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // callOnTokenExpireHandlers calls registered functions when an error
// from remote kite is received that token used is expired. | [
"callOnTokenExpireHandlers",
"calls",
"registered",
"functions",
"when",
"an",
"error",
"from",
"remote",
"kite",
"is",
"received",
"that",
"token",
"used",
"is",
"expired",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L669-L679 | train |
koding/kite | client.go | callOnTokenRenewHandlers | func (c *Client) callOnTokenRenewHandlers(token string) {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onTokenRenewHandlers {
func() {
defer nopRecover()
handler(token)
}()
}
} | go | func (c *Client) callOnTokenRenewHandlers(token string) {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onTokenRenewHandlers {
func() {
defer nopRecover()
handler(token)
}()
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"callOnTokenRenewHandlers",
"(",
"token",
"string",
")",
"{",
"c",
".",
"m",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"m",
".",
"RUnlock",
"(",
")",
"\n",
"for",
"_",
",",
"handler",
":=",
"range",
"c",
".",
"onTokenRenewHandlers",
"{",
"func",
"(",
")",
"{",
"defer",
"nopRecover",
"(",
")",
"\n",
"handler",
"(",
"token",
")",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // callOnTokenRenewHandlers calls all registered functions when
// we successfully obtain new token from kontrol. | [
"callOnTokenRenewHandlers",
"calls",
"all",
"registered",
"functions",
"when",
"we",
"successfully",
"obtain",
"new",
"token",
"from",
"kontrol",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L683-L693 | train |
koding/kite | client.go | Tell | func (c *Client) Tell(method string, args ...interface{}) (result *dnode.Partial, err error) {
return c.TellWithTimeout(method, 0, args...)
} | go | func (c *Client) Tell(method string, args ...interface{}) (result *dnode.Partial, err error) {
return c.TellWithTimeout(method, 0, args...)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Tell",
"(",
"method",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"(",
"result",
"*",
"dnode",
".",
"Partial",
",",
"err",
"error",
")",
"{",
"return",
"c",
".",
"TellWithTimeout",
"(",
"method",
",",
"0",
",",
"args",
"...",
")",
"\n",
"}"
] | // Tell makes a blocking method call to the server.
// Waits until the callback function is called by the other side and
// returns the result and the error. | [
"Tell",
"makes",
"a",
"blocking",
"method",
"call",
"to",
"the",
"server",
".",
"Waits",
"until",
"the",
"callback",
"function",
"is",
"called",
"by",
"the",
"other",
"side",
"and",
"returns",
"the",
"result",
"and",
"the",
"error",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L710-L712 | train |
koding/kite | client.go | Go | func (c *Client) Go(method string, args ...interface{}) chan *response {
return c.GoWithTimeout(method, 0, args...)
} | go | func (c *Client) Go(method string, args ...interface{}) chan *response {
return c.GoWithTimeout(method, 0, args...)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Go",
"(",
"method",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"chan",
"*",
"response",
"{",
"return",
"c",
".",
"GoWithTimeout",
"(",
"method",
",",
"0",
",",
"args",
"...",
")",
"\n",
"}"
] | // Go makes an unblocking method call to the server.
// It returns a channel that the caller can wait on it to get the response. | [
"Go",
"makes",
"an",
"unblocking",
"method",
"call",
"to",
"the",
"server",
".",
"It",
"returns",
"a",
"channel",
"that",
"the",
"caller",
"can",
"wait",
"on",
"it",
"to",
"get",
"the",
"response",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L734-L736 | train |
koding/kite | client.go | sendMethod | func (c *Client) sendMethod(method string, args []interface{}, timeout time.Duration, responseChan chan *response) {
// To clean the sent callback after response is received.
// Send/Receive in a channel to prevent race condition because
// the callback is run in a separate goroutine.
removeCallback := make(chan uint64, 1)
// When a callback is called it will send the response to this channel.
doneChan := make(chan *response, 1)
cb := c.makeResponseCallback(doneChan, removeCallback, method, args)
args = c.wrapMethodArgs(args, cb)
callbacks, errC, err := c.marshalAndSend(method, args)
if err != nil {
responseChan <- &response{
Result: nil,
Err: &Error{
Type: "sendError",
Message: err.Error(),
},
}
return
}
// nil value of afterTimeout means no timeout, it will not selected in
// select statement
var afterTimeout <-chan time.Time
if timeout > 0 {
afterTimeout = time.After(timeout)
}
// Waits until the response has came or the connection has disconnected.
go func() {
c.disconnectMu.Lock()
defer c.disconnectMu.Unlock()
select {
case resp := <-doneChan:
if e, ok := resp.Err.(*Error); ok {
if e.Type == "authenticationError" && strings.Contains(e.Message, "token is expired") {
c.callOnTokenExpireHandlers()
}
}
responseChan <- resp
case <-c.disconnect:
responseChan <- &response{
nil,
&Error{
Type: "disconnect",
Message: "Remote kite has disconnected",
},
}
case err := <-errC:
if err != nil {
responseChan <- &response{
nil,
&Error{
Type: "sendError",
Message: err.Error(),
},
}
}
case <-afterTimeout:
responseChan <- &response{
nil,
&Error{
Type: "timeout",
Message: fmt.Sprintf("No response to %q method in %s", method, timeout),
},
}
// Remove the callback function from the map so we do not
// consume memory for unused callbacks.
if id, ok := <-removeCallback; ok {
c.scrubber.RemoveCallback(id)
}
}
}()
sendCallbackID(callbacks, removeCallback)
} | go | func (c *Client) sendMethod(method string, args []interface{}, timeout time.Duration, responseChan chan *response) {
// To clean the sent callback after response is received.
// Send/Receive in a channel to prevent race condition because
// the callback is run in a separate goroutine.
removeCallback := make(chan uint64, 1)
// When a callback is called it will send the response to this channel.
doneChan := make(chan *response, 1)
cb := c.makeResponseCallback(doneChan, removeCallback, method, args)
args = c.wrapMethodArgs(args, cb)
callbacks, errC, err := c.marshalAndSend(method, args)
if err != nil {
responseChan <- &response{
Result: nil,
Err: &Error{
Type: "sendError",
Message: err.Error(),
},
}
return
}
// nil value of afterTimeout means no timeout, it will not selected in
// select statement
var afterTimeout <-chan time.Time
if timeout > 0 {
afterTimeout = time.After(timeout)
}
// Waits until the response has came or the connection has disconnected.
go func() {
c.disconnectMu.Lock()
defer c.disconnectMu.Unlock()
select {
case resp := <-doneChan:
if e, ok := resp.Err.(*Error); ok {
if e.Type == "authenticationError" && strings.Contains(e.Message, "token is expired") {
c.callOnTokenExpireHandlers()
}
}
responseChan <- resp
case <-c.disconnect:
responseChan <- &response{
nil,
&Error{
Type: "disconnect",
Message: "Remote kite has disconnected",
},
}
case err := <-errC:
if err != nil {
responseChan <- &response{
nil,
&Error{
Type: "sendError",
Message: err.Error(),
},
}
}
case <-afterTimeout:
responseChan <- &response{
nil,
&Error{
Type: "timeout",
Message: fmt.Sprintf("No response to %q method in %s", method, timeout),
},
}
// Remove the callback function from the map so we do not
// consume memory for unused callbacks.
if id, ok := <-removeCallback; ok {
c.scrubber.RemoveCallback(id)
}
}
}()
sendCallbackID(callbacks, removeCallback)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"sendMethod",
"(",
"method",
"string",
",",
"args",
"[",
"]",
"interface",
"{",
"}",
",",
"timeout",
"time",
".",
"Duration",
",",
"responseChan",
"chan",
"*",
"response",
")",
"{",
"removeCallback",
":=",
"make",
"(",
"chan",
"uint64",
",",
"1",
")",
"\n",
"doneChan",
":=",
"make",
"(",
"chan",
"*",
"response",
",",
"1",
")",
"\n",
"cb",
":=",
"c",
".",
"makeResponseCallback",
"(",
"doneChan",
",",
"removeCallback",
",",
"method",
",",
"args",
")",
"\n",
"args",
"=",
"c",
".",
"wrapMethodArgs",
"(",
"args",
",",
"cb",
")",
"\n",
"callbacks",
",",
"errC",
",",
"err",
":=",
"c",
".",
"marshalAndSend",
"(",
"method",
",",
"args",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"responseChan",
"<-",
"&",
"response",
"{",
"Result",
":",
"nil",
",",
"Err",
":",
"&",
"Error",
"{",
"Type",
":",
"\"sendError\"",
",",
"Message",
":",
"err",
".",
"Error",
"(",
")",
",",
"}",
",",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"var",
"afterTimeout",
"<-",
"chan",
"time",
".",
"Time",
"\n",
"if",
"timeout",
">",
"0",
"{",
"afterTimeout",
"=",
"time",
".",
"After",
"(",
"timeout",
")",
"\n",
"}",
"\n",
"go",
"func",
"(",
")",
"{",
"c",
".",
"disconnectMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"disconnectMu",
".",
"Unlock",
"(",
")",
"\n",
"select",
"{",
"case",
"resp",
":=",
"<-",
"doneChan",
":",
"if",
"e",
",",
"ok",
":=",
"resp",
".",
"Err",
".",
"(",
"*",
"Error",
")",
";",
"ok",
"{",
"if",
"e",
".",
"Type",
"==",
"\"authenticationError\"",
"&&",
"strings",
".",
"Contains",
"(",
"e",
".",
"Message",
",",
"\"token is expired\"",
")",
"{",
"c",
".",
"callOnTokenExpireHandlers",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"responseChan",
"<-",
"resp",
"\n",
"case",
"<-",
"c",
".",
"disconnect",
":",
"responseChan",
"<-",
"&",
"response",
"{",
"nil",
",",
"&",
"Error",
"{",
"Type",
":",
"\"disconnect\"",
",",
"Message",
":",
"\"Remote kite has disconnected\"",
",",
"}",
",",
"}",
"\n",
"case",
"err",
":=",
"<-",
"errC",
":",
"if",
"err",
"!=",
"nil",
"{",
"responseChan",
"<-",
"&",
"response",
"{",
"nil",
",",
"&",
"Error",
"{",
"Type",
":",
"\"sendError\"",
",",
"Message",
":",
"err",
".",
"Error",
"(",
")",
",",
"}",
",",
"}",
"\n",
"}",
"\n",
"case",
"<-",
"afterTimeout",
":",
"responseChan",
"<-",
"&",
"response",
"{",
"nil",
",",
"&",
"Error",
"{",
"Type",
":",
"\"timeout\"",
",",
"Message",
":",
"fmt",
".",
"Sprintf",
"(",
"\"No response to %q method in %s\"",
",",
"method",
",",
"timeout",
")",
",",
"}",
",",
"}",
"\n",
"if",
"id",
",",
"ok",
":=",
"<-",
"removeCallback",
";",
"ok",
"{",
"c",
".",
"scrubber",
".",
"RemoveCallback",
"(",
"id",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"sendCallbackID",
"(",
"callbacks",
",",
"removeCallback",
")",
"\n",
"}"
] | // sendMethod wraps the arguments, adds a response callback,
// marshals the message and send it over the wire. | [
"sendMethod",
"wraps",
"the",
"arguments",
"adds",
"a",
"response",
"callback",
"marshals",
"the",
"message",
"and",
"send",
"it",
"over",
"the",
"wire",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L753-L834 | train |
koding/kite | client.go | marshalAndSend | func (c *Client) marshalAndSend(method interface{}, arguments []interface{}) (callbacks map[string]dnode.Path, errC <-chan error, err error) {
// scrub trough the arguments and save any callbacks.
callbacks = c.scrubber.Scrub(arguments)
defer func() {
if err != nil {
c.removeCallbacks(callbacks)
}
}()
// Do not encode empty arguments as "null", make it "[]".
if arguments == nil {
arguments = make([]interface{}, 0)
}
rawArgs, err := json.Marshal(arguments)
if err != nil {
return nil, nil, err
}
msg := dnode.Message{
Method: method,
Arguments: &dnode.Partial{Raw: rawArgs},
Callbacks: callbacks,
}
p, err := json.Marshal(msg)
if err != nil {
return nil, nil, err
}
select {
case <-c.closeChan:
return nil, nil, errors.New("can't send, client is closed")
default:
if c.getSession() == nil {
return nil, nil, errors.New("can't send, session is not established yet")
}
errC := make(chan error, 1)
c.send <- &message{
p: p,
errC: errC,
}
return callbacks, errC, nil
}
} | go | func (c *Client) marshalAndSend(method interface{}, arguments []interface{}) (callbacks map[string]dnode.Path, errC <-chan error, err error) {
// scrub trough the arguments and save any callbacks.
callbacks = c.scrubber.Scrub(arguments)
defer func() {
if err != nil {
c.removeCallbacks(callbacks)
}
}()
// Do not encode empty arguments as "null", make it "[]".
if arguments == nil {
arguments = make([]interface{}, 0)
}
rawArgs, err := json.Marshal(arguments)
if err != nil {
return nil, nil, err
}
msg := dnode.Message{
Method: method,
Arguments: &dnode.Partial{Raw: rawArgs},
Callbacks: callbacks,
}
p, err := json.Marshal(msg)
if err != nil {
return nil, nil, err
}
select {
case <-c.closeChan:
return nil, nil, errors.New("can't send, client is closed")
default:
if c.getSession() == nil {
return nil, nil, errors.New("can't send, session is not established yet")
}
errC := make(chan error, 1)
c.send <- &message{
p: p,
errC: errC,
}
return callbacks, errC, nil
}
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"marshalAndSend",
"(",
"method",
"interface",
"{",
"}",
",",
"arguments",
"[",
"]",
"interface",
"{",
"}",
")",
"(",
"callbacks",
"map",
"[",
"string",
"]",
"dnode",
".",
"Path",
",",
"errC",
"<-",
"chan",
"error",
",",
"err",
"error",
")",
"{",
"callbacks",
"=",
"c",
".",
"scrubber",
".",
"Scrub",
"(",
"arguments",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"removeCallbacks",
"(",
"callbacks",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"if",
"arguments",
"==",
"nil",
"{",
"arguments",
"=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"0",
")",
"\n",
"}",
"\n",
"rawArgs",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"arguments",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"msg",
":=",
"dnode",
".",
"Message",
"{",
"Method",
":",
"method",
",",
"Arguments",
":",
"&",
"dnode",
".",
"Partial",
"{",
"Raw",
":",
"rawArgs",
"}",
",",
"Callbacks",
":",
"callbacks",
",",
"}",
"\n",
"p",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"msg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"select",
"{",
"case",
"<-",
"c",
".",
"closeChan",
":",
"return",
"nil",
",",
"nil",
",",
"errors",
".",
"New",
"(",
"\"can't send, client is closed\"",
")",
"\n",
"default",
":",
"if",
"c",
".",
"getSession",
"(",
")",
"==",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"errors",
".",
"New",
"(",
"\"can't send, session is not established yet\"",
")",
"\n",
"}",
"\n",
"errC",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"c",
".",
"send",
"<-",
"&",
"message",
"{",
"p",
":",
"p",
",",
"errC",
":",
"errC",
",",
"}",
"\n",
"return",
"callbacks",
",",
"errC",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // marshalAndSend takes a method and arguments, scrubs the arguments to create
// a dnode message, marshals the message to JSON and sends it over the wire. | [
"marshalAndSend",
"takes",
"a",
"method",
"and",
"arguments",
"scrubs",
"the",
"arguments",
"to",
"create",
"a",
"dnode",
"message",
"marshals",
"the",
"message",
"to",
"JSON",
"and",
"sends",
"it",
"over",
"the",
"wire",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L838-L886 | train |
koding/kite | client.go | sendCallbackID | func sendCallbackID(callbacks map[string]dnode.Path, ch chan<- uint64) {
// TODO fix finding of responseCallback in dnode message when removing callback
for id, path := range callbacks {
if len(path) != 2 {
continue
}
p0, ok := path[0].(string)
if !ok {
continue
}
p1, ok := path[1].(string)
if !ok {
continue
}
if p0 != "0" || p1 != "responseCallback" {
continue
}
i, _ := strconv.ParseUint(id, 10, 64)
ch <- i
return
}
close(ch)
} | go | func sendCallbackID(callbacks map[string]dnode.Path, ch chan<- uint64) {
// TODO fix finding of responseCallback in dnode message when removing callback
for id, path := range callbacks {
if len(path) != 2 {
continue
}
p0, ok := path[0].(string)
if !ok {
continue
}
p1, ok := path[1].(string)
if !ok {
continue
}
if p0 != "0" || p1 != "responseCallback" {
continue
}
i, _ := strconv.ParseUint(id, 10, 64)
ch <- i
return
}
close(ch)
} | [
"func",
"sendCallbackID",
"(",
"callbacks",
"map",
"[",
"string",
"]",
"dnode",
".",
"Path",
",",
"ch",
"chan",
"<-",
"uint64",
")",
"{",
"for",
"id",
",",
"path",
":=",
"range",
"callbacks",
"{",
"if",
"len",
"(",
"path",
")",
"!=",
"2",
"{",
"continue",
"\n",
"}",
"\n",
"p0",
",",
"ok",
":=",
"path",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"p1",
",",
"ok",
":=",
"path",
"[",
"1",
"]",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"p0",
"!=",
"\"0\"",
"||",
"p1",
"!=",
"\"responseCallback\"",
"{",
"continue",
"\n",
"}",
"\n",
"i",
",",
"_",
":=",
"strconv",
".",
"ParseUint",
"(",
"id",
",",
"10",
",",
"64",
")",
"\n",
"ch",
"<-",
"i",
"\n",
"return",
"\n",
"}",
"\n",
"close",
"(",
"ch",
")",
"\n",
"}"
] | // sendCallbackID send the callback number to be deleted after response is received. | [
"sendCallbackID",
"send",
"the",
"callback",
"number",
"to",
"be",
"deleted",
"after",
"response",
"is",
"received",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L922-L944 | train |
koding/kite | client.go | onError | func onError(err error) {
// TODO do not marshal options again here
switch e := err.(type) {
case dnode.MethodNotFoundError: // Tell the requester "method is not found".
args, err2 := e.Args.Slice()
if err2 != nil {
return
}
if len(args) < 1 {
return
}
var options callOptions
if err := args[0].Unmarshal(&options); err != nil {
return
}
if options.ResponseCallback.Caller != nil {
response := Response{
Result: nil,
Error: &Error{
Type: "methodNotFound",
Message: err.Error(),
},
}
options.ResponseCallback.Call(response)
}
}
} | go | func onError(err error) {
// TODO do not marshal options again here
switch e := err.(type) {
case dnode.MethodNotFoundError: // Tell the requester "method is not found".
args, err2 := e.Args.Slice()
if err2 != nil {
return
}
if len(args) < 1 {
return
}
var options callOptions
if err := args[0].Unmarshal(&options); err != nil {
return
}
if options.ResponseCallback.Caller != nil {
response := Response{
Result: nil,
Error: &Error{
Type: "methodNotFound",
Message: err.Error(),
},
}
options.ResponseCallback.Call(response)
}
}
} | [
"func",
"onError",
"(",
"err",
"error",
")",
"{",
"switch",
"e",
":=",
"err",
".",
"(",
"type",
")",
"{",
"case",
"dnode",
".",
"MethodNotFoundError",
":",
"args",
",",
"err2",
":=",
"e",
".",
"Args",
".",
"Slice",
"(",
")",
"\n",
"if",
"err2",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"len",
"(",
"args",
")",
"<",
"1",
"{",
"return",
"\n",
"}",
"\n",
"var",
"options",
"callOptions",
"\n",
"if",
"err",
":=",
"args",
"[",
"0",
"]",
".",
"Unmarshal",
"(",
"&",
"options",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"options",
".",
"ResponseCallback",
".",
"Caller",
"!=",
"nil",
"{",
"response",
":=",
"Response",
"{",
"Result",
":",
"nil",
",",
"Error",
":",
"&",
"Error",
"{",
"Type",
":",
"\"methodNotFound\"",
",",
"Message",
":",
"err",
".",
"Error",
"(",
")",
",",
"}",
",",
"}",
"\n",
"options",
".",
"ResponseCallback",
".",
"Call",
"(",
"response",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // onError is called when an error happened in a method handler. | [
"onError",
"is",
"called",
"when",
"an",
"error",
"happened",
"in",
"a",
"method",
"handler",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/client.go#L1003-L1032 | train |
koding/kite | server.go | Run | func (k *Kite) Run() {
if os.Getenv("KITE_VERSION") != "" {
fmt.Println(k.Kite().Version)
os.Exit(0)
}
// An error string equivalent to net.errClosing for using with http.Serve()
// during a graceful exit. Needed to declare here again because it is not
// exported by "net" package.
const errClosing = "use of closed network connection"
err := k.listenAndServe()
if err != nil {
if strings.Contains(err.Error(), errClosing) {
// The server is closed by Close() method
k.Log.Info("Kite server is closed.")
return
}
k.Log.Fatal(err.Error())
}
} | go | func (k *Kite) Run() {
if os.Getenv("KITE_VERSION") != "" {
fmt.Println(k.Kite().Version)
os.Exit(0)
}
// An error string equivalent to net.errClosing for using with http.Serve()
// during a graceful exit. Needed to declare here again because it is not
// exported by "net" package.
const errClosing = "use of closed network connection"
err := k.listenAndServe()
if err != nil {
if strings.Contains(err.Error(), errClosing) {
// The server is closed by Close() method
k.Log.Info("Kite server is closed.")
return
}
k.Log.Fatal(err.Error())
}
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"Run",
"(",
")",
"{",
"if",
"os",
".",
"Getenv",
"(",
"\"KITE_VERSION\"",
")",
"!=",
"\"\"",
"{",
"fmt",
".",
"Println",
"(",
"k",
".",
"Kite",
"(",
")",
".",
"Version",
")",
"\n",
"os",
".",
"Exit",
"(",
"0",
")",
"\n",
"}",
"\n",
"const",
"errClosing",
"=",
"\"use of closed network connection\"",
"\n",
"err",
":=",
"k",
".",
"listenAndServe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"strings",
".",
"Contains",
"(",
"err",
".",
"Error",
"(",
")",
",",
"errClosing",
")",
"{",
"k",
".",
"Log",
".",
"Info",
"(",
"\"Kite server is closed.\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"k",
".",
"Log",
".",
"Fatal",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] | // Run is a blocking method. It runs the kite server and then accepts requests
// asynchronously. It supports graceful restart via SIGUSR2. | [
"Run",
"is",
"a",
"blocking",
"method",
".",
"It",
"runs",
"the",
"kite",
"server",
"and",
"then",
"accepts",
"requests",
"asynchronously",
".",
"It",
"supports",
"graceful",
"restart",
"via",
"SIGUSR2",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/server.go#L18-L38 | train |
koding/kite | server.go | Close | func (k *Kite) Close() {
k.Log.Info("Closing kite...")
k.kontrol.Lock()
if k.kontrol != nil && k.kontrol.Client != nil {
k.kontrol.Close()
}
k.kontrol.Unlock()
if k.listener != nil {
k.listener.Close()
k.listener = nil
}
k.mu.Lock()
cache := k.verifyCache
k.mu.Unlock()
if cache != nil {
cache.StopGC()
}
} | go | func (k *Kite) Close() {
k.Log.Info("Closing kite...")
k.kontrol.Lock()
if k.kontrol != nil && k.kontrol.Client != nil {
k.kontrol.Close()
}
k.kontrol.Unlock()
if k.listener != nil {
k.listener.Close()
k.listener = nil
}
k.mu.Lock()
cache := k.verifyCache
k.mu.Unlock()
if cache != nil {
cache.StopGC()
}
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"Close",
"(",
")",
"{",
"k",
".",
"Log",
".",
"Info",
"(",
"\"Closing kite...\"",
")",
"\n",
"k",
".",
"kontrol",
".",
"Lock",
"(",
")",
"\n",
"if",
"k",
".",
"kontrol",
"!=",
"nil",
"&&",
"k",
".",
"kontrol",
".",
"Client",
"!=",
"nil",
"{",
"k",
".",
"kontrol",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"k",
".",
"kontrol",
".",
"Unlock",
"(",
")",
"\n",
"if",
"k",
".",
"listener",
"!=",
"nil",
"{",
"k",
".",
"listener",
".",
"Close",
"(",
")",
"\n",
"k",
".",
"listener",
"=",
"nil",
"\n",
"}",
"\n",
"k",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"cache",
":=",
"k",
".",
"verifyCache",
"\n",
"k",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"cache",
"!=",
"nil",
"{",
"cache",
".",
"StopGC",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Close stops the server and the kontrol client instance. | [
"Close",
"stops",
"the",
"server",
"and",
"the",
"kontrol",
"client",
"instance",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/server.go#L41-L62 | train |
koding/kite | server.go | listenAndServe | func (k *Kite) listenAndServe() error {
// create a new one if there doesn't exist
l, err := net.Listen("tcp4", k.Addr())
if err != nil {
return err
}
k.Log.Info("New listening: %s", l.Addr())
if k.TLSConfig != nil {
if k.TLSConfig.NextProtos == nil {
k.TLSConfig.NextProtos = []string{"http/1.1"}
}
l = tls.NewListener(l, k.TLSConfig)
}
k.listener = newGracefulListener(l)
// listener is ready, notify waiters.
close(k.readyC)
defer close(k.closeC) // serving is finished, notify waiters.
k.Log.Info("Serving...")
return k.serve(k.listener, k)
} | go | func (k *Kite) listenAndServe() error {
// create a new one if there doesn't exist
l, err := net.Listen("tcp4", k.Addr())
if err != nil {
return err
}
k.Log.Info("New listening: %s", l.Addr())
if k.TLSConfig != nil {
if k.TLSConfig.NextProtos == nil {
k.TLSConfig.NextProtos = []string{"http/1.1"}
}
l = tls.NewListener(l, k.TLSConfig)
}
k.listener = newGracefulListener(l)
// listener is ready, notify waiters.
close(k.readyC)
defer close(k.closeC) // serving is finished, notify waiters.
k.Log.Info("Serving...")
return k.serve(k.listener, k)
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"listenAndServe",
"(",
")",
"error",
"{",
"l",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"tcp4\"",
",",
"k",
".",
"Addr",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"k",
".",
"Log",
".",
"Info",
"(",
"\"New listening: %s\"",
",",
"l",
".",
"Addr",
"(",
")",
")",
"\n",
"if",
"k",
".",
"TLSConfig",
"!=",
"nil",
"{",
"if",
"k",
".",
"TLSConfig",
".",
"NextProtos",
"==",
"nil",
"{",
"k",
".",
"TLSConfig",
".",
"NextProtos",
"=",
"[",
"]",
"string",
"{",
"\"http/1.1\"",
"}",
"\n",
"}",
"\n",
"l",
"=",
"tls",
".",
"NewListener",
"(",
"l",
",",
"k",
".",
"TLSConfig",
")",
"\n",
"}",
"\n",
"k",
".",
"listener",
"=",
"newGracefulListener",
"(",
"l",
")",
"\n",
"close",
"(",
"k",
".",
"readyC",
")",
"\n",
"defer",
"close",
"(",
"k",
".",
"closeC",
")",
"\n",
"k",
".",
"Log",
".",
"Info",
"(",
"\"Serving...\"",
")",
"\n",
"return",
"k",
".",
"serve",
"(",
"k",
".",
"listener",
",",
"k",
")",
"\n",
"}"
] | // listenAndServe listens on the TCP network address k.URL.Host and then
// calls Serve to handle requests on incoming connectionk. | [
"listenAndServe",
"listens",
"on",
"the",
"TCP",
"network",
"address",
"k",
".",
"URL",
".",
"Host",
"and",
"then",
"calls",
"Serve",
"to",
"handle",
"requests",
"on",
"incoming",
"connectionk",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/server.go#L70-L95 | train |
koding/kite | kontrol/onceevery/onceevery.go | Do | func (o *OnceEvery) Do(f func()) {
if f == nil {
panic("passed function is nil")
}
o.mu.Lock()
now := time.Now()
ok := o.last.Add(o.Interval).Before(now)
if ok {
o.last = now
}
o.mu.Unlock()
if ok {
f()
}
} | go | func (o *OnceEvery) Do(f func()) {
if f == nil {
panic("passed function is nil")
}
o.mu.Lock()
now := time.Now()
ok := o.last.Add(o.Interval).Before(now)
if ok {
o.last = now
}
o.mu.Unlock()
if ok {
f()
}
} | [
"func",
"(",
"o",
"*",
"OnceEvery",
")",
"Do",
"(",
"f",
"func",
"(",
")",
")",
"{",
"if",
"f",
"==",
"nil",
"{",
"panic",
"(",
"\"passed function is nil\"",
")",
"\n",
"}",
"\n",
"o",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"now",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"ok",
":=",
"o",
".",
"last",
".",
"Add",
"(",
"o",
".",
"Interval",
")",
".",
"Before",
"(",
"now",
")",
"\n",
"if",
"ok",
"{",
"o",
".",
"last",
"=",
"now",
"\n",
"}",
"\n",
"o",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"ok",
"{",
"f",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Do calls the function f if and only if Do hits the given periodic interval.
// In other words Do can be called multiple times during the interval but it
// gets called only once if it hits the interval tick. So if the interval is
// 10 seconds, and a total of 100 calls are made during this period, f will
// be called it every 10 seconds. | [
"Do",
"calls",
"the",
"function",
"f",
"if",
"and",
"only",
"if",
"Do",
"hits",
"the",
"given",
"periodic",
"interval",
".",
"In",
"other",
"words",
"Do",
"can",
"be",
"called",
"multiple",
"times",
"during",
"the",
"interval",
"but",
"it",
"gets",
"called",
"only",
"once",
"if",
"it",
"hits",
"the",
"interval",
"tick",
".",
"So",
"if",
"the",
"interval",
"is",
"10",
"seconds",
"and",
"a",
"total",
"of",
"100",
"calls",
"are",
"made",
"during",
"this",
"period",
"f",
"will",
"be",
"called",
"it",
"every",
"10",
"seconds",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/onceevery/onceevery.go#L28-L44 | train |
koding/kite | systeminfo/systeminfo_darwin.go | sysctlbyname | func sysctlbyname(name string, data interface{}) (err error) {
val, err := syscall.Sysctl(name)
if err != nil {
return err
}
buf := []byte(val)
switch v := data.(type) {
case *uint64:
*v = *(*uint64)(unsafe.Pointer(&buf[0]))
return
}
bbuf := bytes.NewBuffer([]byte(val))
return binary.Read(bbuf, binary.LittleEndian, data)
} | go | func sysctlbyname(name string, data interface{}) (err error) {
val, err := syscall.Sysctl(name)
if err != nil {
return err
}
buf := []byte(val)
switch v := data.(type) {
case *uint64:
*v = *(*uint64)(unsafe.Pointer(&buf[0]))
return
}
bbuf := bytes.NewBuffer([]byte(val))
return binary.Read(bbuf, binary.LittleEndian, data)
} | [
"func",
"sysctlbyname",
"(",
"name",
"string",
",",
"data",
"interface",
"{",
"}",
")",
"(",
"err",
"error",
")",
"{",
"val",
",",
"err",
":=",
"syscall",
".",
"Sysctl",
"(",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"buf",
":=",
"[",
"]",
"byte",
"(",
"val",
")",
"\n",
"switch",
"v",
":=",
"data",
".",
"(",
"type",
")",
"{",
"case",
"*",
"uint64",
":",
"*",
"v",
"=",
"*",
"(",
"*",
"uint64",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"buf",
"[",
"0",
"]",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"bbuf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"[",
"]",
"byte",
"(",
"val",
")",
")",
"\n",
"return",
"binary",
".",
"Read",
"(",
"bbuf",
",",
"binary",
".",
"LittleEndian",
",",
"data",
")",
"\n",
"}"
] | // generic Sysctl buffer unmarshalling | [
"generic",
"Sysctl",
"buffer",
"unmarshalling"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/systeminfo/systeminfo_darwin.go#L79-L95 | train |
koding/kite | kitekey/kitekey.go | KiteHome | func KiteHome() (string, error) {
kiteHome := os.Getenv("KITE_HOME")
if kiteHome != "" {
return kiteHome, nil
}
usr, err := user.Current()
if err != nil {
return "", err
}
return filepath.Join(usr.HomeDir, kiteDirName), nil
} | go | func KiteHome() (string, error) {
kiteHome := os.Getenv("KITE_HOME")
if kiteHome != "" {
return kiteHome, nil
}
usr, err := user.Current()
if err != nil {
return "", err
}
return filepath.Join(usr.HomeDir, kiteDirName), nil
} | [
"func",
"KiteHome",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"kiteHome",
":=",
"os",
".",
"Getenv",
"(",
"\"KITE_HOME\"",
")",
"\n",
"if",
"kiteHome",
"!=",
"\"\"",
"{",
"return",
"kiteHome",
",",
"nil",
"\n",
"}",
"\n",
"usr",
",",
"err",
":=",
"user",
".",
"Current",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"filepath",
".",
"Join",
"(",
"usr",
".",
"HomeDir",
",",
"kiteDirName",
")",
",",
"nil",
"\n",
"}"
] | // KiteHome returns the home path of Kite directory.
// The returned value can be overridden by setting KITE_HOME environment variable. | [
"KiteHome",
"returns",
"the",
"home",
"path",
"of",
"Kite",
"directory",
".",
"The",
"returned",
"value",
"can",
"be",
"overridden",
"by",
"setting",
"KITE_HOME",
"environment",
"variable",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitekey/kitekey.go#L31-L41 | train |
koding/kite | kitekey/kitekey.go | Read | func Read() (string, error) {
keyPath, err := kiteKeyPath()
if err != nil {
return "", err
}
data, err := ioutil.ReadFile(keyPath)
if err != nil {
return "", err
}
return strings.TrimSpace(string(data)), nil
} | go | func Read() (string, error) {
keyPath, err := kiteKeyPath()
if err != nil {
return "", err
}
data, err := ioutil.ReadFile(keyPath)
if err != nil {
return "", err
}
return strings.TrimSpace(string(data)), nil
} | [
"func",
"Read",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"keyPath",
",",
"err",
":=",
"kiteKeyPath",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"keyPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"strings",
".",
"TrimSpace",
"(",
"string",
"(",
"data",
")",
")",
",",
"nil",
"\n",
"}"
] | // Read the contents of the kite.key file. | [
"Read",
"the",
"contents",
"of",
"the",
"kite",
".",
"key",
"file",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitekey/kitekey.go#L52-L62 | train |
koding/kite | kitekey/kitekey.go | Write | func Write(kiteKey string) error {
keyPath, err := kiteKeyPath()
if err != nil {
return err
}
err = os.MkdirAll(filepath.Dir(keyPath), 0700)
if err != nil {
return err
}
// Need to remove the previous key first because we can't write over
// when previous file's mode is 0400.
os.Remove(keyPath)
return ioutil.WriteFile(keyPath, []byte(kiteKey), 0400)
} | go | func Write(kiteKey string) error {
keyPath, err := kiteKeyPath()
if err != nil {
return err
}
err = os.MkdirAll(filepath.Dir(keyPath), 0700)
if err != nil {
return err
}
// Need to remove the previous key first because we can't write over
// when previous file's mode is 0400.
os.Remove(keyPath)
return ioutil.WriteFile(keyPath, []byte(kiteKey), 0400)
} | [
"func",
"Write",
"(",
"kiteKey",
"string",
")",
"error",
"{",
"keyPath",
",",
"err",
":=",
"kiteKeyPath",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"os",
".",
"MkdirAll",
"(",
"filepath",
".",
"Dir",
"(",
"keyPath",
")",
",",
"0700",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"os",
".",
"Remove",
"(",
"keyPath",
")",
"\n",
"return",
"ioutil",
".",
"WriteFile",
"(",
"keyPath",
",",
"[",
"]",
"byte",
"(",
"kiteKey",
")",
",",
"0400",
")",
"\n",
"}"
] | // Write over the kite.key file. | [
"Write",
"over",
"the",
"kite",
".",
"key",
"file",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitekey/kitekey.go#L65-L81 | train |
koding/kite | kitekey/kitekey.go | Parse | func Parse() (*jwt.Token, error) {
kiteKey, err := Read()
if err != nil {
return nil, err
}
return jwt.ParseWithClaims(kiteKey, &KiteClaims{}, GetKontrolKey)
} | go | func Parse() (*jwt.Token, error) {
kiteKey, err := Read()
if err != nil {
return nil, err
}
return jwt.ParseWithClaims(kiteKey, &KiteClaims{}, GetKontrolKey)
} | [
"func",
"Parse",
"(",
")",
"(",
"*",
"jwt",
".",
"Token",
",",
"error",
")",
"{",
"kiteKey",
",",
"err",
":=",
"Read",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"jwt",
".",
"ParseWithClaims",
"(",
"kiteKey",
",",
"&",
"KiteClaims",
"{",
"}",
",",
"GetKontrolKey",
")",
"\n",
"}"
] | // Parse the kite.key file and return it as JWT token. | [
"Parse",
"the",
"kite",
".",
"key",
"file",
"and",
"return",
"it",
"as",
"JWT",
"token",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitekey/kitekey.go#L84-L91 | train |
koding/kite | kitekey/kitekey.go | ParseFile | func ParseFile(file string) (*jwt.Token, error) {
kiteKey, err := ioutil.ReadFile(file)
if err != nil {
return nil, err
}
return jwt.ParseWithClaims(string(bytes.TrimSpace(kiteKey)), &KiteClaims{}, GetKontrolKey)
} | go | func ParseFile(file string) (*jwt.Token, error) {
kiteKey, err := ioutil.ReadFile(file)
if err != nil {
return nil, err
}
return jwt.ParseWithClaims(string(bytes.TrimSpace(kiteKey)), &KiteClaims{}, GetKontrolKey)
} | [
"func",
"ParseFile",
"(",
"file",
"string",
")",
"(",
"*",
"jwt",
".",
"Token",
",",
"error",
")",
"{",
"kiteKey",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"jwt",
".",
"ParseWithClaims",
"(",
"string",
"(",
"bytes",
".",
"TrimSpace",
"(",
"kiteKey",
")",
")",
",",
"&",
"KiteClaims",
"{",
"}",
",",
"GetKontrolKey",
")",
"\n",
"}"
] | // ParseFile reads the given kite key file and parses it as a JWT token. | [
"ParseFile",
"reads",
"the",
"given",
"kite",
"key",
"file",
"and",
"parses",
"it",
"as",
"a",
"JWT",
"token",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitekey/kitekey.go#L94-L101 | train |
koding/kite | kitekey/kitekey.go | Extract | func (e *Extractor) Extract(token *jwt.Token) (interface{}, error) {
e.Token = token
if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
return nil, errors.New("invalid signing method")
}
claims, ok := token.Claims.(*KiteClaims)
if !ok {
return nil, fmt.Errorf("no kontrol key found")
}
e.Claims = claims
return jwt.ParseRSAPublicKeyFromPEM([]byte(claims.KontrolKey))
} | go | func (e *Extractor) Extract(token *jwt.Token) (interface{}, error) {
e.Token = token
if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
return nil, errors.New("invalid signing method")
}
claims, ok := token.Claims.(*KiteClaims)
if !ok {
return nil, fmt.Errorf("no kontrol key found")
}
e.Claims = claims
return jwt.ParseRSAPublicKeyFromPEM([]byte(claims.KontrolKey))
} | [
"func",
"(",
"e",
"*",
"Extractor",
")",
"Extract",
"(",
"token",
"*",
"jwt",
".",
"Token",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"e",
".",
"Token",
"=",
"token",
"\n",
"if",
"_",
",",
"ok",
":=",
"token",
".",
"Method",
".",
"(",
"*",
"jwt",
".",
"SigningMethodRSA",
")",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"invalid signing method\"",
")",
"\n",
"}",
"\n",
"claims",
",",
"ok",
":=",
"token",
".",
"Claims",
".",
"(",
"*",
"KiteClaims",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"no kontrol key found\"",
")",
"\n",
"}",
"\n",
"e",
".",
"Claims",
"=",
"claims",
"\n",
"return",
"jwt",
".",
"ParseRSAPublicKeyFromPEM",
"(",
"[",
"]",
"byte",
"(",
"claims",
".",
"KontrolKey",
")",
")",
"\n",
"}"
] | // Extract is a keyFunc argument for jwt.Parse function. | [
"Extract",
"is",
"a",
"keyFunc",
"argument",
"for",
"jwt",
".",
"Parse",
"function",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitekey/kitekey.go#L110-L125 | train |
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", err)
}
// If Kontrol does not hold any key pairs that was used
// to generate its kitekey or no kitekey is defined,
// use a dummy entry in order to register the kontrol.
keyPair = &KeyPair{
Public: "kontrol-self",
Private: "kontrol-self",
}
if id, err := uuid.NewV4(); err == nil {
keyPair.ID = id.String()
if err := k.keyPair.AddKey(keyPair); err != nil {
k.log.Error("%s", err)
}
} else {
k.log.Error("%s", err)
}
}
if pair, err := k.keyPair.GetKeyFromPublic(keyPair.Public); err == nil {
keyPair = pair
}
value.KeyID = keyPair.ID
// Register first by adding the value to the storage. We don't return any
// error because we need to know why kontrol doesn't register itself
if err := k.storage.Add(k.Kite.Kite(), value); err != nil {
k.log.Error("%s", err)
}
for {
select {
case <-k.closed:
return
default:
if err := k.storage.Update(k.Kite.Kite(), value); err != nil {
k.log.Error("%s", err)
time.Sleep(time.Second)
continue
}
time.Sleep(HeartbeatDelay + HeartbeatInterval)
}
}
} | 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", err)
}
// If Kontrol does not hold any key pairs that was used
// to generate its kitekey or no kitekey is defined,
// use a dummy entry in order to register the kontrol.
keyPair = &KeyPair{
Public: "kontrol-self",
Private: "kontrol-self",
}
if id, err := uuid.NewV4(); err == nil {
keyPair.ID = id.String()
if err := k.keyPair.AddKey(keyPair); err != nil {
k.log.Error("%s", err)
}
} else {
k.log.Error("%s", err)
}
}
if pair, err := k.keyPair.GetKeyFromPublic(keyPair.Public); err == nil {
keyPair = pair
}
value.KeyID = keyPair.ID
// Register first by adding the value to the storage. We don't return any
// error because we need to know why kontrol doesn't register itself
if err := k.storage.Add(k.Kite.Kite(), value); err != nil {
k.log.Error("%s", err)
}
for {
select {
case <-k.closed:
return
default:
if err := k.storage.Update(k.Kite.Kite(), value); err != nil {
k.log.Error("%s", err)
time.Sleep(time.Second)
continue
}
time.Sleep(HeartbeatDelay + HeartbeatInterval)
}
}
} | [
"func",
"(",
"k",
"*",
"Kontrol",
")",
"registerSelf",
"(",
")",
"{",
"value",
":=",
"&",
"kontrolprotocol",
".",
"RegisterValue",
"{",
"URL",
":",
"k",
".",
"Kite",
".",
"Config",
".",
"KontrolURL",
",",
"}",
"\n",
"if",
"k",
".",
"RegisterURL",
"!=",
"\"\"",
"{",
"value",
".",
"URL",
"=",
"k",
".",
"RegisterURL",
"\n",
"}",
"\n",
"keyPair",
",",
"err",
":=",
"k",
".",
"KeyPair",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"!=",
"errNoSelfKeyPair",
"{",
"k",
".",
"log",
".",
"Error",
"(",
"\"%s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"keyPair",
"=",
"&",
"KeyPair",
"{",
"Public",
":",
"\"kontrol-self\"",
",",
"Private",
":",
"\"kontrol-self\"",
",",
"}",
"\n",
"if",
"id",
",",
"err",
":=",
"uuid",
".",
"NewV4",
"(",
")",
";",
"err",
"==",
"nil",
"{",
"keyPair",
".",
"ID",
"=",
"id",
".",
"String",
"(",
")",
"\n",
"if",
"err",
":=",
"k",
".",
"keyPair",
".",
"AddKey",
"(",
"keyPair",
")",
";",
"err",
"!=",
"nil",
"{",
"k",
".",
"log",
".",
"Error",
"(",
"\"%s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"k",
".",
"log",
".",
"Error",
"(",
"\"%s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"pair",
",",
"err",
":=",
"k",
".",
"keyPair",
".",
"GetKeyFromPublic",
"(",
"keyPair",
".",
"Public",
")",
";",
"err",
"==",
"nil",
"{",
"keyPair",
"=",
"pair",
"\n",
"}",
"\n",
"value",
".",
"KeyID",
"=",
"keyPair",
".",
"ID",
"\n",
"if",
"err",
":=",
"k",
".",
"storage",
".",
"Add",
"(",
"k",
".",
"Kite",
".",
"Kite",
"(",
")",
",",
"value",
")",
";",
"err",
"!=",
"nil",
"{",
"k",
".",
"log",
".",
"Error",
"(",
"\"%s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"k",
".",
"closed",
":",
"return",
"\n",
"default",
":",
"if",
"err",
":=",
"k",
".",
"storage",
".",
"Update",
"(",
"k",
".",
"Kite",
".",
"Kite",
"(",
")",
",",
"value",
")",
";",
"err",
"!=",
"nil",
"{",
"k",
".",
"log",
".",
"Error",
"(",
"\"%s\"",
",",
"err",
")",
"\n",
"time",
".",
"Sleep",
"(",
"time",
".",
"Second",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"time",
".",
"Sleep",
"(",
"HeartbeatDelay",
"+",
"HeartbeatInterval",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // 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 | train |
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.lastPublic) - i - 1
keyFn := func(token *jwt.Token) (interface{}, error) {
if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
return nil, errors.New("invalid signing method")
}
return jwt.ParseRSAPublicKeyFromPEM([]byte(k.lastPublic[ri]))
}
if _, err := jwt.ParseWithClaims(kiteKey, &kitekey.KiteClaims{}, keyFn); err != nil {
me.err = append(me.err, err)
continue
}
keyIndex = ri
break
}
if keyIndex == -1 {
return nil, fmt.Errorf("no matching self key pair found: %s", me)
}
k.selfKeyPair = &KeyPair{
ID: k.lastIDs[keyIndex],
Public: k.lastPublic[keyIndex],
Private: k.lastPrivate[keyIndex],
}
return k.selfKeyPair, nil
} | 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.lastPublic) - i - 1
keyFn := func(token *jwt.Token) (interface{}, error) {
if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
return nil, errors.New("invalid signing method")
}
return jwt.ParseRSAPublicKeyFromPEM([]byte(k.lastPublic[ri]))
}
if _, err := jwt.ParseWithClaims(kiteKey, &kitekey.KiteClaims{}, keyFn); err != nil {
me.err = append(me.err, err)
continue
}
keyIndex = ri
break
}
if keyIndex == -1 {
return nil, fmt.Errorf("no matching self key pair found: %s", me)
}
k.selfKeyPair = &KeyPair{
ID: k.lastIDs[keyIndex],
Public: k.lastPublic[keyIndex],
Private: k.lastPrivate[keyIndex],
}
return k.selfKeyPair, nil
} | [
"func",
"(",
"k",
"*",
"Kontrol",
")",
"KeyPair",
"(",
")",
"(",
"pair",
"*",
"KeyPair",
",",
"err",
"error",
")",
"{",
"if",
"k",
".",
"selfKeyPair",
"!=",
"nil",
"{",
"return",
"k",
".",
"selfKeyPair",
",",
"nil",
"\n",
"}",
"\n",
"kiteKey",
":=",
"k",
".",
"Kite",
".",
"KiteKey",
"(",
")",
"\n",
"if",
"kiteKey",
"==",
"\"\"",
"||",
"len",
"(",
"k",
".",
"lastPublic",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errNoSelfKeyPair",
"\n",
"}",
"\n",
"keyIndex",
":=",
"-",
"1",
"\n",
"me",
":=",
"new",
"(",
"multiError",
")",
"\n",
"for",
"i",
":=",
"range",
"k",
".",
"lastPublic",
"{",
"ri",
":=",
"len",
"(",
"k",
".",
"lastPublic",
")",
"-",
"i",
"-",
"1",
"\n",
"keyFn",
":=",
"func",
"(",
"token",
"*",
"jwt",
".",
"Token",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"token",
".",
"Method",
".",
"(",
"*",
"jwt",
".",
"SigningMethodRSA",
")",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"invalid signing method\"",
")",
"\n",
"}",
"\n",
"return",
"jwt",
".",
"ParseRSAPublicKeyFromPEM",
"(",
"[",
"]",
"byte",
"(",
"k",
".",
"lastPublic",
"[",
"ri",
"]",
")",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"jwt",
".",
"ParseWithClaims",
"(",
"kiteKey",
",",
"&",
"kitekey",
".",
"KiteClaims",
"{",
"}",
",",
"keyFn",
")",
";",
"err",
"!=",
"nil",
"{",
"me",
".",
"err",
"=",
"append",
"(",
"me",
".",
"err",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"keyIndex",
"=",
"ri",
"\n",
"break",
"\n",
"}",
"\n",
"if",
"keyIndex",
"==",
"-",
"1",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"no matching self key pair found: %s\"",
",",
"me",
")",
"\n",
"}",
"\n",
"k",
".",
"selfKeyPair",
"=",
"&",
"KeyPair",
"{",
"ID",
":",
"k",
".",
"lastIDs",
"[",
"keyIndex",
"]",
",",
"Public",
":",
"k",
".",
"lastPublic",
"[",
"keyIndex",
"]",
",",
"Private",
":",
"k",
".",
"lastPrivate",
"[",
"keyIndex",
"]",
",",
"}",
"\n",
"return",
"k",
".",
"selfKeyPair",
",",
"nil",
"\n",
"}"
] | // 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 | train |
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",
"}",
"\n",
"k",
".",
"tokenCache",
"[",
"key",
"]",
"=",
"cachedToken",
"{",
"signed",
":",
"signed",
",",
"timer",
":",
"time",
".",
"AfterFunc",
"(",
"k",
".",
"tokenTTL",
"(",
")",
"-",
"k",
".",
"tokenLeeway",
"(",
")",
",",
"func",
"(",
")",
"{",
"k",
".",
"tokenCacheMu",
".",
"Lock",
"(",
")",
"\n",
"delete",
"(",
"k",
".",
"tokenCache",
",",
"key",
")",
"\n",
"k",
".",
"tokenCacheMu",
".",
"Unlock",
"(",
")",
"\n",
"}",
")",
",",
"}",
"\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",
"cache",
"it",
"will",
"be",
"overwritten",
"with",
"a",
"new",
"value",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/kontrol.go#L543-L556 | train |
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",
"(",
"\"json.Partial: UnmarshalJSON on nil pointer\"",
")",
"\n",
"}",
"\n",
"p",
".",
"Raw",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"data",
")",
")",
"\n",
"copy",
"(",
"p",
".",
"Raw",
",",
"data",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // 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 | train |
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",
"{",
"return",
"\n",
"}",
"\n",
"if",
"len",
"(",
"a",
")",
"!=",
"length",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"\"Invalid array length\"",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // 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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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 | train |
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",
"for",
"k",
",",
"v",
":=",
"range",
"fields",
"{",
"if",
"v",
"==",
"\"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Empty Kite field: %s\"",
",",
"k",
")",
"\n",
"}",
"\n",
"if",
"strings",
".",
"ContainsRune",
"(",
"v",
",",
"'/'",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Field \\\"%s\\\" must not contain '/'\"",
",",
"\\\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"\\\"",
"\n",
"}"
] | // 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 | train |
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 true
}
// ID is empty too!
return false
} | 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 true
}
// ID is empty too!
return false
} | [
"func",
"onlyIDQuery",
"(",
"q",
"*",
"protocol",
".",
"KontrolQuery",
")",
"bool",
"{",
"fields",
":=",
"q",
".",
"Fields",
"(",
")",
"\n",
"for",
"_",
",",
"k",
":=",
"range",
"keyOrder",
"{",
"v",
":=",
"fields",
"[",
"k",
"]",
"\n",
"if",
"k",
"!=",
"\"id\"",
"&&",
"v",
"!=",
"\"\"",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"fields",
"[",
"\"id\"",
"]",
"!=",
"\"\"",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // 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 | train |
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/go1.3#map, order is important and we can't rely on
// maps because the keys are not ordered :)
for _, key := range keyOrder {
v := fields[key]
if v == "" {
empty = true
empytField = key
continue
}
if empty && v != "" {
return "", fmt.Errorf("Invalid query. Query option is not set: %s", empytField)
}
path = path + v + "/"
}
path = strings.TrimSuffix(path, "/")
return path, nil
} | 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/go1.3#map, order is important and we can't rely on
// maps because the keys are not ordered :)
for _, key := range keyOrder {
v := fields[key]
if v == "" {
empty = true
empytField = key
continue
}
if empty && v != "" {
return "", fmt.Errorf("Invalid query. Query option is not set: %s", empytField)
}
path = path + v + "/"
}
path = strings.TrimSuffix(path, "/")
return path, nil
} | [
"func",
"GetQueryKey",
"(",
"q",
"*",
"protocol",
".",
"KontrolQuery",
")",
"(",
"string",
",",
"error",
")",
"{",
"fields",
":=",
"q",
".",
"Fields",
"(",
")",
"\n",
"if",
"q",
".",
"Username",
"==",
"\"\"",
"{",
"return",
"\"\"",
",",
"errors",
".",
"New",
"(",
"\"Empty username field\"",
")",
"\n",
"}",
"\n",
"path",
":=",
"\"/\"",
"\n",
"empty",
":=",
"false",
"\n",
"empytField",
":=",
"\"\"",
"\n",
"for",
"_",
",",
"key",
":=",
"range",
"keyOrder",
"{",
"v",
":=",
"fields",
"[",
"key",
"]",
"\n",
"if",
"v",
"==",
"\"\"",
"{",
"empty",
"=",
"true",
"\n",
"empytField",
"=",
"key",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"empty",
"&&",
"v",
"!=",
"\"\"",
"{",
"return",
"\"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"Invalid query. Query option is not set: %s\"",
",",
"empytField",
")",
"\n",
"}",
"\n",
"path",
"=",
"path",
"+",
"v",
"+",
"\"/\"",
"\n",
"}",
"\n",
"path",
"=",
"strings",
".",
"TrimSuffix",
"(",
"path",
",",
"\"/\"",
")",
"\n",
"return",
"path",
",",
"nil",
"\n",
"}"
] | // 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 | train |
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",
"by",
"others",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L163-L165 | train |
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)
kClient := &kontrolClient{
readyConnected: make(chan struct{}),
readyRegistered: make(chan struct{}),
registerChan: make(chan *url.URL, 1),
}
k := &Kite{
Config: cfg,
Log: l,
SetLogLevel: setlevel,
Authenticators: make(map[string]func(*Request) error),
handlers: make(map[string]*Method),
kontrol: kClient,
name: name,
version: version,
Id: kiteID.String(),
readyC: make(chan bool),
closeC: make(chan bool),
heartbeatC: make(chan *heartbeatReq, 1),
muxer: mux.NewRouter(),
}
if cfg != nil && cfg.UseWebRTC {
k.WebRTCHandler = NewWebRCTHandler()
}
// All sockjs communication is done through this endpoint..
k.muxer.PathPrefix("/kite").Handler(sockjs.NewHandler("/kite", *cfg.SockJS, k.sockjsHandler))
// Add useful debug logs
k.OnConnect(func(c *Client) { k.Log.Debug("New session: %s", c.session.ID()) })
k.OnFirstRequest(func(c *Client) { k.Log.Debug("Session %q is identified as %q", c.session.ID(), c.Kite) })
k.OnDisconnect(func(c *Client) { k.Log.Debug("Kite has disconnected: %q", c.Kite) })
k.OnRegister(k.updateAuth)
// Every kite should be able to authenticate the user from token.
// Tokens are granted by Kontrol Kite.
k.Authenticators["token"] = k.AuthenticateFromToken
// A kite accepts requests with the same username.
k.Authenticators["kiteKey"] = k.AuthenticateFromKiteKey
// Register default methods and handlers.
k.addDefaultHandlers()
go k.processHeartbeats()
return k
} | 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)
kClient := &kontrolClient{
readyConnected: make(chan struct{}),
readyRegistered: make(chan struct{}),
registerChan: make(chan *url.URL, 1),
}
k := &Kite{
Config: cfg,
Log: l,
SetLogLevel: setlevel,
Authenticators: make(map[string]func(*Request) error),
handlers: make(map[string]*Method),
kontrol: kClient,
name: name,
version: version,
Id: kiteID.String(),
readyC: make(chan bool),
closeC: make(chan bool),
heartbeatC: make(chan *heartbeatReq, 1),
muxer: mux.NewRouter(),
}
if cfg != nil && cfg.UseWebRTC {
k.WebRTCHandler = NewWebRCTHandler()
}
// All sockjs communication is done through this endpoint..
k.muxer.PathPrefix("/kite").Handler(sockjs.NewHandler("/kite", *cfg.SockJS, k.sockjsHandler))
// Add useful debug logs
k.OnConnect(func(c *Client) { k.Log.Debug("New session: %s", c.session.ID()) })
k.OnFirstRequest(func(c *Client) { k.Log.Debug("Session %q is identified as %q", c.session.ID(), c.Kite) })
k.OnDisconnect(func(c *Client) { k.Log.Debug("Kite has disconnected: %q", c.Kite) })
k.OnRegister(k.updateAuth)
// Every kite should be able to authenticate the user from token.
// Tokens are granted by Kontrol Kite.
k.Authenticators["token"] = k.AuthenticateFromToken
// A kite accepts requests with the same username.
k.Authenticators["kiteKey"] = k.AuthenticateFromKiteKey
// Register default methods and handlers.
k.addDefaultHandlers()
go k.processHeartbeats()
return k
} | [
"func",
"NewWithConfig",
"(",
"name",
",",
"version",
"string",
",",
"cfg",
"*",
"config",
".",
"Config",
")",
"*",
"Kite",
"{",
"if",
"name",
"==",
"\"\"",
"{",
"panic",
"(",
"\"kite: name cannot be empty\"",
")",
"\n",
"}",
"\n",
"if",
"digits",
":=",
"strings",
".",
"Split",
"(",
"version",
",",
"\".\"",
")",
";",
"len",
"(",
"digits",
")",
"!=",
"3",
"{",
"panic",
"(",
"\"kite: version must be 3-digits semantic version\"",
")",
"\n",
"}",
"\n",
"kiteID",
":=",
"uuid",
".",
"Must",
"(",
"uuid",
".",
"NewV4",
"(",
")",
")",
"\n",
"l",
",",
"setlevel",
":=",
"newLogger",
"(",
"name",
")",
"\n",
"kClient",
":=",
"&",
"kontrolClient",
"{",
"readyConnected",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"readyRegistered",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"registerChan",
":",
"make",
"(",
"chan",
"*",
"url",
".",
"URL",
",",
"1",
")",
",",
"}",
"\n",
"k",
":=",
"&",
"Kite",
"{",
"Config",
":",
"cfg",
",",
"Log",
":",
"l",
",",
"SetLogLevel",
":",
"setlevel",
",",
"Authenticators",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"func",
"(",
"*",
"Request",
")",
"error",
")",
",",
"handlers",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Method",
")",
",",
"kontrol",
":",
"kClient",
",",
"name",
":",
"name",
",",
"version",
":",
"version",
",",
"Id",
":",
"kiteID",
".",
"String",
"(",
")",
",",
"readyC",
":",
"make",
"(",
"chan",
"bool",
")",
",",
"closeC",
":",
"make",
"(",
"chan",
"bool",
")",
",",
"heartbeatC",
":",
"make",
"(",
"chan",
"*",
"heartbeatReq",
",",
"1",
")",
",",
"muxer",
":",
"mux",
".",
"NewRouter",
"(",
")",
",",
"}",
"\n",
"if",
"cfg",
"!=",
"nil",
"&&",
"cfg",
".",
"UseWebRTC",
"{",
"k",
".",
"WebRTCHandler",
"=",
"NewWebRCTHandler",
"(",
")",
"\n",
"}",
"\n",
"k",
".",
"muxer",
".",
"PathPrefix",
"(",
"\"/kite\"",
")",
".",
"Handler",
"(",
"sockjs",
".",
"NewHandler",
"(",
"\"/kite\"",
",",
"*",
"cfg",
".",
"SockJS",
",",
"k",
".",
"sockjsHandler",
")",
")",
"\n",
"k",
".",
"OnConnect",
"(",
"func",
"(",
"c",
"*",
"Client",
")",
"{",
"k",
".",
"Log",
".",
"Debug",
"(",
"\"New session: %s\"",
",",
"c",
".",
"session",
".",
"ID",
"(",
")",
")",
"}",
")",
"\n",
"k",
".",
"OnFirstRequest",
"(",
"func",
"(",
"c",
"*",
"Client",
")",
"{",
"k",
".",
"Log",
".",
"Debug",
"(",
"\"Session %q is identified as %q\"",
",",
"c",
".",
"session",
".",
"ID",
"(",
")",
",",
"c",
".",
"Kite",
")",
"}",
")",
"\n",
"k",
".",
"OnDisconnect",
"(",
"func",
"(",
"c",
"*",
"Client",
")",
"{",
"k",
".",
"Log",
".",
"Debug",
"(",
"\"Kite has disconnected: %q\"",
",",
"c",
".",
"Kite",
")",
"}",
")",
"\n",
"k",
".",
"OnRegister",
"(",
"k",
".",
"updateAuth",
")",
"\n",
"k",
".",
"Authenticators",
"[",
"\"token\"",
"]",
"=",
"k",
".",
"AuthenticateFromToken",
"\n",
"k",
".",
"Authenticators",
"[",
"\"kiteKey\"",
"]",
"=",
"k",
".",
"AuthenticateFromKiteKey",
"\n",
"k",
".",
"addDefaultHandlers",
"(",
")",
"\n",
"go",
"k",
".",
"processHeartbeats",
"(",
")",
"\n",
"return",
"k",
"\n",
"}"
] | // 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 | train |
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",
".",
"Environment",
",",
"Name",
":",
"k",
".",
"name",
",",
"Version",
":",
"k",
".",
"version",
",",
"Region",
":",
"k",
".",
"Config",
".",
"Region",
",",
"Hostname",
":",
"hostname",
",",
"ID",
":",
"k",
".",
"Id",
",",
"}",
"\n",
"}"
] | // 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 | train |
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",
"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 | train |
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",
"return",
"k",
".",
"kontrolKey",
"\n",
"}"
] | // 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 | train |
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 | train |
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",
",",
"handler",
")",
"\n",
"}"
] | // 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 | train |
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 | train |
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",
",",
"handler",
")",
"\n",
"k",
".",
"handlersMu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // 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 | train |
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",
".",
"onFirstRequestHandlers",
",",
"handler",
")",
"\n",
"k",
".",
"handlersMu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // 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 | train |
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",
",",
"handler",
")",
"\n",
"k",
".",
"handlersMu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // 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 | train |
koding/kite | kite.go | OnRegister | func (k *Kite) OnRegister(handler func(*protocol.RegisterResult)) {
k.handlersMu.Lock()
k.onRegisterHandlers = append(k.onRegisterHandlers, handler)
k.handlersMu.Unlock()
} | go | func (k *Kite) OnRegister(handler func(*protocol.RegisterResult)) {
k.handlersMu.Lock()
k.onRegisterHandlers = append(k.onRegisterHandlers, handler)
k.handlersMu.Unlock()
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"OnRegister",
"(",
"handler",
"func",
"(",
"*",
"protocol",
".",
"RegisterResult",
")",
")",
"{",
"k",
".",
"handlersMu",
".",
"Lock",
"(",
")",
"\n",
"k",
".",
"onRegisterHandlers",
"=",
"append",
"(",
"k",
".",
"onRegisterHandlers",
",",
"handler",
")",
"\n",
"k",
".",
"handlersMu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // OnRegister registers a callback which is called when a Kite registers
// to a Kontrol. | [
"OnRegister",
"registers",
"a",
"callback",
"which",
"is",
"called",
"when",
"a",
"Kite",
"registers",
"to",
"a",
"Kontrol",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L327-L331 | train |
koding/kite | kite.go | RSAKey | func (k *Kite) RSAKey(token *jwt.Token) (interface{}, error) {
k.verifyOnce.Do(k.verifyInit)
kontrolKey := k.KontrolKey()
if kontrolKey == nil {
panic("kontrol key is not set in config")
}
if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
return nil, errors.New("invalid signing method")
}
claims, ok := token.Claims.(*kitekey.KiteClaims)
if !ok {
return nil, errors.New("token does not have valid claims")
}
if claims.Issuer != k.Config.KontrolUser {
return nil, fmt.Errorf("issuer is not trusted: %s", claims.Issuer)
}
return kontrolKey, nil
} | go | func (k *Kite) RSAKey(token *jwt.Token) (interface{}, error) {
k.verifyOnce.Do(k.verifyInit)
kontrolKey := k.KontrolKey()
if kontrolKey == nil {
panic("kontrol key is not set in config")
}
if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
return nil, errors.New("invalid signing method")
}
claims, ok := token.Claims.(*kitekey.KiteClaims)
if !ok {
return nil, errors.New("token does not have valid claims")
}
if claims.Issuer != k.Config.KontrolUser {
return nil, fmt.Errorf("issuer is not trusted: %s", claims.Issuer)
}
return kontrolKey, nil
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"RSAKey",
"(",
"token",
"*",
"jwt",
".",
"Token",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"k",
".",
"verifyOnce",
".",
"Do",
"(",
"k",
".",
"verifyInit",
")",
"\n",
"kontrolKey",
":=",
"k",
".",
"KontrolKey",
"(",
")",
"\n",
"if",
"kontrolKey",
"==",
"nil",
"{",
"panic",
"(",
"\"kontrol key is not set in config\"",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"token",
".",
"Method",
".",
"(",
"*",
"jwt",
".",
"SigningMethodRSA",
")",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"invalid signing method\"",
")",
"\n",
"}",
"\n",
"claims",
",",
"ok",
":=",
"token",
".",
"Claims",
".",
"(",
"*",
"kitekey",
".",
"KiteClaims",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"token does not have valid claims\"",
")",
"\n",
"}",
"\n",
"if",
"claims",
".",
"Issuer",
"!=",
"k",
".",
"Config",
".",
"KontrolUser",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"issuer is not trusted: %s\"",
",",
"claims",
".",
"Issuer",
")",
"\n",
"}",
"\n",
"return",
"kontrolKey",
",",
"nil",
"\n",
"}"
] | // RSAKey returns the corresponding public key for the issuer of the token.
// It is called by jwt-go package when validating the signature in the token. | [
"RSAKey",
"returns",
"the",
"corresponding",
"public",
"key",
"for",
"the",
"issuer",
"of",
"the",
"token",
".",
"It",
"is",
"called",
"by",
"jwt",
"-",
"go",
"package",
"when",
"validating",
"the",
"signature",
"in",
"the",
"token",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L422-L445 | train |
koding/kite | kite.go | Error | func (err *ErrClose) Error() string {
if len(err.Errs) == 1 {
return err.Errs[0].Error()
}
var buf bytes.Buffer
fmt.Fprintf(&buf, "The following kites failed to close:\n\n")
for i, e := range err.Errs {
if e == nil {
continue
}
fmt.Fprintf(&buf, "\t[%d] %s\n", i, e)
}
return buf.String()
} | go | func (err *ErrClose) Error() string {
if len(err.Errs) == 1 {
return err.Errs[0].Error()
}
var buf bytes.Buffer
fmt.Fprintf(&buf, "The following kites failed to close:\n\n")
for i, e := range err.Errs {
if e == nil {
continue
}
fmt.Fprintf(&buf, "\t[%d] %s\n", i, e)
}
return buf.String()
} | [
"func",
"(",
"err",
"*",
"ErrClose",
")",
"Error",
"(",
")",
"string",
"{",
"if",
"len",
"(",
"err",
".",
"Errs",
")",
"==",
"1",
"{",
"return",
"err",
".",
"Errs",
"[",
"0",
"]",
".",
"Error",
"(",
")",
"\n",
"}",
"\n",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"fmt",
".",
"Fprintf",
"(",
"&",
"buf",
",",
"\"The following kites failed to close:\\n\\n\"",
")",
"\n",
"\\n",
"\n",
"\\n",
"\n",
"}"
] | // Error implements the built-in error interface. | [
"Error",
"implements",
"the",
"built",
"-",
"in",
"error",
"interface",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kite.go#L456-L474 | train |
koding/kite | kontrol/postgres.go | RunCleaner | func (p *Postgres) RunCleaner(interval, expire time.Duration) {
cleanFunc := func() {
affectedRows, err := p.CleanExpiredRows(expire)
if err != nil {
p.Log.Warning("postgres: cleaning old rows failed: %s", err)
} else if affectedRows != 0 {
p.Log.Debug("postgres: cleaned up %d rows", affectedRows)
}
}
for range time.Tick(interval) {
cleanFunc()
}
} | go | func (p *Postgres) RunCleaner(interval, expire time.Duration) {
cleanFunc := func() {
affectedRows, err := p.CleanExpiredRows(expire)
if err != nil {
p.Log.Warning("postgres: cleaning old rows failed: %s", err)
} else if affectedRows != 0 {
p.Log.Debug("postgres: cleaned up %d rows", affectedRows)
}
}
for range time.Tick(interval) {
cleanFunc()
}
} | [
"func",
"(",
"p",
"*",
"Postgres",
")",
"RunCleaner",
"(",
"interval",
",",
"expire",
"time",
".",
"Duration",
")",
"{",
"cleanFunc",
":=",
"func",
"(",
")",
"{",
"affectedRows",
",",
"err",
":=",
"p",
".",
"CleanExpiredRows",
"(",
"expire",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"p",
".",
"Log",
".",
"Warning",
"(",
"\"postgres: cleaning old rows failed: %s\"",
",",
"err",
")",
"\n",
"}",
"else",
"if",
"affectedRows",
"!=",
"0",
"{",
"p",
".",
"Log",
".",
"Debug",
"(",
"\"postgres: cleaned up %d rows\"",
",",
"affectedRows",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"range",
"time",
".",
"Tick",
"(",
"interval",
")",
"{",
"cleanFunc",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // RunCleaner deletes every "interval" duration rows which are older than
// "expire" duration based on the "updated_at" field. For more info check
// CleanExpireRows which is used to delete old rows. | [
"RunCleaner",
"deletes",
"every",
"interval",
"duration",
"rows",
"which",
"are",
"older",
"than",
"expire",
"duration",
"based",
"on",
"the",
"updated_at",
"field",
".",
"For",
"more",
"info",
"check",
"CleanExpireRows",
"which",
"is",
"used",
"to",
"delete",
"old",
"rows",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/postgres.go#L93-L106 | train |
koding/kite | kontrol/postgres.go | CleanExpiredRows | func (p *Postgres) CleanExpiredRows(expire time.Duration) (int64, error) {
// See: http://stackoverflow.com/questions/14465727/how-to-insert-things-like-now-interval-2-minutes-into-php-pdo-query
// basically by passing an integer to INTERVAL is not possible, we need to
// cast it. However there is a more simpler way, we can multiply INTERVAL
// with an integer so we just declare a one second INTERVAL and multiply it
// with the amount we want.
cleanOldRows := `DELETE FROM kite.kite WHERE updated_at < (now() at time zone 'utc') - ((INTERVAL '1 second') * $1)`
rows, err := p.DB.Exec(cleanOldRows, int64(expire/time.Second))
if err != nil {
return 0, err
}
return rows.RowsAffected()
} | go | func (p *Postgres) CleanExpiredRows(expire time.Duration) (int64, error) {
// See: http://stackoverflow.com/questions/14465727/how-to-insert-things-like-now-interval-2-minutes-into-php-pdo-query
// basically by passing an integer to INTERVAL is not possible, we need to
// cast it. However there is a more simpler way, we can multiply INTERVAL
// with an integer so we just declare a one second INTERVAL and multiply it
// with the amount we want.
cleanOldRows := `DELETE FROM kite.kite WHERE updated_at < (now() at time zone 'utc') - ((INTERVAL '1 second') * $1)`
rows, err := p.DB.Exec(cleanOldRows, int64(expire/time.Second))
if err != nil {
return 0, err
}
return rows.RowsAffected()
} | [
"func",
"(",
"p",
"*",
"Postgres",
")",
"CleanExpiredRows",
"(",
"expire",
"time",
".",
"Duration",
")",
"(",
"int64",
",",
"error",
")",
"{",
"cleanOldRows",
":=",
"`DELETE FROM kite.kite WHERE updated_at < (now() at time zone 'utc') - ((INTERVAL '1 second') * $1)`",
"\n",
"rows",
",",
"err",
":=",
"p",
".",
"DB",
".",
"Exec",
"(",
"cleanOldRows",
",",
"int64",
"(",
"expire",
"/",
"time",
".",
"Second",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"rows",
".",
"RowsAffected",
"(",
")",
"\n",
"}"
] | // CleanExpiredRows deletes rows that are at least "expire" duration old. So if
// say an expire duration of 10 second is given, it will delete all rows that
// were updated 10 seconds ago | [
"CleanExpiredRows",
"deletes",
"rows",
"that",
"are",
"at",
"least",
"expire",
"duration",
"old",
".",
"So",
"if",
"say",
"an",
"expire",
"duration",
"of",
"10",
"second",
"is",
"given",
"it",
"will",
"delete",
"all",
"rows",
"that",
"were",
"updated",
"10",
"seconds",
"ago"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/postgres.go#L111-L125 | train |
koding/kite | kontrol/postgres.go | selectQuery | func selectQuery(query *protocol.KontrolQuery) (string, []interface{}, error) {
psql := sq.StatementBuilder.PlaceholderFormat(sq.Dollar)
kites := psql.Select("*").From("kite.kite")
fields := query.Fields()
andQuery := sq.And{}
// we stop for the first empty value
for _, key := range keyOrder {
v := fields[key]
if v == "" {
continue
}
// we are using "kitename" as the columname
if key == "name" {
key = "kitename"
}
andQuery = append(andQuery, sq.Eq{key: v})
}
if len(andQuery) == 0 {
return "", nil, ErrQueryFieldsEmpty
}
return kites.Where(andQuery).ToSql()
} | go | func selectQuery(query *protocol.KontrolQuery) (string, []interface{}, error) {
psql := sq.StatementBuilder.PlaceholderFormat(sq.Dollar)
kites := psql.Select("*").From("kite.kite")
fields := query.Fields()
andQuery := sq.And{}
// we stop for the first empty value
for _, key := range keyOrder {
v := fields[key]
if v == "" {
continue
}
// we are using "kitename" as the columname
if key == "name" {
key = "kitename"
}
andQuery = append(andQuery, sq.Eq{key: v})
}
if len(andQuery) == 0 {
return "", nil, ErrQueryFieldsEmpty
}
return kites.Where(andQuery).ToSql()
} | [
"func",
"selectQuery",
"(",
"query",
"*",
"protocol",
".",
"KontrolQuery",
")",
"(",
"string",
",",
"[",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"psql",
":=",
"sq",
".",
"StatementBuilder",
".",
"PlaceholderFormat",
"(",
"sq",
".",
"Dollar",
")",
"\n",
"kites",
":=",
"psql",
".",
"Select",
"(",
"\"*\"",
")",
".",
"From",
"(",
"\"kite.kite\"",
")",
"\n",
"fields",
":=",
"query",
".",
"Fields",
"(",
")",
"\n",
"andQuery",
":=",
"sq",
".",
"And",
"{",
"}",
"\n",
"for",
"_",
",",
"key",
":=",
"range",
"keyOrder",
"{",
"v",
":=",
"fields",
"[",
"key",
"]",
"\n",
"if",
"v",
"==",
"\"\"",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"key",
"==",
"\"name\"",
"{",
"key",
"=",
"\"kitename\"",
"\n",
"}",
"\n",
"andQuery",
"=",
"append",
"(",
"andQuery",
",",
"sq",
".",
"Eq",
"{",
"key",
":",
"v",
"}",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"andQuery",
")",
"==",
"0",
"{",
"return",
"\"\"",
",",
"nil",
",",
"ErrQueryFieldsEmpty",
"\n",
"}",
"\n",
"return",
"kites",
".",
"Where",
"(",
"andQuery",
")",
".",
"ToSql",
"(",
")",
"\n",
"}"
] | // selectQuery returns a SQL query for the given query | [
"selectQuery",
"returns",
"a",
"SQL",
"query",
"for",
"the",
"given",
"query"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/postgres.go#L334-L361 | train |
koding/kite | kontrol/postgres.go | insertKiteQuery | func insertKiteQuery(kiteProt *protocol.Kite, url, keyId string) (string, []interface{}, error) {
psql := sq.StatementBuilder.PlaceholderFormat(sq.Dollar)
kiteValues := kiteProt.Values()
values := make([]interface{}, len(kiteValues))
for i, kiteVal := range kiteValues {
values[i] = kiteVal
}
values = append(values, url)
values = append(values, keyId)
return psql.Insert("kite.kite").Columns(
"username",
"environment",
"kitename",
"version",
"region",
"hostname",
"id",
"url",
"key_id",
).Values(values...).ToSql()
} | go | func insertKiteQuery(kiteProt *protocol.Kite, url, keyId string) (string, []interface{}, error) {
psql := sq.StatementBuilder.PlaceholderFormat(sq.Dollar)
kiteValues := kiteProt.Values()
values := make([]interface{}, len(kiteValues))
for i, kiteVal := range kiteValues {
values[i] = kiteVal
}
values = append(values, url)
values = append(values, keyId)
return psql.Insert("kite.kite").Columns(
"username",
"environment",
"kitename",
"version",
"region",
"hostname",
"id",
"url",
"key_id",
).Values(values...).ToSql()
} | [
"func",
"insertKiteQuery",
"(",
"kiteProt",
"*",
"protocol",
".",
"Kite",
",",
"url",
",",
"keyId",
"string",
")",
"(",
"string",
",",
"[",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"psql",
":=",
"sq",
".",
"StatementBuilder",
".",
"PlaceholderFormat",
"(",
"sq",
".",
"Dollar",
")",
"\n",
"kiteValues",
":=",
"kiteProt",
".",
"Values",
"(",
")",
"\n",
"values",
":=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"len",
"(",
"kiteValues",
")",
")",
"\n",
"for",
"i",
",",
"kiteVal",
":=",
"range",
"kiteValues",
"{",
"values",
"[",
"i",
"]",
"=",
"kiteVal",
"\n",
"}",
"\n",
"values",
"=",
"append",
"(",
"values",
",",
"url",
")",
"\n",
"values",
"=",
"append",
"(",
"values",
",",
"keyId",
")",
"\n",
"return",
"psql",
".",
"Insert",
"(",
"\"kite.kite\"",
")",
".",
"Columns",
"(",
"\"username\"",
",",
"\"environment\"",
",",
"\"kitename\"",
",",
"\"version\"",
",",
"\"region\"",
",",
"\"hostname\"",
",",
"\"id\"",
",",
"\"url\"",
",",
"\"key_id\"",
",",
")",
".",
"Values",
"(",
"values",
"...",
")",
".",
"ToSql",
"(",
")",
"\n",
"}"
] | // inseryKiteQuery inserts the given kite, url and key to the kite.kite table | [
"inseryKiteQuery",
"inserts",
"the",
"given",
"kite",
"url",
"and",
"key",
"to",
"the",
"kite",
".",
"kite",
"table"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kontrol/postgres.go#L364-L388 | train |
koding/kite | logger_unix.go | SetupSignalHandler | func (k *Kite) SetupSignalHandler() {
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGUSR2)
go func() {
for s := range c {
k.Log.Info("Got signal: %s", s)
if debugMode {
// toogle back to old settings.
k.Log.Info("Disabling debug mode")
if k.SetLogLevel == nil {
k.Log.Error("SetLogLevel is not defined")
continue
}
k.SetLogLevel(getLogLevel())
debugMode = false
} else {
k.Log.Info("Enabling debug mode")
if k.SetLogLevel == nil {
k.Log.Error("SetLogLevel is not defined")
continue
}
k.SetLogLevel(DEBUG)
debugMode = true
}
}
}()
} | go | func (k *Kite) SetupSignalHandler() {
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGUSR2)
go func() {
for s := range c {
k.Log.Info("Got signal: %s", s)
if debugMode {
// toogle back to old settings.
k.Log.Info("Disabling debug mode")
if k.SetLogLevel == nil {
k.Log.Error("SetLogLevel is not defined")
continue
}
k.SetLogLevel(getLogLevel())
debugMode = false
} else {
k.Log.Info("Enabling debug mode")
if k.SetLogLevel == nil {
k.Log.Error("SetLogLevel is not defined")
continue
}
k.SetLogLevel(DEBUG)
debugMode = true
}
}
}()
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"SetupSignalHandler",
"(",
")",
"{",
"c",
":=",
"make",
"(",
"chan",
"os",
".",
"Signal",
",",
"1",
")",
"\n",
"signal",
".",
"Notify",
"(",
"c",
",",
"syscall",
".",
"SIGUSR2",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"s",
":=",
"range",
"c",
"{",
"k",
".",
"Log",
".",
"Info",
"(",
"\"Got signal: %s\"",
",",
"s",
")",
"\n",
"if",
"debugMode",
"{",
"k",
".",
"Log",
".",
"Info",
"(",
"\"Disabling debug mode\"",
")",
"\n",
"if",
"k",
".",
"SetLogLevel",
"==",
"nil",
"{",
"k",
".",
"Log",
".",
"Error",
"(",
"\"SetLogLevel is not defined\"",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"k",
".",
"SetLogLevel",
"(",
"getLogLevel",
"(",
")",
")",
"\n",
"debugMode",
"=",
"false",
"\n",
"}",
"else",
"{",
"k",
".",
"Log",
".",
"Info",
"(",
"\"Enabling debug mode\"",
")",
"\n",
"if",
"k",
".",
"SetLogLevel",
"==",
"nil",
"{",
"k",
".",
"Log",
".",
"Error",
"(",
"\"SetLogLevel is not defined\"",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"k",
".",
"SetLogLevel",
"(",
"DEBUG",
")",
"\n",
"debugMode",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}"
] | // SetupSignalHandler listens to signals and toggles the log level to DEBUG
// mode when it received a SIGUSR2 signal. Another SIGUSR2 toggles the log
// level back to the old level. | [
"SetupSignalHandler",
"listens",
"to",
"signals",
"and",
"toggles",
"the",
"log",
"level",
"to",
"DEBUG",
"mode",
"when",
"it",
"received",
"a",
"SIGUSR2",
"signal",
".",
"Another",
"SIGUSR2",
"toggles",
"the",
"log",
"level",
"back",
"to",
"the",
"old",
"level",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/logger_unix.go#L14-L44 | train |
koding/kite | sockjsclient/xhr.go | DialXHR | func DialXHR(uri string, cfg *config.Config) (*XHRSession, error) {
// following /server_id/session_id should always be the same for every session
serverID := threeDigits()
sessionID := utils.RandomString(20)
sessionURL := uri + "/" + serverID + "/" + sessionID
// start the initial session handshake
sessionResp, err := cfg.XHR.Post(sessionURL+"/xhr", "text/plain", nil)
if err != nil {
return nil, err
}
defer sessionResp.Body.Close()
if sessionResp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("Starting new session failed. Want: %d Got: %d",
http.StatusOK, sessionResp.StatusCode)
}
frame, err := newFrameReader(sessionResp.Body, cfg.Timeout).ReadByte()
if err != nil {
return nil, err
}
if frame != 'o' {
return nil, fmt.Errorf("can't start session, invalid frame: %s", string(frame))
}
return &XHRSession{
client: cfg.XHR,
timeout: cfg.Timeout,
sessionID: sessionID,
sessionURL: sessionURL,
state: sockjs.SessionActive,
abort: make(chan struct{}, 1),
}, nil
} | go | func DialXHR(uri string, cfg *config.Config) (*XHRSession, error) {
// following /server_id/session_id should always be the same for every session
serverID := threeDigits()
sessionID := utils.RandomString(20)
sessionURL := uri + "/" + serverID + "/" + sessionID
// start the initial session handshake
sessionResp, err := cfg.XHR.Post(sessionURL+"/xhr", "text/plain", nil)
if err != nil {
return nil, err
}
defer sessionResp.Body.Close()
if sessionResp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("Starting new session failed. Want: %d Got: %d",
http.StatusOK, sessionResp.StatusCode)
}
frame, err := newFrameReader(sessionResp.Body, cfg.Timeout).ReadByte()
if err != nil {
return nil, err
}
if frame != 'o' {
return nil, fmt.Errorf("can't start session, invalid frame: %s", string(frame))
}
return &XHRSession{
client: cfg.XHR,
timeout: cfg.Timeout,
sessionID: sessionID,
sessionURL: sessionURL,
state: sockjs.SessionActive,
abort: make(chan struct{}, 1),
}, nil
} | [
"func",
"DialXHR",
"(",
"uri",
"string",
",",
"cfg",
"*",
"config",
".",
"Config",
")",
"(",
"*",
"XHRSession",
",",
"error",
")",
"{",
"serverID",
":=",
"threeDigits",
"(",
")",
"\n",
"sessionID",
":=",
"utils",
".",
"RandomString",
"(",
"20",
")",
"\n",
"sessionURL",
":=",
"uri",
"+",
"\"/\"",
"+",
"serverID",
"+",
"\"/\"",
"+",
"sessionID",
"\n",
"sessionResp",
",",
"err",
":=",
"cfg",
".",
"XHR",
".",
"Post",
"(",
"sessionURL",
"+",
"\"/xhr\"",
",",
"\"text/plain\"",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"sessionResp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"if",
"sessionResp",
".",
"StatusCode",
"!=",
"http",
".",
"StatusOK",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"Starting new session failed. Want: %d Got: %d\"",
",",
"http",
".",
"StatusOK",
",",
"sessionResp",
".",
"StatusCode",
")",
"\n",
"}",
"\n",
"frame",
",",
"err",
":=",
"newFrameReader",
"(",
"sessionResp",
".",
"Body",
",",
"cfg",
".",
"Timeout",
")",
".",
"ReadByte",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"frame",
"!=",
"'o'",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"can't start session, invalid frame: %s\"",
",",
"string",
"(",
"frame",
")",
")",
"\n",
"}",
"\n",
"return",
"&",
"XHRSession",
"{",
"client",
":",
"cfg",
".",
"XHR",
",",
"timeout",
":",
"cfg",
".",
"Timeout",
",",
"sessionID",
":",
"sessionID",
",",
"sessionURL",
":",
"sessionURL",
",",
"state",
":",
"sockjs",
".",
"SessionActive",
",",
"abort",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"1",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // DialXHR establishes a SockJS session over a XHR connection.
//
// Requires cfg.XHR to be a valid client. | [
"DialXHR",
"establishes",
"a",
"SockJS",
"session",
"over",
"a",
"XHR",
"connection",
".",
"Requires",
"cfg",
".",
"XHR",
"to",
"be",
"a",
"valid",
"client",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/sockjsclient/xhr.go#L49-L84 | train |
koding/kite | handlers.go | ServeKite | func (w *webRTCHandler) ServeKite(r *Request) (interface{}, error) {
var args protocol.WebRTCSignalMessage
if err := r.Args.One().Unmarshal(&args); err != nil {
return nil, fmt.Errorf("invalid query: %s", err)
}
args.Src = r.Client.ID
w.registerSrc(r.Client)
dst, err := w.getDst(args.Dst)
if err != nil {
return nil, err
}
return nil, dst.SendWebRTCRequest(&args)
} | go | func (w *webRTCHandler) ServeKite(r *Request) (interface{}, error) {
var args protocol.WebRTCSignalMessage
if err := r.Args.One().Unmarshal(&args); err != nil {
return nil, fmt.Errorf("invalid query: %s", err)
}
args.Src = r.Client.ID
w.registerSrc(r.Client)
dst, err := w.getDst(args.Dst)
if err != nil {
return nil, err
}
return nil, dst.SendWebRTCRequest(&args)
} | [
"func",
"(",
"w",
"*",
"webRTCHandler",
")",
"ServeKite",
"(",
"r",
"*",
"Request",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"args",
"protocol",
".",
"WebRTCSignalMessage",
"\n",
"if",
"err",
":=",
"r",
".",
"Args",
".",
"One",
"(",
")",
".",
"Unmarshal",
"(",
"&",
"args",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"invalid query: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"args",
".",
"Src",
"=",
"r",
".",
"Client",
".",
"ID",
"\n",
"w",
".",
"registerSrc",
"(",
"r",
".",
"Client",
")",
"\n",
"dst",
",",
"err",
":=",
"w",
".",
"getDst",
"(",
"args",
".",
"Dst",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"dst",
".",
"SendWebRTCRequest",
"(",
"&",
"args",
")",
"\n",
"}"
] | // ServeKite implements Hander interface. | [
"ServeKite",
"implements",
"Hander",
"interface",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/handlers.go#L64-L81 | train |
koding/kite | handlers.go | handleLog | func (k *Kite) handleLog(r *Request) (interface{}, error) {
msg, err := r.Args.One().String()
if err != nil {
return nil, err
}
k.Log.Info("%s: %s", r.Client.Name, msg)
return nil, nil
} | go | func (k *Kite) handleLog(r *Request) (interface{}, error) {
msg, err := r.Args.One().String()
if err != nil {
return nil, err
}
k.Log.Info("%s: %s", r.Client.Name, msg)
return nil, nil
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"handleLog",
"(",
"r",
"*",
"Request",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"msg",
",",
"err",
":=",
"r",
".",
"Args",
".",
"One",
"(",
")",
".",
"String",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"k",
".",
"Log",
".",
"Info",
"(",
"\"%s: %s\"",
",",
"r",
".",
"Client",
".",
"Name",
",",
"msg",
")",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] | // handleLog prints a log message to stderr. | [
"handleLog",
"prints",
"a",
"log",
"message",
"to",
"stderr",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/handlers.go#L107-L116 | train |
koding/kite | handlers.go | handlePrint | func handlePrint(r *Request) (interface{}, error) {
return fmt.Print(r.Args.One().MustString())
} | go | func handlePrint(r *Request) (interface{}, error) {
return fmt.Print(r.Args.One().MustString())
} | [
"func",
"handlePrint",
"(",
"r",
"*",
"Request",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"return",
"fmt",
".",
"Print",
"(",
"r",
".",
"Args",
".",
"One",
"(",
")",
".",
"MustString",
"(",
")",
")",
"\n",
"}"
] | // handlePrint prints a message to stdout. | [
"handlePrint",
"prints",
"a",
"message",
"to",
"stdout",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/handlers.go#L124-L126 | train |
koding/kite | handlers.go | handlePrompt | func handlePrompt(r *Request) (interface{}, error) {
fmt.Print(r.Args.One().MustString())
var s string
_, err := fmt.Scanln(&s)
return s, err
} | go | func handlePrompt(r *Request) (interface{}, error) {
fmt.Print(r.Args.One().MustString())
var s string
_, err := fmt.Scanln(&s)
return s, err
} | [
"func",
"handlePrompt",
"(",
"r",
"*",
"Request",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"fmt",
".",
"Print",
"(",
"r",
".",
"Args",
".",
"One",
"(",
")",
".",
"MustString",
"(",
")",
")",
"\n",
"var",
"s",
"string",
"\n",
"_",
",",
"err",
":=",
"fmt",
".",
"Scanln",
"(",
"&",
"s",
")",
"\n",
"return",
"s",
",",
"err",
"\n",
"}"
] | // handlePrompt asks user a single line input. | [
"handlePrompt",
"asks",
"user",
"a",
"single",
"line",
"input",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/handlers.go#L129-L134 | train |
koding/kite | handlers.go | handleGetPass | func handleGetPass(r *Request) (interface{}, error) {
fmt.Print(r.Args.One().MustString())
data, err := terminal.ReadPassword(int(os.Stdin.Fd())) // stdin
fmt.Println()
if err != nil {
return nil, err
}
return string(data), nil
} | go | func handleGetPass(r *Request) (interface{}, error) {
fmt.Print(r.Args.One().MustString())
data, err := terminal.ReadPassword(int(os.Stdin.Fd())) // stdin
fmt.Println()
if err != nil {
return nil, err
}
return string(data), nil
} | [
"func",
"handleGetPass",
"(",
"r",
"*",
"Request",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"fmt",
".",
"Print",
"(",
"r",
".",
"Args",
".",
"One",
"(",
")",
".",
"MustString",
"(",
")",
")",
"\n",
"data",
",",
"err",
":=",
"terminal",
".",
"ReadPassword",
"(",
"int",
"(",
"os",
".",
"Stdin",
".",
"Fd",
"(",
")",
")",
")",
"\n",
"fmt",
".",
"Println",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"string",
"(",
"data",
")",
",",
"nil",
"\n",
"}"
] | // handleGetPass reads a line of input from a terminal without local echo. | [
"handleGetPass",
"reads",
"a",
"line",
"of",
"input",
"from",
"a",
"terminal",
"without",
"local",
"echo",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/handlers.go#L137-L145 | train |
koding/kite | handlers.go | handleNotifyDarwin | func handleNotifyDarwin(r *Request) (interface{}, error) {
args := r.Args.MustSliceOfLength(3)
cmd := exec.Command("osascript", "-e", fmt.Sprintf("display notification \"%s\" with title \"%s\" subtitle \"%s\"",
args[1].MustString(), args[2].MustString(), args[0].MustString()))
return nil, cmd.Start()
} | go | func handleNotifyDarwin(r *Request) (interface{}, error) {
args := r.Args.MustSliceOfLength(3)
cmd := exec.Command("osascript", "-e", fmt.Sprintf("display notification \"%s\" with title \"%s\" subtitle \"%s\"",
args[1].MustString(), args[2].MustString(), args[0].MustString()))
return nil, cmd.Start()
} | [
"func",
"handleNotifyDarwin",
"(",
"r",
"*",
"Request",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"args",
":=",
"r",
".",
"Args",
".",
"MustSliceOfLength",
"(",
"3",
")",
"\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"osascript\"",
",",
"\"-e\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"display notification \\\"%s\\\" with title \\\"%s\\\" subtitle \\\"%s\\\"\"",
",",
"\\\"",
",",
"\\\"",
",",
"\\\"",
")",
")",
"\n",
"\\\"",
"\n",
"}"
] | // handleNotifyDarwin displays a desktop notification on OS X. | [
"handleNotifyDarwin",
"displays",
"a",
"desktop",
"notification",
"on",
"OS",
"X",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/handlers.go#L148-L153 | train |
koding/kite | handlers.go | handleTunnel | func handleTunnel(r *Request) (interface{}, error) {
var args struct {
URL string
}
r.Args.One().MustUnmarshal(&args)
parsed, err := url.Parse(args.URL)
if err != nil {
return nil, err
}
requestHeader := http.Header{}
requestHeader.Add("Origin", "http://"+parsed.Host)
remoteConn, _, err := websocket.DefaultDialer.Dial(parsed.String(), requestHeader)
if err != nil {
return nil, err
}
session := sockjsclient.NewWebsocketSession(remoteConn)
go r.LocalKite.sockjsHandler(session)
return nil, nil
} | go | func handleTunnel(r *Request) (interface{}, error) {
var args struct {
URL string
}
r.Args.One().MustUnmarshal(&args)
parsed, err := url.Parse(args.URL)
if err != nil {
return nil, err
}
requestHeader := http.Header{}
requestHeader.Add("Origin", "http://"+parsed.Host)
remoteConn, _, err := websocket.DefaultDialer.Dial(parsed.String(), requestHeader)
if err != nil {
return nil, err
}
session := sockjsclient.NewWebsocketSession(remoteConn)
go r.LocalKite.sockjsHandler(session)
return nil, nil
} | [
"func",
"handleTunnel",
"(",
"r",
"*",
"Request",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"var",
"args",
"struct",
"{",
"URL",
"string",
"\n",
"}",
"\n",
"r",
".",
"Args",
".",
"One",
"(",
")",
".",
"MustUnmarshal",
"(",
"&",
"args",
")",
"\n",
"parsed",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"args",
".",
"URL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"requestHeader",
":=",
"http",
".",
"Header",
"{",
"}",
"\n",
"requestHeader",
".",
"Add",
"(",
"\"Origin\"",
",",
"\"http://\"",
"+",
"parsed",
".",
"Host",
")",
"\n",
"remoteConn",
",",
"_",
",",
"err",
":=",
"websocket",
".",
"DefaultDialer",
".",
"Dial",
"(",
"parsed",
".",
"String",
"(",
")",
",",
"requestHeader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"session",
":=",
"sockjsclient",
".",
"NewWebsocketSession",
"(",
"remoteConn",
")",
"\n",
"go",
"r",
".",
"LocalKite",
".",
"sockjsHandler",
"(",
"session",
")",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] | // handleTunnel opens two websockets, one to proxy kite and one to itself,
// then it copies the message between them. | [
"handleTunnel",
"opens",
"two",
"websockets",
"one",
"to",
"proxy",
"kite",
"and",
"one",
"to",
"itself",
"then",
"it",
"copies",
"the",
"message",
"between",
"them",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/handlers.go#L157-L180 | train |
koding/kite | tokenrenewer.go | parse | func (t *TokenRenewer) parse(tokenString string) error {
claims := &kitekey.KiteClaims{}
_, err := jwt.ParseWithClaims(tokenString, claims, t.localKite.RSAKey)
if err != nil {
valErr, ok := err.(*jwt.ValidationError)
if !ok {
return err
}
// do noy return for ValidationErrorSignatureValid. This is because we
// might asked for a kite who's public Key is different what we have.
// We still should be able to send them requests.
if (valErr.Errors & jwt.ValidationErrorSignatureInvalid) == 0 {
return fmt.Errorf("Cannot parse token: %s", err)
}
}
t.validUntil = time.Unix(claims.ExpiresAt, 0).UTC()
return nil
} | go | func (t *TokenRenewer) parse(tokenString string) error {
claims := &kitekey.KiteClaims{}
_, err := jwt.ParseWithClaims(tokenString, claims, t.localKite.RSAKey)
if err != nil {
valErr, ok := err.(*jwt.ValidationError)
if !ok {
return err
}
// do noy return for ValidationErrorSignatureValid. This is because we
// might asked for a kite who's public Key is different what we have.
// We still should be able to send them requests.
if (valErr.Errors & jwt.ValidationErrorSignatureInvalid) == 0 {
return fmt.Errorf("Cannot parse token: %s", err)
}
}
t.validUntil = time.Unix(claims.ExpiresAt, 0).UTC()
return nil
} | [
"func",
"(",
"t",
"*",
"TokenRenewer",
")",
"parse",
"(",
"tokenString",
"string",
")",
"error",
"{",
"claims",
":=",
"&",
"kitekey",
".",
"KiteClaims",
"{",
"}",
"\n",
"_",
",",
"err",
":=",
"jwt",
".",
"ParseWithClaims",
"(",
"tokenString",
",",
"claims",
",",
"t",
".",
"localKite",
".",
"RSAKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"valErr",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"jwt",
".",
"ValidationError",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"(",
"valErr",
".",
"Errors",
"&",
"jwt",
".",
"ValidationErrorSignatureInvalid",
")",
"==",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Cannot parse token: %s\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"t",
".",
"validUntil",
"=",
"time",
".",
"Unix",
"(",
"claims",
".",
"ExpiresAt",
",",
"0",
")",
".",
"UTC",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // parse the token string and set | [
"parse",
"the",
"token",
"string",
"and",
"set"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/tokenrenewer.go#L41-L61 | train |
koding/kite | tokenrenewer.go | renewDuration | func (t *TokenRenewer) renewDuration() time.Duration {
return t.validUntil.Add(-renewBefore).Sub(time.Now().UTC())
} | go | func (t *TokenRenewer) renewDuration() time.Duration {
return t.validUntil.Add(-renewBefore).Sub(time.Now().UTC())
} | [
"func",
"(",
"t",
"*",
"TokenRenewer",
")",
"renewDuration",
"(",
")",
"time",
".",
"Duration",
"{",
"return",
"t",
".",
"validUntil",
".",
"Add",
"(",
"-",
"renewBefore",
")",
".",
"Sub",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
")",
"\n",
"}"
] | // The duration from now to the time token needs to be renewed.
// Needs to be calculated after renewing the token. | [
"The",
"duration",
"from",
"now",
"to",
"the",
"time",
"token",
"needs",
"to",
"be",
"renewed",
".",
"Needs",
"to",
"be",
"calculated",
"after",
"renewing",
"the",
"token",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/tokenrenewer.go#L111-L113 | train |
koding/kite | tokenrenewer.go | renewToken | func (t *TokenRenewer) renewToken() error {
renew := &protocol.Kite{
ID: t.client.Kite.ID,
}
token, err := t.localKite.GetToken(renew)
if err != nil {
return err
}
if err = t.parse(token); err != nil {
return err
}
t.client.authMu.Lock()
t.client.Auth.Key = token
t.client.authMu.Unlock()
t.client.callOnTokenRenewHandlers(token)
return nil
} | go | func (t *TokenRenewer) renewToken() error {
renew := &protocol.Kite{
ID: t.client.Kite.ID,
}
token, err := t.localKite.GetToken(renew)
if err != nil {
return err
}
if err = t.parse(token); err != nil {
return err
}
t.client.authMu.Lock()
t.client.Auth.Key = token
t.client.authMu.Unlock()
t.client.callOnTokenRenewHandlers(token)
return nil
} | [
"func",
"(",
"t",
"*",
"TokenRenewer",
")",
"renewToken",
"(",
")",
"error",
"{",
"renew",
":=",
"&",
"protocol",
".",
"Kite",
"{",
"ID",
":",
"t",
".",
"client",
".",
"Kite",
".",
"ID",
",",
"}",
"\n",
"token",
",",
"err",
":=",
"t",
".",
"localKite",
".",
"GetToken",
"(",
"renew",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
"=",
"t",
".",
"parse",
"(",
"token",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"t",
".",
"client",
".",
"authMu",
".",
"Lock",
"(",
")",
"\n",
"t",
".",
"client",
".",
"Auth",
".",
"Key",
"=",
"token",
"\n",
"t",
".",
"client",
".",
"authMu",
".",
"Unlock",
"(",
")",
"\n",
"t",
".",
"client",
".",
"callOnTokenRenewHandlers",
"(",
"token",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // renewToken gets a new token from a kontrolClient, parses it and sets it as the token. | [
"renewToken",
"gets",
"a",
"new",
"token",
"from",
"a",
"kontrolClient",
"parses",
"it",
"and",
"sets",
"it",
"as",
"the",
"token",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/tokenrenewer.go#L144-L165 | train |
koding/kite | config/config.go | NewFromKiteKey | func NewFromKiteKey(file string) (*Config, error) {
key, err := kitekey.ParseFile(file)
if err != nil {
return nil, err
}
var c Config
if err := c.ReadToken(key); err != nil {
return nil, err
}
return &c, nil
} | go | func NewFromKiteKey(file string) (*Config, error) {
key, err := kitekey.ParseFile(file)
if err != nil {
return nil, err
}
var c Config
if err := c.ReadToken(key); err != nil {
return nil, err
}
return &c, nil
} | [
"func",
"NewFromKiteKey",
"(",
"file",
"string",
")",
"(",
"*",
"Config",
",",
"error",
")",
"{",
"key",
",",
"err",
":=",
"kitekey",
".",
"ParseFile",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"c",
"Config",
"\n",
"if",
"err",
":=",
"c",
".",
"ReadToken",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"c",
",",
"nil",
"\n",
"}"
] | // NewFromKiteKey parses the given kite key file and gives a new Config value. | [
"NewFromKiteKey",
"parses",
"the",
"given",
"kite",
"key",
"file",
"and",
"gives",
"a",
"new",
"Config",
"value",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/config/config.go#L154-L166 | train |
koding/kite | config/config.go | ReadKiteKey | func (c *Config) ReadKiteKey() error {
key, err := kitekey.Parse()
if err != nil {
return err
}
return c.ReadToken(key)
} | go | func (c *Config) ReadKiteKey() error {
key, err := kitekey.Parse()
if err != nil {
return err
}
return c.ReadToken(key)
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"ReadKiteKey",
"(",
")",
"error",
"{",
"key",
",",
"err",
":=",
"kitekey",
".",
"Parse",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"c",
".",
"ReadToken",
"(",
"key",
")",
"\n",
"}"
] | // ReadKiteKey parsed the user's kite key and returns a new Config. | [
"ReadKiteKey",
"parsed",
"the",
"user",
"s",
"kite",
"key",
"and",
"returns",
"a",
"new",
"Config",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/config/config.go#L244-L251 | train |
koding/kite | config/config.go | ReadToken | func (c *Config) ReadToken(key *jwt.Token) error {
c.KiteKey = key.Raw
claims, ok := key.Claims.(*kitekey.KiteClaims)
if !ok {
return errors.New("no claims found")
}
c.Username = claims.Subject
c.KontrolUser = claims.Issuer
c.Id = claims.Id // jti is used for jwt's but let's also use it for kite ID
c.KontrolURL = claims.KontrolURL
c.KontrolKey = claims.KontrolKey
return nil
} | go | func (c *Config) ReadToken(key *jwt.Token) error {
c.KiteKey = key.Raw
claims, ok := key.Claims.(*kitekey.KiteClaims)
if !ok {
return errors.New("no claims found")
}
c.Username = claims.Subject
c.KontrolUser = claims.Issuer
c.Id = claims.Id // jti is used for jwt's but let's also use it for kite ID
c.KontrolURL = claims.KontrolURL
c.KontrolKey = claims.KontrolKey
return nil
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"ReadToken",
"(",
"key",
"*",
"jwt",
".",
"Token",
")",
"error",
"{",
"c",
".",
"KiteKey",
"=",
"key",
".",
"Raw",
"\n",
"claims",
",",
"ok",
":=",
"key",
".",
"Claims",
".",
"(",
"*",
"kitekey",
".",
"KiteClaims",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"no claims found\"",
")",
"\n",
"}",
"\n",
"c",
".",
"Username",
"=",
"claims",
".",
"Subject",
"\n",
"c",
".",
"KontrolUser",
"=",
"claims",
".",
"Issuer",
"\n",
"c",
".",
"Id",
"=",
"claims",
".",
"Id",
"\n",
"c",
".",
"KontrolURL",
"=",
"claims",
".",
"KontrolURL",
"\n",
"c",
".",
"KontrolKey",
"=",
"claims",
".",
"KontrolKey",
"\n",
"return",
"nil",
"\n",
"}"
] | // ReadToken reads Kite Claims from JWT token and uses them to initialize Config. | [
"ReadToken",
"reads",
"Kite",
"Claims",
"from",
"JWT",
"token",
"and",
"uses",
"them",
"to",
"initialize",
"Config",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/config/config.go#L254-L269 | train |
koding/kite | config/config.go | Copy | func (c *Config) Copy() *Config {
copy := *c
if c.XHR != nil {
xhr := *copy.XHR
copy.XHR = &xhr
}
if c.Client != nil {
client := *copy.Client
copy.Client = &client
}
if c.Websocket != nil {
ws := *copy.Websocket
copy.Websocket = &ws
}
return ©
} | go | func (c *Config) Copy() *Config {
copy := *c
if c.XHR != nil {
xhr := *copy.XHR
copy.XHR = &xhr
}
if c.Client != nil {
client := *copy.Client
copy.Client = &client
}
if c.Websocket != nil {
ws := *copy.Websocket
copy.Websocket = &ws
}
return ©
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"Copy",
"(",
")",
"*",
"Config",
"{",
"copy",
":=",
"*",
"c",
"\n",
"if",
"c",
".",
"XHR",
"!=",
"nil",
"{",
"xhr",
":=",
"*",
"copy",
".",
"XHR",
"\n",
"copy",
".",
"XHR",
"=",
"&",
"xhr",
"\n",
"}",
"\n",
"if",
"c",
".",
"Client",
"!=",
"nil",
"{",
"client",
":=",
"*",
"copy",
".",
"Client",
"\n",
"copy",
".",
"Client",
"=",
"&",
"client",
"\n",
"}",
"\n",
"if",
"c",
".",
"Websocket",
"!=",
"nil",
"{",
"ws",
":=",
"*",
"copy",
".",
"Websocket",
"\n",
"copy",
".",
"Websocket",
"=",
"&",
"ws",
"\n",
"}",
"\n",
"return",
"&",
"copy",
"\n",
"}"
] | // Copy returns a new copy of the config object. | [
"Copy",
"returns",
"a",
"new",
"copy",
"of",
"the",
"config",
"object",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/config/config.go#L272-L291 | train |
koding/kite | request.go | runMethod | func (c *Client) runMethod(method *Method, args *dnode.Partial) {
var (
callFunc func(interface{}, *Error)
request *Request
)
// Recover dnode argument errors and send them back. The caller can use
// functions like MustString(), MustSlice()... without the fear of panic.
defer func() {
if r := recover(); r != nil {
debug.PrintStack()
kiteErr := createError(request, r)
c.LocalKite.Log.Error(kiteErr.Error()) // let's log it too :)
callFunc(nil, kiteErr)
}
}()
// The request that will be constructed from incoming dnode message.
request, callFunc = c.newRequest(method.name, args)
if method.authenticate {
if err := request.authenticate(); err != nil {
callFunc(nil, createError(request, err))
return
}
} else {
// if not validated accept any username it sends, also useful for test
// cases.
request.Username = request.Client.Kite.Username
}
method.mu.Lock()
if !method.initialized {
method.preHandlers = append(method.preHandlers, c.LocalKite.preHandlers...)
method.postHandlers = append(method.postHandlers, c.LocalKite.postHandlers...)
method.finalFuncs = append(method.finalFuncs, c.LocalKite.finalFuncs...)
method.initialized = true
}
method.mu.Unlock()
// check if any throttling is enabled and then check token's available.
// Tokens are filled per frequency of the initial bucket, so every request
// is going to take one token from the bucket. If many requests come in (in
// span time larger than the bucket's frequency), there will be no token's
// available more so it will return a zero.
if method.bucket != nil && method.bucket.TakeAvailable(1) == 0 {
callFunc(nil, &Error{
Type: "requestLimitError",
Message: "The maximum request rate is exceeded.",
RequestID: request.ID,
})
return
}
// Call the handler functions.
result, err := method.ServeKite(request)
callFunc(result, createError(request, err))
} | go | func (c *Client) runMethod(method *Method, args *dnode.Partial) {
var (
callFunc func(interface{}, *Error)
request *Request
)
// Recover dnode argument errors and send them back. The caller can use
// functions like MustString(), MustSlice()... without the fear of panic.
defer func() {
if r := recover(); r != nil {
debug.PrintStack()
kiteErr := createError(request, r)
c.LocalKite.Log.Error(kiteErr.Error()) // let's log it too :)
callFunc(nil, kiteErr)
}
}()
// The request that will be constructed from incoming dnode message.
request, callFunc = c.newRequest(method.name, args)
if method.authenticate {
if err := request.authenticate(); err != nil {
callFunc(nil, createError(request, err))
return
}
} else {
// if not validated accept any username it sends, also useful for test
// cases.
request.Username = request.Client.Kite.Username
}
method.mu.Lock()
if !method.initialized {
method.preHandlers = append(method.preHandlers, c.LocalKite.preHandlers...)
method.postHandlers = append(method.postHandlers, c.LocalKite.postHandlers...)
method.finalFuncs = append(method.finalFuncs, c.LocalKite.finalFuncs...)
method.initialized = true
}
method.mu.Unlock()
// check if any throttling is enabled and then check token's available.
// Tokens are filled per frequency of the initial bucket, so every request
// is going to take one token from the bucket. If many requests come in (in
// span time larger than the bucket's frequency), there will be no token's
// available more so it will return a zero.
if method.bucket != nil && method.bucket.TakeAvailable(1) == 0 {
callFunc(nil, &Error{
Type: "requestLimitError",
Message: "The maximum request rate is exceeded.",
RequestID: request.ID,
})
return
}
// Call the handler functions.
result, err := method.ServeKite(request)
callFunc(result, createError(request, err))
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"runMethod",
"(",
"method",
"*",
"Method",
",",
"args",
"*",
"dnode",
".",
"Partial",
")",
"{",
"var",
"(",
"callFunc",
"func",
"(",
"interface",
"{",
"}",
",",
"*",
"Error",
")",
"\n",
"request",
"*",
"Request",
"\n",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{",
"debug",
".",
"PrintStack",
"(",
")",
"\n",
"kiteErr",
":=",
"createError",
"(",
"request",
",",
"r",
")",
"\n",
"c",
".",
"LocalKite",
".",
"Log",
".",
"Error",
"(",
"kiteErr",
".",
"Error",
"(",
")",
")",
"\n",
"callFunc",
"(",
"nil",
",",
"kiteErr",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"request",
",",
"callFunc",
"=",
"c",
".",
"newRequest",
"(",
"method",
".",
"name",
",",
"args",
")",
"\n",
"if",
"method",
".",
"authenticate",
"{",
"if",
"err",
":=",
"request",
".",
"authenticate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"callFunc",
"(",
"nil",
",",
"createError",
"(",
"request",
",",
"err",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"else",
"{",
"request",
".",
"Username",
"=",
"request",
".",
"Client",
".",
"Kite",
".",
"Username",
"\n",
"}",
"\n",
"method",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"!",
"method",
".",
"initialized",
"{",
"method",
".",
"preHandlers",
"=",
"append",
"(",
"method",
".",
"preHandlers",
",",
"c",
".",
"LocalKite",
".",
"preHandlers",
"...",
")",
"\n",
"method",
".",
"postHandlers",
"=",
"append",
"(",
"method",
".",
"postHandlers",
",",
"c",
".",
"LocalKite",
".",
"postHandlers",
"...",
")",
"\n",
"method",
".",
"finalFuncs",
"=",
"append",
"(",
"method",
".",
"finalFuncs",
",",
"c",
".",
"LocalKite",
".",
"finalFuncs",
"...",
")",
"\n",
"method",
".",
"initialized",
"=",
"true",
"\n",
"}",
"\n",
"method",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"method",
".",
"bucket",
"!=",
"nil",
"&&",
"method",
".",
"bucket",
".",
"TakeAvailable",
"(",
"1",
")",
"==",
"0",
"{",
"callFunc",
"(",
"nil",
",",
"&",
"Error",
"{",
"Type",
":",
"\"requestLimitError\"",
",",
"Message",
":",
"\"The maximum request rate is exceeded.\"",
",",
"RequestID",
":",
"request",
".",
"ID",
",",
"}",
")",
"\n",
"return",
"\n",
"}",
"\n",
"result",
",",
"err",
":=",
"method",
".",
"ServeKite",
"(",
"request",
")",
"\n",
"callFunc",
"(",
"result",
",",
"createError",
"(",
"request",
",",
"err",
")",
")",
"\n",
"}"
] | // runMethod is called when a method is received from remote Kite. | [
"runMethod",
"is",
"called",
"when",
"a",
"method",
"is",
"received",
"from",
"remote",
"Kite",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/request.go#L62-L119 | train |
koding/kite | request.go | runCallback | func (c *Client) runCallback(callback func(*dnode.Partial), args *dnode.Partial) {
// Do not panic no matter what.
defer func() {
if err := recover(); err != nil {
c.LocalKite.Log.Warning("Error in calling the callback function : %v", err)
}
}()
// Call the callback function.
callback(args)
} | go | func (c *Client) runCallback(callback func(*dnode.Partial), args *dnode.Partial) {
// Do not panic no matter what.
defer func() {
if err := recover(); err != nil {
c.LocalKite.Log.Warning("Error in calling the callback function : %v", err)
}
}()
// Call the callback function.
callback(args)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"runCallback",
"(",
"callback",
"func",
"(",
"*",
"dnode",
".",
"Partial",
")",
",",
"args",
"*",
"dnode",
".",
"Partial",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
":=",
"recover",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"c",
".",
"LocalKite",
".",
"Log",
".",
"Warning",
"(",
"\"Error in calling the callback function : %v\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"callback",
"(",
"args",
")",
"\n",
"}"
] | // runCallback is called when a callback method call is received from remote Kite. | [
"runCallback",
"is",
"called",
"when",
"a",
"callback",
"method",
"call",
"is",
"received",
"from",
"remote",
"Kite",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/request.go#L122-L132 | train |
koding/kite | request.go | authenticate | func (r *Request) authenticate() *Error {
// Trust the Kite if we have initiated the connection. Following casts
// means, session is opened by the client.
if _, ok := r.Client.session.(*sockjsclient.WebsocketSession); ok {
return nil
}
if _, ok := r.Client.session.(*sockjsclient.XHRSession); ok {
return nil
}
if r.Auth == nil {
return &Error{
Type: "authenticationError",
Message: "No authentication information is provided",
}
}
// Select authenticator function.
f := r.LocalKite.Authenticators[r.Auth.Type]
if f == nil {
return &Error{
Type: "authenticationError",
Message: fmt.Sprintf("Unknown authentication type: %s", r.Auth.Type),
}
}
// Call authenticator function. It sets the Request.Username field.
err := f(r)
if err != nil {
return &Error{
Type: "authenticationError",
Message: fmt.Sprintf("%s: %s", r.Auth.Type, err),
}
}
// Replace username of the remote Kite with the username that client send
// us. This prevents a Kite to impersonate someone else's Kite.
r.Client.SetUsername(r.Username)
return nil
} | go | func (r *Request) authenticate() *Error {
// Trust the Kite if we have initiated the connection. Following casts
// means, session is opened by the client.
if _, ok := r.Client.session.(*sockjsclient.WebsocketSession); ok {
return nil
}
if _, ok := r.Client.session.(*sockjsclient.XHRSession); ok {
return nil
}
if r.Auth == nil {
return &Error{
Type: "authenticationError",
Message: "No authentication information is provided",
}
}
// Select authenticator function.
f := r.LocalKite.Authenticators[r.Auth.Type]
if f == nil {
return &Error{
Type: "authenticationError",
Message: fmt.Sprintf("Unknown authentication type: %s", r.Auth.Type),
}
}
// Call authenticator function. It sets the Request.Username field.
err := f(r)
if err != nil {
return &Error{
Type: "authenticationError",
Message: fmt.Sprintf("%s: %s", r.Auth.Type, err),
}
}
// Replace username of the remote Kite with the username that client send
// us. This prevents a Kite to impersonate someone else's Kite.
r.Client.SetUsername(r.Username)
return nil
} | [
"func",
"(",
"r",
"*",
"Request",
")",
"authenticate",
"(",
")",
"*",
"Error",
"{",
"if",
"_",
",",
"ok",
":=",
"r",
".",
"Client",
".",
"session",
".",
"(",
"*",
"sockjsclient",
".",
"WebsocketSession",
")",
";",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"r",
".",
"Client",
".",
"session",
".",
"(",
"*",
"sockjsclient",
".",
"XHRSession",
")",
";",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"r",
".",
"Auth",
"==",
"nil",
"{",
"return",
"&",
"Error",
"{",
"Type",
":",
"\"authenticationError\"",
",",
"Message",
":",
"\"No authentication information is provided\"",
",",
"}",
"\n",
"}",
"\n",
"f",
":=",
"r",
".",
"LocalKite",
".",
"Authenticators",
"[",
"r",
".",
"Auth",
".",
"Type",
"]",
"\n",
"if",
"f",
"==",
"nil",
"{",
"return",
"&",
"Error",
"{",
"Type",
":",
"\"authenticationError\"",
",",
"Message",
":",
"fmt",
".",
"Sprintf",
"(",
"\"Unknown authentication type: %s\"",
",",
"r",
".",
"Auth",
".",
"Type",
")",
",",
"}",
"\n",
"}",
"\n",
"err",
":=",
"f",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"&",
"Error",
"{",
"Type",
":",
"\"authenticationError\"",
",",
"Message",
":",
"fmt",
".",
"Sprintf",
"(",
"\"%s: %s\"",
",",
"r",
".",
"Auth",
".",
"Type",
",",
"err",
")",
",",
"}",
"\n",
"}",
"\n",
"r",
".",
"Client",
".",
"SetUsername",
"(",
"r",
".",
"Username",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // authenticate tries to authenticate the user by selecting appropriate
// authenticator function. | [
"authenticate",
"tries",
"to",
"authenticate",
"the",
"user",
"by",
"selecting",
"appropriate",
"authenticator",
"function",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/request.go#L182-L222 | train |
koding/kite | request.go | AuthenticateFromToken | func (k *Kite) AuthenticateFromToken(r *Request) error {
k.verifyOnce.Do(k.verifyInit)
token, err := jwt.ParseWithClaims(r.Auth.Key, &kitekey.KiteClaims{}, r.LocalKite.RSAKey)
if e, ok := err.(*jwt.ValidationError); ok {
// Translate public key mismatch errors to token-is-expired one.
// This is to signal remote client the key pairs have been
// updated on kontrol and it should invalidate all tokens.
if (e.Errors & jwt.ValidationErrorSignatureInvalid) != 0 {
return errors.New("token is expired")
}
}
if err != nil {
return err
}
if !token.Valid {
return errors.New("Invalid signature in token")
}
claims, ok := token.Claims.(*kitekey.KiteClaims)
if !ok {
return errors.New("token does not have valid claims")
}
if claims.Audience == "" {
return errors.New("token has no audience")
}
if claims.Subject == "" {
return errors.New("token has no username")
}
// check if we have an audience and it matches our own signature
if err := k.verifyAudienceFunc(k.Kite(), claims.Audience); err != nil {
return err
}
// We don't check for exp and nbf claims here because jwt-go package
// already checks them.
// replace the requester username so we reflect the validated
r.Username = claims.Subject
return nil
} | go | func (k *Kite) AuthenticateFromToken(r *Request) error {
k.verifyOnce.Do(k.verifyInit)
token, err := jwt.ParseWithClaims(r.Auth.Key, &kitekey.KiteClaims{}, r.LocalKite.RSAKey)
if e, ok := err.(*jwt.ValidationError); ok {
// Translate public key mismatch errors to token-is-expired one.
// This is to signal remote client the key pairs have been
// updated on kontrol and it should invalidate all tokens.
if (e.Errors & jwt.ValidationErrorSignatureInvalid) != 0 {
return errors.New("token is expired")
}
}
if err != nil {
return err
}
if !token.Valid {
return errors.New("Invalid signature in token")
}
claims, ok := token.Claims.(*kitekey.KiteClaims)
if !ok {
return errors.New("token does not have valid claims")
}
if claims.Audience == "" {
return errors.New("token has no audience")
}
if claims.Subject == "" {
return errors.New("token has no username")
}
// check if we have an audience and it matches our own signature
if err := k.verifyAudienceFunc(k.Kite(), claims.Audience); err != nil {
return err
}
// We don't check for exp and nbf claims here because jwt-go package
// already checks them.
// replace the requester username so we reflect the validated
r.Username = claims.Subject
return nil
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"AuthenticateFromToken",
"(",
"r",
"*",
"Request",
")",
"error",
"{",
"k",
".",
"verifyOnce",
".",
"Do",
"(",
"k",
".",
"verifyInit",
")",
"\n",
"token",
",",
"err",
":=",
"jwt",
".",
"ParseWithClaims",
"(",
"r",
".",
"Auth",
".",
"Key",
",",
"&",
"kitekey",
".",
"KiteClaims",
"{",
"}",
",",
"r",
".",
"LocalKite",
".",
"RSAKey",
")",
"\n",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"jwt",
".",
"ValidationError",
")",
";",
"ok",
"{",
"if",
"(",
"e",
".",
"Errors",
"&",
"jwt",
".",
"ValidationErrorSignatureInvalid",
")",
"!=",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"\"token is expired\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"token",
".",
"Valid",
"{",
"return",
"errors",
".",
"New",
"(",
"\"Invalid signature in token\"",
")",
"\n",
"}",
"\n",
"claims",
",",
"ok",
":=",
"token",
".",
"Claims",
".",
"(",
"*",
"kitekey",
".",
"KiteClaims",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"token does not have valid claims\"",
")",
"\n",
"}",
"\n",
"if",
"claims",
".",
"Audience",
"==",
"\"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"token has no audience\"",
")",
"\n",
"}",
"\n",
"if",
"claims",
".",
"Subject",
"==",
"\"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"token has no username\"",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"k",
".",
"verifyAudienceFunc",
"(",
"k",
".",
"Kite",
"(",
")",
",",
"claims",
".",
"Audience",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"r",
".",
"Username",
"=",
"claims",
".",
"Subject",
"\n",
"return",
"nil",
"\n",
"}"
] | // AuthenticateFromToken is the default Authenticator for Kite. | [
"AuthenticateFromToken",
"is",
"the",
"default",
"Authenticator",
"for",
"Kite",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/request.go#L225-L272 | train |
koding/kite | request.go | AuthenticateFromKiteKey | func (k *Kite) AuthenticateFromKiteKey(r *Request) error {
claims := &kitekey.KiteClaims{}
token, err := jwt.ParseWithClaims(r.Auth.Key, claims, k.verify)
if err != nil {
return err
}
if !token.Valid {
return errors.New("Invalid signature in kite key")
}
if claims.Subject == "" {
return errors.New("token has no username")
}
r.Username = claims.Subject
return nil
} | go | func (k *Kite) AuthenticateFromKiteKey(r *Request) error {
claims := &kitekey.KiteClaims{}
token, err := jwt.ParseWithClaims(r.Auth.Key, claims, k.verify)
if err != nil {
return err
}
if !token.Valid {
return errors.New("Invalid signature in kite key")
}
if claims.Subject == "" {
return errors.New("token has no username")
}
r.Username = claims.Subject
return nil
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"AuthenticateFromKiteKey",
"(",
"r",
"*",
"Request",
")",
"error",
"{",
"claims",
":=",
"&",
"kitekey",
".",
"KiteClaims",
"{",
"}",
"\n",
"token",
",",
"err",
":=",
"jwt",
".",
"ParseWithClaims",
"(",
"r",
".",
"Auth",
".",
"Key",
",",
"claims",
",",
"k",
".",
"verify",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"token",
".",
"Valid",
"{",
"return",
"errors",
".",
"New",
"(",
"\"Invalid signature in kite key\"",
")",
"\n",
"}",
"\n",
"if",
"claims",
".",
"Subject",
"==",
"\"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"token has no username\"",
")",
"\n",
"}",
"\n",
"r",
".",
"Username",
"=",
"claims",
".",
"Subject",
"\n",
"return",
"nil",
"\n",
"}"
] | // AuthenticateFromKiteKey authenticates user from kite key. | [
"AuthenticateFromKiteKey",
"authenticates",
"user",
"from",
"kite",
"key",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/request.go#L275-L294 | train |
koding/kite | registerurl.go | publicIP | func publicIP() (net.IP, error) {
resp, err := http.Get(publicEcho)
if err != nil {
return nil, err
}
defer resp.Body.Close()
// The ip address is 16 chars long, we read more
// to account for excessive whitespace.
p, err := ioutil.ReadAll(io.LimitReader(resp.Body, 24))
if err != nil {
return nil, err
}
n := net.ParseIP(string(bytes.TrimSpace(p)))
if n == nil {
return nil, fmt.Errorf("cannot parse ip %s", p)
}
return n, nil
} | go | func publicIP() (net.IP, error) {
resp, err := http.Get(publicEcho)
if err != nil {
return nil, err
}
defer resp.Body.Close()
// The ip address is 16 chars long, we read more
// to account for excessive whitespace.
p, err := ioutil.ReadAll(io.LimitReader(resp.Body, 24))
if err != nil {
return nil, err
}
n := net.ParseIP(string(bytes.TrimSpace(p)))
if n == nil {
return nil, fmt.Errorf("cannot parse ip %s", p)
}
return n, nil
} | [
"func",
"publicIP",
"(",
")",
"(",
"net",
".",
"IP",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"http",
".",
"Get",
"(",
"publicEcho",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"p",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"io",
".",
"LimitReader",
"(",
"resp",
".",
"Body",
",",
"24",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"n",
":=",
"net",
".",
"ParseIP",
"(",
"string",
"(",
"bytes",
".",
"TrimSpace",
"(",
"p",
")",
")",
")",
"\n",
"if",
"n",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"cannot parse ip %s\"",
",",
"p",
")",
"\n",
"}",
"\n",
"return",
"n",
",",
"nil",
"\n",
"}"
] | // publicIP returns an IP that is supposed to be Public. | [
"publicIP",
"returns",
"an",
"IP",
"that",
"is",
"supposed",
"to",
"be",
"Public",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/registerurl.go#L80-L100 | train |
koding/kite | kitectl/command/install.go | extractTar | func extractTar(r io.Reader, dir string) error {
first := true // true if we are on the first entry of tarball
tr := tar.NewReader(r)
for {
hdr, err := tr.Next()
if err == io.EOF {
// end of tar archive
break
}
if err != nil {
return err
}
// Check if the same kite version is installed before
if first {
first = false
kiteName := strings.TrimSuffix(hdr.Name, ".kite/")
installed, err := isInstalled(kiteName)
if err != nil {
return err
}
if installed {
return fmt.Errorf("Already installed: %s", kiteName)
}
}
path := filepath.Join(dir, hdr.Name)
if hdr.FileInfo().IsDir() {
os.MkdirAll(path, 0700)
} else {
mode := 0600
if isBinaryFile(hdr.Name) {
mode = 0700
}
f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, os.FileMode(mode))
if err != nil {
return err
}
if _, err := io.Copy(f, tr); err != nil {
return err
}
}
}
return nil
} | go | func extractTar(r io.Reader, dir string) error {
first := true // true if we are on the first entry of tarball
tr := tar.NewReader(r)
for {
hdr, err := tr.Next()
if err == io.EOF {
// end of tar archive
break
}
if err != nil {
return err
}
// Check if the same kite version is installed before
if first {
first = false
kiteName := strings.TrimSuffix(hdr.Name, ".kite/")
installed, err := isInstalled(kiteName)
if err != nil {
return err
}
if installed {
return fmt.Errorf("Already installed: %s", kiteName)
}
}
path := filepath.Join(dir, hdr.Name)
if hdr.FileInfo().IsDir() {
os.MkdirAll(path, 0700)
} else {
mode := 0600
if isBinaryFile(hdr.Name) {
mode = 0700
}
f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, os.FileMode(mode))
if err != nil {
return err
}
if _, err := io.Copy(f, tr); err != nil {
return err
}
}
}
return nil
} | [
"func",
"extractTar",
"(",
"r",
"io",
".",
"Reader",
",",
"dir",
"string",
")",
"error",
"{",
"first",
":=",
"true",
"\n",
"tr",
":=",
"tar",
".",
"NewReader",
"(",
"r",
")",
"\n",
"for",
"{",
"hdr",
",",
"err",
":=",
"tr",
".",
"Next",
"(",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"break",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"first",
"{",
"first",
"=",
"false",
"\n",
"kiteName",
":=",
"strings",
".",
"TrimSuffix",
"(",
"hdr",
".",
"Name",
",",
"\".kite/\"",
")",
"\n",
"installed",
",",
"err",
":=",
"isInstalled",
"(",
"kiteName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"installed",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"Already installed: %s\"",
",",
"kiteName",
")",
"\n",
"}",
"\n",
"}",
"\n",
"path",
":=",
"filepath",
".",
"Join",
"(",
"dir",
",",
"hdr",
".",
"Name",
")",
"\n",
"if",
"hdr",
".",
"FileInfo",
"(",
")",
".",
"IsDir",
"(",
")",
"{",
"os",
".",
"MkdirAll",
"(",
"path",
",",
"0700",
")",
"\n",
"}",
"else",
"{",
"mode",
":=",
"0600",
"\n",
"if",
"isBinaryFile",
"(",
"hdr",
".",
"Name",
")",
"{",
"mode",
"=",
"0700",
"\n",
"}",
"\n",
"f",
",",
"err",
":=",
"os",
".",
"OpenFile",
"(",
"path",
",",
"os",
".",
"O_WRONLY",
"|",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_TRUNC",
",",
"os",
".",
"FileMode",
"(",
"mode",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"f",
",",
"tr",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // extractTar reads from the io.Reader and writes the files into the directory. | [
"extractTar",
"reads",
"from",
"the",
"io",
".",
"Reader",
"and",
"writes",
"the",
"files",
"into",
"the",
"directory",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitectl/command/install.go#L189-L238 | train |
koding/kite | kitectl/command/install.go | validatePackage | func validatePackage(tempKitePath, repoName string) (bundlePath string, err error) {
dirs, err := ioutil.ReadDir(tempKitePath)
if err != nil {
return "", err
}
if len(dirs) != 1 {
return "", errors.New("Invalid package: Package must contain only one directory.")
}
bundlePath = filepath.Join(tempKitePath, dirs[0].Name())
parts := strings.Split(repoName, "/")
if len(parts) == 0 {
return "", errors.New("invalid repo URL")
}
kiteName := strings.TrimSuffix(parts[len(parts)-1], ".kite")
_, err = os.Stat(filepath.Join(bundlePath, "bin", kiteName))
return bundlePath, err
} | go | func validatePackage(tempKitePath, repoName string) (bundlePath string, err error) {
dirs, err := ioutil.ReadDir(tempKitePath)
if err != nil {
return "", err
}
if len(dirs) != 1 {
return "", errors.New("Invalid package: Package must contain only one directory.")
}
bundlePath = filepath.Join(tempKitePath, dirs[0].Name())
parts := strings.Split(repoName, "/")
if len(parts) == 0 {
return "", errors.New("invalid repo URL")
}
kiteName := strings.TrimSuffix(parts[len(parts)-1], ".kite")
_, err = os.Stat(filepath.Join(bundlePath, "bin", kiteName))
return bundlePath, err
} | [
"func",
"validatePackage",
"(",
"tempKitePath",
",",
"repoName",
"string",
")",
"(",
"bundlePath",
"string",
",",
"err",
"error",
")",
"{",
"dirs",
",",
"err",
":=",
"ioutil",
".",
"ReadDir",
"(",
"tempKitePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"len",
"(",
"dirs",
")",
"!=",
"1",
"{",
"return",
"\"\"",
",",
"errors",
".",
"New",
"(",
"\"Invalid package: Package must contain only one directory.\"",
")",
"\n",
"}",
"\n",
"bundlePath",
"=",
"filepath",
".",
"Join",
"(",
"tempKitePath",
",",
"dirs",
"[",
"0",
"]",
".",
"Name",
"(",
")",
")",
"\n",
"parts",
":=",
"strings",
".",
"Split",
"(",
"repoName",
",",
"\"/\"",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"==",
"0",
"{",
"return",
"\"\"",
",",
"errors",
".",
"New",
"(",
"\"invalid repo URL\"",
")",
"\n",
"}",
"\n",
"kiteName",
":=",
"strings",
".",
"TrimSuffix",
"(",
"parts",
"[",
"len",
"(",
"parts",
")",
"-",
"1",
"]",
",",
"\".kite\"",
")",
"\n",
"_",
",",
"err",
"=",
"os",
".",
"Stat",
"(",
"filepath",
".",
"Join",
"(",
"bundlePath",
",",
"\"bin\"",
",",
"kiteName",
")",
")",
"\n",
"return",
"bundlePath",
",",
"err",
"\n",
"}"
] | // validatePackage does some checks on kite bundle and returns the bundle path. | [
"validatePackage",
"does",
"some",
"checks",
"on",
"kite",
"bundle",
"and",
"returns",
"the",
"bundle",
"path",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/kitectl/command/install.go#L241-L262 | train |
koding/kite | dnode/scrubber.go | RemoveCallback | func (s *Scrubber) RemoveCallback(id uint64) {
s.Lock()
delete(s.callbacks, id)
s.Unlock()
} | go | func (s *Scrubber) RemoveCallback(id uint64) {
s.Lock()
delete(s.callbacks, id)
s.Unlock()
} | [
"func",
"(",
"s",
"*",
"Scrubber",
")",
"RemoveCallback",
"(",
"id",
"uint64",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"delete",
"(",
"s",
".",
"callbacks",
",",
"id",
")",
"\n",
"s",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // RemoveCallback removes the callback with id from callbacks.
// Can be used to remove unused callbacks to free memory. | [
"RemoveCallback",
"removes",
"the",
"callback",
"with",
"id",
"from",
"callbacks",
".",
"Can",
"be",
"used",
"to",
"remove",
"unused",
"callbacks",
"to",
"free",
"memory",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/dnode/scrubber.go#L24-L28 | train |
koding/kite | method.go | addHandle | func (k *Kite) addHandle(method string, handler Handler) *Method {
authenticate := true
if k.Config.DisableAuthentication {
authenticate = false
}
m := &Method{
name: method,
handler: handler,
authenticate: authenticate,
handling: k.MethodHandling,
}
k.handlers[method] = m
return m
} | go | func (k *Kite) addHandle(method string, handler Handler) *Method {
authenticate := true
if k.Config.DisableAuthentication {
authenticate = false
}
m := &Method{
name: method,
handler: handler,
authenticate: authenticate,
handling: k.MethodHandling,
}
k.handlers[method] = m
return m
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"addHandle",
"(",
"method",
"string",
",",
"handler",
"Handler",
")",
"*",
"Method",
"{",
"authenticate",
":=",
"true",
"\n",
"if",
"k",
".",
"Config",
".",
"DisableAuthentication",
"{",
"authenticate",
"=",
"false",
"\n",
"}",
"\n",
"m",
":=",
"&",
"Method",
"{",
"name",
":",
"method",
",",
"handler",
":",
"handler",
",",
"authenticate",
":",
"authenticate",
",",
"handling",
":",
"k",
".",
"MethodHandling",
",",
"}",
"\n",
"k",
".",
"handlers",
"[",
"method",
"]",
"=",
"m",
"\n",
"return",
"m",
"\n",
"}"
] | // addHandle is an internal method to add a handler | [
"addHandle",
"is",
"an",
"internal",
"method",
"to",
"add",
"a",
"handler"
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/method.go#L78-L93 | train |
koding/kite | method.go | PreHandle | func (m *Method) PreHandle(handler Handler) *Method {
m.preHandlers = append(m.preHandlers, handler)
return m
} | go | func (m *Method) PreHandle(handler Handler) *Method {
m.preHandlers = append(m.preHandlers, handler)
return m
} | [
"func",
"(",
"m",
"*",
"Method",
")",
"PreHandle",
"(",
"handler",
"Handler",
")",
"*",
"Method",
"{",
"m",
".",
"preHandlers",
"=",
"append",
"(",
"m",
".",
"preHandlers",
",",
"handler",
")",
"\n",
"return",
"m",
"\n",
"}"
] | // PreHandler adds a new kite handler which is executed before the method. | [
"PreHandler",
"adds",
"a",
"new",
"kite",
"handler",
"which",
"is",
"executed",
"before",
"the",
"method",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/method.go#L126-L129 | train |
koding/kite | method.go | PostHandle | func (m *Method) PostHandle(handler Handler) *Method {
m.postHandlers = append(m.postHandlers, handler)
return m
} | go | func (m *Method) PostHandle(handler Handler) *Method {
m.postHandlers = append(m.postHandlers, handler)
return m
} | [
"func",
"(",
"m",
"*",
"Method",
")",
"PostHandle",
"(",
"handler",
"Handler",
")",
"*",
"Method",
"{",
"m",
".",
"postHandlers",
"=",
"append",
"(",
"m",
".",
"postHandlers",
",",
"handler",
")",
"\n",
"return",
"m",
"\n",
"}"
] | // PostHandle adds a new kite handler which is executed after the method. | [
"PostHandle",
"adds",
"a",
"new",
"kite",
"handler",
"which",
"is",
"executed",
"after",
"the",
"method",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/method.go#L138-L141 | train |
koding/kite | method.go | FinalFunc | func (m *Method) FinalFunc(f FinalFunc) *Method {
m.finalFuncs = append(m.finalFuncs, f)
return m
} | go | func (m *Method) FinalFunc(f FinalFunc) *Method {
m.finalFuncs = append(m.finalFuncs, f)
return m
} | [
"func",
"(",
"m",
"*",
"Method",
")",
"FinalFunc",
"(",
"f",
"FinalFunc",
")",
"*",
"Method",
"{",
"m",
".",
"finalFuncs",
"=",
"append",
"(",
"m",
".",
"finalFuncs",
",",
"f",
")",
"\n",
"return",
"m",
"\n",
"}"
] | // FinalFunc registers a function that is always called as a last one
// after pre-, handler and post- functions for the given method.
//
// It receives a result and an error from last handler that
// got executed prior to calling final func. | [
"FinalFunc",
"registers",
"a",
"function",
"that",
"is",
"always",
"called",
"as",
"a",
"last",
"one",
"after",
"pre",
"-",
"handler",
"and",
"post",
"-",
"functions",
"for",
"the",
"given",
"method",
".",
"It",
"receives",
"a",
"result",
"and",
"an",
"error",
"from",
"last",
"handler",
"that",
"got",
"executed",
"prior",
"to",
"calling",
"final",
"func",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/method.go#L154-L157 | train |
koding/kite | method.go | Handle | func (k *Kite) Handle(method string, handler Handler) *Method {
return k.addHandle(method, handler)
} | go | func (k *Kite) Handle(method string, handler Handler) *Method {
return k.addHandle(method, handler)
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"Handle",
"(",
"method",
"string",
",",
"handler",
"Handler",
")",
"*",
"Method",
"{",
"return",
"k",
".",
"addHandle",
"(",
"method",
",",
"handler",
")",
"\n",
"}"
] | // Handle registers the handler for the given method. The handler is called
// when a method call is received from a Kite. | [
"Handle",
"registers",
"the",
"handler",
"for",
"the",
"given",
"method",
".",
"The",
"handler",
"is",
"called",
"when",
"a",
"method",
"call",
"is",
"received",
"from",
"a",
"Kite",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/method.go#L161-L163 | train |
koding/kite | method.go | PreHandle | func (k *Kite) PreHandle(handler Handler) {
k.preHandlers = append(k.preHandlers, handler)
} | go | func (k *Kite) PreHandle(handler Handler) {
k.preHandlers = append(k.preHandlers, handler)
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"PreHandle",
"(",
"handler",
"Handler",
")",
"{",
"k",
".",
"preHandlers",
"=",
"append",
"(",
"k",
".",
"preHandlers",
",",
"handler",
")",
"\n",
"}"
] | // PreHandle registers an handler which is executed before a kite.Handler
// method is executed. Calling PreHandle multiple times registers multiple
// handlers. A non-error return triggers the execution of the next handler. The
// execution order is FIFO. | [
"PreHandle",
"registers",
"an",
"handler",
"which",
"is",
"executed",
"before",
"a",
"kite",
".",
"Handler",
"method",
"is",
"executed",
".",
"Calling",
"PreHandle",
"multiple",
"times",
"registers",
"multiple",
"handlers",
".",
"A",
"non",
"-",
"error",
"return",
"triggers",
"the",
"execution",
"of",
"the",
"next",
"handler",
".",
"The",
"execution",
"order",
"is",
"FIFO",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/method.go#L176-L178 | train |
koding/kite | method.go | PostHandle | func (k *Kite) PostHandle(handler Handler) {
k.postHandlers = append(k.postHandlers, handler)
} | go | func (k *Kite) PostHandle(handler Handler) {
k.postHandlers = append(k.postHandlers, handler)
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"PostHandle",
"(",
"handler",
"Handler",
")",
"{",
"k",
".",
"postHandlers",
"=",
"append",
"(",
"k",
".",
"postHandlers",
",",
"handler",
")",
"\n",
"}"
] | // PostHandle registers an handler which is executed after a kite.Handler
// method is executed. Calling PostHandler multiple times registers multiple
// handlers. A non-error return triggers the execution of the next handler. The
// execution order is FIFO. | [
"PostHandle",
"registers",
"an",
"handler",
"which",
"is",
"executed",
"after",
"a",
"kite",
".",
"Handler",
"method",
"is",
"executed",
".",
"Calling",
"PostHandler",
"multiple",
"times",
"registers",
"multiple",
"handlers",
".",
"A",
"non",
"-",
"error",
"return",
"triggers",
"the",
"execution",
"of",
"the",
"next",
"handler",
".",
"The",
"execution",
"order",
"is",
"FIFO",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/method.go#L189-L191 | train |
koding/kite | method.go | FinalFunc | func (k *Kite) FinalFunc(f FinalFunc) {
k.finalFuncs = append(k.finalFuncs, f)
} | go | func (k *Kite) FinalFunc(f FinalFunc) {
k.finalFuncs = append(k.finalFuncs, f)
} | [
"func",
"(",
"k",
"*",
"Kite",
")",
"FinalFunc",
"(",
"f",
"FinalFunc",
")",
"{",
"k",
".",
"finalFuncs",
"=",
"append",
"(",
"k",
".",
"finalFuncs",
",",
"f",
")",
"\n",
"}"
] | // FinalFunc registers a function that is always called as a last one
// after pre-, handler and post- functions.
//
// It receives a result and an error from last handler that
// got executed prior to calling final func. | [
"FinalFunc",
"registers",
"a",
"function",
"that",
"is",
"always",
"called",
"as",
"a",
"last",
"one",
"after",
"pre",
"-",
"handler",
"and",
"post",
"-",
"functions",
".",
"It",
"receives",
"a",
"result",
"and",
"an",
"error",
"from",
"last",
"handler",
"that",
"got",
"executed",
"prior",
"to",
"calling",
"final",
"func",
"."
] | baa1a54919e3035417f7571dd46005e91afe8abe | https://github.com/koding/kite/blob/baa1a54919e3035417f7571dd46005e91afe8abe/method.go#L203-L205 | train |
inverse-inc/packetfence | go/caddy/caddy/caddyhttp/httpserver/path.go | Matches | func (p Path) Matches(other string) bool {
if CaseSensitivePath {
return strings.HasPrefix(string(p), other)
}
return strings.HasPrefix(strings.ToLower(string(p)), strings.ToLower(other))
} | go | func (p Path) Matches(other string) bool {
if CaseSensitivePath {
return strings.HasPrefix(string(p), other)
}
return strings.HasPrefix(strings.ToLower(string(p)), strings.ToLower(other))
} | [
"func",
"(",
"p",
"Path",
")",
"Matches",
"(",
"other",
"string",
")",
"bool",
"{",
"if",
"CaseSensitivePath",
"{",
"return",
"strings",
".",
"HasPrefix",
"(",
"string",
"(",
"p",
")",
",",
"other",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"HasPrefix",
"(",
"strings",
".",
"ToLower",
"(",
"string",
"(",
"p",
")",
")",
",",
"strings",
".",
"ToLower",
"(",
"other",
")",
")",
"\n",
"}"
] | // Matches checks to see if other matches p.
//
// Path matching will probably not always be a direct
// comparison; this method assures that paths can be
// easily and consistently matched. | [
"Matches",
"checks",
"to",
"see",
"if",
"other",
"matches",
"p",
".",
"Path",
"matching",
"will",
"probably",
"not",
"always",
"be",
"a",
"direct",
"comparison",
";",
"this",
"method",
"assures",
"that",
"paths",
"can",
"be",
"easily",
"and",
"consistently",
"matched",
"."
] | f29912bde7974931d699aba60aa8fde1c5d9a826 | https://github.com/inverse-inc/packetfence/blob/f29912bde7974931d699aba60aa8fde1c5d9a826/go/caddy/caddy/caddyhttp/httpserver/path.go#L16-L21 | train |
inverse-inc/packetfence | go/caddy/caddy/caddyhttp/gzip/gzip.go | Write | func (w *gzipResponseWriter) Write(b []byte) (int, error) {
if w.Header().Get("Content-Type") == "" {
w.Header().Set("Content-Type", http.DetectContentType(b))
}
if !w.statusCodeWritten {
w.WriteHeader(http.StatusOK)
}
n, err := w.Writer.Write(b)
return n, err
} | go | func (w *gzipResponseWriter) Write(b []byte) (int, error) {
if w.Header().Get("Content-Type") == "" {
w.Header().Set("Content-Type", http.DetectContentType(b))
}
if !w.statusCodeWritten {
w.WriteHeader(http.StatusOK)
}
n, err := w.Writer.Write(b)
return n, err
} | [
"func",
"(",
"w",
"*",
"gzipResponseWriter",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"w",
".",
"Header",
"(",
")",
".",
"Get",
"(",
"\"Content-Type\"",
")",
"==",
"\"\"",
"{",
"w",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"Content-Type\"",
",",
"http",
".",
"DetectContentType",
"(",
"b",
")",
")",
"\n",
"}",
"\n",
"if",
"!",
"w",
".",
"statusCodeWritten",
"{",
"w",
".",
"WriteHeader",
"(",
"http",
".",
"StatusOK",
")",
"\n",
"}",
"\n",
"n",
",",
"err",
":=",
"w",
".",
"Writer",
".",
"Write",
"(",
"b",
")",
"\n",
"return",
"n",
",",
"err",
"\n",
"}"
] | // Write wraps the underlying Write method to do compression. | [
"Write",
"wraps",
"the",
"underlying",
"Write",
"method",
"to",
"do",
"compression",
"."
] | f29912bde7974931d699aba60aa8fde1c5d9a826 | https://github.com/inverse-inc/packetfence/blob/f29912bde7974931d699aba60aa8fde1c5d9a826/go/caddy/caddy/caddyhttp/gzip/gzip.go#L126-L135 | train |
inverse-inc/packetfence | go/caddy/caddy/caddyhttp/staticfiles/fileserver.go | IsHidden | func (fs FileServer) IsHidden(d os.FileInfo) bool {
// If the file is supposed to be hidden, return a 404
for _, hiddenPath := range fs.Hide {
// Check if the served file is exactly the hidden file.
if hFile, err := fs.Root.Open(hiddenPath); err == nil {
fs, _ := hFile.Stat()
hFile.Close()
if os.SameFile(d, fs) {
return true
}
}
}
return false
} | go | func (fs FileServer) IsHidden(d os.FileInfo) bool {
// If the file is supposed to be hidden, return a 404
for _, hiddenPath := range fs.Hide {
// Check if the served file is exactly the hidden file.
if hFile, err := fs.Root.Open(hiddenPath); err == nil {
fs, _ := hFile.Stat()
hFile.Close()
if os.SameFile(d, fs) {
return true
}
}
}
return false
} | [
"func",
"(",
"fs",
"FileServer",
")",
"IsHidden",
"(",
"d",
"os",
".",
"FileInfo",
")",
"bool",
"{",
"for",
"_",
",",
"hiddenPath",
":=",
"range",
"fs",
".",
"Hide",
"{",
"if",
"hFile",
",",
"err",
":=",
"fs",
".",
"Root",
".",
"Open",
"(",
"hiddenPath",
")",
";",
"err",
"==",
"nil",
"{",
"fs",
",",
"_",
":=",
"hFile",
".",
"Stat",
"(",
")",
"\n",
"hFile",
".",
"Close",
"(",
")",
"\n",
"if",
"os",
".",
"SameFile",
"(",
"d",
",",
"fs",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsHidden checks if file with FileInfo d is on hide list. | [
"IsHidden",
"checks",
"if",
"file",
"with",
"FileInfo",
"d",
"is",
"on",
"hide",
"list",
"."
] | f29912bde7974931d699aba60aa8fde1c5d9a826 | https://github.com/inverse-inc/packetfence/blob/f29912bde7974931d699aba60aa8fde1c5d9a826/go/caddy/caddy/caddyhttp/staticfiles/fileserver.go#L184-L197 | train |
inverse-inc/packetfence | go/caddy/caddy/caddyhttp/staticfiles/fileserver.go | Redirect | func Redirect(w http.ResponseWriter, r *http.Request, newPath string, statusCode int) {
if q := r.URL.RawQuery; q != "" {
newPath += "?" + q
}
http.Redirect(w, r, newPath, statusCode)
} | go | func Redirect(w http.ResponseWriter, r *http.Request, newPath string, statusCode int) {
if q := r.URL.RawQuery; q != "" {
newPath += "?" + q
}
http.Redirect(w, r, newPath, statusCode)
} | [
"func",
"Redirect",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"newPath",
"string",
",",
"statusCode",
"int",
")",
"{",
"if",
"q",
":=",
"r",
".",
"URL",
".",
"RawQuery",
";",
"q",
"!=",
"\"\"",
"{",
"newPath",
"+=",
"\"?\"",
"+",
"q",
"\n",
"}",
"\n",
"http",
".",
"Redirect",
"(",
"w",
",",
"r",
",",
"newPath",
",",
"statusCode",
")",
"\n",
"}"
] | // Redirect sends an HTTP redirect to the client but will preserve
// the query string for the new path. Based on http.localRedirect
// from the Go standard library. | [
"Redirect",
"sends",
"an",
"HTTP",
"redirect",
"to",
"the",
"client",
"but",
"will",
"preserve",
"the",
"query",
"string",
"for",
"the",
"new",
"path",
".",
"Based",
"on",
"http",
".",
"localRedirect",
"from",
"the",
"Go",
"standard",
"library",
"."
] | f29912bde7974931d699aba60aa8fde1c5d9a826 | https://github.com/inverse-inc/packetfence/blob/f29912bde7974931d699aba60aa8fde1c5d9a826/go/caddy/caddy/caddyhttp/staticfiles/fileserver.go#L202-L207 | train |
inverse-inc/packetfence | go/coredns/plugin/dnstap/handler.go | TapperFromContext | func TapperFromContext(ctx context.Context) (t Tapper) {
t, _ = ctx.(Tapper)
return
} | go | func TapperFromContext(ctx context.Context) (t Tapper) {
t, _ = ctx.(Tapper)
return
} | [
"func",
"TapperFromContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"t",
"Tapper",
")",
"{",
"t",
",",
"_",
"=",
"ctx",
".",
"(",
"Tapper",
")",
"\n",
"return",
"\n",
"}"
] | // TapperFromContext will return a Tapper if the dnstap plugin is enabled. | [
"TapperFromContext",
"will",
"return",
"a",
"Tapper",
"if",
"the",
"dnstap",
"plugin",
"is",
"enabled",
"."
] | f29912bde7974931d699aba60aa8fde1c5d9a826 | https://github.com/inverse-inc/packetfence/blob/f29912bde7974931d699aba60aa8fde1c5d9a826/go/coredns/plugin/dnstap/handler.go#L48-L51 | train |
inverse-inc/packetfence | go/coredns/plugin/dnstap/handler.go | TapBuilder | func (h Dnstap) TapBuilder() msg.Builder {
return msg.Builder{Full: h.Pack}
} | go | func (h Dnstap) TapBuilder() msg.Builder {
return msg.Builder{Full: h.Pack}
} | [
"func",
"(",
"h",
"Dnstap",
")",
"TapBuilder",
"(",
")",
"msg",
".",
"Builder",
"{",
"return",
"msg",
".",
"Builder",
"{",
"Full",
":",
"h",
".",
"Pack",
"}",
"\n",
"}"
] | // TapBuilder implements Tapper. | [
"TapBuilder",
"implements",
"Tapper",
"."
] | f29912bde7974931d699aba60aa8fde1c5d9a826 | https://github.com/inverse-inc/packetfence/blob/f29912bde7974931d699aba60aa8fde1c5d9a826/go/coredns/plugin/dnstap/handler.go#L69-L71 | train |
inverse-inc/packetfence | go/dhcp/pool/pool.go | GetIssues | func (dp *DHCPPool) GetIssues(macs []string) ([]string, map[uint64]string) {
dp.lock.Lock()
defer dp.lock.Unlock()
var found bool
found = false
var inPoolNotInCache []string
var duplicateInPool map[uint64]string
duplicateInPool = make(map[uint64]string)
var count int
var saveindex uint64
for i := uint64(0); i < dp.capacity; i++ {
if dp.free[i] {
continue
}
for _, mac := range macs {
if dp.mac[i] == mac {
found = true
}
}
if !found {
inPoolNotInCache = append(inPoolNotInCache, dp.mac[i]+", "+strconv.Itoa(int(i)))
}
}
for _, mac := range macs {
count = 0
saveindex = 0
for i := uint64(0); i < dp.capacity; i++ {
if dp.free[i] {
continue
}
if dp.mac[i] == mac {
if count == 0 {
saveindex = i
}
if count == 1 {
duplicateInPool[saveindex] = mac
duplicateInPool[i] = mac
} else if count > 1 {
duplicateInPool[i] = mac
}
count++
}
}
}
return inPoolNotInCache, duplicateInPool
} | go | func (dp *DHCPPool) GetIssues(macs []string) ([]string, map[uint64]string) {
dp.lock.Lock()
defer dp.lock.Unlock()
var found bool
found = false
var inPoolNotInCache []string
var duplicateInPool map[uint64]string
duplicateInPool = make(map[uint64]string)
var count int
var saveindex uint64
for i := uint64(0); i < dp.capacity; i++ {
if dp.free[i] {
continue
}
for _, mac := range macs {
if dp.mac[i] == mac {
found = true
}
}
if !found {
inPoolNotInCache = append(inPoolNotInCache, dp.mac[i]+", "+strconv.Itoa(int(i)))
}
}
for _, mac := range macs {
count = 0
saveindex = 0
for i := uint64(0); i < dp.capacity; i++ {
if dp.free[i] {
continue
}
if dp.mac[i] == mac {
if count == 0 {
saveindex = i
}
if count == 1 {
duplicateInPool[saveindex] = mac
duplicateInPool[i] = mac
} else if count > 1 {
duplicateInPool[i] = mac
}
count++
}
}
}
return inPoolNotInCache, duplicateInPool
} | [
"func",
"(",
"dp",
"*",
"DHCPPool",
")",
"GetIssues",
"(",
"macs",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"string",
",",
"map",
"[",
"uint64",
"]",
"string",
")",
"{",
"dp",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"dp",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"var",
"found",
"bool",
"\n",
"found",
"=",
"false",
"\n",
"var",
"inPoolNotInCache",
"[",
"]",
"string",
"\n",
"var",
"duplicateInPool",
"map",
"[",
"uint64",
"]",
"string",
"\n",
"duplicateInPool",
"=",
"make",
"(",
"map",
"[",
"uint64",
"]",
"string",
")",
"\n",
"var",
"count",
"int",
"\n",
"var",
"saveindex",
"uint64",
"\n",
"for",
"i",
":=",
"uint64",
"(",
"0",
")",
";",
"i",
"<",
"dp",
".",
"capacity",
";",
"i",
"++",
"{",
"if",
"dp",
".",
"free",
"[",
"i",
"]",
"{",
"continue",
"\n",
"}",
"\n",
"for",
"_",
",",
"mac",
":=",
"range",
"macs",
"{",
"if",
"dp",
".",
"mac",
"[",
"i",
"]",
"==",
"mac",
"{",
"found",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"found",
"{",
"inPoolNotInCache",
"=",
"append",
"(",
"inPoolNotInCache",
",",
"dp",
".",
"mac",
"[",
"i",
"]",
"+",
"\", \"",
"+",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"i",
")",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"mac",
":=",
"range",
"macs",
"{",
"count",
"=",
"0",
"\n",
"saveindex",
"=",
"0",
"\n",
"for",
"i",
":=",
"uint64",
"(",
"0",
")",
";",
"i",
"<",
"dp",
".",
"capacity",
";",
"i",
"++",
"{",
"if",
"dp",
".",
"free",
"[",
"i",
"]",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"dp",
".",
"mac",
"[",
"i",
"]",
"==",
"mac",
"{",
"if",
"count",
"==",
"0",
"{",
"saveindex",
"=",
"i",
"\n",
"}",
"\n",
"if",
"count",
"==",
"1",
"{",
"duplicateInPool",
"[",
"saveindex",
"]",
"=",
"mac",
"\n",
"duplicateInPool",
"[",
"i",
"]",
"=",
"mac",
"\n",
"}",
"else",
"if",
"count",
">",
"1",
"{",
"duplicateInPool",
"[",
"i",
"]",
"=",
"mac",
"\n",
"}",
"\n",
"count",
"++",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"inPoolNotInCache",
",",
"duplicateInPool",
"\n",
"}"
] | // Compare what we have in the cache with what we have in the pool | [
"Compare",
"what",
"we",
"have",
"in",
"the",
"cache",
"with",
"what",
"we",
"have",
"in",
"the",
"pool"
] | f29912bde7974931d699aba60aa8fde1c5d9a826 | https://github.com/inverse-inc/packetfence/blob/f29912bde7974931d699aba60aa8fde1c5d9a826/go/dhcp/pool/pool.go#L34-L81 | train |
inverse-inc/packetfence | go/dhcp/pool/pool.go | ReserveIPIndex | func (dp *DHCPPool) ReserveIPIndex(index uint64, mac string) (error, string) {
dp.lock.Lock()
defer dp.lock.Unlock()
if index >= dp.capacity {
return errors.New("Trying to reserve an IP that is outside the capacity of this pool"), FreeMac
}
if _, free := dp.free[index]; free {
delete(dp.free, index)
dp.mac[index] = mac
return nil, mac
} else {
return errors.New("IP is already reserved"), FreeMac
}
} | go | func (dp *DHCPPool) ReserveIPIndex(index uint64, mac string) (error, string) {
dp.lock.Lock()
defer dp.lock.Unlock()
if index >= dp.capacity {
return errors.New("Trying to reserve an IP that is outside the capacity of this pool"), FreeMac
}
if _, free := dp.free[index]; free {
delete(dp.free, index)
dp.mac[index] = mac
return nil, mac
} else {
return errors.New("IP is already reserved"), FreeMac
}
} | [
"func",
"(",
"dp",
"*",
"DHCPPool",
")",
"ReserveIPIndex",
"(",
"index",
"uint64",
",",
"mac",
"string",
")",
"(",
"error",
",",
"string",
")",
"{",
"dp",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"dp",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"index",
">=",
"dp",
".",
"capacity",
"{",
"return",
"errors",
".",
"New",
"(",
"\"Trying to reserve an IP that is outside the capacity of this pool\"",
")",
",",
"FreeMac",
"\n",
"}",
"\n",
"if",
"_",
",",
"free",
":=",
"dp",
".",
"free",
"[",
"index",
"]",
";",
"free",
"{",
"delete",
"(",
"dp",
".",
"free",
",",
"index",
")",
"\n",
"dp",
".",
"mac",
"[",
"index",
"]",
"=",
"mac",
"\n",
"return",
"nil",
",",
"mac",
"\n",
"}",
"else",
"{",
"return",
"errors",
".",
"New",
"(",
"\"IP is already reserved\"",
")",
",",
"FreeMac",
"\n",
"}",
"\n",
"}"
] | // Reserves an IP in the pool, returns an error if the IP has already been reserved | [
"Reserves",
"an",
"IP",
"in",
"the",
"pool",
"returns",
"an",
"error",
"if",
"the",
"IP",
"has",
"already",
"been",
"reserved"
] | f29912bde7974931d699aba60aa8fde1c5d9a826 | https://github.com/inverse-inc/packetfence/blob/f29912bde7974931d699aba60aa8fde1c5d9a826/go/dhcp/pool/pool.go#L84-L99 | train |
inverse-inc/packetfence | go/dhcp/pool/pool.go | FreeIPIndex | func (dp *DHCPPool) FreeIPIndex(index uint64) error {
dp.lock.Lock()
defer dp.lock.Unlock()
if !dp.IndexInPool(index) {
return errors.New("Trying to free an IP that is outside the capacity of this pool")
}
if _, free := dp.free[index]; free {
return errors.New("IP is already free")
} else {
dp.free[index] = true
delete(dp.mac, index)
return nil
}
} | go | func (dp *DHCPPool) FreeIPIndex(index uint64) error {
dp.lock.Lock()
defer dp.lock.Unlock()
if !dp.IndexInPool(index) {
return errors.New("Trying to free an IP that is outside the capacity of this pool")
}
if _, free := dp.free[index]; free {
return errors.New("IP is already free")
} else {
dp.free[index] = true
delete(dp.mac, index)
return nil
}
} | [
"func",
"(",
"dp",
"*",
"DHCPPool",
")",
"FreeIPIndex",
"(",
"index",
"uint64",
")",
"error",
"{",
"dp",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"dp",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"!",
"dp",
".",
"IndexInPool",
"(",
"index",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"Trying to free an IP that is outside the capacity of this pool\"",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"free",
":=",
"dp",
".",
"free",
"[",
"index",
"]",
";",
"free",
"{",
"return",
"errors",
".",
"New",
"(",
"\"IP is already free\"",
")",
"\n",
"}",
"else",
"{",
"dp",
".",
"free",
"[",
"index",
"]",
"=",
"true",
"\n",
"delete",
"(",
"dp",
".",
"mac",
",",
"index",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // Frees an IP in the pool, returns an error if the IP is already free | [
"Frees",
"an",
"IP",
"in",
"the",
"pool",
"returns",
"an",
"error",
"if",
"the",
"IP",
"is",
"already",
"free"
] | f29912bde7974931d699aba60aa8fde1c5d9a826 | https://github.com/inverse-inc/packetfence/blob/f29912bde7974931d699aba60aa8fde1c5d9a826/go/dhcp/pool/pool.go#L102-L117 | train |
inverse-inc/packetfence | go/dhcp/pool/pool.go | GetFreeIPIndex | func (dp *DHCPPool) GetFreeIPIndex(mac string) (uint64, string, error) {
dp.lock.Lock()
defer dp.lock.Unlock()
if len(dp.free) == 0 {
return 0, FreeMac, errors.New("DHCP pool is full")
}
index := rand.Intn(len(dp.free))
var available uint64
for available = range dp.free {
if index == 0 {
break
}
index--
}
delete(dp.free, available)
dp.mac[available] = mac
return available, mac, nil
} | go | func (dp *DHCPPool) GetFreeIPIndex(mac string) (uint64, string, error) {
dp.lock.Lock()
defer dp.lock.Unlock()
if len(dp.free) == 0 {
return 0, FreeMac, errors.New("DHCP pool is full")
}
index := rand.Intn(len(dp.free))
var available uint64
for available = range dp.free {
if index == 0 {
break
}
index--
}
delete(dp.free, available)
dp.mac[available] = mac
return available, mac, nil
} | [
"func",
"(",
"dp",
"*",
"DHCPPool",
")",
"GetFreeIPIndex",
"(",
"mac",
"string",
")",
"(",
"uint64",
",",
"string",
",",
"error",
")",
"{",
"dp",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"dp",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"if",
"len",
"(",
"dp",
".",
"free",
")",
"==",
"0",
"{",
"return",
"0",
",",
"FreeMac",
",",
"errors",
".",
"New",
"(",
"\"DHCP pool is full\"",
")",
"\n",
"}",
"\n",
"index",
":=",
"rand",
".",
"Intn",
"(",
"len",
"(",
"dp",
".",
"free",
")",
")",
"\n",
"var",
"available",
"uint64",
"\n",
"for",
"available",
"=",
"range",
"dp",
".",
"free",
"{",
"if",
"index",
"==",
"0",
"{",
"break",
"\n",
"}",
"\n",
"index",
"--",
"\n",
"}",
"\n",
"delete",
"(",
"dp",
".",
"free",
",",
"available",
")",
"\n",
"dp",
".",
"mac",
"[",
"available",
"]",
"=",
"mac",
"\n",
"return",
"available",
",",
"mac",
",",
"nil",
"\n",
"}"
] | // Returns a random free IP address, an error if the pool is full | [
"Returns",
"a",
"random",
"free",
"IP",
"address",
"an",
"error",
"if",
"the",
"pool",
"is",
"full"
] | f29912bde7974931d699aba60aa8fde1c5d9a826 | https://github.com/inverse-inc/packetfence/blob/f29912bde7974931d699aba60aa8fde1c5d9a826/go/dhcp/pool/pool.go#L152-L173 | train |
inverse-inc/packetfence | go/dhcp/pool/pool.go | FreeIPsRemaining | func (dp *DHCPPool) FreeIPsRemaining() uint64 {
dp.lock.Lock()
defer dp.lock.Unlock()
return uint64(len(dp.free))
} | go | func (dp *DHCPPool) FreeIPsRemaining() uint64 {
dp.lock.Lock()
defer dp.lock.Unlock()
return uint64(len(dp.free))
} | [
"func",
"(",
"dp",
"*",
"DHCPPool",
")",
"FreeIPsRemaining",
"(",
")",
"uint64",
"{",
"dp",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"dp",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"return",
"uint64",
"(",
"len",
"(",
"dp",
".",
"free",
")",
")",
"\n",
"}"
] | // Returns the amount of free IPs in the pool | [
"Returns",
"the",
"amount",
"of",
"free",
"IPs",
"in",
"the",
"pool"
] | f29912bde7974931d699aba60aa8fde1c5d9a826 | https://github.com/inverse-inc/packetfence/blob/f29912bde7974931d699aba60aa8fde1c5d9a826/go/dhcp/pool/pool.go#L181-L185 | train |
inverse-inc/packetfence | go/firewallsso/watchguard.go | Stop | func (fw *WatchGuard) Stop(ctx context.Context, info map[string]string) (bool, error) {
p := fw.stopRadiusPacket(ctx, info)
client := fw.getRadiusClient(ctx)
var err error
client.Dialer.LocalAddr, err = net.ResolveUDPAddr("udp", fw.getSourceIp(ctx).String()+":0")
sharedutils.CheckError(err)
// Use the background context since we don't want the lib to use our context
ctx2, cancel := fw.RadiusContextWithTimeout()
defer cancel()
_, err = client.Exchange(ctx2, p, fw.PfconfigHashNS+":"+fw.Port)
if err != nil {
log.LoggerWContext(ctx).Error(fmt.Sprintf("Couldn't SSO to the WatchGuard, got the following error: %s", err))
return false, err
} else {
return true, nil
}
} | go | func (fw *WatchGuard) Stop(ctx context.Context, info map[string]string) (bool, error) {
p := fw.stopRadiusPacket(ctx, info)
client := fw.getRadiusClient(ctx)
var err error
client.Dialer.LocalAddr, err = net.ResolveUDPAddr("udp", fw.getSourceIp(ctx).String()+":0")
sharedutils.CheckError(err)
// Use the background context since we don't want the lib to use our context
ctx2, cancel := fw.RadiusContextWithTimeout()
defer cancel()
_, err = client.Exchange(ctx2, p, fw.PfconfigHashNS+":"+fw.Port)
if err != nil {
log.LoggerWContext(ctx).Error(fmt.Sprintf("Couldn't SSO to the WatchGuard, got the following error: %s", err))
return false, err
} else {
return true, nil
}
} | [
"func",
"(",
"fw",
"*",
"WatchGuard",
")",
"Stop",
"(",
"ctx",
"context",
".",
"Context",
",",
"info",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"p",
":=",
"fw",
".",
"stopRadiusPacket",
"(",
"ctx",
",",
"info",
")",
"\n",
"client",
":=",
"fw",
".",
"getRadiusClient",
"(",
"ctx",
")",
"\n",
"var",
"err",
"error",
"\n",
"client",
".",
"Dialer",
".",
"LocalAddr",
",",
"err",
"=",
"net",
".",
"ResolveUDPAddr",
"(",
"\"udp\"",
",",
"fw",
".",
"getSourceIp",
"(",
"ctx",
")",
".",
"String",
"(",
")",
"+",
"\":0\"",
")",
"\n",
"sharedutils",
".",
"CheckError",
"(",
"err",
")",
"\n",
"ctx2",
",",
"cancel",
":=",
"fw",
".",
"RadiusContextWithTimeout",
"(",
")",
"\n",
"defer",
"cancel",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"client",
".",
"Exchange",
"(",
"ctx2",
",",
"p",
",",
"fw",
".",
"PfconfigHashNS",
"+",
"\":\"",
"+",
"fw",
".",
"Port",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"LoggerWContext",
"(",
"ctx",
")",
".",
"Error",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"Couldn't SSO to the WatchGuard, got the following error: %s\"",
",",
"err",
")",
")",
"\n",
"return",
"false",
",",
"err",
"\n",
"}",
"else",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // Send an SSO stop to the WatchGuard firewall
// Returns an error unless there is a valid reply from the firewall | [
"Send",
"an",
"SSO",
"stop",
"to",
"the",
"WatchGuard",
"firewall",
"Returns",
"an",
"error",
"unless",
"there",
"is",
"a",
"valid",
"reply",
"from",
"the",
"firewall"
] | f29912bde7974931d699aba60aa8fde1c5d9a826 | https://github.com/inverse-inc/packetfence/blob/f29912bde7974931d699aba60aa8fde1c5d9a826/go/firewallsso/watchguard.go#L58-L76 | train |
inverse-inc/packetfence | go/firewallsso/watchguard.go | stopRadiusPacket | func (fw *WatchGuard) stopRadiusPacket(ctx context.Context, info map[string]string) *radius.Packet {
r := radius.New(radius.CodeAccountingRequest, []byte(fw.Password))
rfc2866.AcctSessionID_AddString(r, "acct_pf-"+info["mac"])
rfc2866.AcctStatusType_Add(r, rfc2866.AcctStatusType_Value_Stop)
rfc2865.UserName_AddString(r, info["username"])
rfc2865.FilterID_AddString(r, info["role"])
rfc2865.CalledStationID_AddString(r, "00:11:22:33:44:55")
rfc2865.FramedIPAddress_Add(r, net.ParseIP(info["ip"]))
rfc2865.CallingStationID_AddString(r, info["mac"])
return r
} | go | func (fw *WatchGuard) stopRadiusPacket(ctx context.Context, info map[string]string) *radius.Packet {
r := radius.New(radius.CodeAccountingRequest, []byte(fw.Password))
rfc2866.AcctSessionID_AddString(r, "acct_pf-"+info["mac"])
rfc2866.AcctStatusType_Add(r, rfc2866.AcctStatusType_Value_Stop)
rfc2865.UserName_AddString(r, info["username"])
rfc2865.FilterID_AddString(r, info["role"])
rfc2865.CalledStationID_AddString(r, "00:11:22:33:44:55")
rfc2865.FramedIPAddress_Add(r, net.ParseIP(info["ip"]))
rfc2865.CallingStationID_AddString(r, info["mac"])
return r
} | [
"func",
"(",
"fw",
"*",
"WatchGuard",
")",
"stopRadiusPacket",
"(",
"ctx",
"context",
".",
"Context",
",",
"info",
"map",
"[",
"string",
"]",
"string",
")",
"*",
"radius",
".",
"Packet",
"{",
"r",
":=",
"radius",
".",
"New",
"(",
"radius",
".",
"CodeAccountingRequest",
",",
"[",
"]",
"byte",
"(",
"fw",
".",
"Password",
")",
")",
"\n",
"rfc2866",
".",
"AcctSessionID_AddString",
"(",
"r",
",",
"\"acct_pf-\"",
"+",
"info",
"[",
"\"mac\"",
"]",
")",
"\n",
"rfc2866",
".",
"AcctStatusType_Add",
"(",
"r",
",",
"rfc2866",
".",
"AcctStatusType_Value_Stop",
")",
"\n",
"rfc2865",
".",
"UserName_AddString",
"(",
"r",
",",
"info",
"[",
"\"username\"",
"]",
")",
"\n",
"rfc2865",
".",
"FilterID_AddString",
"(",
"r",
",",
"info",
"[",
"\"role\"",
"]",
")",
"\n",
"rfc2865",
".",
"CalledStationID_AddString",
"(",
"r",
",",
"\"00:11:22:33:44:55\"",
")",
"\n",
"rfc2865",
".",
"FramedIPAddress_Add",
"(",
"r",
",",
"net",
".",
"ParseIP",
"(",
"info",
"[",
"\"ip\"",
"]",
")",
")",
"\n",
"rfc2865",
".",
"CallingStationID_AddString",
"(",
"r",
",",
"info",
"[",
"\"mac\"",
"]",
")",
"\n",
"return",
"r",
"\n",
"}"
] | // Build the RADIUS packet for an SSO stop | [
"Build",
"the",
"RADIUS",
"packet",
"for",
"an",
"SSO",
"stop"
] | f29912bde7974931d699aba60aa8fde1c5d9a826 | https://github.com/inverse-inc/packetfence/blob/f29912bde7974931d699aba60aa8fde1c5d9a826/go/firewallsso/watchguard.go#L79-L90 | train |
inverse-inc/packetfence | go/caddy/requestlimit/requestlimit.go | setup | func setup(c *caddy.Controller) error {
var max int
for c.Next() {
val := c.Val()
switch val {
case "requestlimit":
if !c.NextArg() {
fmt.Println("Missing limit argument for requestlimit")
return c.ArgErr()
} else {
val := c.Val()
if val != "" {
max64, err := strconv.ParseInt(c.Val(), 10, 32)
if err != nil {
msg := fmt.Sprintf("Cannot parse request limit value %s", val)
return errors.New(msg)
} else {
max = int(max64)
fmt.Printf("Setting up requestlimit with a limit of %d\n", max)
break
}
}
}
default:
return c.ArgErr()
}
}
httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
return RequestLimitHandler{Next: next, sem: make(chan int, max)}
})
return nil
} | go | func setup(c *caddy.Controller) error {
var max int
for c.Next() {
val := c.Val()
switch val {
case "requestlimit":
if !c.NextArg() {
fmt.Println("Missing limit argument for requestlimit")
return c.ArgErr()
} else {
val := c.Val()
if val != "" {
max64, err := strconv.ParseInt(c.Val(), 10, 32)
if err != nil {
msg := fmt.Sprintf("Cannot parse request limit value %s", val)
return errors.New(msg)
} else {
max = int(max64)
fmt.Printf("Setting up requestlimit with a limit of %d\n", max)
break
}
}
}
default:
return c.ArgErr()
}
}
httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
return RequestLimitHandler{Next: next, sem: make(chan int, max)}
})
return nil
} | [
"func",
"setup",
"(",
"c",
"*",
"caddy",
".",
"Controller",
")",
"error",
"{",
"var",
"max",
"int",
"\n",
"for",
"c",
".",
"Next",
"(",
")",
"{",
"val",
":=",
"c",
".",
"Val",
"(",
")",
"\n",
"switch",
"val",
"{",
"case",
"\"requestlimit\"",
":",
"if",
"!",
"c",
".",
"NextArg",
"(",
")",
"{",
"fmt",
".",
"Println",
"(",
"\"Missing limit argument for requestlimit\"",
")",
"\n",
"return",
"c",
".",
"ArgErr",
"(",
")",
"\n",
"}",
"else",
"{",
"val",
":=",
"c",
".",
"Val",
"(",
")",
"\n",
"if",
"val",
"!=",
"\"\"",
"{",
"max64",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"c",
".",
"Val",
"(",
")",
",",
"10",
",",
"32",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"msg",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"Cannot parse request limit value %s\"",
",",
"val",
")",
"\n",
"return",
"errors",
".",
"New",
"(",
"msg",
")",
"\n",
"}",
"else",
"{",
"max",
"=",
"int",
"(",
"max64",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"Setting up requestlimit with a limit of %d\\n\"",
",",
"\\n",
")",
"\n",
"max",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"break",
"}",
"\n",
"}",
"\n",
"default",
":",
"return",
"c",
".",
"ArgErr",
"(",
")",
"\n",
"\n",
"httpserver",
".",
"GetConfig",
"(",
"c",
")",
".",
"AddMiddleware",
"(",
"func",
"(",
"next",
"httpserver",
".",
"Handler",
")",
"httpserver",
".",
"Handler",
"{",
"return",
"RequestLimitHandler",
"{",
"Next",
":",
"next",
",",
"sem",
":",
"make",
"(",
"chan",
"int",
",",
"max",
")",
"}",
"\n",
"}",
")",
"\n",
"}"
] | // Setup the rate limiter with the configuration in the Caddyfile | [
"Setup",
"the",
"rate",
"limiter",
"with",
"the",
"configuration",
"in",
"the",
"Caddyfile"
] | f29912bde7974931d699aba60aa8fde1c5d9a826 | https://github.com/inverse-inc/packetfence/blob/f29912bde7974931d699aba60aa8fde1c5d9a826/go/caddy/requestlimit/requestlimit.go#L21-L55 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.