ultravioletrs · drasko · Dec 4, 2024 · Nov 1, 2024 · Dec 4, 2024 · Dec 4, 2024
diff --git a/cli/sdk.go b/cli/sdk.go
@@ -15,12 +15,12 @@
 
 type CLI struct {
 	agentSDK   sdk.SDK
-	config     grpc.Config
+	config     grpc.AgentClientConfig
 	client     grpc.Client
 	connectErr error
 }
 
-func New(config grpc.Config) *CLI {
+func New(config grpc.AgentClientConfig) *CLI {
 	return &CLI{
 		config: config,
 	}

diff --git a/cmd/agent/main.go b/cmd/agent/main.go
@@ -97,14 +97,18 @@ func main() {
 
 	svc := newService(ctx, logger, eventSvc, cfg, qp)
 
-	grpcServerConfig := server.Config{
-		Port:         cfg.AgentConfig.Port,
-		Host:         cfg.AgentConfig.Host,
-		CertFile:     cfg.AgentConfig.CertFile,
-		KeyFile:      cfg.AgentConfig.KeyFile,
-		ServerCAFile: cfg.AgentConfig.ServerCAFile,
-		ClientCAFile: cfg.AgentConfig.ClientCAFile,
-		AttestedTLS:  cfg.AgentConfig.AttestedTls,
+	agentGrpcServerConfig := server.AgentConfig{
+		ServerConfig: server.ServerConfig{
+			BaseConfig: server.BaseConfig{
+				Host:         cfg.AgentConfig.Host,
+				Port:         cfg.AgentConfig.Port,
+				CertFile:     cfg.AgentConfig.CertFile,
+				KeyFile:      cfg.AgentConfig.KeyFile,
+				ServerCAFile: cfg.AgentConfig.ServerCAFile,
+				ClientCAFile: cfg.AgentConfig.ClientCAFile,
+			},
+		},
+		AttestedTLS: cfg.AgentConfig.AttestedTls,
 	}
 
 	registerAgentServiceServer := func(srv *grpc.Server) {
@@ -119,7 +123,7 @@ func main() {
 		return
 	}
 
-	gs := grpcserver.New(ctx, cancel, svcName, grpcServerConfig, registerAgentServiceServer, logger, qp, authSvc)
+	gs := grpcserver.New(ctx, cancel, svcName, agentGrpcServerConfig, registerAgentServiceServer, logger, qp, authSvc)
 
 	g.Go(func() error {
 		for {

diff --git a/cmd/cli/main.go b/cmd/cli/main.go
@@ -91,7 +91,7 @@ func main() {
 		return
 	}
 
-	agentGRPCConfig := grpc.Config{}
+	agentGRPCConfig := grpc.AgentClientConfig{}
 	if err := env.ParseWithOptions(&agentGRPCConfig, env.Options{Prefix: envPrefixAgentGRPC}); err != nil {
 		message := color.New(color.FgRed).Sprintf("failed to load %s gRPC client configuration : %s", svcName, err)
 		rootCmd.Println(message)

diff --git a/cmd/manager/main.go b/cmd/manager/main.go
@@ -25,7 +25,7 @@ import (
 	"github.com/ultravioletrs/cocos/manager/events"
 	"github.com/ultravioletrs/cocos/manager/qemu"
 	"github.com/ultravioletrs/cocos/manager/tracing"
-	"github.com/ultravioletrs/cocos/pkg/clients/grpc"
+	pkggrpc "github.com/ultravioletrs/cocos/pkg/clients/grpc"
 	managergrpc "github.com/ultravioletrs/cocos/pkg/clients/grpc/manager"
 	"go.opentelemetry.io/otel/trace"
 	"golang.org/x/sync/errgroup"
@@ -92,7 +92,7 @@ func main() {
 	args := qemuCfg.ConstructQemuArgs()
 	logger.Info(strings.Join(args, " "))
 
-	managerGRPCConfig := grpc.Config{}
+	managerGRPCConfig := pkggrpc.ManagerClientConfig{}
 	if err := env.ParseWithOptions(&managerGRPCConfig, env.Options{Prefix: envPrefixGRPC}); err != nil {
 		logger.Error(fmt.Sprintf("failed to load %s gRPC client configuration : %s", svcName, err))
 		exitCode = 1

diff --git a/go.mod b/go.mod
@@ -1,8 +1,6 @@
 module github.com/ultravioletrs/cocos
 
-go 1.22.7
-
-toolchain go1.23.1
+go 1.23.0
 
 require (
 	github.com/absmach/magistrala v0.14.1-0.20240709113739-04c359462746

diff --git a/internal/server/grpc/grpc.go b/internal/server/grpc/grpc.go
@@ -60,8 +60,9 @@
 
 var _ server.Server = (*Server)(nil)
 
-func New(ctx context.Context, cancel context.CancelFunc, name string, config server.Config, registerService serviceRegister, logger *slog.Logger, qp client.QuoteProvider, authSvc auth.Authenticator) server.Server {
-	listenFullAddress := fmt.Sprintf("%s:%s", config.Host, config.Port)
+func New(ctx context.Context, cancel context.CancelFunc, name string, config server.ServerConfiguration, registerService serviceRegister, logger *slog.Logger, qp client.QuoteProvider, authSvc auth.Authenticator) server.Server {
+	base := config.GetBaseConfig()
+	listenFullAddress := fmt.Sprintf("%s:%s", base.Host, base.Port)
 	return &Server{
 		BaseServer: server.BaseServer{
 			Ctx:     ctx,
@@ -91,101 +92,98 @@
 
 	creds := grpc.Creds(insecure.NewCredentials())
 	var listener net.Listener = nil
+	switch c := s.Config.(type) {
+	case server.AgentConfig:
+		switch {
+		case c.AttestedTLS:
+			certificateBytes, privateKeyBytes, err := generateCertificatesForATLS()
+			if err != nil {
+				return fmt.Errorf("failed to create certificate: %w", err)
+			}
 
-	switch {
-	case s.Config.AttestedTLS:
-		certificateBytes, privateKeyBytes, err := generateCertificatesForATLS()
-		if err != nil {
-			return fmt.Errorf("failed to create certificate: %w", err)
-		}
-
-		certificate, err := tls.X509KeyPair(certificateBytes, privateKeyBytes)
-		if err != nil {
-			return fmt.Errorf("falied due to invalid key pair: %w", err)
-		}
-
-		tlsConfig := &tls.Config{
-			ClientAuth:   tls.NoClientCert,
-			Certificates: []tls.Certificate{certificate},
-		}
+			certificate, err := tls.X509KeyPair(certificateBytes, privateKeyBytes)
+			if err != nil {
+				return fmt.Errorf("falied due to invalid key pair: %w", err)
+			}
 
-		creds = grpc.Creds(credentials.NewTLS(tlsConfig))
+			tlsConfig := &tls.Config{
+				ClientAuth:   tls.NoClientCert,
+				Certificates: []tls.Certificate{certificate},
+			}
 
-		listener, err = atls.Listen(
-			s.Address,
-			certificateBytes,
-			privateKeyBytes,
-		)
-		if err != nil {
-			return fmt.Errorf("failed to create Listener for aTLS: %w", err)
-		}
-		s.Logger.Info(fmt.Sprintf("%s service gRPC server listening at %s with Attested TLS", s.Name, s.Address))
+			creds = grpc.Creds(credentials.NewTLS(tlsConfig))
 
-	case s.Config.CertFile != "" || s.Config.KeyFile != "":
-		certificate, err := loadX509KeyPair(s.Config.CertFile, s.Config.KeyFile)
-		if err != nil {
-			return fmt.Errorf("failed to load auth certificates: %w", err)
-		}
-		tlsConfig := &tls.Config{
-			ClientAuth:   tls.NoClientCert,
-			Certificates: []tls.Certificate{certificate},
-		}
+			listener, err = atls.Listen(
+				s.Address,
+				certificateBytes,
+				privateKeyBytes,
+			)
+			if err != nil {
+				return fmt.Errorf("failed to create Listener for aTLS: %w", err)
+			}
+			s.Logger.Info(fmt.Sprintf("%s service gRPC server listening at %s with Attested TLS", s.Name, s.Address))
 
-		var mtlsCA string
-		// Loading Server CA file
-		rootCA, err := loadCertFile(s.Config.ServerCAFile)
-		if err != nil {
-			return fmt.Errorf("failed to load root ca file: %w", err)
-		}
-		if len(rootCA) > 0 {
-			if tlsConfig.RootCAs == nil {
-				tlsConfig.RootCAs = x509.NewCertPool()
+		case c.CertFile != "" || c.KeyFile != "":
+			certificate, err := loadX509KeyPair(c.CertFile, c.KeyFile)
+			if err != nil {
+				return fmt.Errorf("failed to load auth certificates: %w", err)
 			}
-			if !tlsConfig.RootCAs.AppendCertsFromPEM(rootCA) {
-				return fmt.Errorf("failed to append root ca to tls.Config")
+			tlsConfig := &tls.Config{
+				ClientAuth:   tls.RequireAndVerifyClientCert,
+				Certificates: []tls.Certificate{certificate},
 			}
-			mtlsCA = fmt.Sprintf("root ca %s", s.Config.ServerCAFile)
-		}
 
-		// Loading Client CA File
-		clientCA, err := loadCertFile(s.Config.ClientCAFile)
-		if err != nil {
-			return fmt.Errorf("failed to load client ca file: %w", err)
-		}
-		if len(clientCA) > 0 {
-			if tlsConfig.ClientCAs == nil {
-				tlsConfig.ClientCAs = x509.NewCertPool()
+			var mtlsCA string
+			// Loading Server CA file
+			rootCA, err := loadCertFile(c.ServerCAFile)
+			if err != nil {
+				return fmt.Errorf("failed to load root ca file: %w", err)
 			}
-			if !tlsConfig.ClientCAs.AppendCertsFromPEM(clientCA) {
-				return fmt.Errorf("failed to append client ca to tls.Config")
+			if len(rootCA) > 0 {
+				if tlsConfig.RootCAs == nil {
+					tlsConfig.RootCAs = x509.NewCertPool()
+				}
+				if !tlsConfig.RootCAs.AppendCertsFromPEM(rootCA) {
+					return fmt.Errorf("failed to append root ca to tls.Config")
+				}
+				mtlsCA = fmt.Sprintf("root ca %s", c.ServerCAFile)
 			}
-			mtlsCA = fmt.Sprintf("%s client ca %s", mtlsCA, s.Config.ClientCAFile)
-		}
 
-		if mtlsCA != "" {
-			tlsConfig.ClientAuth = tls.RequireAndVerifyClientCert
-		}
+			// Loading Client CA File
+			clientCA, err := loadCertFile(c.ClientCAFile)
+			if err != nil {
+				return fmt.Errorf("failed to load client ca file: %w", err)
+			}
+			if len(clientCA) > 0 {
+				if tlsConfig.ClientCAs == nil {
+					tlsConfig.ClientCAs = x509.NewCertPool()
+				}
+				if !tlsConfig.ClientCAs.AppendCertsFromPEM(clientCA) {
+					return fmt.Errorf("failed to append client ca to tls.Config")
+				}
+				mtlsCA = fmt.Sprintf("%s client ca %s", mtlsCA, c.ClientCAFile)
+			}
+			creds = grpc.Creds(credentials.NewTLS(tlsConfig))
+			switch {
+			case mtlsCA != "":
+				s.Logger.Info(fmt.Sprintf("%s service gRPC server listening at %s with TLS/mTLS cert %s , key %s and %s", s.Name, s.Address, c.CertFile, c.KeyFile, mtlsCA))
+			default:
+				s.Logger.Info(fmt.Sprintf("%s service gRPC server listening at %s with TLS cert %s and key %s", s.Name, s.Address, c.CertFile, c.KeyFile))
+			}
 
-		creds = grpc.Creds(credentials.NewTLS(tlsConfig))
-		switch {
-		case mtlsCA != "":
-			s.Logger.Info(fmt.Sprintf("%s service gRPC server listening at %s with TLS/mTLS", s.Name, s.Address))
+			listener, err = net.Listen("tcp", s.Address)
+			if err != nil {
+				return fmt.Errorf("failed to listen on port %s: %w", s.Address, err)
+			}
 		default:
-			s.Logger.Info(fmt.Sprintf("%s service gRPC server listening at %s with TLS", s.Name, s.Address))
-		}
+			var err error
 
-		listener, err = net.Listen("tcp", s.Address)
-		if err != nil {
-			return fmt.Errorf("failed to listen on port %s: %w", s.Address, err)
-		}
-	default:
-		var err error
-
-		listener, err = net.Listen("tcp", s.Address)
-		if err != nil {
-			return fmt.Errorf("failed to listen on port %s: %w", s.Address, err)
+			listener, err = net.Listen("tcp", s.Address)
+			if err != nil {
+				return fmt.Errorf("failed to listen on port %s: %w", s.Address, err)
+			}
+			s.Logger.Info(fmt.Sprintf("%s service gRPC server listening at %s without TLS", s.Name, s.Address))
 		}
-		s.Logger.Info(fmt.Sprintf("%s service gRPC server listening at %s without TLS", s.Name, s.Address))
 	}
 
 	grpcServerOptions = append(grpcServerOptions, creds)