Przykładowa implementacja serwera

server.go

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/reflection"
	"google.golang.org/grpc/status"
	pb "grpc-go-course/calculator"
	"io"
	"log"
	"math"
	"net"
)

const (
	port = ":50052"
)

type CalculatorServiceServer struct {
	pb.UnimplementedCalculatorServiceServer
}

func (*CalculatorServiceServer) Add(_ context.Context, req *pb.AddRequest) (*pb.AddResponse, error) {
	log.Printf("Received: %v", req)
	result := req.A + req.B
	return &pb.AddResponse{Result: result}, nil
}

func (*CalculatorServiceServer) Sum(_ context.Context, req *pb.SumRequest) (*pb.SumResponse, error) {
	log.Printf("Received: %v", req)
	var sum int64
	for _, v := range req.X {
		sum += v
	}
	return &pb.SumResponse{Result: sum}, nil
}

func (*CalculatorServiceServer) PrimeNumberDecomposition(req *pb.PrimeNumberDecompositionRequest, stream pb.CalculatorService_PrimeNumberDecompositionServer) error {
	fmt.Printf("Received PrimeNumberDecomposition: %v\n", req)
	k := int64(2)
	N := req.Number
	for N > 1 {
		if N%k == 0 {
			err := stream.Send(&pb.PrimeNumberDecompositionResponse{Number: k})
			if err != nil {
				return err
			}
			N /= k
		} else {
			k++
		}
	}
	return nil
}

func (*CalculatorServiceServer) ComputeAverage(stream pb.CalculatorService_ComputeAverageServer) error {
	fmt.Println("ComputeAverage function invoked")

	sum := int32(0)
	count := 0
	for {
		req, err := stream.Recv()
		if err == io.EOF {
			fmt.Println("Received EOF. Calculating and sending response")
			average := float64(sum) / float64(count)
			err := stream.SendAndClose(&pb.ComputeAverageResponse{Average: average})
			if err != nil {
				return err
			}
			break
		}
		if err != nil {
			log.Fatalf("Something fatal: %v", err)
		}
		sum += req.Number
		count++
	}
	return nil
}

func (*CalculatorServiceServer) FindMaximum(stream pb.CalculatorService_FindMaximumServer) error {
	fmt.Println("FindMaximum function invoked")

	max := int32(math.MinInt32)
	for {
		req, err := stream.Recv()
		if err == io.EOF {
			return nil
		}
		if err != nil {
			log.Fatalf("Error during receive: %v", err)
		}
		number := req.Number
		fmt.Printf("Received number: %v\n", number)
		if number > max {
			max = number
			fmt.Printf("Sending maximum value: %v\n", max)
			err := stream.Send(&pb.FindMaximumResponse{Maximum: max})
			if err != nil {
				log.Fatalf("Error while sending data to client: %v", err)
				return err
			}
		}
	}
	return nil
}

func (*CalculatorServiceServer) SquareRoot(_ context.Context, req *pb.SquareRootRequest) (*pb.SquareRootResponse, error) {
	fmt.Printf("SquareRoot function received: %v", req)
	number := req.Number
	if number < 0 {
		return nil, status.Errorf(codes.InvalidArgument, "Received negative number")
	}
	return &pb.SquareRootResponse{Value: math.Sqrt(float64(number))}, nil
}

func main() {
	fmt.Println("Hello gRPC (go CalculatorServiceServer)!")

	lis, err := net.Listen("tcp", port)
	if err != nil {
		log.Fatalf("Failed to listen: %v", err)
	}

	s := grpc.NewServer()
	pb.RegisterCalculatorServiceServer(s, &CalculatorServiceServer{})
	reflection.Register(s)

	if err := s.Serve(lis); err != nil {
		log.Fatalf("Failed to serve %v", err)
	}

}