_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q14700 | Extensions | train | func (c *ExtensionManagerClient) Extensions() (osquery.InternalExtensionList, error) {
return c.Client.Extensions(context.Background())
} | go | {
"resource": ""
} |
q14701 | RegisterExtension | train | func (c *ExtensionManagerClient) RegisterExtension(info *osquery.InternalExtensionInfo, registry osquery.ExtensionRegistry) (*osquery.ExtensionStatus, error) {
return c.Client.RegisterExtension(context.Background(), info, registry)
} | go | {
"resource": ""
} |
q14702 | Options | train | func (c *ExtensionManagerClient) Options() (osquery.InternalOptionList, error) {
return c.Client.Options(context.Background())
} | go | {
"resource": ""
} |
q14703 | Query | train | func (c *ExtensionManagerClient) Query(sql string) (*osquery.ExtensionResponse, error) {
return c.Client.Query(context.Background(), sql)
} | go | {
"resource": ""
} |
q14704 | QueryRows | train | func (c *ExtensionManagerClient) QueryRows(sql string) ([]map[string]string, error) {
res, err := c.Query(sql)
if err != nil {
return nil, errors.Wrap(err, "transport error in query")
}
if res.Status == nil {
return nil, errors.New("query returned nil status")
}
if res.Status.Code != 0 {
return nil, errors.Errorf("query returned error: %s", res.Status.Message)
}
return res.Response, nil
} | go | {
"resource": ""
} |
q14705 | QueryRow | train | func (c *ExtensionManagerClient) QueryRow(sql string) (map[string]string, error) {
res, err := c.QueryRows(sql)
if err != nil {
return nil, err
}
if len(res) != 1 {
return nil, errors.Errorf("expected 1 row, got %d", len(res))
}
return res[0], nil
} | go | {
"resource": ""
} |
q14706 | NewPlugin | train | func NewPlugin(name string, getQueries GetQueriesFunc, writeResults WriteResultsFunc) *Plugin {
return &Plugin{name: name, getQueries: getQueries, writeResults: writeResults}
} | go | {
"resource": ""
} |
q14707 | UnmarshalJSON | train | func (oi *OsqueryInt) UnmarshalJSON(buff []byte) error {
s := string(buff)
if strings.Contains(s, `"`) {
unquoted, err := strconv.Unquote(s)
if err != nil {
return &json.UnmarshalTypeError{
Value: string(buff),
Type: reflect.TypeOf(oi),
Struct: "statuses",
}
}
s = unquoted
}
if len(s) == 0 {
*oi = OsqueryInt(0)
return nil
}
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
} | go | {
"resource": ""
} |
q14708 | UnmarshalJSON | train | func (rs *ResultsStruct) UnmarshalJSON(buff []byte) error {
emptyRow := []map[string]string{}
rs.Queries = make(map[string][]map[string]string)
rs.Statuses = make(map[string]OsqueryInt)
// Queries can be []map[string]string OR an empty string
// so we need to deal with an interface to accomodate two types
intermediate := struct {
Queries map[string]interface{} `json:"queries"`
Statuses map[string]OsqueryInt `json:"statuses"`
}{}
if err := json.Unmarshal(buff, &intermediate); err != nil {
return err
}
for queryName, status := range intermediate.Statuses {
rs.Statuses[queryName] = status
// Sometimes we have a status but don't have a corresponding
// result.
queryResult, ok := intermediate.Queries[queryName]
if !ok {
rs.Queries[queryName] = emptyRow
continue
}
// Deal with structurally inconsistent results, sometimes a query
// 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("results for %q unknown type", queryName)
}
}
return nil
} | go | {
"resource": ""
} |
q14709 | CreatePersonTable | train | func CreatePersonTable(db *sql.DB) (sql.Result, error) {
return db.Exec(
fmt.Sprintf("CREATE TABLE %s (%s varchar(255), %s varchar(255), %s int)",
PersonTableName,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
),
)
} | go | {
"resource": ""
} |
q14710 | InsertPerson | train | func InsertPerson(db *sql.DB, person Person) (sql.Result, error) {
return db.Exec(
fmt.Sprintf("INSERT INTO %s VALUES(?, ?, ?)", PersonTableName),
person.FirstName,
person.LastName,
person.Age,
)
} | go | {
"resource": ""
} |
q14711 | SelectPerson | train | func SelectPerson(db *sql.DB, firstName, lastName string, age uint, result *Person) error {
row := db.QueryRow(
fmt.Sprintf(
"SELECT * FROM %s WHERE %s=? AND %s=? AND %s=?",
PersonTableName,
PersonFirstNameCol,
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
} | go | {
"resource": ""
} |
q14712 | UpdatePerson | train | func UpdatePerson(db *sql.DB, firstName, lastName string, age uint, newPerson Person) error {
_, err := db.Exec(
fmt.Sprintf(
"UPDATE %s SET %s=?,%s=?,%s=? WHERE %s=? AND %s=? AND %s=?",
PersonTableName,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
),
newPerson.FirstName,
newPerson.LastName,
newPerson.Age,
firstName,
lastName,
age,
)
return err
} | go | {
"resource": ""
} |
q14713 | DeletePerson | train | func DeletePerson(db *sql.DB, firstName, lastName string, age uint) error {
_, err := db.Exec(
fmt.Sprintf(
"DELETE FROM %s WHERE %s=? AND %s=? AND %s=?",
PersonTableName,
PersonFirstNameCol,
PersonLastNameCol,
PersonAgeCol,
),
firstName,
lastName,
age,
)
return err
} | go | {
"resource": ""
} |
q14714 | OtherHandler | train | func OtherHandler(c buffalo.Context) error {
name := c.Param("name")
c.Set("name", name)
return c.Render(200, r.HTML("other.html"))
} | go | {
"resource": ""
} |
q14715 | NewRenderRenderer | train | func NewRenderRenderer(dir string, extensions []string, funcs []template.FuncMap, dev bool) *RenderRenderer {
opts := render.Options{
Directory: dir,
Extensions: extensions,
Funcs: funcs,
IsDevelopment: dev,
}
return &RenderRenderer{r: render.New(opts)}
} | go | {
"resource": ""
} |
q14716 | Render | train | func (r *RenderRenderer) Render(w http.ResponseWriter, code int, templateName string, data interface{}, layout string) {
if layout != "" {
r.r.HTML(w, code, templateName, data, render.HTMLOptions{Layout: layout})
return
}
r.r.HTML(w, code, templateName, data)
} | go | {
"resource": ""
} |
q14717 | NewMem | train | func NewMem() Data {
return &memData{l: &sync.RWMutex{}, strings: make(map[string]string), ints: make(map[string]int)}
} | go | {
"resource": ""
} |
q14718 | SetInt | train | func (m *memData) SetInt(name string, i int) {
m.l.Lock()
defer m.l.Unlock()
m.ints[name] = i
} | go | {
"resource": ""
} |
q14719 | GetInt | train | func (m *memData) GetInt(name string) (int, error) {
m.l.RLock()
defer m.l.RUnlock()
i, ok := m.ints[name]
if !ok {
return 0, ErrNotFound
}
return i, nil
} | go | {
"resource": ""
} |
q14720 | Save | train | func (m *Mem) Save(key models.Key, model models.Model) error {
m.mut.Lock()
defer m.mut.Unlock()
m.m[key.String()] = model
return nil
} | go | {
"resource": ""
} |
q14721 | Delete | train | func (m *Mem) Delete(key models.Key) error {
m.mut.Lock()
defer m.mut.Unlock()
delete(m.m, key.String())
return nil
} | go | {
"resource": ""
} |
q14722 | Get | train | func (m *Mem) Get(key models.Key, model models.Model) error {
m.mut.RLock()
defer m.mut.RUnlock()
md, ok := m.m[key.String()]
if !ok {
return ErrNotFound
}
return model.Set(md)
} | go | {
"resource": ""
} |
q14723 | randDishIdx | train | func (m *Manager) randDishIdx() int {
if len(m.dishes) == 0 {
return -1
}
return rand.Intn(len(m.dishes))
} | go | {
"resource": ""
} |
q14724 | App | train | func App() *buffalo.App {
if app == nil {
app = buffalo.New(buffalo.Options{
Env: ENV,
SessionName: "_episode24_session",
})
// Automatically redirect to SSL
app.Use(ssl.ForceSSL(secure.Options{
SSLRedirect: ENV == "production",
SSLProxyHeaders: map[string]string{"X-Forwarded-Proto": "https"},
}))
if ENV == "development" {
app.Use(middleware.ParameterLogger)
}
// Protect against CSRF attacks. https://www.owasp.org/index.php/Cross-Site_Request_Forgery_(CSRF)
// Remove to disable this.
app.Use(csrf.New)
// Wraps each request in a transaction.
// c.Value("tx").(*pop.PopTransaction)
// Remove to disable this.
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("/", assetsBox) // serve files from the public directory
}
return app
} | go | {
"resource": ""
} |
q14725 | releaseAllServers | train | func releaseAllServers(w http.ResponseWriter, r *http.Request) {
mx.Lock()
defer mx.Unlock()
for _, status := range servers {
status.Reserved = false
}
if err := json.NewEncoder(w).Encode(servers); err != nil {
log.Printf("[JSON Encoding Error] %s", err)
http.Error(w, err.Error(), http.StatusNoContent)
}
} | go | {
"resource": ""
} |
q14726 | getAllServers | train | func getAllServers(w http.ResponseWriter, r *http.Request) {
mx.RLock()
defer mx.RUnlock()
if err := json.NewEncoder(w).Encode(servers); err != nil {
log.Printf("[JSON Encoding Error] %s", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
}
} | go | {
"resource": ""
} |
q14727 | Save | train | func (r *Redis) Save(k models.Key, m models.Model) error {
b, err := m.MarshalBinary()
if err != nil {
return err
}
return r.client.Set(k.String(), b, time.Duration(0)).Err()
} | go | {
"resource": ""
} |
q14728 | Delete | train | func (r *Redis) Delete(k models.Key) error {
return r.client.Del(k.String()).Err()
} | go | {
"resource": ""
} |
q14729 | hdl | train | func hdl(t *template.Template) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Notice that t.Execute takes an io.Writer as its first argument. The variable w (an http.ResponseWriter) implements io.Writer, so we pass it and allow the implementation to call its Write function as necessary
if err := t.Execute(w, r.URL.Query()); err != nil {
http.Error(w, fmt.Sprintf("error executing template (%s)", err), http.StatusInternalServerError)
}
})
} | go | {
"resource": ""
} |
q14730 | GetConfig | train | func GetConfig() (*Config, error) {
conf := new(Config)
if err := envconfig.Process(AppName, conf); err != nil {
return nil, err
}
return conf, nil
} | go | {
"resource": ""
} |
q14731 | exists | train | func (s *set) exists(elt setElement) bool {
_, ok := s.m[elt]
return ok
} | go | {
"resource": ""
} |
q14732 | add | train | func (s *set) add(elt setElement) bool {
_, ok := s.m[elt]
s.m[elt] = struct{}{}
return !ok
} | go | {
"resource": ""
} |
q14733 | remove | train | func (s *set) remove(elt setElement) bool {
_, ok := s.m[elt]
if !ok {
return false
}
delete(s.m, elt)
return true
} | go | {
"resource": ""
} |
q14734 | removeAll | train | func (s *set) removeAll() int {
ret := len(s.m)
s.m = make(map[setElement]struct{})
return ret
} | go | {
"resource": ""
} |
q14735 | UnmarshalBinary | train | func (a *App) UnmarshalBinary(b []byte) error {
return json.Unmarshal(b, a)
} | go | {
"resource": ""
} |
q14736 | Set | train | func (a *App) Set(m Model) error {
app, ok := m.(*App)
if !ok {
return fmt.Errorf("given model %+v was not an *App", m)
}
*a = *app
return nil
} | go | {
"resource": ""
} |
q14737 | GetKey | train | func GetKey(db storage.DB) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
key := r.URL.Query().Get("key")
if key == "" {
http.Error(w, "missing key name in query string", http.StatusBadRequest)
return
}
val, err := db.Get(key)
if err == storage.ErrNotFound {
http.Error(w, "not found", http.StatusNotFound)
return
} else if err != nil {
http.Error(w, fmt.Sprintf("error getting value from database: %s", err), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
w.Write(val)
})
} | go | {
"resource": ""
} |
q14738 | Upsert | train | func (m *MongoDB) Upsert(key string, val Model) (bool, error) {
sess := m.sess.Copy()
defer sess.Close()
coll := sess.DB(dbName).C(candiesColl)
cInfo, err := coll.Upsert(bson.M{"key": key}, objWrapper{Key: key, Data: val})
if err != nil {
return false, err
}
// 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
} | go | {
"resource": ""
} |
q14739 | releaseServer | train | func releaseServer(w http.ResponseWriter, r *http.Request) {
name, ok := mux.Vars(r)["name"]
if !ok {
http.Error(w, "name missing in URL path", http.StatusBadRequest)
return
}
mx.Lock()
defer mx.Unlock()
server, ok := servers[name]
if !ok {
http.Error(w, "no such server", http.StatusNotFound)
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)
}
} | go | {
"resource": ""
} |
q14740 | PutKey | train | func PutKey(db storage.DB) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
key := r.URL.Query().Get("key")
if key == "" {
http.Error(w, "missing key name in path", http.StatusBadRequest)
return
}
defer r.Body.Close()
val, err := ioutil.ReadAll(r.Body)
if err != nil {
http.Error(w, "error reading PUT body", http.StatusBadRequest)
return
}
if err := db.Set(key, val); err != nil {
http.Error(w, "error setting value in DB", http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
})
} | go | {
"resource": ""
} |
q14741 | Get | train | func (i RedisClientWrapper) Get(key string) ([]byte, error) {
val, ok := i.Client.Get(key).Result()
if ok != nil {
return nil, fmt.Errorf("Error: %s", ok)
}
return []byte(val), nil
} | go | {
"resource": ""
} |
q14742 | Set | train | func (i RedisClientWrapper) Set(key string, val []byte) error {
err := i.Client.Set(key, val, 0).Err()
return err
} | go | {
"resource": ""
} |
q14743 | transform | train | func (t *transformer) transform(key string, fn func(string) string) bool {
t.mut.Lock()
defer t.mut.Unlock()
val, found := t.cache[key]
if !found {
return false
}
str, ok := val.(string)
if !ok {
return false
}
newStr := fn(str)
t.cache[key] = newStr
return true
} | go | {
"resource": ""
} |
q14744 | remove | train | func (t *transformer) remove(key string) bool {
t.mut.Lock()
defer t.mut.Unlock()
if _, found := t.cache[key]; found {
delete(t.cache, key)
return true
}
return false
} | go | {
"resource": ""
} |
q14745 | pluralize | train | func pluralize(i int, singular, plural string) string {
if i == 1 {
return singular
}
return plural
} | go | {
"resource": ""
} |
q14746 | SetPeerLinkIp | train | func (veth *VethPair) SetPeerLinkIp(ip net.IP, nw *net.IPNet) error {
return netlink.NetworkLinkAddIp(veth.peerIfc, ip, nw)
} | go | {
"resource": ""
} |
q14747 | SetPeerLinkNsToDocker | train | func (veth *VethPair) SetPeerLinkNsToDocker(name string, dockerHost string) error {
pid, err := DockerPidByName(name, dockerHost)
if err != nil {
return fmt.Errorf("Failed to find docker %s : %s", name, err)
}
return netlink.NetworkSetNsPid(veth.peerIfc, pid)
} | go | {
"resource": ""
} |
q14748 | SetPeerLinkNsPid | train | func (veth *VethPair) SetPeerLinkNsPid(nspid int) error {
return netlink.NetworkSetNsPid(veth.peerIfc, nspid)
} | go | {
"resource": ""
} |
q14749 | SetPeerLinkNsFd | train | func (veth *VethPair) SetPeerLinkNsFd(nspath string) error {
fd, err := syscall.Open(nspath, syscall.O_RDONLY, 0)
if err != nil {
return fmt.Errorf("Could not attach to Network namespace: %s", err)
}
return netlink.NetworkSetNsFd(veth.peerIfc, fd)
} | go | {
"resource": ""
} |
q14750 | SetPeerLinkNetInNs | train | func (veth *VethPair) SetPeerLinkNetInNs(nspid int, ip net.IP, network *net.IPNet, gw *net.IP) error {
origNs, _ := NetNsHandle(os.Getpid())
defer syscall.Close(int(origNs))
defer system.Setns(origNs, syscall.CLONE_NEWNET)
if err := SetNetNsToPid(nspid); err != nil {
return fmt.Errorf("Setting network namespace failed: %s", err)
}
if err := netlink.NetworkLinkAddIp(veth.peerIfc, ip, network); err != nil {
return fmt.Errorf("Unable to set IP: %s in pid: %d network namespace", ip.String(), nspid)
}
if err := netlink.NetworkLinkUp(veth.peerIfc); err != nil {
return 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
} | go | {
"resource": ""
} |
q14751 | makeNetInterfaceName | train | func makeNetInterfaceName(base string) string {
for {
name := base + randomString(6)
if _, err := net.InterfaceByName(name); err == nil {
continue
}
return name
}
} | go | {
"resource": ""
} |
q14752 | validMacAddress | train | func validMacAddress(macaddr string) error {
if _, err := net.ParseMAC(macaddr); err != nil {
return fmt.Errorf("Can not parse MAC address: %s", err)
}
if _, err := FindInterfaceByMacAddress(macaddr); err == nil {
return fmt.Errorf("MAC Address already assigned on the host: %s", macaddr)
}
return nil
} | go | {
"resource": ""
} |
q14753 | validFlags | train | func validFlags(flags net.Flags) error {
if (flags & syscall.IFF_UP) != syscall.IFF_UP {
return fmt.Errorf("Unsupported network flags specified: %v", flags)
}
return nil
} | go | {
"resource": ""
} |
q14754 | NetInterfaceNameValid | train | func NetInterfaceNameValid(name string) (bool, error) {
if name == "" {
return false, errors.New("Interface name can not be empty")
}
if len(name) == 1 {
return false, fmt.Errorf("Interface name too short: %s", 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
} | go | {
"resource": ""
} |
q14755 | NetNsHandle | train | func NetNsHandle(nspid int) (uintptr, error) {
if nspid <= 0 || nspid == 1 {
return 0, fmt.Errorf("Incorred PID specified: %d", nspid)
}
nsPath := path.Join("/", "proc", strconv.Itoa(nspid), "ns/net")
if nsPath == "" {
return 0, fmt.Errorf("Could not find Network namespace for pid: %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
} | go | {
"resource": ""
} |
q14756 | SetNetNsToPid | train | func SetNetNsToPid(nspid int) error {
if nspid <= 0 || nspid == 1 {
return fmt.Errorf("Incorred PID specified: %d", nspid)
}
nsFd, err := NetNsHandle(nspid)
defer syscall.Close(int(nsFd))
if err != nil {
return fmt.Errorf("Could not get network namespace handle: %s", err)
}
if err := system.Setns(nsFd, syscall.CLONE_NEWNET); err != nil {
return fmt.Errorf("Unable to set the network namespace: %v", err)
}
return nil
} | go | {
"resource": ""
} |
q14757 | BridgeFromName | train | func BridgeFromName(ifcName string) (Bridger, error) {
if ok, err := NetInterfaceNameValid(ifcName); !ok {
return nil, err
}
newIfc, 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
} | go | {
"resource": ""
} |
q14758 | NewLinkFrom | train | func NewLinkFrom(ifcName string) (Linker, error) {
if ok, err := NetInterfaceNameValid(ifcName); !ok {
return nil, err
}
newIfc, err := net.InterfaceByName(ifcName)
if err != nil {
return nil, fmt.Errorf("Could not find the new interface: %s", err)
}
return &Link{
ifc: newIfc,
}, nil
} | go | {
"resource": ""
} |
q14759 | SetLinkNetNsPid | train | func (l *Link) SetLinkNetNsPid(nspid int) error {
return netlink.NetworkSetNsPid(l.NetInterface(), nspid)
} | go | {
"resource": ""
} |
q14760 | SetLinkNetInNs | train | func (l *Link) SetLinkNetInNs(nspid int, ip net.IP, network *net.IPNet, gw *net.IP) error {
origNs, _ := NetNsHandle(os.Getpid())
defer syscall.Close(int(origNs))
defer system.Setns(origNs, syscall.CLONE_NEWNET)
if err := SetNetNsToPid(nspid); err != nil {
return fmt.Errorf("Setting network namespace failed: %s", err)
}
if err := netlink.NetworkLinkAddIp(l.NetInterface(), ip, network); err != nil {
return fmt.Errorf("Unable to set IP: %s in pid: %d network namespace", ip.String(), nspid)
}
if err := netlink.NetworkLinkUp(l.ifc); err != nil {
return 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
} | go | {
"resource": ""
} |
q14761 | SetLinkNsFd | train | func (l *Link) SetLinkNsFd(nspath string) error {
fd, err := syscall.Open(nspath, syscall.O_RDONLY, 0)
if err != nil {
return fmt.Errorf("Could not attach to Network namespace: %s", err)
}
return netlink.NetworkSetNsFd(l.NetInterface(), fd)
} | go | {
"resource": ""
} |
q14762 | SetLinkNsToDocker | train | func (l *Link) SetLinkNsToDocker(name string, dockerHost string) error {
pid, err := DockerPidByName(name, dockerHost)
if err != nil {
return fmt.Errorf("Failed to find docker %s : %s", name, err)
}
return l.SetLinkNetNsPid(pid)
} | go | {
"resource": ""
} |
q14763 | RenameInterfaceByName | train | func RenameInterfaceByName(old string, newName string) error {
iface, err := net.InterfaceByName(old)
if err != nil {
return err
}
return netlink.NetworkChangeName(iface, newName)
} | go | {
"resource": ""
} |
q14764 | setLinkOptions | train | func setLinkOptions(ifc *net.Interface, opts LinkOptions) error {
macaddr, mtu, flags, ns := opts.MacAddr, opts.MTU, opts.Flags, opts.Ns
// if MTU is passed in LinkOptions
if mtu != 0 {
if err := validMtu(mtu); err != nil {
return err
}
if err := netlink.NetworkSetMTU(ifc, mtu); err != nil {
return fmt.Errorf("Unable to set MTU: %s", err)
}
}
// if MacAddress is passed in LinkOptions
if macaddr != "" {
if err := validMacAddress(macaddr); err != nil {
return err
}
if err := netlink.NetworkSetMacAddress(ifc, macaddr); err != nil {
return fmt.Errorf("Unable to set MAC Address: %s", err)
}
}
// if ns is passed in LinkOptions
if ns != 0 {
if err := validNs(ns); err != nil {
return err
}
if err := netlink.NetworkSetNsPid(ifc, ns); err != nil {
return fmt.Errorf("Unable to set Network namespace: %s", err)
}
}
// if flags is passed in LinkOptions
if flags != 0 {
if err := validFlags(flags); 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 {
return fmt.Errorf("Switching to %d network namespace failed: %s", ns, err)
}
if err := netlink.NetworkLinkUp(ifc); err != nil {
return fmt.Errorf("Unable to bring %s interface UP: %s", ifc.Name, ns)
}
}
} else {
if err := netlink.NetworkLinkUp(ifc); err != nil {
return fmt.Errorf("Could not bring up network link %s: %s", ifc.Name, err)
}
}
}
return nil
} | go | {
"resource": ""
} |
q14765 | ExecQuery | train | func (c *Client) ExecQuery(query string) ([]byte, error) {
req := Query(query)
return c.Exec(req)
} | go | {
"resource": ""
} |
q14766 | NewAuthInfo | train | func NewAuthInfo(options ...OptAuth) (*AuthInfo, error) {
auth := &AuthInfo{}
for _, op := range options {
err := op(auth)
if err != nil {
return nil, err
}
}
return auth, nil
} | go | {
"resource": ""
} |
q14767 | OptAuthEnv | train | func OptAuthEnv() OptAuth {
return func(auth *AuthInfo) error {
user, ok := os.LookupEnv("GREMLIN_USER")
if !ok {
return errors.New("Variable GREMLIN_USER is not set")
}
pass, ok := os.LookupEnv("GREMLIN_PASS")
if !ok {
return errors.New("Variable GREMLIN_PASS is not set")
}
auth.User = user
auth.Pass = pass
return nil
}
} | go | {
"resource": ""
} |
q14768 | OptAuthUserPass | train | func OptAuthUserPass(user, pass string) OptAuth {
return func(auth *AuthInfo) error {
auth.User = user
auth.Pass = pass
return nil
}
} | go | {
"resource": ""
} |
q14769 | Authenticate | train | func (c *Client) Authenticate(requestId string) ([]byte, error) {
auth, err := NewAuthInfo(c.Auth...)
if err != nil {
return nil, err
}
var sasl []byte
sasl = append(sasl, 0)
sasl = append(sasl, []byte(auth.User)...)
sasl = append(sasl, 0)
sasl = append(sasl, []byte(auth.Pass)...)
saslEnc := base64.StdEncoding.EncodeToString(sasl)
args := &RequestArgs{Sasl: saslEnc}
authReq := &Request{
RequestId: requestId,
Processor: "trasversal",
Op: "authentication",
Args: args,
}
return c.Exec(authReq)
} | go | {
"resource": ""
} |
q14770 | String | train | func (r Response) String() string {
return fmt.Sprintf("Response \nRequestId: %v, \nStatus: {%#v}, \nResult: {%#v}\n", r.RequestId, r.Status, r.Result)
} | go | {
"resource": ""
} |
q14771 | StartMockFeedbackServer | train | func StartMockFeedbackServer(certFile, keyFile string) {
cert, err := tls.LoadX509KeyPair(certFile, keyFile)
if err != nil {
log.Panic(err)
}
config := tls.Config{Certificates: []tls.Certificate{cert}, ClientAuth: 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)
}
} | go | {
"resource": ""
} |
q14772 | NewPushNotification | train | func NewPushNotification() (pn *PushNotification) {
pn = new(PushNotification)
pn.payload = make(map[string]interface{})
pn.Identifier = rand.New(rand.NewSource(time.Now().UnixNano())).Int31n(IdentifierUbound)
pn.Priority = 10
return
} | go | {
"resource": ""
} |
q14773 | AddPayload | train | func (pn *PushNotification) AddPayload(p *Payload) {
// This deserves some explanation.
//
// Setting an exported field of type int to 0
// triggers the omitempty behavior if you've set it.
// Since the badge is optional, we should omit it if
// it's not set. However, we want to include it if the
// value is 0, so there's a hack in push_notification.go
// that exploits the fact that Apple treats -1 for a
// badge 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)
} | go | {
"resource": ""
} |
q14774 | Set | train | func (pn *PushNotification) Set(key string, value interface{}) {
pn.payload[key] = value
} | go | {
"resource": ""
} |
q14775 | PayloadString | train | func (pn *PushNotification) PayloadString() (string, error) {
j, err := pn.PayloadJSON()
return string(j), err
} | go | {
"resource": ""
} |
q14776 | ToBytes | train | func (pn *PushNotification) ToBytes() ([]byte, error) {
token, err := hex.DecodeString(pn.DeviceToken)
if err != nil {
return nil, err
}
if len(token) != deviceTokenLength {
return nil, errors.New("device token has incorrect length")
}
payload, err := pn.PayloadJSON()
if err != nil {
return nil, err
}
if len(payload) > MaxPayloadSizeBytes {
return nil, errors.New("payload is larger than the " + strconv.Itoa(MaxPayloadSizeBytes) + " byte limit")
}
frameBuffer := new(bytes.Buffer)
binary.Write(frameBuffer, binary.BigEndian, uint8(deviceTokenItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(deviceTokenLength))
binary.Write(frameBuffer, binary.BigEndian, token)
binary.Write(frameBuffer, binary.BigEndian, uint8(payloadItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(len(payload)))
binary.Write(frameBuffer, binary.BigEndian, payload)
binary.Write(frameBuffer, binary.BigEndian, uint8(notificationIdentifierItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(notificationIdentifierLength))
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(priorityItemid))
binary.Write(frameBuffer, binary.BigEndian, uint16(priorityLength))
binary.Write(frameBuffer, binary.BigEndian, pn.Priority)
buffer := bytes.NewBuffer([]byte{})
binary.Write(buffer, binary.BigEndian, uint8(pushCommandValue))
binary.Write(buffer, binary.BigEndian, uint32(frameBuffer.Len()))
binary.Write(buffer, binary.BigEndian, frameBuffer.Bytes())
return buffer.Bytes(), nil
} | go | {
"resource": ""
} |
q14777 | BareClient | train | func BareClient(gateway, certificateBase64, keyBase64 string) (c *Client) {
c = new(Client)
c.Gateway = gateway
c.CertificateBase64 = certificateBase64
c.KeyBase64 = keyBase64
return
} | go | {
"resource": ""
} |
q14778 | NewClient | train | func NewClient(gateway, certificateFile, keyFile string) (c *Client) {
c = new(Client)
c.Gateway = gateway
c.CertificateFile = certificateFile
c.KeyFile = keyFile
return
} | go | {
"resource": ""
} |
q14779 | Send | train | func (client *Client) Send(pn *PushNotification) (resp *PushNotificationResponse) {
resp = new(PushNotificationResponse)
payload, err := pn.ToBytes()
if err != nil {
resp.Success = false
resp.Error = err
return
}
err = client.ConnectAndWrite(resp, payload)
if err != nil {
resp.Success = false
resp.Error = err
return
}
resp.Success = true
resp.Error = nil
return
} | go | {
"resource": ""
} |
q14780 | ParseTime3339OrZero | train | func ParseTime3339OrZero(v string) Time3339 {
t, err := time.Parse(time.RFC3339Nano, v)
if err != nil {
return Time3339{}
}
return Time3339(t)
} | go | {
"resource": ""
} |
q14781 | IsAnyZero | train | func (t *Time3339) IsAnyZero() bool {
return t == nil || time.Time(*t).IsZero() || time.Time(*t).Unix() == 0
} | go | {
"resource": ""
} |
q14782 | ReadFile | train | func (c *ConfigParser) ReadFile(path string) (Obj, error) {
if path == "" && c.Open == nil {
return nil, errors.New("ReadFile of empty string but Open hook not defined")
}
c.touchedFiles = make(map[string]bool)
var err error
c.rootJSON, err = c.recursiveReadJSON(path)
return c.rootJSON, err
} | go | {
"resource": ""
} |
q14783 | recursiveReadJSON | train | func (c *ConfigParser) recursiveReadJSON(configPath string) (decodedObject map[string]interface{}, err error) {
if configPath != "" {
absConfigPath, err := filepath.Abs(configPath)
if err != nil {
return nil, fmt.Errorf("Failed to expand absolute path for %s", configPath)
}
if c.touchedFiles[absConfigPath] {
return nil, fmt.Errorf("ConfigParser include cycle detected reading config: %v",
absConfigPath)
}
c.touchedFiles[absConfigPath] = true
c.includeStack.Push(absConfigPath)
defer c.includeStack.Pop()
}
var f File
if f, err = c.open(configPath); err != nil {
return nil, fmt.Errorf("Failed to open config: %v", err)
}
defer f.Close()
decodedObject = make(map[string]interface{})
dj := json.NewDecoder(f)
if err = dj.Decode(&decodedObject); err != nil {
extra := ""
if serr, ok := err.(*json.SyntaxError); ok {
if _, serr := f.Seek(0, os.SEEK_SET); serr != nil {
log.Fatalf("seek error: %v", serr)
}
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.evaluateExpressions(decodedObject, nil, false); err != nil {
return nil, fmt.Errorf("error expanding JSON config expressions in %s:\n%v",
f.Name(), err)
}
return decodedObject, nil
} | go | {
"resource": ""
} |
q14784 | CheckTypes | train | func (c *ConfigParser) CheckTypes(m map[string]interface{}) error {
return c.evaluateExpressions(m, nil, true)
} | go | {
"resource": ""
} |
q14785 | evaluateExpressions | train | func (c *ConfigParser) evaluateExpressions(m map[string]interface{}, seenKeys []string, testOnly bool) error {
for k, ei := range m {
thisPath := append(seenKeys, k)
switch subval := ei.(type) {
case string, bool, float64, nil:
continue
case []interface{}:
if len(subval) == 0 {
continue
}
evaled, err := c.evalValue(subval)
if err != nil {
return fmt.Errorf("%s: value error %v", strings.Join(thisPath, "."), err)
}
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
} | go | {
"resource": ""
} |
q14786 | ConfigFilePath | train | func (c *ConfigParser) ConfigFilePath(configFile string) (path string, err error) {
// Try to open as absolute / relative to CWD
_, err = os.Stat(configFile)
if err != nil && filepath.IsAbs(configFile) {
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
} | go | {
"resource": ""
} |
q14787 | cachedToken | train | func cachedToken(cacheFile string) (*oauth2.Token, error) {
tok := new(oauth2.Token)
tokenData, err := wkfs.ReadFile(cacheFile)
if err != nil {
return nil, err
}
if err = json.Unmarshal(tokenData, tok); err != nil {
return nil, err
}
if !tok.Valid() {
if tok != nil && time.Now().After(tok.Expiry) {
return nil, errExpiredToken
}
return nil, errors.New("invalid token")
}
return tok, nil
} | go | {
"resource": ""
} |
q14788 | NewRefreshTokenSource | train | func NewRefreshTokenSource(config *oauth2.Config, refreshToken string) oauth2.TokenSource {
var noInitialToken *oauth2.Token = nil
return oauth2.ReuseTokenSource(noInitialToken, config.TokenSource(
oauth2.NoContext, // TODO: maybe accept a context later.
&oauth2.Token{RefreshToken: refreshToken},
))
} | go | {
"resource": ""
} |
q14789 | ReadBox | train | func (r *Reader) ReadBox() (Box, error) {
if r.noMoreBoxes {
return nil, io.EOF
}
if r.lastBox != nil {
if _, err := io.Copy(ioutil.Discard, r.lastBox.Body()); err != nil {
return nil, err
}
}
var buf [8]byte
_, err := io.ReadFull(r.br, buf[:4])
if err != nil {
return nil, err
}
box := &box{
size: int64(binary.BigEndian.Uint32(buf[:4])),
}
_, err = io.ReadFull(r.br, box.boxType[:]) // 4 more bytes
if err != nil {
return nil, err
}
// Special cases for size:
var remain int64
switch box.size {
case 1:
// 1 means it's actually a 64-bit size, after the type.
_, err = io.ReadFull(r.br, buf[:8])
if err != nil {
return nil, err
}
box.size = int64(binary.BigEndian.Uint64(buf[:8]))
if box.size < 0 {
// Go uses int64 for sizes typically, but BMFF uses uint64.
// We assume for now that nobody actually uses boxes larger
// 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, suggesting %d (negative) bytes remain", box.boxType, box.size, remain)
}
if box.size > 0 {
box.body = io.LimitReader(r.br, remain)
} else {
box.body = r.br
}
r.lastBox = box
return box, nil
} | go | {
"resource": ""
} |
q14790 | ReadAndParseBox | train | func (r *Reader) ReadAndParseBox(typ BoxType) (Box, error) {
box, err := r.ReadBox()
if err != nil {
return nil, fmt.Errorf("error reading %q box: %v", typ, err)
}
if box.Type() != typ {
return nil, fmt.Errorf("error reading %q box: got box type %q 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
} | go | {
"resource": ""
} |
q14791 | byteTime | train | func (r Rate) byteTime(n int) time.Duration {
if r.KBps == 0 {
return 0
}
return time.Duration(float64(n)/1024/float64(r.KBps)) * time.Second
} | go | {
"resource": ""
} |
q14792 | lockPortable | train | func lockPortable(name string) (io.Closer, error) {
fi, err := os.Stat(name)
if err == nil && fi.Size() > 0 {
st := portableLockStatus(name)
switch st {
case statusLocked:
return nil, fmt.Errorf("file %q already locked", name)
case statusStale:
os.Remove(name)
case statusInvalid:
return nil, fmt.Errorf("can't Lock file %q: has invalid contents", name)
}
}
f, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_TRUNC|os.O_EXCL, 0666)
if err != nil {
return nil, fmt.Errorf("failed to create lock file %s %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
} | go | {
"resource": ""
} |
q14793 | simpleRequest | train | func simpleRequest(method, url_ string) (*http.Request, error) {
req, err := http.NewRequest(method, url_, nil)
if err != nil {
return nil, err
}
req.Header.Set("x-goog-api-version", "2")
return req, err
} | go | {
"resource": ""
} |
q14794 | GetPartialObject | train | func GetPartialObject(ctx context.Context, obj Object, offset, length int64) (io.ReadCloser, error) {
if offset < 0 {
return nil, errors.New("invalid negative offset")
}
if err := obj.valid(); err != nil {
return nil, err
}
req, err := simpleRequest("GET", gsAccessURL+"/"+obj.Bucket+"/"+obj.Key)
if err != nil {
return nil, err
}
if length >= 0 {
req.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", offset, offset+length-1))
} else {
req.Header.Set("Range", fmt.Sprintf("bytes=%d-", offset))
}
req.Cancel = ctx.Done()
res, err := ctxutil.Client(ctx).Do(req)
if err != nil {
return nil, fmt.Errorf("GET (offset=%d, length=%d) failed: %v\n", offset, length, err)
}
if res.StatusCode == 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.Errorf("GET (offset=%d, length=%d) got failed status: %v\n", offset, length, res.Status)
}
return res.Body, nil
} | go | {
"resource": ""
} |
q14795 | EnumerateObjects | train | func EnumerateObjects(ctx context.Context, bucket, after string, limit int) ([]*storage.ObjectAttrs, error) {
// Build url, with query params
var params []string
if after != "" {
params = append(params, "marker="+url.QueryEscape(after))
}
if limit > 0 {
params = append(params, fmt.Sprintf("max-keys=%v", limit))
}
query := ""
if len(params) > 0 {
query = "?" + strings.Join(params, "&")
}
req, err := simpleRequest("GET", gsAccessURL+"/"+bucket+"/"+query)
if err != nil {
return nil, err
}
req.Cancel = ctx.Done()
res, err := ctxutil.Client(ctx).Do(req)
if err != nil {
return nil, err
}
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, len(xres.Contents))
for k, o := range xres.Contents {
objAttrs[k] = &storage.ObjectAttrs{
Name: o.Key,
Size: o.Size,
}
}
return objAttrs, nil
} | go | {
"resource": ""
} |
q14796 | uploadBinary | train | func (cl *cloudLaunch) uploadBinary() {
ctx := context.Background()
if cl.BinaryBucket == "" {
log.Fatal("cloudlaunch: Config.BinaryBucket is empty")
}
stoClient, err := storage.NewClient(ctx, option.WithHTTPClient(cl.oauthClient))
if err != nil {
log.Fatal(err)
}
w := stoClient.Bucket(cl.BinaryBucket).Object(cl.binaryObject()).NewWriter(ctx)
if err != nil {
log.Fatal(err)
}
w.ACL = []storage.ACLRule{
// If you don't give the owners access, the web UI seems to
// have a bug and doesn't have access to see that it's public, so
// won't render the "Shared Publicly" link. So we do that, even
// though it's dumb and unnecessary otherwise:
{
Entity: storage.ACLEntity("project-owners-" + cl.GCEProjectID),
Role: storage.RoleOwner,
},
// Public, so our systemd unit can get it easily:
{
Entity: storage.AllUsers,
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(); err != nil {
log.Fatal(err)
}
log.Printf("Uploaded %d bytes", n)
} | go | {
"resource": ""
} |
q14797 | findIP | train | func (cl *cloudLaunch) findIP() string {
// Try to find it by name.
aggAddrList, err := cl.computeService.Addresses.AggregatedList(cl.GCEProjectID).Do()
if err != nil {
log.Fatal(err)
}
// https://godoc.org/google.golang.org/api/compute/v1#AddressAggregatedList
var ip string
IPLoop:
for _, asl := range aggAddrList.Items {
for _, addr := 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
} | go | {
"resource": ""
} |
q14798 | lookupInstance | train | func (cl *cloudLaunch) lookupInstance() *compute.Instance {
inst, err := cl.computeService.Instances.Get(cl.GCEProjectID, cl.zone(), cl.instName()).Do()
if ae, ok := err.(*googleapi.Error); ok && ae.Code == 404 {
return nil
} else if err != nil {
log.Fatalf("Instances.Get: %v", err)
}
return inst
} | go | {
"resource": ""
} |
q14799 | Roll | train | func (rs *RollSum) Roll(ch byte) {
wp := &rs.window[rs.wofs]
rs.add(uint32(*wp), uint32(ch))
*wp = ch
rs.wofs = (rs.wofs + 1) & (windowSize - 1)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.