grpc_router.go

/*
 * 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 (
	"context"
	"encoding/base64"
	"errors"
	pb "fachstellen-proxy/gen/go"
	"fachstellen-proxy/internal/config"
	"fachstellen-proxy/internal/mock"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/credentials/insecure"
	"google.golang.org/grpc/status"
	"net"
	"strings"
)

const AddressAttributeSeparator = "/"

type collaborationRouter struct {
	pb.UnimplementedCollaborationServiceServer
}

func (s *collaborationRouter) FindVorgang(ctx context.Context, in *pb.GrpcFindVorgangRequest) (*pb.GrpcFindVorgangResponse, error) {
	if in.VorgangId == "" {
		return nil, status.Error(codes.InvalidArgument, "VorgangId is missing")
	}

	collaborationInfo, decodeErr := DecodeCollaborationInfo(in.VorgangId)
	if decodeErr != nil {
		return nil, status.Error(codes.InvalidArgument, "VorgangId has invalid format, expected base64 encoded 'collaborationServerAddress/vorgangId'")
	}

	client, connCleanUp := createCollaborationClient(collaborationInfo.CollaborationServerAddress)
	defer connCleanUp()
	updatedRequest := &pb.GrpcFindVorgangRequest{VorgangId: collaborationInfo.Attribute, SamlToken: in.SamlToken}

	return client.FindVorgang(context.Background(), updatedRequest)
}

type CollaborationInfo struct {
	CollaborationServerAddress string
	Attribute                  string
}

func DecodeCollaborationInfo(encodedCollaborationInfo string) (*CollaborationInfo, error) {
	decodedBytes, err := base64.StdEncoding.DecodeString(encodedCollaborationInfo)
	if err != nil {
		return nil, errors.New("collaborationInfo has invalid base64 encoding")
	}

	parts := strings.SplitN(string(decodedBytes), AddressAttributeSeparator, 2)
	if len(parts) != 2 {
		return nil, errors.New("collaborationInfo has invalid format, expected 'collaborationServerAddress/attribute'")
	}

	return &CollaborationInfo{
		CollaborationServerAddress: parts[0],
		Attribute:                  parts[1],
	}, nil
}

func createCollaborationClient(collaborationServerAddress string) (pb.CollaborationServiceClient, func()) {
	target := GetCollaborationServerUrl(collaborationServerAddress, conf)
	conn, err := grpc.NewClient(target, grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		logger.Fatal("collaboration router failed to route: %v", err)
	}

	client := pb.NewCollaborationServiceClient(conn)
	connCleanUp := func() {
		conn.Close()
	}

	return client, connCleanUp
}

func GetCollaborationServerUrl(collaborationServerAddress string, c config.Config) string {
	collaborationServerPort := c.Grpc.Collaboration.Server.Port
	if c.Grpc.Mock {
		collaborationServerPort = mock.GrpcMockPort
	}

	return fmt.Sprintf("%v:%d", collaborationServerAddress, collaborationServerPort)
}

func StartCollaborationRouter() *grpc.Server {
	s := grpc.NewServer()
	pb.RegisterCollaborationServiceServer(s, &collaborationRouter{})

	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", conf.Grpc.Collaboration.Router.Port))
	if err != nil {
		logger.Fatal("collaboration router failed to listen: %v", err)
	}

	logger.Info("collaboration router listening on port %d", conf.Grpc.Collaboration.Router.Port)
	if err := s.Serve(lis); err != nil {
		logger.Fatal("collaboration router failed to serve: %v", err)
	}

	return s
}