package server
import (
"context"
"time"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
pb "github.com/myapp/gen/order/v1"
)
type OrderServer struct {
pb.UnimplementedOrderServiceServer
store OrderStore
}
func (s *OrderServer) GetOrder(ctx context.Context, req *pb.GetOrderRequest) (*pb.GetOrderResponse, error) {
if req.OrderId == "" {
return nil, status.Error(codes.InvalidArgument, "order_id is required")
}
if deadline, ok := ctx.Deadline(); ok {
if time.Until(deadline) < 100*time.Millisecond {
return nil, status.Error(codes.DeadlineExceeded, "insufficient time remaining")
}
}
order, err := s.store.GetByID(ctx, req.OrderId)
if err != nil {
if errors.Is(err, ErrNotFound) {
return nil, status.Error(codes.NotFound, "order not found")
}
return nil, status.Error(codes.Internal, "failed to fetch order")
}
return &pb.GetOrderResponse{Order: order}, nil
}
func (s *OrderServer) WatchOrderStatus(
req *pb.WatchOrderStatusRequest,
stream pb.OrderService_WatchOrderStatusServer,
) error {
ctx := stream.Context()
ch := s.store.WatchStatus(ctx, req.OrderId)
for {
select {
case <-ctx.Done():
return status.Error(codes.Cancelled, "client disconnected")
case event, ok := <-ch:
if !ok {
return nil
}
if err := stream.Send(event); err != nil {
return err
}
}
}
}
import (
"google.golang.org/grpc"
"google.golang.org/grpc/metadata"
)
func loggingInterceptor(
ctx context.Context,
req interface{},
info *grpc.UnaryServerInfo,
handler grpc.UnaryHandler,
) (interface{}, error) {
start := time.Now()
resp, err := handler(ctx, req)
duration := time.Since(start)
code := status.Code(err)
log.Info("grpc request",
"method", info.FullMethod,
"code", code,
"duration_ms", duration.Milliseconds(),
)
grpcRequestDuration.WithLabelValues(info.FullMethod, code.String()).Observe(duration.Seconds())
grpcRequestTotal.WithLabelValues(info.FullMethod, code.String()).Inc()
return resp, err
}
func authInterceptor(
ctx context.Context,
req interface{},
info *grpc.UnaryServerInfo,
handler grpc.UnaryHandler,
) (interface{}, error) {
if info.FullMethod == "/grpc.health.v1.Health/Check" {
return handler(ctx, req)
}
md, ok := metadata.FromIncomingContext(ctx)
if !ok {
return nil, status.Error(codes.Unauthenticated, "missing metadata")
}
tokens := md.Get("authorization")
if len(tokens) == 0 {
return nil, status.Error(codes.Unauthenticated, "missing token")
}
user, err := validateToken(tokens[0])
if err != nil {
return nil, status.Error(codes.Unauthenticated, "invalid token")
}
ctx = context.WithValue(ctx, userKey, user)
return handler(ctx, req)
}
server := grpc.NewServer(
grpc.ChainUnaryInterceptor(
recoveryInterceptor,
loggingInterceptor,
authInterceptor,
rateLimitInterceptor,
),
)
import (
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
grpcRetry "github.com/grpc-ecosystem/go-grpc-middleware/retry"
)
func newOrderClient(addr string) (pb.OrderServiceClient, error) {
conn, err := grpc.Dial(addr,
grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithChainUnaryInterceptor(
grpcRetry.UnaryClientInterceptor(
grpcRetry.WithMax(3),
grpcRetry.WithBackoff(grpcRetry.BackoffExponential(100*time.Millisecond)),
grpcRetry.WithCodes(codes.Unavailable, codes.ResourceExhausted),
),
),
)
if err != nil {
return nil, err
}
return pb.NewOrderServiceClient(conn), nil
}
func getOrder(client pb.OrderServiceClient, orderID string) (*pb.Order, error) {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
resp, err := client.GetOrder(ctx, &pb.GetOrderRequest{OrderId: orderID})
if err != nil {
return nil, fmt.Errorf("get order %s: %w", orderID, err)
}
return resp.Order, nil
}