// OnConnect implements the ConnectionHandler interface. func (k *KeybaseDaemonRPC) OnConnect(ctx context.Context, conn *rpc.Connection, rawClient rpc.GenericClient, server *rpc.Server) error { protocols := []rpc.Protocol{ keybase1.LogUiProtocol(daemonLogUI{k.daemonLog}), keybase1.IdentifyUiProtocol(daemonIdentifyUI{k.daemonLog}), keybase1.NotifySessionProtocol(k), keybase1.NotifyUsersProtocol(k), } for _, p := range protocols { err := server.Register(p) if err != nil { if _, ok := err.(rpc.AlreadyRegisteredError); !ok { return err } } } // Using conn.GetClient() here would cause problematic // recursion. c := keybase1.NotifyCtlClient{Cli: rawClient} err := c.SetNotifications(ctx, keybase1.NotificationChannels{ Session: true, Users: true, }) if err != nil { return err } // Introduce ourselves. TODO: move this to SharedKeybaseConnection // somehow? configClient := keybase1.ConfigClient{Cli: rawClient} err = configClient.HelloIAm(ctx, keybase1.ClientDetails{ Pid: os.Getpid(), ClientType: keybase1.ClientType_KBFS, Argv: os.Args, Version: VersionString(), }) if err != nil { return err } return nil }
func NewIdentifyTrackUIProtocol(g *libkb.GlobalContext) rpc.Protocol { ui := g.UI.GetIdentifyTrackUI() return keybase1.IdentifyUiProtocol(&IdentifyUIServer{ui}) }
func NewIdentifyUIProtocol(g *libkb.GlobalContext) rpc.Protocol { return keybase1.IdentifyUiProtocol(&IdentifyUIServer{g.UI.GetIdentifyUI()}) }
func TestDelegateUI(t *testing.T) { tc := setupTest(t, "delegate_ui") tc1 := cloneContext(tc) tc2 := cloneContext(tc) // Make sure we're not using G anywhere in our tests. libkb.G.LocalDb = nil defer tc.Cleanup() stopCh := make(chan error) svc := service.NewService(tc.G, false) startCh := svc.GetStartChannel() go func() { err := svc.Run() if err != nil { t.Logf("Running the service produced an error: %v", err) } stopCh <- err }() // Wait for the server to start up <-startCh dui := newDelegateUI() launchDelegateUI := func(dui *delegateUI) error { cli, xp, err := client.GetRPCClientWithContext(tc2.G) if err != nil { return err } srv := rpc.NewServer(xp, nil) if err = srv.Register(keybase1.IdentifyUiProtocol(dui)); err != nil { return err } ncli := keybase1.DelegateUiCtlClient{Cli: cli} if err = ncli.RegisterIdentifyUI(context.TODO()); err != nil { return err } return nil } // Launch the delegate UI if err := launchDelegateUI(dui); err != nil { t.Fatal(err) } id := client.NewCmdIDRunner(tc1.G) id.SetUser("t_alice") id.UseDelegateUI() if err := id.Run(); err != nil { t.Errorf("Error in Run: %v", err) } // We should get either a 'done' or an 'error' from the delegateUI. err, ok := <-dui.ch if err != nil { t.Errorf("Error with delegate UI: %v", err) } else if ok { t.Errorf("Delegate UI didn't close the channel properly") } else if err = dui.checkSuccess(); err != nil { t.Error(err) } stopper := client.NewCmdCtlStopRunner(tc1.G) if err := stopper.Run(); err != nil { t.Errorf("Error in stopping service: %v", err) } // If the server failed, it's also an error if err := <-stopCh; err != nil { t.Fatal(err) } }
func NewIdentifyTrackUIProtocol() rpc.Protocol { ui := GlobUI.GetIdentifyTrackUI(true) return keybase1.IdentifyUiProtocol(&IdentifyUIServer{ui}) }
func NewIdentifyUIProtocol() rpc.Protocol { return keybase1.IdentifyUiProtocol(&IdentifyUIServer{GlobUI.GetIdentifyUI()}) }