// Create a new record, prepending the prefix to the key if necessary
func (s *RedisKVStore) Create(key string, value string) error {
if !strings.HasPrefix(key, s.prefix) {
key = s.prefix + key
}
err := s.client.Watch(func(tx *redis.Tx) error {
exists, err := tx.Exists(key).Result()
if err != nil {
return err
}
if exists {
return errors.NewErrAlreadyExists(key)
}
_, err = tx.Pipelined(func(pipe *redis.Pipeline) error {
pipe.Set(key, value, 0)
return nil
})
if err != nil {
return err
}
return nil
}, key)
if err != nil {
return err
}
return nil
}
func (h *handlerManager) RegisterApplication(ctx context.Context, in *pb.ApplicationIdentifier) (*empty.Empty, error) {
if err := in.Validate(); err != nil {
return nil, errors.Wrap(err, "Invalid Application Identifier")
}
ctx, claims, err := h.validateTTNAuthAppContext(ctx, in.AppId)
if err != nil {
return nil, err
}
if !claims.AppRight(in.AppId, rights.AppSettings) {
return nil, errors.NewErrPermissionDenied(`No "settings" rights to application`)
}
app, err := h.handler.applications.Get(in.AppId)
if err != nil && errors.GetErrType(err) != errors.NotFound {
return nil, err
}
if app != nil {
return nil, errors.NewErrAlreadyExists("Application")
}
err = h.handler.applications.Set(&application.Application{
AppID: in.AppId,
})
if err != nil {
return nil, err
}
token, _ := api.TokenFromContext(ctx)
err = h.handler.Discovery.AddAppID(in.AppId, token)
if err != nil {
h.handler.Ctx.WithField("AppID", in.AppId).WithError(err).Warn("Could not register Application with Discovery")
}
_, err = h.handler.ttnBrokerManager.RegisterApplicationHandler(ctx, &pb_broker.ApplicationHandlerRegistration{
AppId: in.AppId,
HandlerId: h.handler.Identity.Id,
})
if err != nil {
h.handler.Ctx.WithField("AppID", in.AppId).WithError(err).Warn("Could not register Application with Broker")
}
return &empty.Empty{}, nil
}
// Create a new record, prepending the prefix to the key if necessary, optionally setting only the given properties
func (s *RedisMapStore) Create(key string, value interface{}, properties ...string) error {
if !strings.HasPrefix(key, s.prefix) {
key = s.prefix + key
}
if len(properties) == 0 {
if i, ok := value.(ChangedFielder); ok {
properties = i.ChangedFields()
}
}
vmap, err := s.encoder(value, properties...)
if err != nil {
return err
}
if len(vmap) == 0 {
return nil
}
err = s.client.Watch(func(tx *redis.Tx) error {
exists, err := tx.Exists(key).Result()
if err != nil {
return err
}
if exists {
return errors.NewErrAlreadyExists(key)
}
_, err = tx.Pipelined(func(pipe *redis.Pipeline) error {
pipe.HMSet(key, vmap)
return nil
})
if err != nil {
return err
}
return nil
}, key)
if err != nil {
return err
}
return nil
}
func (h *handlerManager) SetDevice(ctx context.Context, in *pb.Device) (*empty.Empty, error) {
if err := in.Validate(); err != nil {
return nil, errors.Wrap(err, "Invalid Device")
}
ctx, claims, err := h.validateTTNAuthAppContext(ctx, in.AppId)
if err != nil {
return nil, err
}
if !claims.AppRight(in.AppId, rights.Devices) {
return nil, errors.NewErrPermissionDenied(fmt.Sprintf(`No "devices" rights to application "%s"`, in.AppId))
}
if _, err := h.handler.applications.Get(in.AppId); err != nil {
return nil, errors.Wrap(err, "Application not registered to this Handler")
}
dev, err := h.handler.devices.Get(in.AppId, in.DevId)
if err != nil && errors.GetErrType(err) != errors.NotFound {
return nil, err
}
lorawan := in.GetLorawanDevice()
if lorawan == nil {
return nil, errors.NewErrInvalidArgument("Device", "No LoRaWAN Device")
}
if dev != nil { // When this is an update
if dev.AppEUI != *lorawan.AppEui || dev.DevEUI != *lorawan.DevEui {
// If the AppEUI or DevEUI is changed, we should remove the device from the NetworkServer and re-add it later
_, err = h.deviceManager.DeleteDevice(ctx, &pb_lorawan.DeviceIdentifier{
AppEui: &dev.AppEUI,
DevEui: &dev.DevEUI,
})
if err != nil {
return nil, errors.Wrap(errors.FromGRPCError(err), "Broker did not delete device")
}
}
dev.StartUpdate()
} else { // When this is a create
existingDevices, err := h.handler.devices.ListForApp(in.AppId)
if err != nil {
return nil, err
}
for _, existingDevice := range existingDevices {
if existingDevice.AppEUI == *lorawan.AppEui && existingDevice.DevEUI == *lorawan.DevEui {
return nil, errors.NewErrAlreadyExists("Device with AppEUI and DevEUI")
}
}
dev = new(device.Device)
}
dev.AppID = in.AppId
dev.AppEUI = *lorawan.AppEui
dev.DevID = in.DevId
dev.DevEUI = *lorawan.DevEui
dev.Options = device.Options{
DisableFCntCheck: lorawan.DisableFCntCheck,
Uses32BitFCnt: lorawan.Uses32BitFCnt,
ActivationConstraints: lorawan.ActivationConstraints,
}
if dev.Options.ActivationConstraints == "" {
dev.Options.ActivationConstraints = "local"
}
if lorawan.DevAddr != nil {
dev.DevAddr = *lorawan.DevAddr
}
if lorawan.NwkSKey != nil {
dev.NwkSKey = *lorawan.NwkSKey
}
if lorawan.AppSKey != nil {
dev.AppSKey = *lorawan.AppSKey
}
if lorawan.AppKey != nil {
if dev.AppKey != *lorawan.AppKey { // When the AppKey of an existing device is changed
dev.UsedAppNonces = []device.AppNonce{}
dev.UsedDevNonces = []device.DevNonce{}
}
dev.AppKey = *lorawan.AppKey
}
// Update the device in the Broker (NetworkServer)
nsUpdated := dev.GetLoRaWAN()
nsUpdated.FCntUp = lorawan.FCntUp
nsUpdated.FCntDown = lorawan.FCntDown
_, err = h.deviceManager.SetDevice(ctx, nsUpdated)
if err != nil {
return nil, errors.Wrap(errors.FromGRPCError(err), "Broker did not set device")
}
err = h.handler.devices.Set(dev)
if err != nil {
return nil, err
}
return &empty.Empty{}, nil
}
