Feature/52 update initialisation to allow for dynamic loading (#53)

internal/controller/controller.go

@@ -6,6 +6,7 @@ import (
 	"reflect"
 
 	"soarca/internal/capability"
+	"soarca/internal/capability/http"
 	"soarca/internal/capability/ssh"
 	"soarca/internal/decomposer"
 	"soarca/internal/executer"
@@ -16,7 +17,7 @@ import (
 	"github.com/gin-gonic/gin"
 
 	mongo "soarca/database/mongodb"
-	playbookRepo "soarca/database/playbook"
+	playbookrepository "soarca/database/playbook"
 	routes "soarca/routes"
 )
 
@@ -28,34 +29,26 @@ func init() {
 	log = logger.Logger(reflect.TypeOf(Empty{}).PkgPath(), logger.Info, "", logger.Json)
 }
 
-func InitializeAppComponents() error {
-	app := gin.New()
-	log.Info("Testing if this works")
+type Controller struct {
+	playbookRepo playbookrepository.IPlaybookRepository
+}
 
-	initDatabase := utils.GetEnv("DATABASE", "false")
-	if initDatabase == "true" {
-		errDatabase := InitializeDatabase(app)
-		if errDatabase != nil {
-			log.Error("Failed to init core")
-			return errDatabase
-		}
-	}
-	errCore := InitializeCore(app)
+var mainController = Controller{}
 
-	if errCore != nil {
-		log.Error("Failed to init core")
-		return errCore
-	}
+func (controller *Controller) NewDecomposer() decomposer.IDecomposer {
+	ssh := new(ssh.SshCapability)
+	capabilities := map[string]capability.ICapability{ssh.GetType(): ssh}
 
-	port := utils.GetEnv("PORT", "8080")
-	err := app.Run(":" + port)
-	if err != nil {
-		log.Error("failed to run gin")
-	}
-	return err
+	http := new(http.HttpCapability)
+	capabilities[http.GetType()] = http
+
+	executer := executer.New(capabilities)
+	guid := new(guid.Guid)
+	decompose := decomposer.New(executer, guid)
+	return decompose
 }
 
-func InitializeDatabase(app *gin.Engine) error {
+func (controller *Controller) setupDatabase() error {
 	mongo.LoadComponent()
 
 	log.Info("SOARCA API Trying to start")
@@ -71,28 +64,59 @@ func InitializeDatabase(app *gin.Engine) error {
 	if err != nil {
 		return err
 	}
-	// defer database.GetMongoClient().CloseMongoDB()
+	controller.playbookRepo = playbookrepository.SetupPlaybookRepository(mongo.GetCacaoRepo(), mongo.DefaultLimitOpts())
 
-	playbookRepo := playbookRepo.SetupPlaybookRepository(mongo.GetCacaoRepo(), mongo.DefaultLimitOpts())
+	return nil
+}
 
-	// setup database routes
-	err = routes.Database(app, playbookRepo)
+func (controller *Controller) GetDatabaseInstance() playbookrepository.IPlaybookRepository {
+	return controller.playbookRepo
+}
+
+func Initialize() error {
+	app := gin.New()
+	log.Info("Testing if info log works")
+	log.Debug("Testing if debug log works")
+	log.Trace("Testing if Trace log works")
+
+	errCore := initializeCore(app)
+
+	if errCore != nil {
+		log.Error("Failed to init core")
+		return errCore
+	}
+
+	port := utils.GetEnv("PORT", "8080")
+	err := app.Run(":" + port)
+	if err != nil {
+		log.Error("failed to run gin")
+	}
+	log.Info("exit")
 
 	return err
 }
 
-func InitializeCore(app *gin.Engine) error {
-	ssh := new(ssh.SshCapability)
-	capabilities := map[string]capability.ICapability{ssh.GetType(): ssh}
-	executer := executer.New(capabilities)
-	guid := new(guid.Guid)
-	decompose := decomposer.New(executer, guid)
+func initializeCore(app *gin.Engine) error {
 
-	err := routes.Api(app, decompose)
+	err := routes.Api(app, &mainController)
 	if err != nil {
 		log.Error(err)
 		return err
 	}
+
+	initDatabase := utils.GetEnv("DATABASE", "false")
+	if initDatabase == "true" {
+		err = mainController.setupDatabase()
+		if err != nil {
+			log.Error(err)
+			return err
+		}
+		err = routes.Database(app, &mainController)
+		if err != nil {
+			log.Error(err)
+			return err
+		}
+	}
 	routes.Logging(app)
 	routes.Swagger(app)
 	return err

internal/controller/database/controller_database.go

@@ -0,0 +1,9 @@
+package database
+
+import (
+	playbookrepository "soarca/database/playbook"
+)
+
+type IController interface {
+	GetDatabaseInstance() playbookrepository.IPlaybookRepository
+}

internal/controller/decomposer/controller_decomposer.go

@@ -0,0 +1,9 @@
+package decomposer
+
+import (
+	"soarca/internal/decomposer"
+)
+
+type IController interface {
+	NewDecomposer() decomposer.IDecomposer
+}

main.go

@@ -42,7 +42,7 @@ func main() {
 		log.Warning("Failed to read env variable, but will continue")
 	}
 
-	errinit := controller.InitializeAppComponents()
+	errinit := controller.Initialize()
 	if errinit != nil {
 		log.Fatal("Something Went wrong with setting-up the app, msg: ", errinit)
 		panic(errinit)

routes/playbook/playbook_api.go

@@ -5,19 +5,20 @@ import (
 	"net/http"
 	"strconv"
 
-	playbookRepository "soarca/database/playbook"
+	playbookrepository "soarca/database/playbook"
+	"soarca/internal/controller/database"
 
 	"github.com/gin-gonic/gin"
 )
 
 // A PlaybookController implements the playbook API endpoints is dependent on a database.
 type playbookController struct {
-	playbookRepo playbookRepository.IPlaybookRepository
+	playbookRepo playbookrepository.IPlaybookRepository
 }
 
 // NewPlaybookController makes a new instance of playbookControler
-func NewPlaybookController(playbookRepo playbookRepository.IPlaybookRepository) *playbookController {
-	return &playbookController{playbookRepo: playbookRepo}
+func NewPlaybookController(controller database.IController) *playbookController {
+	return &playbookController{playbookRepo: controller.GetDatabaseInstance()}
 }
 
 // getAllPlaybooks GET handler for obtaining all the playbooks in the database and return this to the gin context in json format

routes/playbook/playbook_endpoints.go

@@ -1,7 +1,7 @@
 package playbook
 
 import (
-	playbookRepository "soarca/database/playbook"
+	"soarca/internal/controller/database"
 
 	"github.com/gin-gonic/gin"
 )
@@ -12,8 +12,8 @@ import (
 // GET     /playbook/playbook-id
 // PUT     /playbook/playbook-id
 // DELETE  /playbook/playbook-id
-func Routes(route *gin.Engine, playbookRepo playbookRepository.IPlaybookRepository) {
-	playbookController := NewPlaybookController(playbookRepo)
+func Routes(route *gin.Engine, controller database.IController) {
+	playbookController := NewPlaybookController(controller)
 	playbook := route.Group("/playbook")
 	{
 		playbook.GET("/", playbookController.getAllPlaybooks)

routes/router.go

@@ -1,8 +1,8 @@
 package routes
 
 import (
-	playbookRepository "soarca/database/playbook"
-	"soarca/internal/decomposer"
+	"soarca/internal/controller/database"
+	"soarca/internal/controller/decomposer"
 	coa_routes "soarca/routes/coa"
 	operator "soarca/routes/operator"
 	playbook_routes "soarca/routes/playbook"
@@ -19,9 +19,9 @@ import (
 // Requires database dependency injection.
 
 func Database(app *gin.Engine,
-	playbookRepo playbookRepository.IPlaybookRepository,
+	controller database.IController,
 ) error {
-	playbook_routes.Routes(app, playbookRepo)
+	playbook_routes.Routes(app, controller)
 	return nil
 }
 
@@ -30,12 +30,12 @@ func Logging(app *gin.Engine) {
 }
 
 func Api(app *gin.Engine,
-	decomposer decomposer.IDecomposer,
+	controller decomposer.IController,
 ) error {
 	log.Trace("Trying to setup all Routes")
 	// gin.SetMode(gin.ReleaseMode)
 
-	trigger_api := trigger.New(decomposer)
+	trigger_api := trigger.New(controller)
 
 	coa_routes.Routes(app)
 

routes/trigger/trigger_api.go

@@ -5,7 +5,7 @@ import (
 	"net/http"
 	"reflect"
 
-	"soarca/internal/decomposer"
+	"soarca/internal/controller/decomposer"
 	"soarca/logger"
 	"soarca/models/decoder"
 	"soarca/routes/error"
@@ -26,16 +26,18 @@ func init() {
 }
 
 type TriggerApi struct {
-	decomposer decomposer.IDecomposer
+	controller decomposer.IController
 }
 
-func New(decomposer decomposer.IDecomposer) *TriggerApi {
+func New(controller decomposer.IController) *TriggerApi {
 	instance := TriggerApi{}
-	instance.decomposer = decomposer
+	instance.controller = controller
 	return &instance
 }
 
 func (trigger *TriggerApi) Execute(context *gin.Context) {
+	// create new decomposer when execute is called
+	decomposer := trigger.controller.NewDecomposer()
 	jsonData, errIo := io.ReadAll(context.Request.Body)
 	if errIo != nil {
 		log.Error("failed")
@@ -52,7 +54,7 @@ func (trigger *TriggerApi) Execute(context *gin.Context) {
 			"POST /trigger/playbook", "")
 		return
 	}
-	executionDetail, errDecomposer := trigger.decomposer.Execute(*playbook)
+	executionDetail, errDecomposer := decomposer.Execute(*playbook)
 	if errDecomposer != nil {
 		error.SendErrorResponse(context, http.StatusBadRequest,
 			"Failed to decode playbook",

test/unittest/mocks/mock_controller/database/mock_database_controller.go

@@ -0,0 +1,16 @@
+package mock_database_controller
+
+import (
+	playbookrepository "soarca/database/playbook"
+
+	"github.com/stretchr/testify/mock"
+)
+
+type Mock_Controller struct {
+	mock.Mock
+}
+
+func (mock *Mock_Controller) GetDatabaseInstance() playbookrepository.IPlaybookRepository {
+	args := mock.Called()
+	return args.Get(0).(playbookrepository.IPlaybookRepository)
+}

test/unittest/mocks/mock_controller/decomposer/mock_decomposer_controller.go

@@ -0,0 +1,16 @@
+package mock_decomposer_controller
+
+import (
+	"soarca/internal/decomposer"
+
+	"github.com/stretchr/testify/mock"
+)
+
+type Mock_Controller struct {
+	mock.Mock
+}
+
+func (mock *Mock_Controller) NewDecomposer() decomposer.IDecomposer {
+	args := mock.Called()
+	return args.Get(0).(decomposer.IDecomposer)
+}