id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c174100 | c.Child("", nil, v)
}
if c == nil {
return nil
}
return c.value
} | |
c174101 | json.Unmarshal(res, &v)
if err != nil {
log.Printf("%v\n", err)
return nil
}
ret := &Client{
api: c.api,
Auth: c.Auth,
Url: u,
value: v}
return ret
} | |
c174102 | log.Printf("%v\n", err)
return nil, err
}
ret := &Client{
api: c.api,
Auth: c.Auth,
Url: c.Url + "/" + r["name"],
value: value}
return ret, nil
} | |
c174103 | the root node, clear the value so it gets looked up
// again and populated correctly since we just applied a diffgram
if len(path) == 0 {
c.value = nil
}
return err
} | |
c174104 | error {
_, err := c.api.Call("DELETE", c.Url+"/"+path, c.Auth, nil, params)
return err
} | |
c174105 | v Rules
err = json.Unmarshal(res, &v)
if err != nil {
log.Printf("%v\n", err)
return nil, err
}
return v, nil
} | |
c174106 | _, err = c.api.Call("PUT", c.Url+"/.settings/rules", c.Auth, body, params)
return err
} | |
c174107 |
}
req, err := http.NewRequest(method, path, bytes.NewReader(body))
if err != nil {
log.Printf("Cannot create Firebase request: %v\n", err)
return nil, err
}
req.Close = true
log.Printf("Calling %v %q\n", method, path)
res, err := httpClient.Do(req)
if err != nil {
log.Printf("Request to Firebase failed: %v\n", err)
return nil, err
}
defer res.Body.Close()
ret, err := ioutil.ReadAll(res.Body)
if err != nil {
log.Printf("Cannot parse Firebase response: %v\n", err)
return nil, err
}
if res.StatusCode >= 400 {
err = errors.New(string(ret))
log.Printf("Error encountered from Firebase: %v\n", err)
return nil, err
}
return ret, nil
} | |
c174108 | t.trace.SetTraceInfo(traceID, spanID)
} | |
c174109 | {
incrError(t)
}
t.trace.Finish()
} | |
c174110 | http.Serve(l, promhttp.Handler())
} | |
c174111 | mf := range mfs {
if err := enc.Encode(mf); err != nil {
return buf.String(), errors.Wrap(err, "encoding metrics")
}
}
return buf.String(), nil
} | |
c174112 |
el: xtr.NewEventLog(family, title),
}
return e
} | |
c174113 | a...)
Log.Printf(newfmt, newvals...)
e.el.Printf(format, a...)
} | |
c174114 | {
Log.Printf("[ERROR] "+format, a...)
e.el.Errorf(format, a...)
} | |
c174115 | Log = stdlog.New(out, prefix, flag)
} | |
c174116 | time.Now().Format(th.format)
// log to the trace
t.LazyPrintf("time %v", tm)
w.Write([]byte("The time is: " + tm))
} | |
c174117 | id, ok := ctx.Value(TraceIDKey).(string)
if !ok {
return ""
}
return id
} | |
c174118 | parentOrChildFromContext(ctx, family, title)
return sp, contextWithTrace(ctx, sp)
} | |
c174119 | EndpointURL}
return &Client{apikey, http.DefaultClient, endpoint}
} | |
c174120 | Endpoint{URL: EndpointURL}
return &Client{apikey, client, endpoint}
} | |
c174121 | := json.NewDecoder(resp.Body)
err = dec.Decode(&devResp)
if err != nil {
return nil, err
}
for i := range devResp.Devices {
devResp.Devices[i].Client = c
}
devices := append(devResp.Devices, devResp.SharedDevices...)
return devices, nil
} | |
c174122 | {
devices[i].Client = c
return devices[i], nil
}
}
return nil, ErrDeviceNotFound
} | |
c174123 | d.Client.PushNote(d.Iden, title, body)
} | |
c174124 | d.Client.PushLink(d.Iden, title, u, body)
} | |
c174125 | return d.Client.PushSMS(d.Iden, deviceIden, phoneNumber, message)
} | |
c174126 | dec := json.NewDecoder(resp.Body)
err = dec.Decode(&errjson)
if err == nil {
return nil, &errjson.ErrResponse
}
return nil, errors.New(resp.Status)
}
var userResponse User
dec := json.NewDecoder(resp.Body)
err = dec.Decode(&userResponse)
if err != nil {
return nil, err
}
return &userResponse, nil
} | |
c174127 | err = dec.Decode(&errResponse)
if err == nil {
return &errResponse.ErrResponse
}
return errors.New(resp.Status)
}
return nil
} | |
c174128 | Note{
Iden: iden,
Type: "note",
Title: title,
Body: body,
}
return c.Push("/pushes", data)
} | |
c174129 | := Note{
Tag: tag,
Type: "note",
Title: title,
Body: body,
}
return c.Push("/pushes", data)
} | |
c174130 | Iden: iden,
Type: "link",
Title: title,
URL: u,
Body: body,
}
return c.Push("/pushes", data)
} | |
c174131 | URL: u,
Body: body,
}
return c.Push("/pushes", data)
} | |
c174132 | TargetDeviceIden: deviceIden,
ConversationIden: phoneNumber,
Message: message,
},
}
return c.Push("/ephemerals", data)
} | |
c174133 | if subs[i].Channel.Tag == tag {
subs[i].Client = c
return subs[i], nil
}
}
return nil, ErrDeviceNotFound
} | |
c174134 | s.Client.PushNoteToChannel(s.Channel.Tag, title, body)
} | |
c174135 | s.Client.PushLinkToChannel(s.Channel.Tag, title, u, body)
} | |
c174136 | consul, err := api.NewClient(config)
if err != nil {
return nil, fmt.Errorf("Could not connect to consul: %v", err)
}
return &cachedLoader{namespace: namespace, consulKV: consul.KV()}, nil
} | |
c174137 |
for k, v := range kvMap {
p := &api.KVPair{Key: k, Value: v}
_, err = c.consulKV.Put(p, nil)
if err != nil {
return fmt.Errorf("Could not write key to consul (%s | %s) %v", k, v, err)
}
}
return nil
} | |
c174138 |
c.cacheLock.Lock()
defer c.cacheLock.Unlock()
c.cache = make(map[string][]byte)
for _, kv := range pairs {
c.cache[kv.Key] = kv.Value
}
return nil
} | |
c174139 | c.namespace + divider + key
if ret, ok := c.cache[compiledKey]; ok {
return ret, nil
}
return nil, fmt.Errorf("Could not find value for key: %s", compiledKey)
} | |
c174140 |
if err != nil {
panic(fmt.Sprintf("Could not unmarshal config (%s) %v", key, err))
}
return s
} | |
c174141 | if err != nil {
panic(fmt.Sprintf("Could not unmarshal config (%s) %v", key, err))
}
return ret
} | |
c174142 | if err != nil {
panic(fmt.Sprintf("Could not unmarshal config (%s) %v", key, err))
}
return ret
} | |
c174143 |
panic(fmt.Sprintf("Could not parse config (%s) into a duration: %v", key, err))
}
return ret
} | |
c174144 |
}
r := randomBalancer{}
r.cache = make(map[string]cachedServiceLocation)
r.environment = environment
r.ttl = cacheTTL
r.consulCatalog = consul.Health()
return &r, nil
} | |
c174145 | }
if len(consulServices) == 0 {
return nil, fmt.Errorf("No services found for %s", serviceName)
}
//setup service locations
var services []*balancer.ServiceLocation
for _, v := range consulServices {
s := &balancer.ServiceLocation{}
s.URL = v.Service.Address
s.Port = v.Service.Port
services = append(services, s)
}
// cache
c := cachedServiceLocation{Services: services, CachedAt: time.Now().UTC()}
r.cache[serviceName] = c
return services, nil
} | |
c174146 | value := kv[0], kv[1]
label := &mesos.Label{Key: proto.String(key), Value: proto.String(value)}
labels.Labels = append(labels.Labels, label)
}
return labels
} | |
c174147 | clock_seq
clock_seq = uint16(seq&0x3fff) | 0x8000 // Set our variant
if old_seq != clock_seq {
lasttime = 0
}
} | |
c174148 | dl.logger.Tracef(fmt.Sprintf("%s %s", caller(), message), params...)
} | |
c174149 | dl.logger.Debugf(fmt.Sprintf("%s %s", caller(), message), params...)
} | |
c174150 | dl.logger.Infof(fmt.Sprintf("%s %s", caller(), message), params...)
} | |
c174151 | dl.logger.Warnf(fmt.Sprintf("%s %s", caller(), message), params...)
} | |
c174152 | dl.logger.Errorf(fmt.Sprintf("%s %s", caller(), message), params...)
} | |
c174153 | dl.logger.Criticalf(fmt.Sprintf("%s %s", caller(), message), params...)
} | |
c174154 | values.Set("api_paste_name", paste.Name)
values.Set("api_paste_private", paste.Privacy)
values.Set("api_paste_expire_date", paste.ExpireDate)
response, err := http.PostForm("http://pastebin.com/api/api_post.php", values)
defer response.Body.Close()
if err != nil {
return "", err
}
if response.StatusCode != 200 {
return "", PastePostingError
}
buf := bytes.Buffer{}
_, err = buf.ReadFrom(response.Body)
if err != nil {
return "", err
}
return buf.String(), nil
} | |
c174155 | {
return "", PasteGetError
}
buf := bytes.Buffer{}
_, err = buf.ReadFrom(response.Body)
if err != nil {
return "", err
}
return buf.String(), nil
} | |
c174156 |
e.stdOutAndErrWaitGroup.Wait()
err = cmd.Wait()
if err != nil {
return err
}
return nil
} | |
c174157 | e.d.ExecutorName = executorName
return e
} | |
c174158 | {
e.d.Exe = exe
return e
} | |
c174159 | ExecStreamerBuilder {
e.d.Args = args
return e
} | |
c174160 | {
e.d.Dir = dir
return e
} | |
c174161 | ExecStreamerBuilder {
e.d.Env = env
return e
} | |
c174162 | writers
e.d.StderrWriter = writers
return e
} | |
c174163 | e.d.StdoutWriter = writer
return e
} | |
c174164 | e.d.StdoutPrefix = prefix
return e
} | |
c174165 | e.d.StderrWriter = writer
return e
} | |
c174166 | e.d.StderrPrefix = prefix
return e
} | |
c174167 |
}
if e.d.StdoutWriter == nil {
e.d.StdoutWriter = ioutil.Discard
}
if e.d.StderrWriter == nil {
e.d.StderrWriter = ioutil.Discard
}
return e.d, nil
} | |
c174168 | Widget{
w: w,
x: x,
y: y,
}
} | |
c174169 | = fmt.Sprintf(format, args...)
} | |
c174170 | := l.(*Label)
label.Resize()
label.SetAttributes(defaultAttributes())
label.SetText(format, args...)
return label
} | |
c174171 | we understand this escape seqeunce
cc, skip, err := DecodeColor(out[i:])
if err == nil {
c.Fg = cc.Fg
c.Bg = cc.Bg
rw = skip
continue
}
}
rw = width
c.Ch = v
w.setCell(x+xx, y, c)
xx++
}
} | |
c174172 | if pos < len(w.backingStore) {
w.backingStore[pos] = c
}
} | |
c174173 |
for _, widget := range w.widgets {
widget.Resize()
}
} | |
c174174 | widget.Render()
}
// focus on a widget
w.focusWidget()
} | |
c174175 | are in bounds
if w.focus > len(w.widgets) {
// this really should not happen
return
}
w.widgets[w.focus].Focus()
} | |
c174176 | focus on last focusable widget
for i := len(w.widgets) - 1; i > w.focus; i-- {
widget := w.widgets[i]
if !widget.CanFocus() {
continue
}
setCursor(-1, -1) // hide
w.focus = i
widget.Focus()
return
}
// if we get here it means we found nothing usable and give up
} | |
c174177 | > len(w.widgets) {
return false, w.mgr, nil // not used
}
return w.widgets[w.focus].KeyHandler(ev), w.mgr, w.widgets[w.focus]
} | |
c174178 |
}
switch {
case bg == AttrNA:
break
case bg >= ColorBlack && bg <= ColorWhite:
b = fmt.Sprintf("%v;", bg+ANSIBg)
default:
return "", ErrInvalidBackground
}
es := fmt.Sprintf("\x1b[%v%v%v", a, f, b)
// replace last ; with m
es = es[:len(es)-1] + "m"
return es, nil
} | |
c174179 | if err == nil {
rw = skip
total += skip
continue
}
}
rw = width
}
return total
} | |
c174180 |
if err == nil {
rw = skip
continue
}
}
ret += string(v)
rw = width
}
return ret
} | |
c174181 | fa[0] = nil // just in case to prevent leak
fa = fa[1:]
mtx.Unlock()
// actually do work
f()
}
}
}()
go func() {
wg.Done()
for f := range work {
// queue work
mtx.Lock()
fa = append(fa, f)
mtx.Unlock()
// tell executer there is work
select {
case execute <- true:
default:
}
}
}()
wg.Wait()
} | |
c174182 | // the app is racing this channel
// we need to somehow block here before doing
// anything else
//time.Sleep(25 * time.Millisecond)
})
case termbox.EventResize:
Queue(func() {
resizeAndRender(focus)
})
case termbox.EventMouse:
case termbox.EventError:
return
}
}
} | |
c174183 | maxY = termbox.Size()
_ = termbox.Flush()
// see if we need to launch the key handler
if !keyHandler {
go initKeyHandler()
keyHandler = true
}
termRaw = true // we are now in raw mode
return nil
} | |
c174184 | all windows
rawMtx.Lock()
termRaw = false
rawMtx.Unlock()
wait <- true
})
<-wait
} | |
c174185 | make([]Cell, maxX*maxY),
widgets: make([]Widgeter, 0, 16),
}
lastWindowID++
windows[w.id] = w
windower2window[manager] = w
manager.Init(w)
wc <- w
})
return <-wc
} | |
c174186 | c.dirty = false
// this shall be the only spot where
// termbox.SetCell is called!
termbox.SetCell(x, y, c.Ch, c.Fg, c.Bg)
}
}
_ = termbox.Flush()
} | |
c174187 | if !found {
return
}
if focus == w {
return
}
prevFocus = focus
focus = w
resizeAndRender(w)
} | |
c174188 | w.resize(maxX, maxY)
w.render()
// display all the things
flush()
}
} | |
c174189 | msg := fmt.Sprintf(format, args...)
panic(msg)
} | |
c174190 |
fmt.Fprintf(os.Stderr, format+"\n", args...)
os.Exit(1)
} | |
c174191 | y)
list := l.(*List)
list.width = width
list.height = height
list.Resize()
list.SetAttributes(defaultAttributes())
list.content = make([]string, 0, 1000)
return list
} | |
c174192 |
// adjust at if we are not in a paging operation
if l.paging {
return
}
l.at = len(l.content) - l.trueH
if l.at < 0 {
l.at = 0
}
} | |
c174193 | e.trueX
e.cy = e.trueY
e.at = 0
}
setCursor(e.cx, e.cy)
} | |
c174194 | to position cursor and text
ev := termbox.Event{}
if end {
ev.Key = termbox.KeyCtrlE
} else {
ev.Key = termbox.KeyCtrlA
}
e.KeyHandler(ev)
} | |
c174195 | actual window resizes
edit.prevX = w.x
edit.prevY = w.y
edit.Resize()
// cursor
edit.cx = -1
edit.cy = -1
// set target string
edit.SetText(target, true)
// flip attributes
a := defaultAttributes()
a2 := Attributes{
Fg: a.Bg,
Bg: a.Fg,
}
edit.SetAttributes(a2)
return edit
} | |
c174196 | key == "" {
return "", NewBambouError("Invalid Credentials", "No password or authentication token given")
}
if key == "" {
key = s.Password
}
return "XREST " + base64.StdEncoding.EncodeToString([]byte(s.Username+":"+key)), nil
} | |
c174197 |
berr := s.FetchEntity(s.root)
if berr != nil {
return berr
}
return nil
} | |
c174198 |
response, berr := s.send(request, nil)
if berr != nil {
return berr
}
defer response.Body.Close()
body, _ := ioutil.ReadAll(response.Body)
log.Debugf("Response Body: %s", string(body))
arr := IdentifiablesList{object} // trick for weird api..
if err := json.Unmarshal(body, &arr); err != nil {
return NewBambouError("JSON unmarshalling error", err.Error())
}
return nil
} | |
c174199 |
defer response.Body.Close()
body, _ := ioutil.ReadAll(response.Body)
log.Debugf("Response Body: %s", string(body))
dest := IdentifiablesList{object}
if len(body) > 0 {
if err := json.Unmarshal(body, &dest); err != nil {
return NewBambouError("JSON Unmarshaling error", err.Error())
}
}
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.