// logMessage logs a message for this user and potentially associates an item
func (u *user) logMessage(t time.Time, m gregor.InBandMessage, i *item) {
for _, l := range u.log {
if bytes.Equal(l.m.Metadata().MsgID().Bytes(), m.Metadata().MsgID().Bytes()) {
return
}
}
u.log = append(u.log, loggedMsg{m, t, i})
}
func (s *SQLEngine) consumeInBandMessage(m gregor.InBandMessage) (time.Time, error) {
switch {
case m.ToStateUpdateMessage() != nil:
return s.consumeStateUpdateMessage(m.ToStateUpdateMessage())
default:
return time.Time{}, nil
}
}
func (s *SQLEngine) isDismissed(msg gregor.InBandMessage, c time.Time) bool {
if update := msg.ToStateUpdateMessage(); update != nil {
if creation := update.Creation(); creation != nil {
if dtime := creation.DTime(); dtime != nil {
return dtime.Before(c)
}
}
}
return false
}
func isMessageForDevice(m gregor.InBandMessage, d gregor.DeviceID) bool {
sum := m.ToStateUpdateMessage()
if sum == nil {
return true
}
if d == nil {
return true
}
did := sum.Metadata().DeviceID()
if did == nil {
return true
}
if bytes.Equal(did.Bytes(), d.Bytes()) {
return true
}
return false
}
func (m *MemEngine) consumeInBandMessage(uid gregor.UID, msg gregor.InBandMessage) (time.Time, error) {
user := m.getUser(uid)
now := m.clock.Now()
var i *item
var err error
switch {
case msg.ToStateUpdateMessage() != nil:
i, err = m.consumeStateUpdateMessage(user, now, msg.ToStateUpdateMessage())
default:
}
retTime := now
if i != nil {
retTime = i.ctime
}
user.logMessage(retTime, msg, i)
return retTime, err
}
// handleInBandMessageWithHandler runs a message against the specified handler
func (g *gregorHandler) handleInBandMessageWithHandler(ctx context.Context, cli gregor1.IncomingInterface,
ibm gregor.InBandMessage, handler libkb.GregorInBandMessageHandler) (bool, error) {
g.Debug("handleInBand: %+v", ibm)
gcli, err := g.getGregorCli()
if err != nil {
return false, err
}
state, err := gcli.StateMachineState(nil)
if err != nil {
return false, err
}
sync := ibm.ToStateSyncMessage()
if sync != nil {
g.Debug("state sync message")
return false, nil
}
update := ibm.ToStateUpdateMessage()
if update != nil {
g.Debug("state update message")
item := update.Creation()
if item != nil {
id := item.Metadata().MsgID().String()
g.Debug("msg ID %s created ctime: %s", id,
item.Metadata().CTime())
category := ""
if item.Category() != nil {
category = item.Category().String()
g.Debug("item %s has category %s", id, category)
}
if handled, err := handler.Create(ctx, cli, category, item); err != nil {
return handled, err
}
}
dismissal := update.Dismissal()
if dismissal != nil {
g.Debug("received dismissal")
for _, id := range dismissal.MsgIDsToDismiss() {
item, present := state.GetItem(id)
if !present {
g.Debug("tried to dismiss item %s, not present", id.String())
continue
}
g.Debug("dismissing item %s", id.String())
category := ""
if item.Category() != nil {
category = item.Category().String()
g.Debug("dismissal %s has category %s", id, category)
}
if handled, err := handler.Dismiss(ctx, cli, category, item); handled && err != nil {
return handled, err
}
}
if len(dismissal.RangesToDismiss()) > 0 {
g.Debug("message range dismissing not implemented")
}
}
return true, nil
}
return false, nil
}