Skip to content
Snippets Groups Projects
rueckfrage_router.go 4.33 KiB
Newer Older
  • Learn to ignore specific revisions
  • /*
     * Copyright (C) 2023-2024
     * Das Land Schleswig-Holstein vertreten durch den
     * Ministerpräsidenten des Landes Schleswig-Holstein
     * Staatskanzlei
     * Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
     *
     * Lizenziert unter der EUPL, Version 1.2 oder - sobald
     * diese von der Europäischen Kommission genehmigt wurden -
     * Folgeversionen der EUPL ("Lizenz");
     * Sie dürfen dieses Werk ausschließlich gemäß
     * dieser Lizenz nutzen.
     * Eine Kopie der Lizenz finden Sie hier:
     *
     * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
     *
     * Sofern nicht durch anwendbare Rechtsvorschriften
     * gefordert oder in schriftlicher Form vereinbart, wird
     * die unter der Lizenz verbreitete Software "so wie sie
     * ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
     * ausdrücklich oder stillschweigend - verbreitet.
     * Die sprachspezifischen Genehmigungen und Beschränkungen
     * unter der Lizenz sind dem Lizenztext zu entnehmen.
     */
    
    package server
    
    import (
    	pb "antragsraum-proxy/gen/go"
    	"antragsraum-proxy/internal/config"
    	"antragsraum-proxy/internal/mock"
    	"context"
    	"errors"
    	"fmt"
    	"google.golang.org/grpc"
    	"google.golang.org/grpc/codes"
    	"google.golang.org/grpc/credentials/insecure"
    	"google.golang.org/grpc/metadata"
    	"google.golang.org/grpc/status"
    	"net"
    )
    
    type rueckfrageRouter struct {
    	pb.UnimplementedAntragraumServiceServer
    }
    
    func (s *rueckfrageRouter) FindRueckfragen(ctx context.Context, in *pb.GrpcFindRueckfragenRequest) (*pb.GrpcFindRueckfragenResponse, error) {
    	response, err := s.handleRequest(ctx, func(client pb.AntragraumServiceClient, ctx context.Context) (interface{}, error) {
    		return client.FindRueckfragen(ctx, in)
    	})
    
    	return response.(*pb.GrpcFindRueckfragenResponse), err
    }
    
    func (s *rueckfrageRouter) GetRueckfrage(ctx context.Context, in *pb.GrpcGetRueckfrageRequest) (*pb.GrpcGetRueckfrageResponse, error) {
    	response, err := s.handleRequest(ctx, func(client pb.AntragraumServiceClient, ctx context.Context) (interface{}, error) {
    		return client.GetRueckfrage(ctx, in)
    	})
    
    	return response.(*pb.GrpcGetRueckfrageResponse), err
    }
    
    func (s *rueckfrageRouter) SendRueckfrageAnswer(ctx context.Context, in *pb.GrpcSendRueckfrageAnswerRequest) (*pb.GrpcSendRueckfrageAnswerResponse, error) {
    	response, err := s.handleRequest(ctx, func(client pb.AntragraumServiceClient, ctx context.Context) (interface{}, error) {
    		return client.SendRueckfrageAnswer(ctx, in)
    	})
    
    	return response.(*pb.GrpcSendRueckfrageAnswerResponse), err
    }
    
    func (s *rueckfrageRouter) handleRequest(ctx context.Context, handler func(pb.AntragraumServiceClient, context.Context) (interface{}, error)) (interface{}, error) {
    	md, ok := metadata.FromIncomingContext(ctx)
    	if !ok {
    		return nil, status.Error(codes.InvalidArgument, "unable to retrieve metadata")
    	}
    
    	grpcAddress := md.Get("x-grpc-address")
    	if len(grpcAddress) == 0 {
    		return nil, status.Error(codes.InvalidArgument, "grpc address is missing")
    	}
    
    	client, connCleanUp, err := createRueckfrageClient(grpcAddress[0])
    	if err != nil {
    		return nil, status.Error(codes.Internal, err.Error())
    	}
    	defer connCleanUp()
    
    	return handler(client, ctx)
    }
    
    func createRueckfrageClient(rueckfrageServerAddress string) (pb.AntragraumServiceClient, func() error, error) {
    	target := GetRueckfrageServerUrl(rueckfrageServerAddress, conf)
    	conn, err := grpc.NewClient(target, grpc.WithTransportCredentials(insecure.NewCredentials()))
    	if err != nil {
    		logger.Error("rueckfrage router failed to route: %v", err)
    
    		return nil, nil, errors.New("rueckfrage router failed to route")
    	}
    
    	return pb.NewAntragraumServiceClient(conn), conn.Close, nil
    }
    
    func GetRueckfrageServerUrl(rueckfrageServerAddress string, c config.Config) string {
    	rueckfrageServerPort := c.Grpc.Server.Port
    	if c.Grpc.Server.Mock {
    		rueckfrageServerPort = mock.GrpcMockPort
    	}
    
    	return fmt.Sprintf("%v:%d", rueckfrageServerAddress, rueckfrageServerPort)
    }
    
    func StartRueckfrageRouter() *grpc.Server {
    	s := grpc.NewServer()
    	pb.RegisterAntragraumServiceServer(s, &rueckfrageRouter{})
    
    	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", conf.Grpc.Router.Rueckfragen.Port))
    	if err != nil {
    		logger.Fatal("rueckfrage router failed to listen: %v", err)
    	}
    	logger.Info("rueckfrage router listening on port %d", conf.Grpc.Router.Rueckfragen.Port)
    
    	if err := s.Serve(lis); err != nil {
    		logger.Fatal("rueckfrage router failed to serve: %v", err)
    	}
    
    	return s
    }