func (m *baseModel) fetchIds(conn redis.Conn) ([]string, error) {
ids, err := redis.Strings(conn.Do("SMEMBERS", m.idType+"s"))
m.log.Debugf("Found %d %s id(s)", m.idType, len(ids))
return ids, err
}
func (m *ThingModel) GetDeviceIDForThing(thingID string, conn redis.Conn) (*string, error) {
allRels, err := redis.Strings(redis.Values(conn.Do("HGETALL", "device-thing")))
if err != nil {
return nil, err
}
if len(allRels) == 0 {
return nil, RecordNotFound
}
for i := 0; i < len(allRels); i += 2 {
if allRels[i+1] == thingID {
return &allRels[i], nil
}
}
return nil, RecordNotFound
}
func (m *baseModel) getSyncManifest(conn redis.Conn) (*SyncManifest, error) {
var manifest SyncManifest = make(map[string]int64)
item, err := redis.Strings(conn.Do("HGETALL", m.idType+"s:updated"))
for i := 0; i < len(item); i += 2 {
t := time.Time{}
err := t.UnmarshalText([]byte(item[i+1]))
if err != nil {
return nil, err
}
manifest[item[i]] = t.UnixNano() / int64(time.Millisecond)
}
if err != nil {
return nil, err
}
return &manifest, nil
}
func (m *ChannelModel) FetchAll(deviceID string, conn redis.Conn) (*[]*model.Channel, error) {
m.syncing.Wait()
ids, err := redis.Strings(conn.Do("SMEMBERS", "device:"+deviceID+":channels"))
m.log.Debugf("Found %d channel id(s) for device %s", len(ids), deviceID)
if err != nil {
return nil, err
}
channels := make([]*model.Channel, len(ids))
for i, id := range ids {
channels[i], err = m.Fetch(deviceID, id, conn)
if err != nil {
return nil, err
}
}
return &channels, nil
}
// zpop pops a value from the ZSET key using WATCH/MULTI/EXEC commands.
func zpop(c redis.Conn, key string) (result string, err error) {
defer func() {
// Return connection to normal state on error.
if err != nil {
c.Do("DISCARD")
}
}()
// Loop until transaction is successful.
for {
if _, err := c.Do("WATCH", key); err != nil {
return "", err
}
members, err := redis.Strings(c.Do("ZRANGE", key, 0, 0))
if err != nil {
return "", err
}
if len(members) != 1 {
return "", redis.ErrNil
}
c.Send("MULTI")
c.Send("ZREM", key, members[0])
queued, err := c.Do("EXEC")
if err != nil {
return "", err
}
if queued != nil {
result = members[0]
break
}
}
return result, nil
}
func (m *RoomModel) afterDelete(deletedRoom *model.Room, conn redis.Conn) error {
defer syncFS()
thingIds, err := redis.Strings(conn.Do("SMEMBERS", fmt.Sprintf("room:%s:things", deletedRoom.ID)))
for _, id := range thingIds {
err := m.ThingModel.SetLocation(id, nil, conn)
if err == RecordNotFound {
// We were out of sync, but don't really care...
continue
}
if err != nil {
m.log.Infof("Failed to fetch thing that was in a deleted room. ID: %s error: %s", id, err)
}
}
_, err = conn.Do("DEL", fmt.Sprintf("room:%s:things", deletedRoom.ID))
return err
}
actual valueError
expected valueError
}{
{
"ints([v1, v2])",
ve(redis.Ints([]interface{}{[]byte("4"), []byte("5")}, nil)),
ve([]int{4, 5}, nil),
},
{
"ints(nil)",
ve(redis.Ints(nil, nil)),
ve([]int(nil), redis.ErrNil),
},
{
"strings([v1, v2])",
ve(redis.Strings([]interface{}{[]byte("v1"), []byte("v2")}, nil)),
ve([]string{"v1", "v2"}, nil),
},
{
"strings(nil)",
ve(redis.Strings(nil, nil)),
ve([]string(nil), redis.ErrNil),
},
{
"values([v1, v2])",
ve(redis.Values([]interface{}{[]byte("v1"), []byte("v2")}, nil)),
ve([]interface{}{[]byte("v1"), []byte("v2")}, nil),
},
{
"values(nil)",
ve(redis.Values(nil, nil)),