// Copyright (c) Mainflux // SPDX-License-Identifier: Apache-2.0 package twins import ( "context" "encoding/json" "fmt" "math" "time" "github.com/mainflux/mainflux" "github.com/mainflux/mainflux/logger" "github.com/mainflux/mainflux/pkg/errors" "github.com/mainflux/mainflux/pkg/messaging" "github.com/mainflux/senml" ) const publisher = "twins" // Service specifies an API that must be fullfiled by the domain service // implementation, and all of its decorators (e.g. logging & metrics). type Service interface { // AddTwin adds new twin related to user identified by the provided key. AddTwin(ctx context.Context, token string, twin Twin, def Definition) (tw Twin, err error) // UpdateTwin updates twin identified by the provided Twin that // belongs to the user identified by the provided key. UpdateTwin(ctx context.Context, token string, twin Twin, def Definition) (err error) // ViewTwin retrieves data about twin with the provided // ID belonging to the user identified by the provided key. ViewTwin(ctx context.Context, token, twinID string) (tw Twin, err error) // RemoveTwin removes the twin identified with the provided ID, that // belongs to the user identified by the provided key. RemoveTwin(ctx context.Context, token, twinID string) (err error) // ListTwins retrieves data about subset of twins that belongs to the // user identified by the provided key. ListTwins(ctx context.Context, token string, offset uint64, limit uint64, name string, metadata Metadata) (Page, error) // ListStates retrieves data about subset of states that belongs to the // twin identified by the id. ListStates(ctx context.Context, token string, offset uint64, limit uint64, twinID string) (StatesPage, error) // SaveStates persists states into database SaveStates(ctx context.Context, msg *messaging.Message) error } const ( noop = iota update save millisec = 1e6 nanosec = 1e9 SubtopicWildcard = ">" ) var crudOp = map[string]string{ "createSucc": "create.success", "createFail": "create.failure", "updateSucc": "update.success", "updateFail": "update.failure", "getSucc": "get.success", "getFail": "get.failure", "removeSucc": "remove.success", "removeFail": "remove.failure", "stateSucc": "save.success", "stateFail": "save.failure", } type twinsService struct { publisher messaging.Publisher auth mainflux.AuthServiceClient twins TwinRepository states StateRepository idProvider mainflux.IDProvider channelID string twinCache TwinCache logger logger.Logger } var _ Service = (*twinsService)(nil) // New instantiates the twins service implementation. func New(publisher messaging.Publisher, auth mainflux.AuthServiceClient, twins TwinRepository, tcache TwinCache, sr StateRepository, idp mainflux.IDProvider, chann string, logger logger.Logger) Service { return &twinsService{ publisher: publisher, auth: auth, twins: twins, twinCache: tcache, states: sr, idProvider: idp, channelID: chann, logger: logger, } } func (ts *twinsService) AddTwin(ctx context.Context, token string, twin Twin, def Definition) (tw Twin, err error) { var id string var b []byte defer ts.publish(ctx, &id, &err, crudOp["createSucc"], crudOp["createFail"], &b) res, err := ts.auth.Identify(ctx, &mainflux.IdentityReq{Token: token}) if err != nil { return Twin{}, err } twin.ID, err = ts.idProvider.ID() if err != nil { return Twin{}, err } twin.Owner = res.GetId() t := time.Now() twin.Created = t twin.Updated = t if def.Attributes == nil { def.Attributes = []Attribute{} } if def.Delta == 0 { def.Delta = millisec } def.Created = time.Now() def.ID = 0 twin.Definitions = append(twin.Definitions, def) twin.Revision = 0 if _, err = ts.twins.Save(ctx, twin); err != nil { return Twin{}, err } id = twin.ID b, err = json.Marshal(twin) return twin, ts.twinCache.Save(ctx, twin) } func (ts *twinsService) UpdateTwin(ctx context.Context, token string, twin Twin, def Definition) (err error) { var b []byte var id string defer ts.publish(ctx, &id, &err, crudOp["updateSucc"], crudOp["updateFail"], &b) _, err = ts.auth.Identify(ctx, &mainflux.IdentityReq{Token: token}) if err != nil { return errors.ErrAuthentication } tw, err := ts.twins.RetrieveByID(ctx, twin.ID) if err != nil { return err } revision := false if twin.Name != "" { revision = true tw.Name = twin.Name } if len(def.Attributes) > 0 { revision = true def.Created = time.Now() def.ID = tw.Definitions[len(tw.Definitions)-1].ID + 1 tw.Definitions = append(tw.Definitions, def) } if len(twin.Metadata) > 0 { revision = true tw.Metadata = twin.Metadata } if !revision { return errors.ErrMalformedEntity } tw.Updated = time.Now() tw.Revision++ if err := ts.twins.Update(ctx, tw); err != nil { return err } id = twin.ID b, err = json.Marshal(tw) return ts.twinCache.Update(ctx, twin) } func (ts *twinsService) ViewTwin(ctx context.Context, token, twinID string) (tw Twin, err error) { var b []byte defer ts.publish(ctx, &twinID, &err, crudOp["getSucc"], crudOp["getFail"], &b) _, err = ts.auth.Identify(ctx, &mainflux.IdentityReq{Token: token}) if err != nil { return Twin{}, err } twin, err := ts.twins.RetrieveByID(ctx, twinID) if err != nil { return Twin{}, err } b, err = json.Marshal(twin) return twin, nil } func (ts *twinsService) RemoveTwin(ctx context.Context, token, twinID string) (err error) { var b []byte defer ts.publish(ctx, &twinID, &err, crudOp["removeSucc"], crudOp["removeFail"], &b) _, err = ts.auth.Identify(ctx, &mainflux.IdentityReq{Token: token}) if err != nil { return errors.ErrAuthentication } if err := ts.twins.Remove(ctx, twinID); err != nil { return err } return ts.twinCache.Remove(ctx, twinID) } func (ts *twinsService) ListTwins(ctx context.Context, token string, offset uint64, limit uint64, name string, metadata Metadata) (Page, error) { res, err := ts.auth.Identify(ctx, &mainflux.IdentityReq{Token: token}) if err != nil { return Page{}, errors.ErrAuthentication } return ts.twins.RetrieveAll(ctx, res.GetId(), offset, limit, name, metadata) } func (ts *twinsService) ListStates(ctx context.Context, token string, offset uint64, limit uint64, twinID string) (StatesPage, error) { _, err := ts.auth.Identify(ctx, &mainflux.IdentityReq{Token: token}) if err != nil { return StatesPage{}, errors.ErrAuthentication } return ts.states.RetrieveAll(ctx, offset, limit, twinID) } func (ts *twinsService) SaveStates(ctx context.Context, msg *messaging.Message) error { var ids []string channel, subtopic := msg.Channel, msg.Subtopic ids, err := ts.twinCache.IDs(ctx, channel, subtopic) if err != nil { return err } if len(ids) < 1 { ids, err = ts.twins.RetrieveByAttribute(ctx, channel, subtopic) if err != nil { return err } if len(ids) < 1 { return nil } if err := ts.twinCache.SaveIDs(ctx, channel, subtopic, ids); err != nil { return err } } for _, id := range ids { if err := ts.saveState(ctx, msg, id); err != nil { return err } } return nil } func (ts *twinsService) saveState(ctx context.Context, msg *messaging.Message, twinID string) error { var b []byte var err error defer ts.publish(ctx, &twinID, &err, crudOp["stateSucc"], crudOp["stateFail"], &b) tw, err := ts.twins.RetrieveByID(ctx, twinID) if err != nil { return fmt.Errorf("retrieving twin for %s failed: %s", msg.Publisher, err) } var recs []senml.Record if err := json.Unmarshal(msg.Payload, &recs); err != nil { return fmt.Errorf("unmarshal payload for %s failed: %s", msg.Publisher, err) } st, err := ts.states.RetrieveLast(ctx, tw.ID) if err != nil { return fmt.Errorf("retrieve last state for %s failed: %s", msg.Publisher, err) } for _, rec := range recs { action := ts.prepareState(&st, &tw, rec, msg) switch action { case noop: return nil case update: if err := ts.states.Update(ctx, st); err != nil { return fmt.Errorf("update state for %s failed: %s", msg.Publisher, err) } case save: if err := ts.states.Save(ctx, st); err != nil { return fmt.Errorf("save state for %s failed: %s", msg.Publisher, err) } } } twinID = msg.Publisher b = msg.Payload return nil } func (ts *twinsService) prepareState(st *State, tw *Twin, rec senml.Record, msg *messaging.Message) int { def := tw.Definitions[len(tw.Definitions)-1] st.TwinID = tw.ID st.Definition = def.ID if st.Payload == nil { st.Payload = make(map[string]interface{}) st.ID = -1 // state is incremented on save -> zero-based index } else { for k := range st.Payload { idx := findAttribute(k, def.Attributes) if idx < 0 || !def.Attributes[idx].PersistState { delete(st.Payload, k) } } } recSec := rec.BaseTime + rec.Time recNano := recSec * nanosec sec, dec := math.Modf(recSec) recTime := time.Unix(int64(sec), int64(dec*nanosec)) action := noop for _, attr := range def.Attributes { if !attr.PersistState { continue } if attr.Channel == msg.Channel && (attr.Subtopic == SubtopicWildcard || attr.Subtopic == msg.Subtopic) { action = update delta := math.Abs(float64(st.Created.UnixNano()) - recNano) if recNano == 0 || delta > float64(def.Delta) { action = save st.ID++ st.Created = time.Now() if recNano != 0 { st.Created = recTime } } val := findValue(rec) st.Payload[attr.Name] = val break } } return action } func findValue(rec senml.Record) interface{} { if rec.Value != nil { return rec.Value } if rec.StringValue != nil { return rec.StringValue } if rec.DataValue != nil { return rec.DataValue } if rec.BoolValue != nil { return rec.BoolValue } if rec.Sum != nil { return rec.Sum } return nil } func findAttribute(name string, attrs []Attribute) (idx int) { for idx, attr := range attrs { if attr.Name == name { return idx } } return -1 } func (ts *twinsService) publish(ctx context.Context, twinID *string, err *error, succOp, failOp string, payload *[]byte) { if ts.channelID == "" { return } op := succOp if *err != nil { op = failOp esb := []byte((*err).Error()) payload = &esb } pl := *payload if pl == nil { pl = []byte(fmt.Sprintf("{\"deleted\":\"%s\"}", *twinID)) } msg := messaging.Message{ Channel: ts.channelID, Subtopic: op, Payload: pl, Publisher: publisher, Created: time.Now().UnixNano(), } if err := ts.publisher.Publish(ctx, msg.Channel, &msg); err != nil { ts.logger.Warn(fmt.Sprintf("Failed to publish notification on Message Broker: %s", err)) } }