id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c14700 | c.Client.Extensions(context.Background())
} | |
c14701 |
return c.Client.RegisterExtension(context.Background(), info, registry)
} | |
c14702 | c.Client.Options(context.Background())
} | |
c14703 | c.Client.Query(context.Background(), sql)
} | |
c14704 | status")
}
if res.Status.Code != 0 {
return nil, errors.Errorf("query returned error: %s", res.Status.Message)
}
return res.Response, nil
} | |
c14705 | {
return nil, errors.Errorf("expected 1 row, got %d", len(res))
}
return res[0], nil
} | |
c14706 | &Plugin{name: name, getQueries: getQueries, writeResults: writeResults}
} | |
c14707 |
}
parsedInt, err := strconv.ParseInt(s, 10, 32)
if err != nil {
return &json.UnmarshalTypeError{
Value: string(buff),
Type: reflect.TypeOf(oi),
Struct: "statuses",
}
}
*oi = OsqueryInt(parsedInt)
return nil
} | |
c14708 |
// without any results is just a name with an empty string.
switch val := queryResult.(type) {
case string:
rs.Queries[queryName] = emptyRow
case []interface{}:
results, err := convertRows(val)
if err != nil {
return err
}
rs.Queries[queryName] = results
default:
return fmt.Errorf("resu... | |
c14709 | PersonTableName,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
),
)
} | |
c14710 |
fmt.Sprintf("INSERT INTO %s VALUES(?, ?, ?)", PersonTableName),
person.FirstName,
person.LastName,
person.Age,
)
} | |
c14711 | PersonLastNameCol,
PersonAgeCol,
),
firstName,
lastName,
age,
)
var retFirstName, retLastName string
var retAge uint
if err := row.Scan(&retFirstName, &retLastName, &retAge); err != nil {
return err
}
result.FirstName = retFirstName
result.LastName = retLastName
result.Age = retAge
return nil
} | |
c14712 |
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
),
newPerson.FirstName,
newPerson.LastName,
newPerson.Age,
firstName,
lastName,
age,
)
return err
} | |
c14713 | PersonLastNameCol,
PersonAgeCol,
),
firstName,
lastName,
age,
)
return err
} | |
c14714 | return c.Render(200, r.HTML("other.html"))
} | |
c14715 | Funcs: funcs,
IsDevelopment: dev,
}
return &RenderRenderer{r: render.New(opts)}
} | |
c14716 | r.r.HTML(w, code, templateName, data, render.HTMLOptions{Layout: layout})
return
}
r.r.HTML(w, code, templateName, data)
} | |
c14717 | strings: make(map[string]string), ints: make(map[string]int)}
} | |
c14718 |
defer m.l.Unlock()
m.ints[name] = i
} | |
c14719 | if !ok {
return 0, ErrNotFound
}
return i, nil
} | |
c14720 | defer m.mut.Unlock()
m.m[key.String()] = model
return nil
} | |
c14721 | delete(m.m, key.String())
return nil
} | |
c14722 | if !ok {
return ErrNotFound
}
return model.Set(md)
} | |
c14723 |
return rand.Intn(len(m.dishes))
} | |
c14724 | app.Use(middleware.PopTransaction(models.DB))
// Setup and use translations:
var err error
if T, err = i18n.New(packr.NewBox("../locales"), "en-US"); err != nil {
app.Stop(err)
}
app.Use(T.Middleware())
app.GET("/", HomeHandler)
app.Resource("/gifms", GifmsResource{})
app.ServeFiles("/", assetsB... | |
c14725 | log.Printf("[JSON Encoding Error] %s", err)
http.Error(w, err.Error(), http.StatusNoContent)
}
} | |
c14726 | err != nil {
log.Printf("[JSON Encoding Error] %s", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
}
} | |
c14727 | err
}
return r.client.Set(k.String(), b, time.Duration(0)).Err()
} | |
c14728 | r.client.Del(k.String()).Err()
} | |
c14729 | as necessary
if err := t.Execute(w, r.URL.Query()); err != nil {
http.Error(w, fmt.Sprintf("error executing template (%s)", err), http.StatusInternalServerError)
}
})
} | |
c14730 | != nil {
return nil, err
}
return conf, nil
} | |
c14731 | ok := s.m[elt]
return ok
} | |
c14732 | {
_, ok := s.m[elt]
s.m[elt] = struct{}{}
return !ok
} | |
c14733 | false
}
delete(s.m, elt)
return true
} | |
c14734 | make(map[setElement]struct{})
return ret
} | |
c14735 | return json.Unmarshal(b, a)
} | |
c14736 | {
return fmt.Errorf("given model %+v was not an *App", m)
}
*a = *app
return nil
} | |
c14737 | err != nil {
http.Error(w, fmt.Sprintf("error getting value from database: %s", err), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
w.Write(val)
})
} | |
c14738 | the Updated field is set when already existed, otherwise the UpsertedID field is set.
// see the func at https://bazaar.launchpad.net/+branch/mgo/v2/view/head:/session.go#L1896
return cInfo.UpsertedId != nil, nil
} | |
c14739 | return
}
server.Reserved = false
if err := json.NewEncoder(w).Encode(server); err != nil {
log.Printf("[JSON Encoding Error] %s", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
}
} | |
c14740 | return
}
if err := db.Set(key, val); err != nil {
http.Error(w, "error setting value in DB", http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
})
} | |
c14741 | nil, fmt.Errorf("Error: %s", ok)
}
return []byte(val), nil
} | |
c14742 | err := i.Client.Set(key, val, 0).Err()
return err
} | |
c14743 | val.(string)
if !ok {
return false
}
newStr := fn(str)
t.cache[key] = newStr
return true
} | |
c14744 | delete(t.cache, key)
return true
}
return false
} | |
c14745 | return singular
}
return plural
} | |
c14746 | netlink.NetworkLinkAddIp(veth.peerIfc, ip, nw)
} | |
c14747 | return fmt.Errorf("Failed to find docker %s : %s", name, err)
}
return netlink.NetworkSetNsPid(veth.peerIfc, pid)
} | |
c14748 | return netlink.NetworkSetNsPid(veth.peerIfc, nspid)
} | |
c14749 | return fmt.Errorf("Could not attach to Network namespace: %s", err)
}
return netlink.NetworkSetNsFd(veth.peerIfc, fd)
} | |
c14750 | fmt.Errorf("Unable to bring %s interface UP: %s", veth.peerIfc.Name, nspid)
}
if gw != nil {
if err := netlink.AddDefaultGw(gw.String(), veth.peerIfc.Name); err != nil {
return fmt.Errorf("Unable to set Default gateway: %s in pid: %d network namespace", gw.String(), nspid)
}
}
return nil
} | |
c14751 | randomString(6)
if _, err := net.InterfaceByName(name); err == nil {
continue
}
return name
}
} | |
c14752 | address: %s", err)
}
if _, err := FindInterfaceByMacAddress(macaddr); err == nil {
return fmt.Errorf("MAC Address already assigned on the host: %s", macaddr)
}
return nil
} | |
c14753 | return fmt.Errorf("Unsupported network flags specified: %v", flags)
}
return nil
} | |
c14754 | name)
}
if len(name) > netlink.IFNAMSIZ {
return false, fmt.Errorf("Interface name too long: %s", name)
}
for _, char := range name {
if unicode.IsSpace(char) || char > 0x7F {
return false, fmt.Errorf("Invalid characters in interface name: %s", name)
}
}
return true, nil
} | |
c14755 | %d", nspid)
}
file, err := os.Open(nsPath)
if err != nil {
return 0, fmt.Errorf("Could not open Network Namespace: %s", err)
}
return file.Fd(), nil
} | |
c14756 | }
if err := system.Setns(nsFd, syscall.CLONE_NEWNET); err != nil {
return fmt.Errorf("Unable to set the network namespace: %v", err)
}
return nil
} | |
c14757 | err := net.InterfaceByName(ifcName)
if err != nil {
return nil, fmt.Errorf("Could not find the new interface: %s", err)
}
return &Bridge{
Link: Link{
ifc: newIfc,
},
}, nil
} | |
c14758 | fmt.Errorf("Could not find the new interface: %s", err)
}
return &Link{
ifc: newIfc,
}, nil
} | |
c14759 | {
return netlink.NetworkSetNsPid(l.NetInterface(), nspid)
} | |
c14760 | fmt.Errorf("Unable to bring %s interface UP: %s", l.ifc.Name, nspid)
}
if gw != nil {
if err := netlink.AddDefaultGw(gw.String(), l.NetInterface().Name); err != nil {
return fmt.Errorf("Unable to set Default gateway: %s in pid: %d network namespace", gw.String(), nspid)
}
}
return nil
} | |
c14761 |
if err != nil {
return fmt.Errorf("Could not attach to Network namespace: %s", err)
}
return netlink.NetworkSetNsFd(l.NetInterface(), fd)
} | |
c14762 | return fmt.Errorf("Failed to find docker %s : %s", name, err)
}
return l.SetLinkNetNsPid(pid)
} | |
c14763 | return err
}
return netlink.NetworkChangeName(iface, newName)
} | |
c14764 | err != nil {
return err
}
if ns != 0 && (ns != 1 || ns != os.Getpid()) {
if (flags & syscall.IFF_UP) == syscall.IFF_UP {
origNs, _ := NetNsHandle(os.Getpid())
defer syscall.Close(int(origNs))
defer system.Setns(origNs, syscall.CLONE_NEWNET)
if err := SetNetNsToPid(ns); err != nil {
ret... | |
c14765 | req := Query(query)
return c.Exec(req)
} | |
c14766 | for _, op := range options {
err := op(auth)
if err != nil {
return nil, err
}
}
return auth, nil
} | |
c14767 |
return errors.New("Variable GREMLIN_PASS is not set")
}
auth.User = user
auth.Pass = pass
return nil
}
} | |
c14768 | func(auth *AuthInfo) error {
auth.User = user
auth.Pass = pass
return nil
}
} | |
c14769 | saslEnc}
authReq := &Request{
RequestId: requestId,
Processor: "trasversal",
Op: "authentication",
Args: args,
}
return c.Exec(authReq)
} | |
c14770 | \nResult: {%#v}\n", r.RequestId, r.Status, r.Result)
} | |
c14771 | tls.RequireAnyClientCert}
log.Print("- starting Mock Apple Feedback TCP server at 0.0.0.0:5555")
srv, _ := tls.Listen("tcp", "0.0.0.0:5555", &config)
for {
conn, err := srv.Accept()
if err != nil {
log.Panic(err)
}
go loop(conn)
}
} | |
c14772 |
pn.Identifier = rand.New(rand.NewSource(time.Now().UnixNano())).Int31n(IdentifierUbound)
pn.Priority = 10
return
} | |
c14773 | value as though it were 0 (i.e. it clears the
// badge but doesn't stop the notification from going
// through successfully.)
//
// Still a hack though :)
if p.Badge == 0 {
p.Badge = -1
}
pn.Set("aps", p)
} | |
c14774 | {
pn.payload[key] = value
} | |
c14775 | err := pn.PayloadJSON()
return string(j), err
} | |
c14776 |
binary.Write(frameBuffer, binary.BigEndian, pn.Identifier)
binary.Write(frameBuffer, binary.BigEndian, uint8(expirationDateItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(expirationDateLength))
binary.Write(frameBuffer, binary.BigEndian, pn.Expiry)
binary.Write(frameBuffer, binary.BigEndian, uint8(pri... | |
c14777 | c.CertificateBase64 = certificateBase64
c.KeyBase64 = keyBase64
return
} | |
c14778 | c.CertificateFile = certificateFile
c.KeyFile = keyFile
return
} | |
c14779 | }
err = client.ConnectAndWrite(resp, payload)
if err != nil {
resp.Success = false
resp.Error = err
return
}
resp.Success = true
resp.Error = nil
return
} | |
c14780 | v)
if err != nil {
return Time3339{}
}
return Time3339(t)
} | |
c14781 | time.Time(*t).IsZero() || time.Time(*t).Unix() == 0
} | |
c14782 | }
c.touchedFiles = make(map[string]bool)
var err error
c.rootJSON, err = c.recursiveReadJSON(path)
return c.rootJSON, err
} | |
c14783 | }
line, col, highlight := errorutil.HighlightBytePosition(f, serr.Offset)
extra = fmt.Sprintf(":\nError at line %d, column %d (file offset %d):\n%s",
line, col, serr.Offset, highlight)
}
return nil, fmt.Errorf("error parsing JSON object in config file %s%s\n%v",
f.Name(), extra, err)
}
if err = c.... | |
c14784 | c.evaluateExpressions(m, nil, true)
} | |
c14785 |
}
if !testOnly {
m[k] = evaled
}
case map[string]interface{}:
if err := c.evaluateExpressions(subval, thisPath, testOnly); err != nil {
return err
}
default:
return fmt.Errorf("%s: unhandled type %T", strings.Join(thisPath, "."), ei)
}
}
return nil
} | |
c14786 | return "", err
}
if err == nil {
return configFile, nil
}
for _, d := range c.IncludeDirs {
if _, err := os.Stat(filepath.Join(d, configFile)); err == nil {
return filepath.Join(d, configFile), nil
}
}
return "", os.ErrNotExist
} | |
c14787 | }
if !tok.Valid() {
if tok != nil && time.Now().After(tok.Expiry) {
return nil, errExpiredToken
}
return nil, errors.New("invalid token")
}
return tok, nil
} | |
c14788 | = nil
return oauth2.ReuseTokenSource(noInitialToken, config.TokenSource(
oauth2.NoContext, // TODO: maybe accept a context later.
&oauth2.Token{RefreshToken: refreshToken},
))
} | |
c14789 | than int64.
return nil, fmt.Errorf("unexpectedly large box %q", box.boxType)
}
remain = box.size - 2*4 - 8
case 0:
// 0 means unknown & to read to end of file. No more boxes.
r.noMoreBoxes = true
default:
remain = box.size - 2*4
}
if remain < 0 {
return nil, fmt.Errorf("Box header for %q has size %d... | |
c14790 | instead", typ, box.Type())
}
pbox, err := box.Parse()
if err != nil {
return nil, fmt.Errorf("error parsing read %q box: %v", typ, err)
}
return pbox, nil
} | |
c14791 | return time.Duration(float64(n)/1024/float64(r.KBps)) * time.Second
} | |
c14792 | %v", name, err)
}
if err := json.NewEncoder(f).Encode(&pidLockMeta{OwnerPID: os.Getpid()}); err != nil {
return nil, fmt.Errorf("cannot write owner pid: %v", err)
}
return &unlocker{
f: f,
abs: name,
portable: true,
}, nil
} | |
c14793 | return nil, err
}
req.Header.Set("x-goog-api-version", "2")
return req, err
} | |
c14794 | == http.StatusNotFound {
res.Body.Close()
return nil, os.ErrNotExist
}
if !(res.StatusCode == http.StatusPartialContent || (offset == 0 && res.StatusCode == http.StatusOK)) {
res.Body.Close()
if res.StatusCode == http.StatusRequestedRangeNotSatisfiable {
return nil, ErrInvalidRange
}
return nil, fmt.E... | |
c14795 |
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
return nil, fmt.Errorf("gcsutil: bad enumerate response code: %v", res.Status)
}
var xres struct {
Contents []SizedObject
}
if err = xml.NewDecoder(res.Body).Decode(&xres); err != nil {
return nil, err
}
objAttrs := make([]*storage.ObjectAttrs... | |
c14796 | Role: storage.RoleReader,
},
}
w.CacheControl = "no-cache"
selfPath := getSelfPath()
log.Printf("Uploading %q to %v", selfPath, cl.binaryURL())
f, err := os.Open(selfPath)
if err != nil {
log.Fatal(err)
}
defer f.Close()
n, err := io.Copy(w, f)
if err != nil {
log.Fatal(err)
}
if err := w.Close()... | |
c14797 | := range asl.Addresses {
log.Printf(" addr: %#v", addr)
if addr.Name == cl.Name+"-ip" && addr.Status == "RESERVED" && zoneInRegion(cl.zone(), addr.Region) {
ip = addr.Address
break IPLoop
}
}
}
return ip
} | |
c14798 | ae.Code == 404 {
return nil
} else if err != nil {
log.Fatalf("Instances.Get: %v", err)
}
return inst
} | |
c14799 |
rs.add(uint32(*wp), uint32(ch))
*wp = ch
rs.wofs = (rs.wofs + 1) & (windowSize - 1)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.