func (g *gregorHandler) InjectOutOfBandMessage(system string, body []byte) error {
var err error
defer g.G().Trace(fmt.Sprintf("gregorHandler.InjectOutOfBandMessage(%s)", system),
func() error { return err },
)()
uid := g.G().Env.GetUID()
if uid.IsNil() {
err = fmt.Errorf("Can't create new gregor items without a current UID.")
return err
}
gregorUID := gregor1.UID(uid.ToBytes())
msg := gregor1.Message{
Oobm_: &gregor1.OutOfBandMessage{
Uid_: gregorUID,
System_: gregor1.System(system),
Body_: gregor1.Body(body),
},
}
incomingClient := gregor1.IncomingClient{Cli: g.cli}
// TODO: Should the interface take a context from the caller?
err = incomingClient.ConsumeMessage(context.TODO(), msg)
return err
}
func rekeySetup(tc libkb.TestContext) (gregor1.UID, *gregorHandler, *RekeyUIHandler) {
tc.G.SetService()
kbUID, err := keybase1.UIDFromString("9f9611a4b7920637b1c2a839b2a0e119")
if err != nil {
tc.T.Fatal(err)
}
gUID := gregor1.UID(kbUID.ToBytes())
did, err := libkb.NewDeviceID()
if err != nil {
tc.T.Fatal(err)
}
tc.G.Env.GetConfigWriter().SetUserConfig(libkb.NewUserConfig(kbUID, "", nil, did), true)
h, err := newGregorHandler(tc.G)
if err != nil {
tc.T.Fatal(err)
}
rekeyHandler := NewRekeyUIHandler(tc.G, 0)
rekeyHandler.alwaysAlive = true
rekeyHandler.notifyStart = make(chan int, 10)
rekeyHandler.notifyComplete = make(chan int, 10)
rekeyHandler.scorer = fakeScoreProblemFoldersEmpty
h.PushHandler(rekeyHandler)
return gUID, h, rekeyHandler
}
func (c *Client) State(cli gregor1.IncomingInterface) (gregor.State, error) {
ctx, _ := context.WithTimeout(context.Background(), 5*time.Second)
arg := gregor1.StateArg{
Uid: gregor1.UID(c.user.Bytes()),
Deviceid: gregor1.DeviceID(c.device.Bytes()),
TimeOrOffset: gregor1.TimeOrOffset{},
}
res, err := cli.State(ctx, arg)
if err != nil {
return nil, err
}
return res, nil
}
func (c *Client) syncFromTime(cli gregor1.IncomingInterface, t *time.Time) (msgs []gregor.InBandMessage, err error) {
ctx, _ := context.WithTimeout(context.Background(), time.Second)
arg := gregor1.SyncArg{
Uid: gregor1.UID(c.user.Bytes()),
Deviceid: gregor1.DeviceID(c.device.Bytes()),
}
if t != nil {
arg.Ctime = gregor1.ToTime(*t)
}
// Grab the events from gregord
c.log.Debug("syncFromTime from: %s", gregor1.FromTime(arg.Ctime))
res, err := cli.Sync(ctx, arg)
if err != nil {
return nil, err
}
c.log.Debug("syncFromTime consuming %d messages", len(res.Msgs))
for _, ibm := range res.Msgs {
m := gregor1.Message{Ibm_: &ibm}
msgs = append(msgs, ibm)
c.sm.ConsumeMessage(m)
}
// Check to make sure the server state is legit
state, err := c.sm.State(c.user, c.device, nil)
if err != nil {
return nil, err
}
hash, err := state.Hash()
if err != nil {
return nil, err
}
if !bytes.Equal(res.Hash, hash) {
return nil, errHashMismatch{}
}
return msgs, nil
}
func (g *gregorHandler) templateMessage() (*gregor1.Message, error) {
uid := g.G().Env.GetUID()
if uid.IsNil() {
return nil, fmt.Errorf("Can't create new gregor items without a current UID.")
}
gregorUID := gregor1.UID(uid.ToBytes())
newMsgID, err := NewGregorMsgID()
if err != nil {
return nil, err
}
return &gregor1.Message{
Ibm_: &gregor1.InBandMessage{
StateUpdate_: &gregor1.StateUpdateMessage{
Md_: gregor1.Metadata{
Uid_: gregorUID,
MsgID_: newMsgID,
},
},
},
}, nil
}