_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.... | 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) ... | 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
interme... | 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,... | 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,
... | 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": "h... | 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 a... | 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 {
ht... | 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, ot... | 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
}
... | 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 != n... | 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 ... | 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"... | 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 :... | 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, sys... | 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,
},
}... | 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"... | 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... | 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... | 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.StdEncodi... | 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")
... | 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, ... | 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... | 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.Err... | 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] ... | 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
}
evale... | 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 ... | 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) {
retu... | 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... | 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... | 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.Er... | 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 != ni... | 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)... | 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).Objec... | 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 aggAddr... | 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.