git.zd.zone/hrpc/hrpc@v0.0.12/server/grpc.go (about)

     1  package server
     2  
     3  import (
     4  	"crypto/tls"
     5  	"fmt"
     6  	"net"
     7  
     8  	"git.zd.zone/hrpc/hrpc/client"
     9  	"git.zd.zone/hrpc/hrpc/filter"
    10  	"git.zd.zone/hrpc/hrpc/life"
    11  	"git.zd.zone/hrpc/hrpc/log"
    12  	"git.zd.zone/hrpc/hrpc/metrics"
    13  	"git.zd.zone/hrpc/hrpc/option"
    14  	"git.zd.zone/hrpc/hrpc/tracer"
    15  	grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
    16  	"google.golang.org/grpc"
    17  	"google.golang.org/grpc/credentials"
    18  )
    19  
    20  type HRPC struct {
    21  	server *grpc.Server
    22  	opts   *option.Options
    23  }
    24  
    25  // Run can be used in cron jobs.
    26  // It will make connections to the enabled databases without serving a port
    27  func (h HRPC) Run() error {
    28  	if err := h.makeDatabase(); err != nil {
    29  		return err
    30  	}
    31  	if err := h.makeMessageQueue(); err != nil {
    32  		return err
    33  	}
    34  	// enable all dependent clients
    35  	if err := client.Load(); err != nil {
    36  		return err
    37  	}
    38  	return nil
    39  }
    40  
    41  func (h HRPC) Serve() error {
    42  	defer func() {
    43  		if err := recover(); err != nil {
    44  			fmt.Println(err)
    45  		}
    46  	}()
    47  
    48  	lis, err := net.Listen("tcp", fmt.Sprintf("0.0.0.0:%d", h.opts.ListenPort))
    49  	if err != nil {
    50  		return err
    51  	}
    52  	// registeration
    53  	if err := registeration(
    54  		h.opts.ID, h.opts.ServerName, h.opts.ListenPort,
    55  		[]string{h.opts.ENV.String()},
    56  		h.opts.HealthCheck,
    57  	); err != nil {
    58  		return err
    59  	}
    60  
    61  	if h.opts.MetricsEnabled {
    62  		metrics.Run(Name())
    63  	}
    64  
    65  	go func() {
    66  		defer func() {
    67  			if err := recover(); err != nil {
    68  				fmt.Println(err)
    69  			}
    70  		}()
    71  		h.server.Serve(lis)
    72  	}()
    73  
    74  	h.opts.WhenExit = append(h.opts.WhenExit, func() {
    75  		deregisteration(h.opts.ID)
    76  		h.server.Stop()
    77  	})
    78  	h.opts.WhenRestart = append(h.opts.WhenRestart, func() {
    79  		deregisteration(h.opts.ID)
    80  		h.server.Stop()
    81  	})
    82  	life.WhenExit(h.opts.WhenExit...)
    83  	life.WhenRestart(h.opts.WhenRestart...)
    84  	life.Start()
    85  	return nil
    86  }
    87  
    88  func (h HRPC) Server() *grpc.Server {
    89  	return h.server
    90  }
    91  
    92  func grpcOption(opt *option.Options) ([]grpc.ServerOption, error) {
    93  	interceptors := []grpc.UnaryServerInterceptor{
    94  		tracer.AddTraceID,
    95  		log.AuditLog,
    96  	}
    97  	interceptors = append(interceptors, filter.ToInterceptors()...)
    98  	gopt := []grpc.ServerOption{
    99  		grpc.UnaryInterceptor(
   100  			grpc_middleware.ChainUnaryServer(
   101  				interceptors...,
   102  			),
   103  		),
   104  	}
   105  	if opt.ServerCerts != nil {
   106  		cert, err := tls.X509KeyPair(opt.ServerCerts.PubKey, opt.ServerCerts.PriKey)
   107  		if err != nil {
   108  			return nil, err
   109  		}
   110  		gopt = append(gopt, grpc.Creds(credentials.NewServerTLSFromCert(&cert)))
   111  	}
   112  	return gopt, nil
   113  }
   114  
   115  func NewHRPC(opt *option.Options) (Server, error) {
   116  	// set current environment
   117  	env = opt.ENV
   118  	name = opt.ServerName
   119  	gopt, err := grpcOption(opt)
   120  	if err != nil {
   121  		return nil, err
   122  	}
   123  	h := &HRPC{
   124  		server: grpc.NewServer(gopt...),
   125  		opts:   opt,
   126  	}
   127  	if err := h.makeDatabase(); err != nil {
   128  		return nil, err
   129  	}
   130  	if err := h.makeMessageQueue(); err != nil {
   131  		return nil, err
   132  	}
   133  	// enable all dependent clients
   134  	if err := client.Load(); err != nil {
   135  		return nil, err
   136  	}
   137  	return h, nil
   138  }