ducky/devices

Paddy 2015-11-15 Parent:408abf6e48d3 Child:f5a9d5f8f28d

7:1e2743834209 Go to Latest

ducky/devices/devices.go

Add ToMap and ToSlice helpers. Add helper functions that convert a map of ID-keyed Devices into a slice, and back. We'll use these a lot (especially with GetMany) as shorthand helper functions.

Download raw file
View source Diff to previous Annotate
History
paddy@0 1 package devices
paddy@0 2
paddy@0 3 import (
paddy@0 4 "errors"
paddy@5 5 "fmt"
paddy@0 6 "log"
paddy@0 7 "time"
paddy@0 8
paddy@0 9 "golang.org/x/net/context"
paddy@0 10
paddy@0 11 "code.secondbit.org/uuid.hg"
paddy@0 12 )
paddy@0 13
paddy@0 14 var (
paddy@0 15 // ErrDeviceNotFound is returned when the specified device couldn't be found.
paddy@0 16 ErrDeviceNotFound = errors.New("device not found")
paddy@0 17 )
paddy@0 18
paddy@0 19 // Device represents a specific device that updates can be pushed to.
paddy@0 20 type Device struct {
paddy@0 21 ID uuid.ID
paddy@0 22 Name string
paddy@0 23 Owner uuid.ID
paddy@0 24 Type DeviceType
paddy@0 25 Created time.Time
paddy@0 26 LastSeen time.Time
paddy@0 27 PushToken string
paddy@0 28 }
paddy@0 29
paddy@0 30 // ApplyChange returns a Device that is a copy of the passed Device,
paddy@0 31 // but with the passed DeviceChange applied.
paddy@0 32 func ApplyChange(d Device, change DeviceChange) Device {
paddy@0 33 result := d
paddy@0 34 if change.Name != nil {
paddy@0 35 result.Name = *change.Name
paddy@0 36 }
paddy@0 37 if change.Owner != nil {
paddy@0 38 result.Owner = *change.Owner
paddy@0 39 } else {
paddy@0 40 // We don't want to accidentally leave a slice that
paddy@0 41 // is owned by both behind.
paddy@0 42 result.Owner = d.Owner.Copy()
paddy@0 43 }
paddy@0 44 if change.Type != nil {
paddy@0 45 result.Type = *change.Type
paddy@0 46 }
paddy@0 47 if change.Created != nil {
paddy@0 48 result.Created = *change.Created
paddy@0 49 }
paddy@0 50 if change.LastSeen != nil {
paddy@0 51 result.LastSeen = *change.LastSeen
paddy@0 52 }
paddy@0 53 if change.PushToken != nil {
paddy@0 54 result.PushToken = *change.PushToken
paddy@0 55 }
paddy@0 56 return result
paddy@0 57 }
paddy@0 58
paddy@0 59 // DeviceChange represents a set of changes to a Device that will be used
paddy@0 60 // to update a Device.
paddy@0 61 type DeviceChange struct {
paddy@0 62 DeviceID uuid.ID
paddy@0 63 Name *string
paddy@0 64 Owner *uuid.ID
paddy@0 65 Type *DeviceType
paddy@0 66 Created *time.Time
paddy@0 67 LastSeen *time.Time
paddy@0 68 PushToken *string
paddy@0 69 }
paddy@0 70
paddy@0 71 // Storer is an interface to control how data is stored in and retrieved from
paddy@0 72 // the datastore.
paddy@0 73 type Storer interface {
paddy@0 74 GetDevices(ids []uuid.ID, c context.Context) (map[string]Device, error)
paddy@0 75 UpdateDevice(change DeviceChange, c context.Context) error
paddy@0 76 DeleteDevices(ids []uuid.ID, c context.Context) error
paddy@0 77 CreateDevices(devices []Device, c context.Context) error
paddy@0 78 ListDevicesByOwner(user uuid.ID, c context.Context) ([]Device, error)
paddy@0 79
paddy@0 80 // These are used for testing only.
paddy@0 81 Factory(c context.Context) (Storer, error)
paddy@0 82 Destroy(c context.Context) error
paddy@0 83 }
paddy@0 84
paddy@5 85 type ErrDeviceAlreadyExists uuid.ID
paddy@5 86
paddy@5 87 func (e ErrDeviceAlreadyExists) Error() string {
paddy@5 88 return fmt.Sprintf("device with ID %s already exists in datastore", uuid.ID(e).String())
paddy@5 89 }
paddy@5 90
paddy@0 91 // GetMany returns as many of the Devices specified by the passed IDs as possible.
paddy@0 92 // They are returned as a map, with the key being the string version of the ID.
paddy@0 93 // No error will be returned if a Device can't be found.
paddy@0 94 func GetMany(ids []uuid.ID, c context.Context) (map[string]Device, error) {
paddy@0 95 results := map[string]Device{}
paddy@0 96 storer, err := getStorer(c)
paddy@0 97 if err != nil {
paddy@0 98 log.Printf("Error retrieving Storer: %+v\n", err)
paddy@0 99 return results, err
paddy@0 100 }
paddy@0 101 results, err = storer.GetDevices(ids, c)
paddy@0 102 if err != nil {
paddy@0 103 log.Printf("Error retrieving Devices from %T: %+v\n", storer, err)
paddy@0 104 return results, err
paddy@0 105 }
paddy@0 106 return results, nil
paddy@0 107 }
paddy@0 108
paddy@0 109 // Get returns the Device specified by the passed ID. If the Device can't be found,
paddy@0 110 // an ErrDeviceNotFound error is returned.
paddy@0 111 func Get(id uuid.ID, c context.Context) (Device, error) {
paddy@0 112 results, err := GetMany([]uuid.ID{id}, c)
paddy@0 113 if err != nil {
paddy@0 114 return Device{}, err
paddy@0 115 }
paddy@0 116 result, ok := results[id.String()]
paddy@0 117 if !ok {
paddy@0 118 return Device{}, ErrDeviceNotFound
paddy@0 119 }
paddy@0 120 return result, nil
paddy@0 121 }
paddy@0 122
paddy@0 123 // Update applies the DeviceChange to the passed Device, and returns the result. If
paddy@0 124 // the Device can't be found, an ErrDeviceNotFound error was returned.
paddy@0 125 func Update(device Device, change DeviceChange, c context.Context) (Device, error) {
paddy@0 126 storer, err := getStorer(c)
paddy@0 127 if err != nil {
paddy@0 128 log.Printf("Error retrieving Storer: %+v\n", err)
paddy@0 129 return Device{}, err
paddy@0 130 }
paddy@0 131 change.DeviceID = device.ID
paddy@0 132 err = storer.UpdateDevice(change, c)
paddy@0 133 if err != nil {
paddy@0 134 return Device{}, err
paddy@0 135 }
paddy@0 136 return ApplyChange(device, change), nil
paddy@0 137 }
paddy@0 138
paddy@0 139 // DeleteMany removes the passed IDs from the datastore. No error is returned if the
paddy@0 140 // ID doesn't correspond to a Device in the datastore.
paddy@0 141 func DeleteMany(ids []uuid.ID, c context.Context) error {
paddy@0 142 storer, err := getStorer(c)
paddy@0 143 if err != nil {
paddy@0 144 log.Printf("Error retrieving Storer: %+v\n", err)
paddy@0 145 return err
paddy@0 146 }
paddy@0 147 return storer.DeleteDevices(ids, c)
paddy@0 148 }
paddy@0 149
paddy@0 150 // Delete removes the passed ID from the datastore. No error is returned if the ID doesn't
paddy@0 151 // correspond to a Device in the datastore.
paddy@0 152 func Delete(id uuid.ID, c context.Context) error {
paddy@0 153 return DeleteMany([]uuid.ID{id}, c)
paddy@0 154 }
paddy@0 155
paddy@0 156 // CreateMany stores the passed Devices in the datastore, assigning default values if
paddy@0 157 // necessary. The Devices that were ultimately stored (including any default values, if
paddy@0 158 // applicable) are returned.
paddy@0 159 func CreateMany(devices []Device, c context.Context) ([]Device, error) {
paddy@0 160 storer, err := getStorer(c)
paddy@0 161 if err != nil {
paddy@0 162 log.Printf("Error retrieving Storer: %+v\n", err)
paddy@0 163 return []Device{}, err
paddy@0 164 }
paddy@0 165 modified := make([]Device, 0, len(devices))
paddy@0 166 for _, device := range devices {
paddy@0 167 if device.ID.IsZero() {
paddy@0 168 device.ID = uuid.NewID()
paddy@0 169 }
paddy@0 170 if device.Created.IsZero() {
paddy@0 171 device.Created = time.Now()
paddy@0 172 }
paddy@0 173 if device.LastSeen.IsZero() {
paddy@0 174 device.LastSeen = time.Now()
paddy@0 175 }
paddy@0 176 modified = append(modified, device)
paddy@0 177 }
paddy@0 178 err = storer.CreateDevices(devices, c)
paddy@0 179 if err != nil {
paddy@0 180 return []Device{}, err
paddy@0 181 }
paddy@0 182 return modified, nil
paddy@0 183 }
paddy@0 184
paddy@0 185 // Create stores the passed Device in the datastore, assigning default values if
paddy@0 186 // necessary. The Devices that were ultimately stored (including any default values, if
paddy@0 187 // applicable) are returned.
paddy@0 188 func Create(device Device, c context.Context) (Device, error) {
paddy@0 189 devices, err := CreateMany([]Device{device}, c)
paddy@0 190 if err != nil {
paddy@0 191 return Device{}, err
paddy@0 192 }
paddy@0 193 // There should never be a case where we don't return a result.
paddy@0 194 // Ideally, we'd return an error here instead of letting the panic
paddy@0 195 // happen, but seeing as I can't come up with a reason the error would
paddy@0 196 // occur, I'm having trouble coming up with a reasonable error to return.
paddy@0 197 return devices[0], nil
paddy@0 198 }
paddy@0 199
paddy@0 200 // ListByOwner returns a slice of all the Devices with an Owner property that
paddy@0 201 // matches the passed ID. There's no guarantee on the order the Devices will be
paddy@0 202 // returned in.
paddy@0 203 func ListByOwner(user uuid.ID, c context.Context) ([]Device, error) {
paddy@0 204 // BUG(paddy): Eventually, we'll need to support paging for devices. But right now, I don't foresee any user creating enough of them to make pagination worthwhile.
paddy@0 205 storer, err := getStorer(c)
paddy@0 206 if err != nil {
paddy@0 207 log.Printf("Error retrieving Storer: %+v\n", err)
paddy@0 208 return []Device{}, err
paddy@0 209 }
paddy@0 210 devices, err := storer.ListDevicesByOwner(user, c)
paddy@0 211 return devices, err
paddy@0 212 }
paddy@7 213
paddy@7 214 func ToMap(devices []Device) map[string]Device {
paddy@7 215 results := make(map[string]Device, len(devices))
paddy@7 216 for _, device := range devices {
paddy@7 217 results[device.ID.String()] = device
paddy@7 218 }
paddy@7 219 return results
paddy@7 220 }
paddy@7 221
paddy@7 222 func ToSlice(devices map[string]Device) []Device {
paddy@7 223 results := make([]Device, 0, len(devices))
paddy@7 224 for _, device := range devices {
paddy@7 225 results = append(results, device)
paddy@7 226 }
paddy@7 227 return results
paddy@7 228 }