func main() {
sig := runOutput()
on := fmt.Sprintf(":%d", comm.Port())
cert, err := tls.X509KeyPair(comm.Cert(), comm.Key())
if err != nil {
log.Fatal("failed to load cert and key", err)
}
creds := credentials.NewServerTLSFromCert(&cert)
s := grpc.NewServer(
grpc.Creds(creds),
)
svr := &server{sig: sig}
comm.RegisterGarageServer(s, svr)
listener, err := net.Listen("tcp", on)
if err != nil {
log.Fatal("failed to listen", err)
}
err = s.Serve(listener)
if err != nil {
log.Fatal("failed to serve", err)
}
}
func startRPCServers(walletLoader *wallet.Loader) (*grpc.Server, *legacyrpc.Server, error) {
var (
server *grpc.Server
legacyServer *legacyrpc.Server
legacyListen = net.Listen
keyPair tls.Certificate
err error
)
if cfg.DisableServerTLS {
log.Info("Server TLS is disabled. Only legacy RPC may be used")
} else {
keyPair, err = openRPCKeyPair()
if err != nil {
return nil, nil, err
}
// Change the standard net.Listen function to the tls one.
tlsConfig := &tls.Config{
Certificates: []tls.Certificate{keyPair},
MinVersion: tls.VersionTLS12,
NextProtos: []string{"h2"}, // HTTP/2 over TLS
}
legacyListen = func(net string, laddr string) (net.Listener, error) {
return tls.Listen(net, laddr, tlsConfig)
}
if len(cfg.ExperimentalRPCListeners) != 0 {
listeners := makeListeners(cfg.ExperimentalRPCListeners, net.Listen)
if len(listeners) == 0 {
err := errors.New("failed to create listeners for RPC server")
return nil, nil, err
}
creds := credentials.NewServerTLSFromCert(&keyPair)
server = grpc.NewServer(grpc.Creds(creds))
rpcserver.StartWalletLoaderService(server, walletLoader, activeNet)
for _, lis := range listeners {
lis := lis
go func() {
log.Infof("Experimental RPC server listening on %s",
lis.Addr())
err := server.Serve(lis)
log.Tracef("Finished serving expimental RPC: %v",
err)
}()
}
}
}
if cfg.Username == "" || cfg.Password == "" {
log.Info("Legacy RPC server disabled (requires username and password)")
} else if len(cfg.LegacyRPCListeners) != 0 {
listeners := makeListeners(cfg.LegacyRPCListeners, legacyListen)
if len(listeners) == 0 {
err := errors.New("failed to create listeners for legacy RPC server")
return nil, nil, err
}
opts := legacyrpc.Options{
Username: cfg.Username,
Password: cfg.Password,
MaxPOSTClients: cfg.LegacyRPCMaxClients,
MaxWebsocketClients: cfg.LegacyRPCMaxWebsockets,
}
legacyServer = legacyrpc.NewServer(&opts, walletLoader, listeners)
}
// Error when neither the GRPC nor legacy RPC servers can be started.
if server == nil && legacyServer == nil {
return nil, nil, errors.New("no suitable RPC services can be started")
}
return server, legacyServer, nil
}