gRPC-gateway

type User struct {
	Mail				string	`json:"mail"`
	Username			string	`json:"name"`
}

// store.go
type RedisValue interface {
	MarshalBinary() ([]byte, error)
	UnmarshalBinary(data[]byte) error
}

type UserStore interface {
	Save(key string, value RedisValue) error
	Find(key string) (interface{},error)
}

type GrpcServer struct {
	server *grpc.Server
	userStore store.UserStore
	logger *logrus.Entry
}

func NewGrpcServer(serverCrt string, serverKey string, userStore store.UserStore , opts ...grpc.ServerOption) (*GrpcServer , error) {
	if serverCrt == "" || serverKey == "" {
		return nil, errors.New("Server certificate path needed.")
	}

	cred, tlsErr := credentials.NewServerTLSFromFile(serverCrt, serverKey)

	if tlsErr != nil {
		return nil, tlsErr
	}

	opts = append(opts, grpc.Creds(cred))

	return &GrpcServer{
		server: grpc.NewServer(opts...),
		userStore: userStore,
		logger: logrus.WithFields(logrus.Fields{
			"Name": "gRPC-Server",
		}),
	}, nil
}

// CheckEnrollment Service
// which checks user enrollemnt.
func (gs *GrpcServer) CheckEnrollment(ctx context.Context, req *pb.CheckEnrollmentRequest) (*pb.CommonResponseMsg, error) {
	v, err := gs.userStore.Find(req.Mail)
	if err != nil {
		se, _ := err.(*store.StoreError)
		if se.Code == store.ErrNoConnWithRedis {
			gs.logger.Fatal("No Connection with redis.")
			return nil, status.Error(codes.Internal, "Internal Error")
		} else if se.Code == store.ErrKeyNotExists {
			return nil, status.Error(codes.NotFound, "Mail Not Found")
		} else {
			// No matched StoreError here.
		}
	}

	asserted, ok := v.(*redis.StringCmd)
	if !ok {
		return nil, status.Error(codes.Internal, "Marshal/Unmarshal error")
	}

	unmarshaled, err := asserted.Bytes()
	if err != nil {
		return nil, status.Error(codes.Internal, "Marshal/Unmarshal error")
	}

	user := &User{}
	err = json.Unmarshal(unmarshaled, user)
	if err != nil {
		return nil, status.Error(codes.Internal, "Marshal/Unmarshal error")
	}

	if user.Username != req.Name {
		return nil, status.Error(codes.NotFound, "No mathches with request")
	}

	result := &pb.CommonResponseMsg{
		Message: req.Mail + " is verified.",
	}
	return result, nil
}

func (gs *GrpcServer) Enroll(ctx context.Context, req *pb.EnrollmentRequest) (*pb.CommonResponseMsg, error) {
	err := gs.userStore.Save(req.Mail, NewUser(req.Name,req.Mail))
	if err != nil {
		se, _ := err.(*store.StoreError)
		if se.Code == store.ErrKeyExistsAlready {
			return nil, status.Error(codes.AlreadyExists, "The mail is already enrolled.")
		} else if se.Code == store.ErrNoConnWithRedis {
			gs.logger.Fatal("No Connection with redis.")
			return nil, status.Error(codes.Internal, "Internal Error")
		} else {
			return nil, status.Error(codes.Internal, "Internal Error")
		}
	}
	result := &pb.CommonResponseMsg{Message: "Enrolled successfully"}
	return result, nil
}

func serverInterceptor (ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
	p, ok := peer.FromContext(ctx)
	if ok {
		interceptorLogger.Infof("Request from %s",p.Addr.String())
	}
	h, err := handler(ctx, req)
	// handle을 gRPC 서버로 넘기고, 받음

	if ok {
		interceptorLogger.Infof("Response to %s", p.Addr.String())
	}
	return h, err
}

type User struct {
	Mail				string	`json:"mail"`
	Username			string	`json:"name"`
}

func NewUser(username string, mail string) *User {
	return &User {
		Username: username,
		Mail: mail,
	}
}

func (u *User) MarshalBinary() ([]byte, error) {
	return json.Marshal(u)
}

func (u *User) UnmarshalBinary(data []byte) error {
	return json.Unmarshal(data, u)
}

func NewGateway(ctx context.Context, opts ...runtime.ServeMuxOption) (http.Handler, error) {
	mux := runtime.NewServeMux(opts...) // + runtime.WithMarshalerOption()
	grpcDialOpts := []grpc.DialOption{}

	if cred, err := credentials.NewClientTLSFromFile(grpcServerCert,""); err == nil {
		grpcDialOpts = append(grpcDialOpts, grpc.WithTransportCredentials(cred))
	} else {
		return nil, err
	}

	err := gw.RegisterEnrollmentHandlerFromEndpoint(ctx, mux, *getEndpoint, grpcDialOpts)
	if err != nil {
		return nil, errors.New("grpc Gateway : `GET` error")
	}

	err = gw.RegisterEnrollmentHandlerFromEndpoint(ctx, mux, *postEndpoint,grpcDialOpts)
	if err != nil {
		return nil, errors.New("grpc Gateway : `POST error")
	}

	return mux, nil
}

func Serve(address string, opts ...runtime.ServeMuxOption) error {
	ctx := context.Background()
	ctx, cancel := context.WithCancel(ctx)
	defer cancel()

	mux := http.NewServeMux()

	mux.HandleFunc("/swagger/", swaggerHandler)
	//opts = append(opts, runtime.WithProtoErrorHandler(runtime.DefaultHTTPProtoErrorHandler))
	gwHandler, err := NewGateway(ctx, opts...)
	if err != nil {
		return err
	}

	mux.Handle("/", gwHandler)

	return http.ListenAndServeTLS(address, gwCert, gwKey, allowCORS(mux))
}