func (d *Service) Handle(c net.Conn) {
xp := rpc.NewTransport(c, libkb.NewRPCLogFactory(), libkb.WrapError)
server := rpc.NewServer(xp, libkb.WrapError)
cl := make(chan error)
server.AddCloseListener(cl)
connID := d.G().NotifyRouter.AddConnection(xp, cl)
var logReg *logRegister
if d.isDaemon {
// Create a new log register object that the Log handler can use to
// register a logger. When this function finishes, the logger
// will be removed.
logReg = newLogRegister(d.logForwarder, d.G().Log)
defer logReg.UnregisterLogger()
}
if err := d.RegisterProtocols(server, xp, connID, logReg, d.G()); err != nil {
d.G().Log.Warning("RegisterProtocols error: %s", err)
return
}
if err := server.Run(false /* bg */); err != nil {
if err != io.EOF {
d.G().Log.Warning("Run error: %s", err)
}
}
d.G().Log.Debug("Handle() complete for connection %d", connID)
}
func (d *Service) Handle(c net.Conn) {
xp := rpc.NewTransport(c, libkb.NewRPCLogFactory(), libkb.WrapError)
server := rpc.NewServer(xp, libkb.WrapError)
cl := make(chan error)
server.AddCloseListener(cl)
connID := d.G().NotifyRouter.AddConnection(xp, cl)
if err := d.RegisterProtocols(server, xp, connID, d.G()); err != nil {
d.G().Log.Warning("RegisterProtocols error: %s", err)
return
}
if d.isDaemon {
baseHandler := NewBaseHandler(xp)
logUI := LogUI{sessionID: 0, cli: baseHandler.getLogUICli()}
handle := d.G().Log.AddExternalLogger(&logUI)
defer d.G().Log.RemoveExternalLogger(handle)
}
if err := server.Run(false /* bg */); err != nil {
if err != io.EOF {
d.G().Log.Warning("Run error: %s", err)
}
}
}
// Dial is an implementation of the ConnectionTransport interface.
func (ct *ConnectionTransportTLS) Dial(ctx context.Context) (
rpc.Transporter, error) {
var conn net.Conn
err := runUnlessCanceled(ctx, func() error {
// load CA certificate
certs := x509.NewCertPool()
if !certs.AppendCertsFromPEM(ct.rootCerts) {
return errors.New("Unable to load root certificates")
}
// connect
config := tls.Config{RootCAs: certs}
var err error
conn, err = tls.Dial("tcp", ct.srvAddr, &config)
return err
})
if err != nil {
return nil, err
}
transport := rpc.NewTransport(conn, libkb.NewRPCLogFactory(), libkb.WrapError)
ct.mutex.Lock()
defer ct.mutex.Unlock()
ct.conn = conn
ct.stagedTransport = transport
return transport, nil
}
func (t *connTransport) Dial(context.Context) (rpc.Transporter, error) {
var err error
t.conn, err = net.Dial("tcp", t.host)
if err != nil {
return nil, err
}
t.stagedTransport = rpc.NewTransport(t.conn, libkb.NewRPCLogFactory(t.G()), libkb.WrapError)
return t.stagedTransport, nil
}
func (d *Service) Handle(c net.Conn) {
xp := rpc.NewTransport(c, libkb.NewRPCLogFactory(d.G()), libkb.WrapError)
server := rpc.NewServer(xp, libkb.WrapError)
cl := make(chan error, 1)
connID := d.G().NotifyRouter.AddConnection(xp, cl)
var logReg *logRegister
if d.isDaemon {
// Create a new log register object that the Log handler can use to
// register a logger. When this function finishes, the logger
// will be removed.
logReg = newLogRegister(d.logForwarder, d.G().Log)
defer logReg.UnregisterLogger()
}
shutdowners, err := d.RegisterProtocols(server, xp, connID, logReg, d.G())
var shutdownOnce sync.Once
shutdown := func() error {
shutdownOnce.Do(func() {
for _, shutdowner := range shutdowners {
shutdowner.Shutdown()
}
})
return nil
}
// Clean up handlers when the connection closes.
defer shutdown()
// Make sure shutdown is called when service shuts down but the connection
// isn't closed yet.
d.G().PushShutdownHook(shutdown)
if err != nil {
d.G().Log.Warning("RegisterProtocols error: %s", err)
return
}
// Run the server and wait for it to finish.
<-server.Run()
// err is always non-nil.
err = server.Err()
cl <- err
if err != io.EOF {
d.G().Log.Warning("Run error: %s", err)
}
d.G().Log.Debug("Handle() complete for connection %d", connID)
}
// NewMDServerRemote returns a new instance of MDServerRemote.
func NewMDServerRemote(config Config, srvAddr string) *MDServerRemote {
mdServer := &MDServerRemote{
config: config,
observers: make(map[TlfID]chan<- error),
log: config.MakeLogger(""),
rekeyTimer: time.NewTimer(MdServerBackgroundRekeyPeriod),
}
mdServer.authToken = NewAuthToken(config,
MdServerTokenServer, MdServerTokenExpireIn,
"libkbfs_mdserver_remote", mdServer)
conn := rpc.NewTLSConnection(srvAddr, GetRootCerts(srvAddr),
MDServerErrorUnwrapper{}, mdServer, true,
libkb.NewRPCLogFactory(libkb.G), libkb.WrapError,
config.MakeLogger(""), LogTagsFromContext)
mdServer.conn = conn
mdServer.client = keybase1.MetadataClient{Cli: conn.GetClient()}
// Check for rekey opportunities periodically.
rekeyCtx, rekeyCancel := context.WithCancel(context.Background())
mdServer.rekeyCancel = rekeyCancel
go mdServer.backgroundRekeyChecker(rekeyCtx)
return mdServer
}
func (g *gregorHandler) connectTLS(uri *rpc.FMPURI) error {
g.Debug("connecting to gregord via TLS at %s", uri)
rawCA := g.G().Env.GetBundledCA(uri.Host)
if len(rawCA) == 0 {
return fmt.Errorf("No bundled CA for %s", uri.Host)
}
g.Debug("Using CA for gregor: %s", libkb.ShortCA(rawCA))
g.connMutex.Lock()
g.conn = rpc.NewTLSConnection(uri.HostPort, []byte(rawCA), keybase1.ErrorUnwrapper{}, g, true, libkb.NewRPCLogFactory(g.G()), keybase1.WrapError, g.G().Log, nil)
g.connMutex.Unlock()
// The client we get here will reconnect to gregord on disconnect if necessary.
// We should grab it here instead of in OnConnect, since the connection is not
// fully established in OnConnect. Anything that wants to make calls outside
// of OnConnect should use g.cli, everything else should the client that is
// a paramater to OnConnect
g.cli = g.conn.GetClient()
// Start up ping loop to keep the connection to gregord alive, and to kick
// off the reconnect logic in the RPC library
go g.pingLoop()
return nil
}
