- Added RabbitMQ integration

- Infrastructure Now Handles most of the Errors
- Added Logger

infrastructure/infrastructure/infrastrucutre.go

@@ -6,24 +6,29 @@ import (
 	"github.com/leapfrogtechnology/shift/infrastructure/utils"
 	"path/filepath"
 
-	"github.com/leapfrogtechnology/shift/infrastructure/utils"
 )
 
-func InitializeFrontend(infrastructureArgs string) error{
+func InitializeFrontend(infrastructureArgs []byte) (string, error){
 
 	var frontendArgs utils.FrontendInfrastructureVariables
-	err := json.Unmarshal([]byte(infrastructureArgs), &frontendArgs)
+	utils.LogInfo("Gathering Info")
+	err := json.Unmarshal(infrastructureArgs, &frontendArgs)
 	if err != nil {
 		utils.LogError(err, "Error Parsing Body")
-		return err
+		return "", err
 	}
 	workspaceDir := filepath.Join("/tmp", frontendArgs.CLIENT_NAME)
-
+	utils.LogInfo("Generating Template")
 	err = utils.GenerateFrontendTemplateFile(frontend_architecture.InfrastructureTemplate, frontendArgs, workspaceDir)
 	if err != nil {
 		utils.LogError(err, "Cannot Generate Template")
-		return err
+		return "", err
+	}
+	utils.LogInfo("Running Infrastructure Changes")
+	infrastructureInfo, err := utils.RunInfrastructureChanges(workspaceDir)
+	if err != nil {
+		utils.LogError(err, "Cannot Run Changes")
+		return "", err
 	}
-	utils.RunInfrastructureChanges(workspaceDir)
-	return nil
+	return infrastructureInfo, err
 }

infrastructure/shift-infrastructure.go

@@ -1,7 +1,53 @@
 package main
 
-import "github.com/leapfrogtechnology/shift/infrastructure/infrastructure"
+import (
+	"github.com/leapfrogtechnology/shift/infrastructure/infrastructure"
+	"github.com/leapfrogtechnology/shift/infrastructure/utils"
+	"github.com/streadway/amqp"
+	"log"
+)
 
-func main()  {
-	infrastrucuture.InitializeFrontend()
-}
+func main() {
+
+	conn, err := amqp.Dial(utils.GenerateQueueUrl())
+	utils.FailOnError(err, "Failed to Connect to Message Queue")
+	defer conn.Close()
+
+	ch, err := conn.Channel()
+	utils.FailOnError(err, "Failed to open a channel")
+	defer ch.Close()
+
+	q, err := ch.QueueDeclare(
+		"initialize", // name
+		false,   // durable
+		false,   // delete when usused
+		false,   // exclusive
+		false,   // no-wait
+		nil,     // arguments
+	)
+	utils.FailOnError(err, "Failed to declare a queue")
+
+	messages, err := ch.Consume(
+		q.Name, //name
+		"", //consumer
+		true, //autoAck
+		false, // exclusive
+		false, //noLocal
+		false, //noWait
+		nil, // args
+	)
+	forever := make(chan bool)
+	go func() {
+		for message := range messages {
+			log.Printf("Received a message: %s", message.MessageId)
+			infrastructureInfo, err := infrastrucuture.InitializeFrontend(message.Body)
+			if err != nil {
+				utils.LogError(err, "Cannot Init Infrastructure")
+			} else {
+				utils.LogOutput(infrastructureInfo)
+			}
+		}
+	}()
+	utils.LogInfo("[*] Waiting for messages. To exit Press Ctrl+C")
+	<-forever
+}

infrastructure/utils/logger.go

@@ -1,13 +1,24 @@
 package utils
 
-import "log"
+import (
+	"github.com/logrusorgru/aurora"
+	"log"
+)
 
 func FailOnError(err error, msg string) {
 	if err != nil {
-		log.Fatalf("%s: %s", msg, err)
+		log.Fatalf("Fatal\n%s: %s",aurora.Red(msg), aurora.Red(err))
 	}
 }
 
 func LogError(err error, msg string) {
-	log.Printf("%s: %s", msg, err)
+	log.Printf("%s: %s", aurora.Red(msg), aurora.Red(err))
+}
+
+func LogOutput(msg string) {
+	log.Println(aurora.Cyan(msg))
+}
+
+func LogInfo(msg string) {
+	log.Println(aurora.Blue(msg))
 }

infrastructure/utils/message-queue.go

@@ -0,0 +1,15 @@
+package utils
+
+import (
+	"fmt"
+	"os"
+)
+
+func GenerateQueueUrl() string{
+	rabbitUserName := os.Getenv("RABBIT_USERNAME")
+	rabbitPassword := os.Getenv("RABBIT_PASSWORD")
+	rabbitHost := os.Getenv("RABBIT_HOST")
+	rabbitPort := os.Getenv("RABBIT_PORT")
+	rabbitUrl := fmt.Sprintf("amqp://%s:%s@%s:%s/", rabbitUserName,rabbitPassword,rabbitHost,rabbitPort)
+	return rabbitUrl
+}

infrastructure/utils/terraform.go

@@ -2,6 +2,7 @@ package utils
 
 import (
 	"bytes"
+	"fmt"
 	"github.com/briandowns/spinner"
 	"os/exec"
 	"time"
@@ -13,15 +14,16 @@ func initTerraform(workspaceDir string) error {
 	s.Suffix = "  Initializing"
 	_ = s.Color("cyan", "bold")
 	s.Start()
-	cmd := exec.Command("terraform", "infrastructure")
+	cmd := exec.Command("terraform", "init")
 	cmd.Dir = workspaceDir
 	var stdout bytes.Buffer
 	var stderr bytes.Buffer
 	cmd.Stdout = &stdout
 	cmd.Stderr = &stderr
 	err := cmd.Run()
 	if err != nil {
-		LogError(err, stderr.String())
+		fmt.Println()
+		s.Stop()
 		return err
 	}
 	s.Stop()
@@ -85,24 +87,36 @@ func getTerraformOutput(workspaceDir string) (string, error) {
 	err := cmd.Run()
 	if err != nil {
 		LogError(err, stderr.String())
+		s.Stop()
 		return "", err
 	}
 	s.Stop()
 	return stdout.String(), nil
 }
 
-func RunInfrastructureChanges(workspaceDir string) {
-	if initTerraform(workspaceDir) != nil {
-		return
+func RunInfrastructureChanges(workspaceDir string) (string, error) {
+	LogInfo("Initializing")
+	err := initTerraform(workspaceDir)
+	if err != nil {
+		LogError(err, "Something Went Wrong")
+		return "", err
 	}
-	if planTerraform(workspaceDir) !=nil {
-		return
+	LogInfo("Planning")
+	err = planTerraform(workspaceDir)
+	if err != nil {
+		LogError(err, "Something Went Wrong")
+		return "", err
 	}
-	if applyTerraform(workspaceDir) != nil {
-		return
+	LogInfo("Applying")
+	err = applyTerraform(workspaceDir)
+	if err != nil {
+		LogError(err, "Something Went Wrong")
+		return "", err
 	}
-	if getTerraformOutput(workspaceDir) != nil {
-		return
+	infrastructureInfo, err := getTerraformOutput(workspaceDir)
+	if err != nil {
+		LogError(err, "Something Went Wrong")
+		return "", err
 	}
-
+	return infrastructureInfo, err
 }