feat(service): add a config package to load application configuration using Viper

service/configs/espressoconfig.yaml

@@ -1,3 +1,9 @@
+app:
+  log_level: "debug"
+  server_port: 8081
+  enable_ui: true
+  rod_browser_bin: "/opt/homebrew/bin/chromium"
+
 template_storage:
   storage_type: "mysql"
 
@@ -9,37 +15,37 @@ browser:
 
 workerpool:
   worker_count: 6
-  worker_timeout: 310 # milliseconds
+  worker_timeout_ms: 310 # milliseconds
 
 s3:
   endpoint: "http://localstack:4566"
   debug: false
   region: "us-west-2"
-  forcePathStyle: true
-  uploaderConcurrency: 5
+  force_path_style: true
+  uploader_concurrency: 5
   # 5MB chunks
-  uploaderPartSize: 5
-  downloaderConcurrency: 5
+  uploader_part_size_mb: 5
+  downloader_concurrency: 5
   # 5MB chunks
-  downloaderPartSize: 5242880
-  retryMaxAttempts: 3
+  downloader_part_size_mb: 5242880
+  retry_max_attempts: 3
   bucket: "local-bucket"
-  useCustomTransport: false
+  use_custom_transport: false
 
 aws:
-  accessKeyID: "xxxxx-xxxxx-xxxxx-xxxxx-xxxxx"
-  secretAccessKey: "xxxxx-xxxxx-xxxxx-xxxxx-xxxxx"
-  sessionToken: ""
+  access_key_id: "xxxxx-xxxxx-xxxxx-xxxxx-xxxxx"
+  secret_access_key: "xxxxx-xxxxx-xxxxx-xxxxx-xxxxx"
+  session_token: ""
 
-digital_certificates:
+certificates:
   cert1:
-    cert_filepath: "./inputfiles/certificates/cert.pem"
-    key_filepath: "./inputfiles/certificates/key_pkcs8_encrypted.pem"
+    cert_file_path: "./inputfiles/certificates/cert.pem"
+    key_file_path: "./inputfiles/certificates/key_pkcs8_encrypted.pem"
     key_password: "test"
-  cert2:
-    cert_filepath: "./certificates/certificate2.pem"
-    key_filepath: "./certificates/pirvatekey2.key"
-    key_password: "password2"
 
-mysql:
-  dsn: "pdf_user:pdf_password@tcp(mysql:3306)/pdf_templates?parseTime=true"
+db:
+  host: "mysql"
+  port: 3306
+  username: "pdf_user"
+  password: "pdf_password"
+  database: "pdf_templates"

service/controller/pdf_generation/pdf_generation.go

@@ -14,7 +14,6 @@ import (
 	"github.com/Zomato/espresso/service/internal/pkg/httppkg"
 	"github.com/Zomato/espresso/service/internal/service/generateDoc"
 	svcUtils "github.com/Zomato/espresso/service/utils"
-	"github.com/spf13/viper"
 )
 
 func (s *EspressoService) GeneratePDF(w http.ResponseWriter, r *http.Request) {
@@ -56,7 +55,7 @@ func (s *EspressoService) GeneratePDF(w http.ResponseWriter, r *http.Request) {
 		generatePdfReq.SignParams = req.SignParams
 	}
 
-	err = generateDoc.GeneratePDF(ctx, generatePdfReq, s.TemplateStorageAdapter, s.FileStorageAdapter)
+	err = generateDoc.GeneratePDF(ctx, generatePdfReq, s.TemplateStorageAdapter, s.FileStorageAdapter, s.CredentialStore)
 	if err != nil {
 		svcUtils.Logger.Error(ctx, "error in generating pdf :: %v", err, nil)
 		httppkg.RespondWithError(w, "Failed to generate PDF: "+err.Error(), http.StatusInternalServerError)
@@ -143,7 +142,7 @@ func (s *EspressoService) GeneratePDFStream(w http.ResponseWriter, r *http.Reque
 	if pdfReq.SignPdf {
 		generatePdfReq.SignParams = &generateDoc.SignParams{
 			SignPdf:       true,
-			CertConfigKey: "digital_certificates.cert1", // certificate details are stored in config file
+			CertConfigKey: "cert1", // certificate details are stored in config file
 		}
 	}
 
@@ -155,16 +154,8 @@ func (s *EspressoService) GeneratePDFStream(w http.ResponseWriter, r *http.Reque
 		httppkg.RespondWithError(w, "Failed to get file storage adapter: "+err.Error(), http.StatusExpectationFailed)
 		return
 	}
-	templateStorageAdapter, err := templatestore.TemplateStorageAdapterFactory(&templatestore.StorageConfig{
-		StorageType: "mysql",
-		MysqlDSN:    viper.GetString("mysql.dsn"),
-	})
-	if err != nil {
-		svcUtils.Logger.Error(ctx, "error in getting file storage adapter :: %v", err, nil)
-		httppkg.RespondWithError(w, "Failed to get file storage adapter: "+err.Error(), http.StatusExpectationFailed)
-		return
-	}
-	err = generateDoc.GeneratePDF(ctx, generatePdfReq, &templateStorageAdapter, &fileStorageAdapter)
+
+	err = generateDoc.GeneratePDF(ctx, generatePdfReq, s.TemplateStorageAdapter, &fileStorageAdapter, s.CredentialStore)
 	if err != nil {
 		svcUtils.Logger.Error(ctx, "error in generating pdf stream:: %v", err, nil)
 		httppkg.RespondWithError(w, "Failed to generate PDF stream: "+err.Error(), http.StatusInternalServerError)
@@ -243,7 +234,7 @@ func (s *EspressoService) SignPDF(w http.ResponseWriter, r *http.Request) {
 		httppkg.RespondWithError(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-	err := generateDoc.SignPDF(ctx, signPDFDto, s.FileStorageAdapter)
+	err := generateDoc.SignPDF(ctx, signPDFDto, s.FileStorageAdapter, s.CredentialStore)
 	if err != nil {
 		svcUtils.Logger.Error(ctx, "error in signing pdf :: : %v", err, nil)
 		httppkg.RespondWithError(w, "Failed to sign PDF: "+err.Error(), http.StatusInternalServerError)

service/controller/pdf_generation/register.go

@@ -4,62 +4,63 @@ import (
 	"fmt"
 	"log"
 	"net/http"
-	"os"
 
-	"github.com/Zomato/espresso/lib/s3"
+	"github.com/Zomato/espresso/lib/certmanager"
 	"github.com/Zomato/espresso/lib/templatestore"
-	"github.com/spf13/viper"
+	"github.com/Zomato/espresso/service/internal/pkg/config"
 )
 
 type EspressoService struct {
 	TemplateStorageAdapter *templatestore.StorageAdapter
 	FileStorageAdapter     *templatestore.StorageAdapter
+	CredentialStore        *certmanager.CredentialStore
 }
 
-func NewEspressoService() (*EspressoService, error) {
-	templateStorageType := viper.GetString("template_storage.storage_type")
-	if os.Getenv("ENABLE_UI") == "true" && templateStorageType != templatestore.StorageAdapterTypeMySQL {
+func NewEspressoService(config config.Config) (*EspressoService, error) {
+	templateStorageType := config.TemplateStorageConfig.StorageType
+
+	if config.AppConfig.EnableUI && templateStorageType != templatestore.StorageAdapterTypeMySQL {
 		return nil, fmt.Errorf("UI requires MySQL as template storage adapter, got: %s", templateStorageType)
 	}
+
+	mySqlDsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?parseTime=true",
+		config.DBConfig.Username,
+		config.DBConfig.Password,
+		config.DBConfig.Host,
+		config.DBConfig.Port,
+		config.DBConfig.Database,
+	)
+
 	templateStorageAdapter, err := templatestore.TemplateStorageAdapterFactory(&templatestore.StorageConfig{
-		StorageType: templateStorageType,
-		// for s3 storage only
-		S3Config: &s3.Config{
-			Endpoint:              viper.GetString("s3.endpoint"),
-			Region:                viper.GetString("s3.region"),
-			Bucket:                viper.GetString("s3.bucket"),
-			Debug:                 viper.GetBool("s3.debug"),
-			ForcePathStyle:        viper.GetBool("s3.forcePathStyle"),
-			UploaderConcurrency:   viper.GetInt("s3.uploaderConcurrency"),
-			UploaderPartSize:      viper.GetInt64("s3.uploaderPartSize"),
-			DownloaderConcurrency: viper.GetInt("s3.downloaderConcurrency"),
-			DownloaderPartSize:    viper.GetInt64("s3.downloaderPartSize"),
-			RetryMaxAttempts:      viper.GetInt("s3.retryMaxAttempts"),
-			UseCustomTransport:    viper.GetBool("s3.useCustomTransport"),
-		},
-		// for s3 storage only
-		AwsCredConfig: &s3.AwsCredConfig{
-			AccessKeyID:     viper.GetString("aws.accessKeyID"),
-			SecretAccessKey: viper.GetString("aws.secretAccessKey"),
-			SessionToken:    viper.GetString("aws.sessionToken"),
-		},
-		MysqlDSN: viper.GetString("mysql.dsn"), // for mysql adapter
+		StorageType:   templateStorageType,
+		S3Config:      &config.S3Config,  // for s3 storage only
+		AwsCredConfig: &config.AWSConfig, // for s3 storage only
+		MysqlDSN:      mySqlDsn,          // for mysql adapter
 	})
 	if err != nil {
 		return nil, err
 	}
 
 	fileStorageAdapter, err := templatestore.TemplateStorageAdapterFactory(&templatestore.StorageConfig{
-		StorageType: viper.GetString("file_storage.storage_type"),
+		StorageType: config.FileStorageConfig.StorageType,
 	})
 	if err != nil {
 		return nil, err
 	}
 
-	return &EspressoService{TemplateStorageAdapter: &templateStorageAdapter, FileStorageAdapter: &fileStorageAdapter}, nil
+	credentialStore, err := certmanager.NewCredentialStore(config.CertConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	return &EspressoService{
+		TemplateStorageAdapter: &templateStorageAdapter,
+		FileStorageAdapter:     &fileStorageAdapter,
+		CredentialStore:        credentialStore,
+	}, nil
 }
-func Register(mux *http.ServeMux) {
-	espressoService, err := NewEspressoService()
+func Register(mux *http.ServeMux, config config.Config) {
+	espressoService, err := NewEspressoService(config)
 	if err != nil {
 		log.Fatalf("Failed to initialize PDF service: %v", err)
 	}

service/internal/pkg/config/config.go

@@ -0,0 +1,43 @@
+package config
+
+import (
+	"fmt"
+
+	"github.com/spf13/viper"
+)
+
+func Load() (Config, error) {
+	viper.AutomaticEnv()
+
+	viper.SetDefault(CONFIG_FILE_NAME, "espressoconfig")
+	viper.SetDefault(CONFIG_FILE_TYPE, "yaml")
+	viper.SetDefault(CONFIG_FILE_PATH, "/app/espresso/configs")
+
+	viper.SetConfigName(viper.GetString(CONFIG_FILE_NAME)) // File name without extension
+	viper.SetConfigType(viper.GetString(CONFIG_FILE_TYPE)) // File type
+
+	// Search paths relative to where the binary runs in container
+	viper.AddConfigPath(CONFIG_FILE_PATH) // Main config path in container
+	viper.AddConfigPath("../../configs")  // For local development
+	viper.AddConfigPath("./configs")      // Fallback path for local development
+
+	err := viper.ReadInConfig()
+	if err != nil {
+		return Config{}, err
+	}
+
+	var config Config
+	err = viper.Unmarshal(&config)
+	if err != nil {
+		return Config{}, err
+	}
+
+	// TODO: Why are these fields set in the Dockerfile and not in the config.yaml file?
+	config.AppConfig.EnableUI = viper.GetBool(ENABLE_UI)
+	config.AppConfig.RodBrowserBin = viper.GetString(ROD_BROWSER_BIN)
+	if config.AppConfig.RodBrowserBin == "" {
+		return Config{}, fmt.Errorf("environment variable %s not set", ROD_BROWSER_BIN)
+	}
+
+	return config, nil
+}

service/internal/pkg/config/constant.go

@@ -0,0 +1,10 @@
+package config
+
+const (
+	CONFIG_FILE_NAME = "CONFIG_FILE_NAME"
+	CONFIG_FILE_TYPE = "CONFIG_FILE_TYPE"
+	CONFIG_FILE_PATH = "CONFIG_FILE_PATH"
+
+	ENABLE_UI       = "ENABLE_UI"
+	ROD_BROWSER_BIN = "ROD_BROWSER_BIN"
+)

service/internal/pkg/config/model.go

@@ -0,0 +1,46 @@
+package config
+
+import (
+	"github.com/Zomato/espresso/lib/certmanager"
+	"github.com/Zomato/espresso/lib/s3"
+)
+
+type Config struct {
+	AppConfig             AppConfig                                `mapstructure:"app"`
+	TemplateStorageConfig StorageConfig                            `mapstructure:"template_storage"`
+	FileStorageConfig     StorageConfig                            `mapstructure:"file_storage"`
+	BrowserConfig         BrowserConfig                            `mapstructure:"browser"`
+	WorkerPoolConfig      WorkerPoolConfig                         `mapstructure:"workerpool"`
+	S3Config              s3.Config                                `mapstructure:"s3"`
+	AWSConfig             s3.AwsCredConfig                         `mapstructure:"aws"`
+	CertConfig            map[string]certmanager.CertificateConfig `mapstructure:"certificates"`
+	DBConfig              DBConfig                                 `mapstructure:"db"`
+}
+
+type AppConfig struct {
+	LogLevel      string `mapstructure:"log_level"`
+	ServerPort    int    `mapstructure:"server_port"`
+	EnableUI      bool   `mapstructure:"enable_ui"`
+	RodBrowserBin string `mapstructure:"rod_browser_bin"`
+}
+
+type StorageConfig struct {
+	StorageType string `mapstructure:"storage_type"`
+}
+
+type BrowserConfig struct {
+	TabPool int `mapstructure:"tab_pool"`
+}
+
+type WorkerPoolConfig struct {
+	WorkerCount     int `mapstructure:"worker_count"`
+	WorkerTimeoutMs int `mapstructure:"worker_timeout_ms"`
+}
+
+type DBConfig struct {
+	Host     string `mapstructure:"host"`
+	Port     int    `mapstructure:"port"`
+	Username string `mapstructure:"username"`
+	Password string `mapstructure:"password"`
+	Database string `mapstructure:"database"`
+}