event

var RunCmd = &cobra.Command{
	Use:   "event",
	Short: "",
	Long:  ``,
	Run: func(cmd *cobra.Command, args []string) {
		defer log.Flush()
		defer func() {
			if r := recover(); r != nil {

				err, ok := r.(error)
				if !ok {
					err = fmt.Errorf("unknown error: %v", r)
				}
				log.Err(err).Panic("unknown error")
			}
		}()

		config.EnvPrefix = "STARTER"
		cfg := config.New("app.yml")
		err := initialize(cfg)
		if err != nil {
			log.Fatalf("main: initialize failed: %v", err)
			return
		}

		fn := cfg.InitTracer("event")
		defer fn()

		lis, err := net.Listen("tcp", cfg.Event.GRPCBind)
		if err != nil {
			log.Fatalf("main: failed to grpc listen: %v", err)
		}

		grpcServer := grpc.NewServer(
			grpc.KeepaliveParams(
				keepalive.ServerParameters{
					Time:    (time.Duration(5) * time.Second),
					Timeout: (time.Duration(5) * time.Second),
				},
			),
			grpc.KeepaliveEnforcementPolicy(
				keepalive.EnforcementPolicy{
					MinTime:             (time.Duration(2) * time.Second),
					PermitWithoutStream: true,
				},
			),
			grpc.ChainUnaryInterceptor(
				otelgrpc.UnaryServerInterceptor(),
				eventGRPC.Interceptor(),
			),
			grpc.StreamInterceptor(otelgrpc.StreamServerInterceptor()),
		)
		eventProto.RegisterEventServiceServer(grpcServer, _eventServer)
		log.Infof("event grpc service listen on %s", cfg.Event.GRPCBind)
		go func() {
			if err = grpcServer.Serve(lis); err != nil {
				log.Fatalf("main: failed to start agent order grpc server: %v", err)
			}
		}()

		stopChan := make(chan os.Signal, 1)
		signal.Notify(stopChan, syscall.SIGINT, syscall.SIGKILL, syscall.SIGHUP, syscall.SIGTERM)
		<-stopChan
		log.Info("main: shutting down server...")

		grpcServer.GracefulStop()
		log.Info("main: event grpc server gracefully stopped")

	},
}