_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q30100 | HasDir | train | func (b *Box) HasDir(name string) bool {
oncer.Do("packr2/box/HasDir"+b.Name, func() {
for _, f := range b.List() {
for d := filepath.Dir(f); d != "."; d = filepath.Dir(d) {
b.dirs.Store(d, true)
}
}
})
if name == "/" {
return b.Has("index.html")
}
_, ok := b.dirs.Load(name)
return ok
} | go | {
"resource": ""
} |
q30101 | Resolve | train | func (b *Box) Resolve(key string) (file.File, error) {
key = strings.TrimPrefix(key, "/")
var r resolver.Resolver
b.resolvers.Range(func(k string, vr resolver.Resolver) bool {
lk := strings.ToLower(resolver.Key(k))
lkey := strings.ToLower(resolver.Key(key))
if lk == lkey {
r = vr
return false
}
ret... | go | {
"resource": ""
} |
q30102 | NewFromRoots | train | func NewFromRoots(roots []string, opts *RootsOptions) (*Parser, error) {
if opts == nil {
opts = &RootsOptions{}
}
if len(roots) == 0 {
pwd, _ := os.Getwd()
roots = append(roots, pwd)
}
p := New()
plog.Debug(p, "NewFromRoots", "roots", roots, "options", opts)
callback := func(path string, de *godirwalk.Di... | go | {
"resource": ""
} |
q30103 | NewFile | train | func NewFile(name string, b []byte) (File, error) {
return packd.NewFile(name, bytes.NewReader(b))
} | go | {
"resource": ""
} |
q30104 | RegisterHTTPForever | train | func (k *Kite) RegisterHTTPForever(kiteURL *url.URL) {
// Create the httpBackoffRegister that RegisterHTTPForever will
// use to backoff repeated register attempts.
httpRegisterBackOff := backoff.NewExponentialBackOff()
httpRegisterBackOff.InitialInterval = 30 * time.Second
httpRegisterBackOff.MaxInterval = 5 * ti... | go | {
"resource": ""
} |
q30105 | handleHeartbeat | train | func (k *Kite) handleHeartbeat(r *Request) (interface{}, error) {
req, err := newHeartbeatReq(r)
if err != nil {
return nil, err
}
k.heartbeatC <- req
return nil, req.ping()
} | go | {
"resource": ""
} |
q30106 | Call | train | func (f Function) Call(args ...interface{}) error {
if !f.IsValid() {
return errors.New("invalid function")
}
return f.Caller.Call(args...)
} | go | {
"resource": ""
} |
q30107 | ParseCallbacks | train | func ParseCallbacks(msg *Message, sender func(id uint64, args []interface{}) error) error {
// Parse callbacks field and create callback functions.
for methodID, path := range msg.Callbacks {
id, err := strconv.ParseUint(methodID, 10, 64)
if err != nil {
return err
}
f := func(args ...interface{}) error {... | go | {
"resource": ""
} |
q30108 | Flatten | train | func (n *Node) Flatten() []*Node {
nodes := make([]*Node, 0)
for _, node := range n.Node.Nodes {
if node.Dir {
nodes = append(nodes, NewNode(node).Flatten()...)
continue
}
nodes = append(nodes, NewNode(node))
}
return nodes
} | go | {
"resource": ""
} |
q30109 | Kite | train | func (n *Node) Kite() (*protocol.KiteWithToken, error) {
kite, err := n.KiteFromKey()
if err != nil {
return nil, err
}
val, err := n.Value()
if err != nil {
return nil, err
}
return &protocol.KiteWithToken{
Kite: *kite,
URL: val.URL,
KeyID: val.KeyID,
}, nil
} | go | {
"resource": ""
} |
q30110 | Value | train | func (n *Node) Value() (kontrolprotocol.RegisterValue, error) {
var rv kontrolprotocol.RegisterValue
err := json.Unmarshal([]byte(n.Node.Value), &rv)
return rv, err
} | go | {
"resource": ""
} |
q30111 | Kites | train | func (n *Node) Kites() (Kites, error) {
// Get all nodes recursively.
nodes := n.Flatten()
// Convert etcd nodes to kites.
var err error
kites := make(Kites, len(nodes))
for i, n := range nodes {
kites[i], err = n.Kite()
if err != nil {
return nil, err
}
}
return kites, nil
} | go | {
"resource": ""
} |
q30112 | createError | train | func createError(req *Request, r interface{}) *Error {
if r == nil {
return nil
}
var kiteErr *Error
switch err := r.(type) {
case *Error:
kiteErr = err
case *dnode.ArgumentError:
kiteErr = &Error{
Type: "argumentError",
Message: err.Error(),
}
default:
kiteErr = &Error{
Type: "genericE... | go | {
"resource": ""
} |
q30113 | isWebsocket | train | func isWebsocket(req *http.Request) bool {
if strings.ToLower(req.Header.Get("Upgrade")) != "websocket" ||
!strings.Contains(strings.ToLower(req.Header.Get("Connection")), "upgrade") {
return false
}
return true
} | go | {
"resource": ""
} |
q30114 | ListenAndServe | train | func (p *Proxy) ListenAndServe() error {
var err error
p.listener, err = net.Listen("tcp4",
net.JoinHostPort(p.Kite.Config.IP, strconv.Itoa(p.Kite.Config.Port)))
if err != nil {
return err
}
p.Kite.Log.Info("Listening on: %s", p.listener.Addr().String())
close(p.readyC)
server := http.Server{
Handler: p.... | go | {
"resource": ""
} |
q30115 | diskStats | train | func diskStats() (*disk, error) {
var (
freeBytes uint64 = 0
totalBytes uint64 = 0
)
// windows sets return value to 0 when function fails.
ret, _, err := procGetDiskFreeSpaceExW.Call(
0,
uintptr(unsafe.Pointer(&freeBytes)),
uintptr(unsafe.Pointer(&totalBytes)),
0,
)
if ret == 0 {
return nil, err
... | go | {
"resource": ""
} |
q30116 | memoryStats | train | func memoryStats() (*memory, error) {
mstat := struct {
size uint32
_ uint32
totalPhys uint64
availPhys uint64
_ [5]uint64
}{}
// windows sets return value to 0 when function fails.
mstat.size = uint32(unsafe.Sizeof(mstat))
ret, _, err := procGlobalMemoryStatusEx.Call(uintptr(unsafe... | go | {
"resource": ""
} |
q30117 | ParsePayload | train | func (w *WebRTCSignalMessage) ParsePayload() (*Payload, error) {
w.mu.Lock()
defer w.mu.Unlock()
if w.isParsed {
return w.parsedPayload, nil
}
payload := &Payload{}
if err := json.Unmarshal(w.Payload, payload); err != nil {
return nil, err
}
w.parsedPayload = payload
return payload, nil
} | go | {
"resource": ""
} |
q30118 | getLogLevel | train | func getLogLevel() Level {
switch strings.ToUpper(os.Getenv("KITE_LOG_LEVEL")) {
case "DEBUG":
return DEBUG
case "WARNING":
return WARNING
case "ERROR":
return ERROR
case "FATAL":
return FATAL
default:
return INFO
}
} | go | {
"resource": ""
} |
q30119 | convertLevel | train | func convertLevel(l Level) logging.Level {
switch l {
case DEBUG:
return logging.DEBUG
case WARNING:
return logging.WARNING
case ERROR:
return logging.ERROR
case FATAL:
return logging.CRITICAL
default:
return logging.INFO
}
} | go | {
"resource": ""
} |
q30120 | fields | train | func (s *Scrubber) fields(rv reflect.Value, path Path, callbacks map[string]Path) {
for i := 0; i < rv.NumField(); i++ {
sf := rv.Type().Field(i)
if sf.PkgPath != "" && !sf.Anonymous { // unexported.
continue
}
// dnode uses JSON package tags for field naming so we need to
// discard their comma-separate... | go | {
"resource": ""
} |
q30121 | methods | train | func (s *Scrubber) methods(rv reflect.Value, path Path, callbacks map[string]Path) {
for i := 0; i < rv.NumMethod(); i++ {
if rv.Type().Method(i).PkgPath == "" { // exported
cb, ok := rv.Method(i).Interface().(func(*Partial))
if !ok {
continue
}
name := rv.Type().Method(i).Name
name = strings.ToL... | go | {
"resource": ""
} |
q30122 | SetupKontrolClient | train | func (k *Kite) SetupKontrolClient() error {
if k.kontrol.Client != nil {
return nil // already prepared
}
if k.Config.KontrolURL == "" {
return errors.New("no kontrol URL given in config")
}
client := k.NewClient(k.Config.KontrolURL)
client.Kite = protocol.Kite{Name: "kontrol"} // for logging purposes
clie... | go | {
"resource": ""
} |
q30123 | GetToken | train | func (k *Kite) GetToken(kite *protocol.Kite) (string, error) {
if err := k.SetupKontrolClient(); err != nil {
return "", err
}
<-k.kontrol.readyConnected
result, err := k.kontrol.TellWithTimeout("getToken", k.Config.Timeout, kite)
if err != nil {
return "", err
}
var tkn string
err = result.Unmarshal(&tk... | go | {
"resource": ""
} |
q30124 | GetTokenForce | train | func (k *Kite) GetTokenForce(kite *protocol.Kite) (string, error) {
if err := k.SetupKontrolClient(); err != nil {
return "", err
}
<-k.kontrol.readyConnected
args := &protocol.GetTokenArgs{
KontrolQuery: *kite.Query(),
Force: true,
}
result, err := k.kontrol.TellWithTimeout("getToken", k.Config.T... | go | {
"resource": ""
} |
q30125 | GetKey | train | func (k *Kite) GetKey() (string, error) {
if err := k.SetupKontrolClient(); err != nil {
return "", err
}
<-k.kontrol.readyConnected
result, err := k.kontrol.TellWithTimeout("getKey", k.Config.Timeout)
if err != nil {
return "", err
}
var key string
err = result.Unmarshal(&key)
if err != nil {
return ... | go | {
"resource": ""
} |
q30126 | NewKeyRenewer | train | func (k *Kite) NewKeyRenewer(interval time.Duration) {
ticker := time.NewTicker(interval)
for range ticker.C {
_, err := k.GetKey()
if err != nil {
k.Log.Warning("Key renew failed: %s", err)
}
}
} | go | {
"resource": ""
} |
q30127 | signalReady | train | func (k *Kite) signalReady() {
k.kontrol.onceRegistered.Do(func() { close(k.kontrol.readyRegistered) })
} | go | {
"resource": ""
} |
q30128 | RegisterToTunnel | train | func (k *Kite) RegisterToTunnel() {
query := &protocol.KontrolQuery{
Username: k.Config.KontrolUser,
Environment: k.Config.Environment,
Name: "tunnelproxy",
}
k.RegisterToProxy(nil, query)
} | go | {
"resource": ""
} |
q30129 | RegisterToProxy | train | func (k *Kite) RegisterToProxy(registerURL *url.URL, query *protocol.KontrolQuery) {
go k.RegisterForever(nil)
for {
var proxyKite *Client
// The proxy kite to connect can be overridden with the
// environmental variable "KITE_PROXY_URL". If it is not set
// we will ask Kontrol for available Proxy kites.
... | go | {
"resource": ""
} |
q30130 | registerToProxyKite | train | func (k *Kite) registerToProxyKite(c *Client, kiteURL *url.URL) (*url.URL, error) {
err := c.Dial()
if err != nil {
k.Log.Error("Cannot connect to Proxy kite: %s", err.Error())
return nil, err
}
// Disconnect from Proxy Kite if error happens while registering.
defer func() {
if err != nil {
c.Close()
}... | go | {
"resource": ""
} |
q30131 | TellKontrolWithTimeout | train | func (k *Kite) TellKontrolWithTimeout(method string, timeout time.Duration, args ...interface{}) (result *dnode.Partial, err error) {
if err := k.SetupKontrolClient(); err != nil {
return nil, err
}
// Wait for readyConnect, or timeout
select {
case <-time.After(k.Config.Timeout):
return nil, &Error{
Type:... | go | {
"resource": ""
} |
q30132 | Get | train | func (i *IdLock) Get(id string) sync.Locker {
i.locksMu.Lock()
defer i.locksMu.Unlock()
var l sync.Locker
var ok bool
l, ok = i.locks[id]
if !ok {
l = &sync.Mutex{}
i.locks[id] = l
}
return l
} | go | {
"resource": ""
} |
q30133 | BinPath | train | func (k *InstalledKite) BinPath() string {
return filepath.Join(k.Domain, k.User, k.Repo, k.Version, "bin", strings.TrimSuffix(k.Repo, ".kite"))
} | go | {
"resource": ""
} |
q30134 | Error | train | func (err *ErrSession) Error() string {
if err.Err == nil {
return fmt.Sprintf("%s (%s)", stateTexts[err.State], err.Type)
}
return fmt.Sprintf("%s: %s (%s)", stateTexts[err.State], err.Err, err.Type)
} | go | {
"resource": ""
} |
q30135 | IsSessionClosed | train | func IsSessionClosed(err error) bool {
switch err {
case ErrSessionClosed, sockjs.ErrSessionNotOpen, websocket.ErrCloseSent:
return true
}
if e, ok := err.(*ErrSession); ok && e.State > sockjs.SessionActive {
return true
}
_, ok := err.(*websocket.CloseError)
return ok
} | go | {
"resource": ""
} |
q30136 | DialWebsocket | train | func DialWebsocket(uri string, cfg *config.Config) (*WebsocketSession, error) {
u, err := url.Parse(uri)
if err != nil {
return nil, err
}
h := http.Header{
"Origin": {u.Scheme + "://" + u.Host},
}
serverID := threeDigits()
sessionID := utils.RandomString(20)
u = makeWebsocketURL(u, serverID, sessionID)
... | go | {
"resource": ""
} |
q30137 | Recv | train | func (w *WebsocketSession) Recv() (string, error) {
// Return previously received messages if there is any.
if len(w.messages) > 0 {
msg := w.messages[0]
w.messages = w.messages[1:]
return msg, nil
}
read_frame:
if atomic.LoadInt32(&w.closed) == 1 {
return "", ErrSessionClosed
}
// Read one SockJS frame... | go | {
"resource": ""
} |
q30138 | Send | train | func (w *WebsocketSession) Send(str string) error {
if atomic.LoadInt32(&w.closed) == 1 {
return ErrSessionClosed
}
w.mu.Lock()
defer w.mu.Unlock()
b, _ := json.Marshal([]string{str})
return w.conn.WriteMessage(websocket.TextMessage, b)
} | go | {
"resource": ""
} |
q30139 | Close | train | func (w *WebsocketSession) Close(uint32, string) error {
if atomic.CompareAndSwapInt32(&w.closed, 0, 1) {
return w.conn.Close()
}
return ErrSessionClosed
} | go | {
"resource": ""
} |
q30140 | isInstalled | train | func isInstalled(fullKiteName string) (bool, error) {
bundlePath, err := getBundlePath(fullKiteName)
if err != nil {
return false, err
}
return exists(bundlePath)
} | go | {
"resource": ""
} |
q30141 | NewCachedStorage | train | func NewCachedStorage(backend KeyPairStorage, cache KeyPairStorage) *CachedStorage {
return &CachedStorage{
cache: cache,
backend: backend,
}
} | go | {
"resource": ""
} |
q30142 | Attach | train | func (k Kites) Attach(token string) {
for _, kite := range k {
kite.Token = token
}
} | go | {
"resource": ""
} |
q30143 | Shuffle | train | func (k *Kites) Shuffle() {
shuffled := make(Kites, len(*k))
for i, v := range rand.Perm(len(*k)) {
shuffled[v] = (*k)[i]
}
*k = shuffled
} | go | {
"resource": ""
} |
q30144 | Filter | train | func (k *Kites) Filter(constraint version.Constraints, keyRest string) {
filtered := make(Kites, 0)
for _, kite := range *k {
if isValid(&kite.Kite, constraint, keyRest) {
filtered = append(filtered, kite)
}
}
*k = filtered
} | go | {
"resource": ""
} |
q30145 | DialForever | train | func (c *Client) DialForever() (connected chan bool, err error) {
c.Reconnect = true
connected = make(chan bool, 1) // This will be closed on first connection.
go c.dialForever(connected)
return
} | go | {
"resource": ""
} |
q30146 | run | train | func (c *Client) run() {
err := c.readLoop()
if err != nil {
c.LocalKite.Log.Debug("readloop err: %s", err)
}
// falls here when connection disconnects
c.callOnDisconnectHandlers()
// let others know that the client has disconnected
c.disconnectMu.Lock()
if c.disconnect != nil {
close(c.disconnect)
c.di... | go | {
"resource": ""
} |
q30147 | readLoop | train | func (c *Client) readLoop() error {
for {
p, err := c.receiveData()
c.LocalKite.Log.Debug("readloop received: %s %v", p, err)
if err != nil {
return err
}
msg, fn, err := c.processMessage(p)
if err != nil {
if _, ok := err.(dnode.CallbackNotFoundError); !ok {
c.LocalKite.Log.Warning("error pro... | go | {
"resource": ""
} |
q30148 | receiveData | train | func (c *Client) receiveData() ([]byte, error) {
type recv struct {
msg []byte
err error
}
session := c.getSession()
if session == nil {
return nil, errors.New("not connected")
}
done := make(chan recv, 1)
go func() {
msg, err := session.Recv()
done <- recv{[]byte(msg), err}
}()
select {
case r ... | go | {
"resource": ""
} |
q30149 | processMessage | train | func (c *Client) processMessage(data []byte) (msg *dnode.Message, fn interface{}, err error) {
// Call error handler.
defer func() {
if err != nil {
onError(err)
}
}()
msg = &dnode.Message{}
if err = json.Unmarshal(data, &msg); err != nil {
return nil, nil, err
}
sender := func(id uint64, args []inte... | go | {
"resource": ""
} |
q30150 | sendHub | train | func (c *Client) sendHub() {
defer c.wg.Done()
for {
select {
case msg := <-c.send:
c.LocalKite.Log.Debug("sending: %s", msg)
session := c.getSession()
if session == nil {
c.LocalKite.Log.Error("not connected")
continue
}
err := session.Send(string(msg.p))
if err != nil {
if msg.er... | go | {
"resource": ""
} |
q30151 | OnConnect | train | func (c *Client) OnConnect(handler func()) {
c.m.Lock()
c.onConnectHandlers = append(c.onConnectHandlers, handler)
c.m.Unlock()
} | go | {
"resource": ""
} |
q30152 | OnDisconnect | train | func (c *Client) OnDisconnect(handler func()) {
c.m.Lock()
c.onDisconnectHandlers = append(c.onDisconnectHandlers, handler)
c.m.Unlock()
} | go | {
"resource": ""
} |
q30153 | OnTokenExpire | train | func (c *Client) OnTokenExpire(handler func()) {
c.m.Lock()
c.onTokenExpireHandlers = append(c.onTokenExpireHandlers, handler)
c.m.Unlock()
} | go | {
"resource": ""
} |
q30154 | OnTokenRenew | train | func (c *Client) OnTokenRenew(handler func(token string)) {
c.m.Lock()
c.onTokenRenewHandlers = append(c.onTokenRenewHandlers, handler)
c.m.Unlock()
} | go | {
"resource": ""
} |
q30155 | callOnConnectHandlers | train | func (c *Client) callOnConnectHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onConnectHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | go | {
"resource": ""
} |
q30156 | callOnDisconnectHandlers | train | func (c *Client) callOnDisconnectHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onDisconnectHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | go | {
"resource": ""
} |
q30157 | callOnTokenExpireHandlers | train | func (c *Client) callOnTokenExpireHandlers() {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onTokenExpireHandlers {
func() {
defer nopRecover()
handler()
}()
}
} | go | {
"resource": ""
} |
q30158 | callOnTokenRenewHandlers | train | func (c *Client) callOnTokenRenewHandlers(token string) {
c.m.RLock()
defer c.m.RUnlock()
for _, handler := range c.onTokenRenewHandlers {
func() {
defer nopRecover()
handler(token)
}()
}
} | go | {
"resource": ""
} |
q30159 | Tell | train | func (c *Client) Tell(method string, args ...interface{}) (result *dnode.Partial, err error) {
return c.TellWithTimeout(method, 0, args...)
} | go | {
"resource": ""
} |
q30160 | Go | train | func (c *Client) Go(method string, args ...interface{}) chan *response {
return c.GoWithTimeout(method, 0, args...)
} | go | {
"resource": ""
} |
q30161 | sendMethod | train | func (c *Client) sendMethod(method string, args []interface{}, timeout time.Duration, responseChan chan *response) {
// To clean the sent callback after response is received.
// Send/Receive in a channel to prevent race condition because
// the callback is run in a separate goroutine.
removeCallback := make(chan ui... | go | {
"resource": ""
} |
q30162 | marshalAndSend | train | func (c *Client) marshalAndSend(method interface{}, arguments []interface{}) (callbacks map[string]dnode.Path, errC <-chan error, err error) {
// scrub trough the arguments and save any callbacks.
callbacks = c.scrubber.Scrub(arguments)
defer func() {
if err != nil {
c.removeCallbacks(callbacks)
}
}()
// ... | go | {
"resource": ""
} |
q30163 | sendCallbackID | train | func sendCallbackID(callbacks map[string]dnode.Path, ch chan<- uint64) {
// TODO fix finding of responseCallback in dnode message when removing callback
for id, path := range callbacks {
if len(path) != 2 {
continue
}
p0, ok := path[0].(string)
if !ok {
continue
}
p1, ok := path[1].(string)
if !ok... | go | {
"resource": ""
} |
q30164 | onError | train | func onError(err error) {
// TODO do not marshal options again here
switch e := err.(type) {
case dnode.MethodNotFoundError: // Tell the requester "method is not found".
args, err2 := e.Args.Slice()
if err2 != nil {
return
}
if len(args) < 1 {
return
}
var options callOptions
if err := args[0].... | go | {
"resource": ""
} |
q30165 | Run | train | func (k *Kite) Run() {
if os.Getenv("KITE_VERSION") != "" {
fmt.Println(k.Kite().Version)
os.Exit(0)
}
// An error string equivalent to net.errClosing for using with http.Serve()
// during a graceful exit. Needed to declare here again because it is not
// exported by "net" package.
const errClosing = "use of... | go | {
"resource": ""
} |
q30166 | Close | train | func (k *Kite) Close() {
k.Log.Info("Closing kite...")
k.kontrol.Lock()
if k.kontrol != nil && k.kontrol.Client != nil {
k.kontrol.Close()
}
k.kontrol.Unlock()
if k.listener != nil {
k.listener.Close()
k.listener = nil
}
k.mu.Lock()
cache := k.verifyCache
k.mu.Unlock()
if cache != nil {
cache.Sto... | go | {
"resource": ""
} |
q30167 | listenAndServe | train | func (k *Kite) listenAndServe() error {
// create a new one if there doesn't exist
l, err := net.Listen("tcp4", k.Addr())
if err != nil {
return err
}
k.Log.Info("New listening: %s", l.Addr())
if k.TLSConfig != nil {
if k.TLSConfig.NextProtos == nil {
k.TLSConfig.NextProtos = []string{"http/1.1"}
}
l... | go | {
"resource": ""
} |
q30168 | Do | train | 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 | {
"resource": ""
} |
q30169 | sysctlbyname | train | func sysctlbyname(name string, data interface{}) (err error) {
val, err := syscall.Sysctl(name)
if err != nil {
return err
}
buf := []byte(val)
switch v := data.(type) {
case *uint64:
*v = *(*uint64)(unsafe.Pointer(&buf[0]))
return
}
bbuf := bytes.NewBuffer([]byte(val))
return binary.Read(bbuf, binary... | go | {
"resource": ""
} |
q30170 | KiteHome | train | 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 | {
"resource": ""
} |
q30171 | Read | train | 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 | {
"resource": ""
} |
q30172 | Write | train | func Write(kiteKey string) error {
keyPath, err := kiteKeyPath()
if err != nil {
return err
}
err = os.MkdirAll(filepath.Dir(keyPath), 0700)
if err != nil {
return err
}
// Need to remove the previous key first because we can't write over
// when previous file's mode is 0400.
os.Remove(keyPath)
return ... | go | {
"resource": ""
} |
q30173 | Parse | train | func Parse() (*jwt.Token, error) {
kiteKey, err := Read()
if err != nil {
return nil, err
}
return jwt.ParseWithClaims(kiteKey, &KiteClaims{}, GetKontrolKey)
} | go | {
"resource": ""
} |
q30174 | ParseFile | train | 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 | {
"resource": ""
} |
q30175 | Extract | train | func (e *Extractor) Extract(token *jwt.Token) (interface{}, error) {
e.Token = token
if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
return nil, errors.New("invalid signing method")
}
claims, ok := token.Claims.(*KiteClaims)
if !ok {
return nil, fmt.Errorf("no kontrol key found")
}
e.Claims = clai... | go | {
"resource": ""
} |
q30176 | registerSelf | train | func (k *Kontrol) registerSelf() {
value := &kontrolprotocol.RegisterValue{
URL: k.Kite.Config.KontrolURL,
}
// change if the user wants something different
if k.RegisterURL != "" {
value.URL = k.RegisterURL
}
keyPair, err := k.KeyPair()
if err != nil {
if err != errNoSelfKeyPair {
k.log.Error("%s", e... | go | {
"resource": ""
} |
q30177 | KeyPair | train | func (k *Kontrol) KeyPair() (pair *KeyPair, err error) {
if k.selfKeyPair != nil {
return k.selfKeyPair, nil
}
kiteKey := k.Kite.KiteKey()
if kiteKey == "" || len(k.lastPublic) == 0 {
return nil, errNoSelfKeyPair
}
keyIndex := -1
me := new(multiError)
for i := range k.lastPublic {
ri := len(k.lastPub... | go | {
"resource": ""
} |
q30178 | cacheToken | train | 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 | {
"resource": ""
} |
q30179 | UnmarshalJSON | train | 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 | {
"resource": ""
} |
q30180 | SliceOfLength | train | 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 | {
"resource": ""
} |
q30181 | Map | train | func (p *Partial) Map() (m map[string]*Partial, err error) {
err = p.Unmarshal(&m)
return
} | go | {
"resource": ""
} |
q30182 | String | train | func (p *Partial) String() (s string, err error) {
err = p.Unmarshal(&s)
return
} | go | {
"resource": ""
} |
q30183 | Float64 | train | func (p *Partial) Float64() (f float64, err error) {
err = p.Unmarshal(&f)
return
} | go | {
"resource": ""
} |
q30184 | Bool | train | func (p *Partial) Bool() (b bool, err error) {
err = p.Unmarshal(&b)
return
} | go | {
"resource": ""
} |
q30185 | Function | train | func (p *Partial) Function() (f Function, err error) {
err = p.Unmarshal(&f)
return
} | go | {
"resource": ""
} |
q30186 | validateKiteKey | train | 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 | {
"resource": ""
} |
q30187 | onlyIDQuery | train | func onlyIDQuery(q *protocol.KontrolQuery) bool {
fields := q.Fields()
// check if any other key exist, if yes return a false
for _, k := range keyOrder {
v := fields[k]
if k != "id" && v != "" {
return false
}
}
// now all other keys are empty, check finally for our ID
if fields["id"] != "" {
return... | go | {
"resource": ""
} |
q30188 | GetQueryKey | train | func GetQueryKey(q *protocol.KontrolQuery) (string, error) {
fields := q.Fields()
if q.Username == "" {
return "", errors.New("Empty username field")
}
// Validate query and build key.
path := "/"
empty := false // encountered with empty field?
empytField := "" // for error log
// http://golang.org/doc/... | go | {
"resource": ""
} |
q30189 | New | train | func New(name, version string) *Kite {
return NewWithConfig(name, version, config.New())
} | go | {
"resource": ""
} |
q30190 | NewWithConfig | train | func NewWithConfig(name, version string, cfg *config.Config) *Kite {
if name == "" {
panic("kite: name cannot be empty")
}
if digits := strings.Split(version, "."); len(digits) != 3 {
panic("kite: version must be 3-digits semantic version")
}
kiteID := uuid.Must(uuid.NewV4())
l, setlevel := newLogger(name)... | go | {
"resource": ""
} |
q30191 | Kite | train | 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 | {
"resource": ""
} |
q30192 | KiteKey | train | func (k *Kite) KiteKey() string {
k.configMu.RLock()
defer k.configMu.RUnlock()
return k.Config.KiteKey
} | go | {
"resource": ""
} |
q30193 | KontrolKey | train | func (k *Kite) KontrolKey() *rsa.PublicKey {
k.configMu.RLock()
defer k.configMu.RUnlock()
return k.kontrolKey
} | go | {
"resource": ""
} |
q30194 | HandleHTTP | train | func (k *Kite) HandleHTTP(pattern string, handler http.Handler) {
k.muxer.Handle(pattern, handler)
} | go | {
"resource": ""
} |
q30195 | HandleHTTPFunc | train | func (k *Kite) HandleHTTPFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) {
k.muxer.HandleFunc(pattern, handler)
} | go | {
"resource": ""
} |
q30196 | ServeHTTP | train | func (k *Kite) ServeHTTP(w http.ResponseWriter, req *http.Request) {
k.muxer.ServeHTTP(w, req)
} | go | {
"resource": ""
} |
q30197 | OnConnect | train | func (k *Kite) OnConnect(handler func(*Client)) {
k.handlersMu.Lock()
k.onConnectHandlers = append(k.onConnectHandlers, handler)
k.handlersMu.Unlock()
} | go | {
"resource": ""
} |
q30198 | OnFirstRequest | train | func (k *Kite) OnFirstRequest(handler func(*Client)) {
k.handlersMu.Lock()
k.onFirstRequestHandlers = append(k.onFirstRequestHandlers, handler)
k.handlersMu.Unlock()
} | go | {
"resource": ""
} |
q30199 | OnDisconnect | train | func (k *Kite) OnDisconnect(handler func(*Client)) {
k.handlersMu.Lock()
k.onDisconnectHandlers = append(k.onDisconnectHandlers, handler)
k.handlersMu.Unlock()
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.