_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q37000 | notifyProvisionWatcherAssociates | train | func notifyProvisionWatcherAssociates(pw models.ProvisionWatcher, action string) error {
// Get the device service for the provision watcher
ds, err := dbClient.GetDeviceServiceById(pw.Service.Id)
if err != nil {
return err
}
// Notify the service
if err = notifyAssociates([]models.DeviceService{ds}, pw.Id, ac... | go | {
"resource": ""
} |
q37001 | updateDeviceLastReportedConnected | train | func updateDeviceLastReportedConnected(device string) {
// Config set to skip update last reported
if !Configuration.Writable.DeviceUpdateLastConnected {
LoggingClient.Debug("Skipping update of device connected/reported times for: " + device)
return
}
d, err := mdc.CheckForDevice(device, context.Background())... | go | {
"resource": ""
} |
q37002 | updateDeviceServiceLastReportedConnected | train | func updateDeviceServiceLastReportedConnected(device string) {
if !Configuration.Writable.ServiceUpdateLastConnected {
LoggingClient.Debug("Skipping update of device service connected/reported times for: " + device)
return
}
t := db.MakeTimestamp()
// Get the device
d, err := mdc.CheckForDevice(device, cont... | go | {
"resource": ""
} |
q37003 | getObjectsByRangeFilter | train | func getObjectsByRangeFilter(conn redis.Conn, key string, filter string, start, end int) (objects [][]byte, err error) {
ids, err := redis.Values(conn.Do("ZRANGE", key, start, end))
if err != nil && err != redis.ErrNil {
return nil, err
}
// https://github.com/golang/go/wiki/SliceTricks#filtering-without-allocat... | go | {
"resource": ""
} |
q37004 | addObject | train | func addObject(data []byte, adder models.Adder, id string, conn redis.Conn) {
_ = conn.Send("SET", id, data)
for _, cmd := range adder.Add() {
switch cmd.Command {
case "ZADD":
_ = conn.Send(cmd.Command, cmd.Hash, cmd.Rank, cmd.Key)
case "SADD":
_ = conn.Send(cmd.Command, cmd.Hash, cmd.Key)
case "HSET"... | go | {
"resource": ""
} |
q37005 | deleteObject | train | func deleteObject(remover models.Remover, id string, conn redis.Conn) {
_ = conn.Send("DEL", id)
for _, cmd := range remover.Remove() {
switch cmd.Command {
case "ZREM":
case "SREM":
case "HDEL":
_ = conn.Send(cmd.Command, cmd.Hash, cmd.Key)
}
}
} | go | {
"resource": ""
} |
q37006 | NewGetCommand | train | func NewGetCommand(device contract.Device, command contract.Command, context context.Context, httpCaller internal.HttpCaller) (Executor, error) {
url := device.Service.Addressable.GetBaseURL() + strings.Replace(command.Get.Action.Path, DEVICEIDURLPARAM, device.Id, -1)
request, err := http.NewRequest(http.MethodGet, u... | go | {
"resource": ""
} |
q37007 | newHTTPSender | train | func newHTTPSender(addr contract.Addressable) sender {
sender := httpSender{
url: addr.Protocol + "://" + addr.Address + ":" + strconv.Itoa(addr.Port) + addr.Path,
method: addr.HTTPMethod,
}
return sender
} | go | {
"resource": ""
} |
q37008 | Send | train | func (sender httpSender) Send(data []byte, event *models.Event) bool {
switch sender.method {
case http.MethodPost:
ctx := context.WithValue(context.Background(), clients.CorrelationHeader, event.CorrelationId)
req, err := http.NewRequest(http.MethodPost, sender.url, bytes.NewReader(data))
if err != nil {
r... | go | {
"resource": ""
} |
q37009 | NewClient | train | func NewClient(config db.Configuration) (MongoClient, error) {
m := MongoClient{}
// Create the dial info for the Mongo session
connectionString := config.Host + ":" + strconv.Itoa(config.Port)
mongoDBDialInfo := &mgo.DialInfo{
Addrs: []string{connectionString},
Timeout: time.Duration(config.Timeout) * tim... | go | {
"resource": ""
} |
q37010 | SetLogLevel | train | func (l privLogger) SetLogLevel(logLevel string) error {
if logger.IsValidLogLevel(logLevel) == true {
*l.logLevel = logLevel
return nil
}
return types.ErrNotFound{}
} | go | {
"resource": ""
} |
q37011 | GetDeviceProfilesByCommandId | train | func (mc MongoClient) GetDeviceProfilesByCommandId(id string) ([]contract.DeviceProfile, error) {
command, err := mc.getCommandById(id)
if err != nil {
return []contract.DeviceProfile{}, err
}
dps, err := mc.getDeviceProfiles(bson.M{"commands.$id": command.Id})
if err != nil {
return []contract.DeviceProfile{... | go | {
"resource": ""
} |
q37012 | DeleteCommandById | train | func (mc MongoClient) DeleteCommandById(id string) error {
s := mc.session.Copy()
defer s.Close()
col := s.DB(mc.database.Name).C(db.Command)
// Check if the command is still in use
findParameters, err := idToBsonM(id)
if err != nil {
return err
}
query := bson.M{"commands": bson.M{"$elemMatch": findParamete... | go | {
"resource": ""
} |
q37013 | ScrubMetadata | train | func (mc MongoClient) ScrubMetadata() error {
s := mc.session.Copy()
defer s.Close()
_, err := s.DB(mc.database.Name).C(db.Addressable).RemoveAll(nil)
if err != nil {
return errorMap(err)
}
_, err = s.DB(mc.database.Name).C(db.DeviceService).RemoveAll(nil)
if err != nil {
return errorMap(err)
}
_, err = s... | go | {
"resource": ""
} |
q37014 | GetNotifications | train | func (c Client) GetNotifications() (n []contract.Notification, err error) {
conn := c.Pool.Get()
defer conn.Close()
objects, err := getObjectsByRange(conn, db.Notification, 0, -1)
if err != nil {
return nil, err
}
n, err = unmarshalNotifications(objects)
if err != nil {
return n, err
}
return n, nil
} | go | {
"resource": ""
} |
q37015 | DeleteNotificationsOld | train | func (c Client) DeleteNotificationsOld(age int) error {
conn := c.Pool.Get()
defer conn.Close()
currentTime := db.MakeTimestamp()
end := int64(int(currentTime) - age)
objects, err := getObjectsByScore(conn, db.Notification+":modified", 0, end, 0)
for _, object := range objects {
if len(object) > 0 {
var n... | go | {
"resource": ""
} |
q37016 | DeleteTransmission | train | func (c Client) DeleteTransmission(age int64, status contract.TransmissionStatus) error {
conn := c.Pool.Get()
defer conn.Close()
currentTime := db.MakeTimestamp()
end := currentTime - age
objects, err := getObjectsByRangeFilter(conn, db.Transmission+":modified", db.Transmission+":status:"+fmt.Sprintf("%s", stat... | go | {
"resource": ""
} |
q37017 | Cleanup | train | func (c Client) Cleanup() error {
//conn := c.Pool.Get()
//defer conn.Close()
//
//cols := []string{
// db.Transmission, db.Notification,
//}
//
//for _, col := range cols {
// err := unlinkCollection(conn, col)
// if err != nil {
// return err
// }
//}
err := c.CleanupOld(0)
if err != nil {
return er... | go | {
"resource": ""
} |
q37018 | CleanupOld | train | func (c Client) CleanupOld(age int) error {
conn := c.Pool.Get()
defer conn.Close()
currentTime := db.MakeTimestamp()
end := currentTime - int64(age)
objects, err := getObjectsByScore(conn, db.Notification+":created", 0, end, -1)
if err != nil {
return err
}
notifications, err := unmarshalNotifications(obje... | go | {
"resource": ""
} |
q37019 | ImportProperties | train | func ImportProperties(root string) error {
err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
// Skip directories & unacceptable property extension
if info.IsDir() || !isAcceptablePropertyExtensions(info.Name()) {
return nil
}
dir, file :=... | go | {
"resource": ""
} |
q37020 | listDirectories | train | func listDirectories() [9]string {
var names = [9]string{internal.CoreMetaDataServiceKey, internal.CoreCommandServiceKey, internal.CoreDataServiceKey,
internal.ExportDistroServiceKey, internal.ExportClientServiceKey, internal.SupportLoggingServiceKey,
internal.SupportSchedulerServiceKey, internal.SupportNotificati... | go | {
"resource": ""
} |
q37021 | readPropertiesFile | train | func readPropertiesFile(filePath string) (map[string]string, error) {
props, err := properties.LoadFile(filePath, properties.UTF8)
if err != nil {
return nil, err
}
return props.Map(), nil
} | go | {
"resource": ""
} |
q37022 | traverse | train | func traverse(path string, j interface{}) ([]*pair, error) {
kvs := make([]*pair, 0)
pathPre := ""
if path != "" {
pathPre = path + "/"
}
switch j.(type) {
case []interface{}:
for sk, sv := range j.([]interface{}) {
skvs, err := traverse(pathPre+strconv.Itoa(sk), sv)
if err != nil {
return nil, er... | go | {
"resource": ""
} |
q37023 | Loop | train | func Loop() {
go func() {
p := fmt.Sprintf(":%d", Configuration.Service.Port)
LoggingClient.Info(fmt.Sprintf("Starting Export Distro %s", p))
messageErrors <- http.ListenAndServe(p, httpServer())
}()
registrations := make(map[string]*registrationInfo)
allRegs, err := getRegistrations()
for allRegs == nil ... | go | {
"resource": ""
} |
q37024 | checkDuplicateProfileNames | train | func checkDuplicateProfileNames(dp models.DeviceProfile, w http.ResponseWriter) error {
profiles, err := dbClient.GetAllDeviceProfiles()
if err != nil {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return err
}
for _, p := range profiles {
if p.Name == dp.Name && p.Id != dp.Id {
err = errors.... | go | {
"resource": ""
} |
q37025 | checkDuplicateCommands | train | func checkDuplicateCommands(dp models.DeviceProfile, w http.ResponseWriter) error {
// Check if there are duplicate names in the device profile command list
for _, c1 := range dp.CoreCommands {
count := 0
for _, c2 := range dp.CoreCommands {
if c1.Name == c2.Name {
count += 1
}
}
if count > 1 {
e... | go | {
"resource": ""
} |
q37026 | deleteCommands | train | func deleteCommands(dp models.DeviceProfile, w http.ResponseWriter) error {
for _, command := range dp.CoreCommands {
err := dbClient.DeleteCommandById(command.Id)
if err != nil {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return err
}
}
return nil
} | go | {
"resource": ""
} |
q37027 | addCommands | train | func addCommands(dp *models.DeviceProfile, w http.ResponseWriter) error {
for i := range dp.CoreCommands {
if newId, err := dbClient.AddCommand(dp.CoreCommands[i]); err != nil {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return err
} else {
dp.CoreCommands[i].Id = newId
}
}
return nil
... | go | {
"resource": ""
} |
q37028 | restDeleteProfileByName | train | func restDeleteProfileByName(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
n, err := url.QueryUnescape(vars[NAME])
if err != nil {
LoggingClient.Error(err.Error())
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
// Check if the device profile exists
dp, err := dbClient.GetDeviceP... | go | {
"resource": ""
} |
q37029 | deleteDeviceProfile | train | func deleteDeviceProfile(dp models.DeviceProfile, w http.ResponseWriter) error {
// Check if the device profile is still in use by devices
d, err := dbClient.GetDevicesByProfileId(dp.Id)
// XXX ErrNotFound should always be returned but this is not consistent in the implementations
if err == db.ErrNotFound {
err ... | go | {
"resource": ""
} |
q37030 | restAddProfileByYamlRaw | train | func restAddProfileByYamlRaw(w http.ResponseWriter, r *http.Request) {
// Get the YAML string
body, err := ioutil.ReadAll(r.Body)
if err != nil {
LoggingClient.Error(err.Error())
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
addDeviceProfileYaml(body, w)
} | go | {
"resource": ""
} |
q37031 | notifyProfileAssociates | train | func notifyProfileAssociates(dp models.DeviceProfile, action string) error {
// Get the devices
d, err := dbClient.GetDevicesByProfileId(dp.Id)
if err != nil {
LoggingClient.Error(err.Error())
return err
}
// Get the services for each device
// Use map as a Set
dsMap := map[string]models.DeviceService{}
ds... | go | {
"resource": ""
} |
q37032 | restUpdateCommand | train | func restUpdateCommand(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
var c contract.Command
if err := json.NewDecoder(r.Body).Decode(&c); err != nil {
LoggingClient.Error(err.Error())
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
// Check if command exists (By ID)
former, err ... | go | {
"resource": ""
} |
q37033 | restDeleteCommandById | train | func restDeleteCommandById(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
var id string = vars[ID]
// Check if the command exists
_, err := dbClient.GetCommandById(id)
if err != nil {
LoggingClient.Error(err.Error())
http.Error(w, err.Error(), http.StatusNotFound)
return
}
// Check if the ... | go | {
"resource": ""
} |
q37034 | isCommandStillInUse | train | func isCommandStillInUse(id string) (bool, error) {
dp, err := dbClient.GetDeviceProfilesByCommandId(id)
if err == db.ErrNotFound { // XXX Inconsistent return values. Should be ErrNotFound
err = nil
} else if err != nil {
return false, err
}
if len(dp) == 0 {
return false, err
}
return true, err
} | go | {
"resource": ""
} |
q37035 | HelpCallback | train | func HelpCallback() {
msg := fmt.Sprintf(usageStr, os.Args[0])
fmt.Printf("%s\n", msg)
os.Exit(0)
} | go | {
"resource": ""
} |
q37036 | updateDeviceReportFields | train | func updateDeviceReportFields(from models.DeviceReport, to *models.DeviceReport, w http.ResponseWriter) error {
if from.Device != "" {
to.Device = from.Device
if err := validateDevice(to.Device, w); err != nil {
return err
}
}
if from.Action != "" {
to.Action = from.Action
}
if from.Expected != nil {
... | go | {
"resource": ""
} |
q37037 | validateDevice | train | func validateDevice(d string, w http.ResponseWriter) error {
if _, err := dbClient.GetDeviceByName(d); err != nil {
if err == db.ErrNotFound {
http.Error(w, "Device was not found", http.StatusNotFound)
} else {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
}
return err
}
return nil
} | go | {
"resource": ""
} |
q37038 | restGetValueDescriptorsForDeviceName | train | func restGetValueDescriptorsForDeviceName(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
n, err := url.QueryUnescape(vars[DEVICENAME])
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
LoggingClient.Error(err.Error())
return
}
// Get all the associated device reports
reports,... | go | {
"resource": ""
} |
q37039 | notifyDeviceReportAssociates | train | func notifyDeviceReportAssociates(dr models.DeviceReport, action string) error {
// Get the device of the report
d, err := dbClient.GetDeviceByName(dr.Device)
if err != nil {
return err
}
// Get the device service for the device
ds, err := dbClient.GetDeviceServiceById(d.Service.Id)
if err != nil {
return e... | go | {
"resource": ""
} |
q37040 | HealthCheck | train | func (s ServiceInfo) HealthCheck() string {
hc := fmt.Sprintf("%s://%s:%v%s", s.Protocol, s.Host, s.Port, clients.ApiPingRoute)
return hc
} | go | {
"resource": ""
} |
q37041 | Url | train | func (s ServiceInfo) Url() string {
url := fmt.Sprintf("%s://%s:%v", s.Protocol, s.Host, s.Port)
return url
} | go | {
"resource": ""
} |
q37042 | Url | train | func (e IntervalActionInfo) Url() string {
url := fmt.Sprintf("%s://%s:%v", e.Protocol, e.Host, e.Port)
return url
} | go | {
"resource": ""
} |
q37043 | msToTime | train | func msToTime(ms string) (time.Time, error) {
msInt, err := strconv.ParseInt(ms, 10, 64)
if err != nil {
// todo: support-scheduler will be removed later issue_650a
t, err := time.Parse(TIMELAYOUT, ms)
if err == nil {
return t, nil
}
return time.Time{}, err
}
return time.Unix(0, msInt*int64(time.Milli... | go | {
"resource": ""
} |
q37044 | DeleteRegistrationByName | train | func (c *Client) DeleteRegistrationByName(name string) error {
conn := c.Pool.Get()
defer conn.Close()
id, err := redis.String(conn.Do("HGET", db.ExportCollection+":name", name))
if err == redis.ErrNil {
return db.ErrNotFound
} else if err != nil {
return err
}
return deleteRegistration(conn, id)
} | go | {
"resource": ""
} |
q37045 | ScrubAllRegistrations | train | func (c *Client) ScrubAllRegistrations() (err error) {
conn := c.Pool.Get()
defer conn.Close()
return unlinkCollection(conn, db.ExportCollection)
} | go | {
"resource": ""
} |
q37046 | updateDeviceServiceFields | train | func updateDeviceServiceFields(from models.DeviceService, to *models.DeviceService, w http.ResponseWriter) error {
// Use .String() to compare empty structs (not ideal, but there is no .equals method)
if (from.Addressable.String() != models.Addressable{}.String()) {
var addr models.Addressable
var err error
if ... | go | {
"resource": ""
} |
q37047 | deleteDeviceService | train | func deleteDeviceService(ds models.DeviceService, w http.ResponseWriter, ctx context.Context) error {
// Delete the associated devices
devices, err := dbClient.GetDevicesByServiceId(ds.Id)
if err != nil {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return err
}
for _, device := range devices {
... | go | {
"resource": ""
} |
q37048 | updateServiceLastConnected | train | func updateServiceLastConnected(ds models.DeviceService, lc int64, w http.ResponseWriter) error {
ds.LastConnected = lc
if err := dbClient.UpdateDeviceService(ds); err != nil {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return err
}
return nil
} | go | {
"resource": ""
} |
q37049 | updateServiceOpState | train | func updateServiceOpState(ds models.DeviceService, os models.OperatingState, w http.ResponseWriter) error {
ds.OperatingState = os
if err := dbClient.UpdateDeviceService(ds); err != nil {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return err
}
return nil
} | go | {
"resource": ""
} |
q37050 | updateServiceAdminState | train | func updateServiceAdminState(ds models.DeviceService, as models.AdminState, w http.ResponseWriter) error {
ds.AdminState = as
if err := dbClient.UpdateDeviceService(ds); err != nil {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return err
}
return nil
} | go | {
"resource": ""
} |
q37051 | updateServiceLastReported | train | func updateServiceLastReported(ds models.DeviceService, lr int64, w http.ResponseWriter) error {
ds.LastReported = lr
if err := dbClient.UpdateDeviceService(ds); err != nil {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return err
}
return nil
} | go | {
"resource": ""
} |
q37052 | callback | train | func callback(service models.DeviceService, id string, action string, actionType models.ActionType) error {
client := &http.Client{}
url := service.Addressable.GetCallbackURL()
if len(url) > 0 {
body, err := getBody(id, actionType)
if err != nil {
return err
}
req, err := http.NewRequest(string(action), u... | go | {
"resource": ""
} |
q37053 | getBody | train | func getBody(id string, actionType models.ActionType) ([]byte, error) {
return json.Marshal(models.CallbackAlert{ActionType: actionType, Id: id})
} | go | {
"resource": ""
} |
q37054 | scrubAllHandler | train | func scrubAllHandler(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
LoggingClient.Info("Deleting all events from database")
err := deleteAllEvents()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
LoggingClient.Error(err.Error())
return
}
encode(true, w)
} | go | {
"resource": ""
} |
q37055 | Execute | train | func (sc serviceCommand) Execute() (string, int, error) {
if sc.AdminState == contract.Locked {
LoggingClient.Error(sc.Name + " is in admin locked state")
return "", DefaultErrorCode, ErrDeviceLocked{}
}
LoggingClient.Info("Issuing" + sc.Request.Method + " command to: " + sc.Request.URL.String())
resp, reqErr... | go | {
"resource": ""
} |
q37056 | IntervalByName | train | func (mc MongoClient) IntervalByName(name string) (contract.Interval, error) {
s := mc.getSessionCopy()
defer s.Close()
query := bson.M{"name": name}
mi := models.Interval{}
if err := s.DB(mc.database.Name).C(db.Interval).Find(query).One(&mi); err != nil {
return contract.Interval{}, errorMap(err)
}
return m... | go | {
"resource": ""
} |
q37057 | IntervalById | train | func (mc MongoClient) IntervalById(id string) (contract.Interval, error) {
s := mc.getSessionCopy()
defer s.Close()
query, err := idToBsonM(id)
if err != nil {
return contract.Interval{}, err
}
var interval models.Interval
if err := s.DB(mc.database.Name).C(db.Interval).Find(query).One(&interval); err != nil... | go | {
"resource": ""
} |
q37058 | UpdateInterval | train | func (mc MongoClient) UpdateInterval(interval contract.Interval) error {
var mapped models.Interval
id, err := mapped.FromContract(interval)
if err != nil {
return err
}
mapped.TimestampForUpdate()
return mc.updateId(db.Interval, id, mapped)
} | go | {
"resource": ""
} |
q37059 | DeleteIntervalById | train | func (mc MongoClient) DeleteIntervalById(id string) error {
return mc.deleteById(db.Interval, id)
} | go | {
"resource": ""
} |
q37060 | IntervalActionById | train | func (mc MongoClient) IntervalActionById(id string) (contract.IntervalAction, error) {
s := mc.getSessionCopy()
defer s.Close()
query, err := idToBsonM(id)
if err != nil {
return contract.IntervalAction{}, err
}
var action models.IntervalAction
if err := s.DB(mc.database.Name).C(db.IntervalAction).Find(query... | go | {
"resource": ""
} |
q37061 | IntervalActionByName | train | func (mc MongoClient) IntervalActionByName(name string) (contract.IntervalAction, error) {
s := mc.getSessionCopy()
defer s.Close()
query := bson.M{"name": name}
mia := models.IntervalAction{}
if err := s.DB(mc.database.Name).C(db.IntervalAction).Find(query).One(&mia); err != nil {
return contract.IntervalActi... | go | {
"resource": ""
} |
q37062 | AddIntervalAction | train | func (mc MongoClient) AddIntervalAction(action contract.IntervalAction) (string, error) {
s := mc.getSessionCopy()
defer s.Close()
var mapped models.IntervalAction
id, err := mapped.FromContract(action)
if err != nil {
return "", err
}
// See if the name is unique and add the value descriptors
found, err :=... | go | {
"resource": ""
} |
q37063 | UpdateIntervalAction | train | func (mc MongoClient) UpdateIntervalAction(action contract.IntervalAction) error {
var mapped models.IntervalAction
id, err := mapped.FromContract(action)
if err != nil {
return err
}
mapped.TimestampForUpdate()
return mc.updateId(db.IntervalAction, id, mapped)
} | go | {
"resource": ""
} |
q37064 | DeleteIntervalActionById | train | func (mc MongoClient) DeleteIntervalActionById(id string) error {
return mc.deleteById(db.IntervalAction, id)
} | go | {
"resource": ""
} |
q37065 | NewClient | train | func NewClient(config db.Configuration) (*Client, error) {
once.Do(func() {
connectionString := fmt.Sprintf("%s:%d", config.Host, config.Port)
opts := []redis.DialOption{
redis.DialPassword(config.Password),
redis.DialConnectTimeout(time.Duration(config.Timeout) * time.Millisecond),
}
dialFunc := func()... | go | {
"resource": ""
} |
q37066 | CloseSession | train | func (c *Client) CloseSession() {
c.Pool.Close()
currClient = nil
once = sync.Once{}
} | go | {
"resource": ""
} |
q37067 | getConnection | train | func getConnection() (conn redis.Conn, err error) {
if currClient == nil {
return nil, errors.New("No current Redis client: create a new client before getting a connection from it")
}
conn = currClient.Pool.Get()
return conn, nil
} | go | {
"resource": ""
} |
q37068 | IntervalByName | train | func (c *Client) IntervalByName(name string) (interval contract.Interval, err error) {
conn := c.Pool.Get()
defer conn.Close()
err = getObjectByKey(conn, models.IntervalNameKey, name, &interval)
return interval, err
} | go | {
"resource": ""
} |
q37069 | IntervalById | train | func (c *Client) IntervalById(id string) (interval contract.Interval, err error) {
conn := c.Pool.Get()
defer conn.Close()
object, err := redis.Bytes(conn.Do("GET", id))
if err == redis.ErrNil {
return contract.Interval{}, db.ErrNotFound
} else if err != nil {
return contract.Interval{}, err
}
err = json.U... | go | {
"resource": ""
} |
q37070 | AddInterval | train | func (c *Client) AddInterval(from contract.Interval) (id string, err error) {
interval := models.NewInterval(from)
if interval.ID != "" {
_, err = uuid.Parse(interval.ID)
if err != nil {
return "", db.ErrInvalidObjectId
}
} else {
interval.ID = uuid.New().String()
}
if interval.Timestamps.Created == 0 ... | go | {
"resource": ""
} |
q37071 | UpdateInterval | train | func (c *Client) UpdateInterval(from contract.Interval) (err error) {
check, err := c.IntervalByName(from.Name)
if err != nil && err != redis.ErrNil {
return err
}
if err == nil && from.ID != check.ID {
// IDs are different -> name not unique
return db.ErrNotUnique
}
from.Timestamps.Modified = db.MakeTimes... | go | {
"resource": ""
} |
q37072 | DeleteIntervalById | train | func (c *Client) DeleteIntervalById(id string) (err error) {
check, err := c.IntervalById(id)
if err != nil {
if err == db.ErrNotFound {
return nil
}
return
}
interval := models.NewInterval(check)
conn := c.Pool.Get()
defer conn.Close()
_ = conn.Send("MULTI")
deleteObject(interval, id, conn)
_, err... | go | {
"resource": ""
} |
q37073 | IntervalActionById | train | func (c *Client) IntervalActionById(id string) (action contract.IntervalAction, err error) {
conn := c.Pool.Get()
defer conn.Close()
object, err := redis.Bytes(conn.Do("GET", id))
if err == redis.ErrNil {
return contract.IntervalAction{}, db.ErrNotFound
} else if err != nil {
return contract.IntervalAction{},... | go | {
"resource": ""
} |
q37074 | IntervalActionByName | train | func (c *Client) IntervalActionByName(name string) (action contract.IntervalAction, err error) {
conn := c.Pool.Get()
defer conn.Close()
err = getObjectByKey(conn, models.IntervalActionNameKey, name, &action)
return action, err
} | go | {
"resource": ""
} |
q37075 | AddIntervalAction | train | func (c *Client) AddIntervalAction(from contract.IntervalAction) (id string, err error) {
action := models.NewIntervalAction(from)
if action.ID != "" {
_, err = uuid.Parse(action.ID)
if err != nil {
return "", db.ErrInvalidObjectId
}
} else {
action.ID = uuid.New().String()
}
if action.Created == 0 {
... | go | {
"resource": ""
} |
q37076 | UpdateIntervalAction | train | func (c *Client) UpdateIntervalAction(from contract.IntervalAction) (err error) {
check, err := c.IntervalActionByName(from.Name)
if err != nil && err != redis.ErrNil {
return err
}
if err == nil && from.ID != check.ID {
// IDs are different -> name not unique
return db.ErrNotUnique
}
from.Modified = db.Ma... | go | {
"resource": ""
} |
q37077 | DeleteIntervalActionById | train | func (c *Client) DeleteIntervalActionById(id string) (err error) {
check, err := c.IntervalActionById(id)
if err != nil {
if err == db.ErrNotFound {
return nil
}
return
}
action := models.NewIntervalAction(check)
conn := c.Pool.Get()
defer conn.Close()
_ = conn.Send("MULTI")
deleteObject(action, id, ... | go | {
"resource": ""
} |
q37078 | EventCount | train | func (c *Client) EventCount() (count int, err error) {
conn := c.Pool.Get()
defer conn.Close()
count, err = redis.Int(conn.Do("ZCARD", db.EventsCollection))
if err != nil {
return 0, err
}
return count, nil
} | go | {
"resource": ""
} |
q37079 | DeleteEventById | train | func (c *Client) DeleteEventById(id string) (err error) {
conn := c.Pool.Get()
defer conn.Close()
err = deleteEvent(conn, id)
if err != nil {
if err == redis.ErrNil {
return db.ErrNotFound
}
return err
}
return nil
} | go | {
"resource": ""
} |
q37080 | ScrubAllEvents | train | func (c *Client) ScrubAllEvents() (err error) {
conn := c.Pool.Get()
defer conn.Close()
err = unlinkCollection(conn, db.EventsCollection)
if err != nil {
return err
}
err = unlinkCollection(conn, db.ReadingsCollection)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q37081 | AddReading | train | func (c *Client) AddReading(r contract.Reading) (id string, err error) {
conn := c.Pool.Get()
defer conn.Close()
if r.Id != "" {
_, err = uuid.Parse(r.Id)
if err != nil {
return "", db.ErrInvalidObjectId
}
}
return addReading(conn, true, r)
} | go | {
"resource": ""
} |
q37082 | ReadingCount | train | func (c *Client) ReadingCount() (int, error) {
conn := c.Pool.Get()
defer conn.Close()
count, err := redis.Int(conn.Do("ZCARD", db.ReadingsCollection))
if err != nil {
return 0, err
}
return count, nil
} | go | {
"resource": ""
} |
q37083 | ReadingsByCreationTime | train | func (c *Client) ReadingsByCreationTime(start, end int64, limit int) (readings []contract.Reading, err error) {
conn := c.Pool.Get()
defer conn.Close()
if limit == 0 {
return readings, nil
}
objects, err := getObjectsByScore(conn, db.ReadingsCollection+":created", start, end, limit)
if err != nil {
return r... | go | {
"resource": ""
} |
q37084 | DeleteValueDescriptorById | train | func (c *Client) DeleteValueDescriptorById(id string) error {
conn := c.Pool.Get()
defer conn.Close()
err := deleteValue(conn, id)
if err != nil {
if err == redis.ErrNil {
return db.ErrNotFound
}
return err
}
return nil
} | go | {
"resource": ""
} |
q37085 | ValueDescriptorByName | train | func (c *Client) ValueDescriptorByName(name string) (value contract.ValueDescriptor, err error) {
conn := c.Pool.Get()
defer conn.Close()
value, err = valueByName(conn, name)
if err != nil {
if err == redis.ErrNil {
return value, db.ErrNotFound
}
return value, err
}
return value, nil
} | go | {
"resource": ""
} |
q37086 | ValueDescriptorsByName | train | func (c *Client) ValueDescriptorsByName(names []string) (values []contract.ValueDescriptor, err error) {
conn := c.Pool.Get()
defer conn.Close()
for _, name := range names {
value, err := valueByName(conn, name)
if err != nil && err != redis.ErrNil {
return nil, err
}
if err == nil {
values = append(... | go | {
"resource": ""
} |
q37087 | ValueDescriptorsByUomLabel | train | func (c *Client) ValueDescriptorsByUomLabel(uomLabel string) (values []contract.ValueDescriptor, err error) {
conn := c.Pool.Get()
defer conn.Close()
objects, err := getObjectsByRange(conn, db.ValueDescriptorCollection+":uomlabel:"+uomLabel, 0, -1)
if err != nil {
if err != redis.ErrNil {
return values, err
... | go | {
"resource": ""
} |
q37088 | ScrubAllValueDescriptors | train | func (c *Client) ScrubAllValueDescriptors() error {
conn := c.Pool.Get()
defer conn.Close()
err := unlinkCollection(conn, db.ValueDescriptorCollection)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q37089 | addReading | train | func addReading(conn redis.Conn, tx bool, r contract.Reading) (id string, err error) {
if r.Created == 0 {
r.Created = db.MakeTimestamp()
}
if r.Id == "" {
r.Id = uuid.New().String()
}
m, err := marshalObject(r)
if err != nil {
return r.Id, err
}
if tx {
_ = conn.Send("MULTI")
}
_ = conn.Send("SET"... | go | {
"resource": ""
} |
q37090 | DeleteCommandById | train | func (c *Client) DeleteCommandById(id string) error {
conn := c.Pool.Get()
defer conn.Close()
// TODO: ??? Check if the command is still in use by device profiles
return deleteCommand(conn, id)
} | go | {
"resource": ""
} |
q37091 | newAzureMessage | train | func newAzureMessage() (*AzureMessage, error) {
msg := &AzureMessage{
Ack: none,
Properties: make(map[string]string),
Created: time.Now(),
}
id := uuid.New()
msg.ID = id.String()
correlationID := uuid.New()
msg.CorrelationID = correlationID.String()
return msg, nil
} | go | {
"resource": ""
} |
q37092 | AddProperty | train | func (am *AzureMessage) AddProperty(key, value string) error {
am.Properties[key] = value
return nil
} | go | {
"resource": ""
} |
q37093 | newBIoTMessage | train | func newBIoTMessage() (*BIoTMessage, error) {
msg := &BIoTMessage{
Severity: "1",
MsgType: "Q",
}
id := uuid.New()
msg.MsgId = id.String()
return msg, nil
} | go | {
"resource": ""
} |
q37094 | newIoTCoreSender | train | func newIoTCoreSender(addr models.Addressable) sender {
protocol := strings.ToLower(addr.Protocol)
broker := fmt.Sprintf("%s%s", addr.GetBaseURL(), addr.Path)
deviceID := extractDeviceID(addr.Publisher)
opts := MQTT.NewClientOptions()
opts.AddBroker(broker)
opts.SetClientID(addr.Publisher)
opts.SetUsername(addr... | go | {
"resource": ""
} |
q37095 | ToContract | train | func (e Event) ToContract() *contract.Event {
event := contract.Event{
ID: e.ID,
Pushed: e.Pushed,
Device: e.Device,
Created: e.Created,
Modified: e.Modified,
Origin: e.Origin,
}
for _, r := range e.Readings {
event.Readings = append(event.Readings, r)
}
return &event
} | go | {
"resource": ""
} |
q37096 | updateDeviceFields | train | func updateDeviceFields(from models.Device, to *models.Device) error {
if (from.Service.String() != models.DeviceService{}.String()) {
// Check if the new service exists
// Try ID first
ds, err := dbClient.GetDeviceServiceById(from.Service.Id)
if err != nil {
// Then try name
ds, err = dbClient.GetDevic... | go | {
"resource": ""
} |
q37097 | restGetDeviceByServiceName | train | func restGetDeviceByServiceName(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
sn, err := url.QueryUnescape(vars[SERVICENAME])
if err != nil {
LoggingClient.Error(err.Error())
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return
}
// Check if the device service exists
ds, err := ... | go | {
"resource": ""
} |
q37098 | restCheckForDevice | train | func restCheckForDevice(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
token := vars[ID] //referring to this as "token" for now since the source variable is double purposed
//Check for name first since we're using that meaning by default.
dev, err := dbClient.GetDeviceByName(token)
if err != nil {
... | go | {
"resource": ""
} |
q37099 | deleteDevice | train | func deleteDevice(d models.Device, w http.ResponseWriter, ctx context.Context) error {
if err := deleteAssociatedReportsForDevice(d, w); err != nil {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return err
}
if err := dbClient.DeleteDeviceById(d.Id); err != nil {
http.Error(w, err.Error(), http.S... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.