progress sync, level structure added

ABresting · ABresting · commit 9954891c3027 · 2021-08-12T00:15:31.000+02:00
diff --git a/configs/samples/configuration.yml b/configs/samples/configuration.yml
@@ -13,7 +13,7 @@ riotpot:
   # list of services desired to be loaded and run at start, and `emulators` with
   # the list of available services to the app.
   autod: false
-  local_build_on: 0
+  local_build_on: 1
 
   # The name of the services is the name of the folder in which the plugin
   # is stored, inside the `pkg/` folder.
@@ -31,6 +31,10 @@ riotpot:
     - coapd
     - modbusd
 
+  images:
+    - mqtt, eclipse-mosquitto
+    - coap, COAP_IMAGE
+
   # Contains a list of available services in the application.
   # This gives the user the ability to navigate or load
   # just the emulators that appear in this list, wether or not
diff --git a/internal/configuration/autopilot.go b/internal/configuration/autopilot.go
@@ -12,8 +12,10 @@ import (
 
 	"gorm.io/gorm"
 	"github.com/riotpot/pkg/services"
+	"github.com/riotpot/pkg/profiles/ports"
 	"github.com/riotpot/internal/greeting"
 	"github.com/riotpot/tools/environ"
+	"github.com/riotpot/tools/arrays"
 )
 
 type Autopilot struct {
@@ -26,7 +28,10 @@ type Autopilot struct {
 	DB       *gorm.DB
 
 	loaded_plugins []string
+	loaded_containers []string
 	plugins_to_run []string
+	contianers_to_run [] string
+	interaction_mode string
 }
 
 // Method to start the autopilot.
@@ -41,53 +46,83 @@ func (a *Autopilot) Start() {
 	a.wg = sync.WaitGroup{}
 	a.wg.Add(1)
 
-	// register all the services
-	a.RegisterServices()
+	// register all the services plugins
+	a.RegisterPlugins()
+	a.DiscoverImages()
+	_ = environ.CheckDockerExists("mongodb")
 
 	// loads the services which are available for user to run
 	a.loaded_plugins = a.services.GetServicesNames(a.services.GetServices())
 
-
 	// set the plugins to run from the config file
 	a.plugins_to_run = a.Settings.Riotpot.Start
 
 	// check if the build is local or containerized
 	if a.Settings.Riotpot.Local_build_on == "1" {
-		// check if user want to run via config file or manually input
-		// plugins to run.
-		// _ = a.CheckInteractionMode()
-		running_mode_decision := a.CheckRunningMode()
-
-		// based on the user decision set the plugin running list
-		if !running_mode_decision {
-			// user decided to provide plugins manually
-			a.plugins_to_run = a.GetPluginsFromUser()
+		a.interaction_mode = a.CheckInteractionMode()
+
+		if a.interaction_mode == "low" {
+			// check if user want to run via config file or manually input
+			// plugins to run.
+			// _ = a.CheckInteractionMode()
+			running_mode_decision := a.CheckRunningMode()
+
+			// based on the user decision set the plugin running list
+			if !running_mode_decision {
+				fmt.Printf("Plugins available to run ")
+				fmt.Println(a.loaded_plugins)
+
+				// user decided to provide plugins manually
+				a.plugins_to_run = a.GetPluginsFromUser()
+			}	
+		} else if a.interaction_mode == "high" {
+			fmt.Printf("Docker images available to run ")
+			fmt.Println(a.loaded_containers)
+
+			running_mode_decision := a.CheckContainersRunMode()
+			if !running_mode_decision {
+				fmt.Printf("Containers available to run ")
+				fmt.Println(a.Settings.GetDockerImages())
+
+				// user decided to provide contianers manually
+				a.contianers_to_run = a.GetContainersFromUser()
+			}
+
+
+		} else {
+			fmt.Printf("\nPlugins available to run ")
+			fmt.Println(a.loaded_plugins)
+			fmt.Printf("\n")
+			fmt.Printf("Docker images available to run ")
+			fmt.Println(a.loaded_containers)
+			fmt.Printf("\n")
+
 		}
 	}
 
-	fmt.Printf("Plugins to run ")
-	fmt.Println(a.plugins_to_run)
+	// fmt.Printf("Plugins to run ")
+	// fmt.Println(a.plugins_to_run)
 
-	// cmd, err := exec.Command("/bin/sh", "bash.sh").Output()
-	// cmd, err := exec.LookPath("go")	
-	// if err != nil {
-	//     log.Fatalf("[!] Error: %v", err)
- //    }
+	// // cmd, err := exec.Command("/bin/sh", "bash.sh").Output()
+	// // cmd, err := exec.LookPath("go")
+	// // if err != nil {
+	// //     log.Fatalf("[!] Error: %v", err)
+ // //    }
 
- //    output := string(cmd)
-	// fmt.Println(output)
+ // //    output := string(cmd)
+	// // fmt.Println(output)
 
-	server := environ.CheckPortBusy("tcp", ":22")
-	if server != true {
-		fmt.Println("Port is busy")
-	}
-	fmt.Println(server)	
+	// server := environ.CheckPortBusy("tcp", ":22")
+	// if server != true {
+	// 	fmt.Println("Port is busy")
+	// }
+	// fmt.Println(server)	
 
-	servicePath, exists := environ.GetPath("glider")
-	if exists {
-		_ 	= environ.ExecuteBackgroundCmd(servicePath, "aaa")
-		_ 	= environ.ExecuteCmd(servicePath, "aaa")	
-	} 
+	// _, exists := environ.GetPath("glider")
+	// if exists {
+	// 	a.ValidateDefaultDockerContext("docker-test")
+	// 	_ 	= environ.ExecuteCmd("go", "version")	
+	// } 
 
 	// fmt.Println(demo1)		
 
@@ -124,8 +159,8 @@ func (a *Autopilot) available(name string, port int) (available bool) {
 	return true
 }
 
-// Register the services
-func (a *Autopilot) RegisterServices() {
+// Register the services plugins
+func (a *Autopilot) RegisterPlugins() {
 	a.services = services.Services{}
 
 	service_paths := a.services.Autodiscover(a.Settings.Riotpot.Local_build_on)
@@ -136,6 +171,15 @@ func (a *Autopilot) RegisterServices() {
 	a.services.AddDB(a.DB)
 }
 
+// Discover the docker images available
+func (a *Autopilot) DiscoverImages() {
+	a.loaded_containers = a.Settings.GetDockerImages()
+	fmt.Printf("[+] Found %d docker images \n", len(a.loaded_containers))
+	fmt.Printf("[+] Allowed Docker images ")
+	fmt.Println(a.loaded_containers)
+
+}
+
 // Load the greeting
 func (a *Autopilot) Greeting() {
 	a.greeting = greeting.Greet{
@@ -146,12 +190,6 @@ func (a *Autopilot) Greeting() {
 	a.greeting.Greeting()
 }
 
-// Converts the text separated by spaces into list items
-func (a *Autopilot) TextToList(in string) (out []string) {
-	out = strings.Fields(in)
-	return out
-}
-
 // Reads the input from the terminal, returns the string
 func (a *Autopilot) ReadInput() (text string) {
 	reader := bufio.NewReader(os.Stdin)
@@ -181,9 +219,27 @@ func (a *Autopilot) CheckRunningMode() (decision bool) {
 	}
 }
 
+// Checks if the user wants to run containers manually
+func (a *Autopilot) CheckContainersRunMode() (decision bool) {
+	fmt.Print("Run containers from configuation file? [y/n]")
+
+	for {
+		response := a.ReadInput()
+		response = strings.ToLower(strings.TrimSpace(response))
+
+		if response == "y" || response == "yes" {
+			return true
+		} else if response == "n" || response == "no" {
+			return false
+		} else{
+			fmt.Printf("Please type Yes(y) or No(n) only\n")
+		}
+	}
+}
+
 // Checks in which mode user wants to run RIoTPot
 func (a *Autopilot) CheckInteractionMode() (decision string) {
-	fmt.Print("\nSelect RIoTPot mode, Low-interaction mode, High-interaction mode or Hybrid-mode? [l,h,hy] [low, high, hybrid]")
+	fmt.Printf("\nSelect RIoTPot mode, Low-interaction mode, High-interaction mode or Hybrid-mode? [l,h,hy] [low, high, hybrid] \n")
 
 	for {
 		response := a.ReadInput()
@@ -201,11 +257,11 @@ func (a *Autopilot) CheckInteractionMode() (decision string) {
 	}
 }
 
-// Validates if the plugins inputed by the users match the available plugins
+// Validates if the plugins inputed by the user matches the available plugins
 // TODO: print all the invalid plugins not just the first one encountered
 func (a *Autopilot) ValidatePlugin(input_plugins []string) (validated bool){
 	for _, plugin := range input_plugins {
-		validated := a.services.ValidatePluginByName(strings.Title(plugin), a.loaded_plugins)
+		validated := arrays.Contains(a.loaded_plugins, strings.Title(strings.ToLower(plugin)))
 		if !validated {
 			fmt.Printf("\n[-] Entered plugin \"%s\" doesn't exist, please enter plugins again... \n", plugin)
 			return false
@@ -214,15 +270,27 @@ func (a *Autopilot) ValidatePlugin(input_plugins []string) (validated bool){
 	return true
 }
 
+// Validates if the contianers inputed by the users match the loaded containers
+// TODO: print all the invalid containers not just the first one encountered
+func (a *Autopilot) ValidateContianers(input_containers []string) (validated bool){
+	for _, container := range input_containers {
+		validated := arrays.Contains( a.loaded_containers, strings.ToLower(container))
+		if !validated {
+			fmt.Printf("\n[-] Entered container \"%s\" doesn't exist, please enter plugins again... \n", container)
+			return false
+		}
+	}
+	return true
+}
+
 // Gives which plugins user wants to load in RIoTPot
 func (a *Autopilot) GetPluginsFromUser() (plugins []string) {
 	for {
-		fmt.Printf("\nPlugins available to run ")
-		fmt.Println(a.loaded_plugins)
 		fmt.Print("Enter the plugins to run separated by space: ")
 
-		text := a.ReadInput()
-		plugins = a.TextToList(text)
+		input := a.ReadInput()
+		plugins = arrays.StringToArray(input)
+
 		validated := a.ValidatePlugin(plugins)
 		if !validated {
 			continue
@@ -231,3 +299,36 @@ func (a *Autopilot) GetPluginsFromUser() (plugins []string) {
 	}
 	return plugins
 }
+
+// Gives which plugins user wants to load in RIoTPot
+func (a *Autopilot) GetContainersFromUser() (containers []string) {
+	for {
+		fmt.Print("Enter the contianers to run separated by space: ")
+
+		input := a.ReadInput()
+		containers = arrays.StringToArray(input)
+		validated := a.ValidateContianers(containers)
+
+		if !validated {
+			continue
+		}
+		break
+	}
+
+	return containers
+}
+
+
+// Validates if the given docker context exists and set to default
+func (a *Autopilot) ValidateDefaultDockerContext(to_check string)  {
+	cmd_output	:= environ.ExecuteCmd("docker", "context" , "ls")
+	cmd_out_slice := arrays.StringToArray(cmd_output)
+	val_position := arrays.GetItemPosition(cmd_out_slice, to_check)
+
+	if val_position== -1 {
+		log.Fatalf("Docker context %q, not found", to_check)
+	}
+	if cmd_out_slice[val_position+1] != "*" {
+		log.Fatalf("Docker context %q, is not set to default", to_check)
+	}
+}
diff --git a/internal/configuration/configuration.go b/internal/configuration/configuration.go
@@ -9,9 +9,9 @@ import (
 	"strings"
 
 	"github.com/gobuffalo/packr"
-	"github.com/riotpot/tools/arrays"
 	environ "github.com/riotpot/tools/environ"
 	errors "github.com/riotpot/tools/errors"
+	arrays "github.com/riotpot/tools/arrays"
 
 	"gopkg.in/yaml.v3"
 )
@@ -52,6 +52,15 @@ func (conf *Settings) Load() (err error) {
 	return err
 }
 
+// Retrieve the image name from Images tag
+func (conf *Settings) GetDockerImages() (images []string) {
+	for _, val := range conf.Riotpot.Images {
+		images = append(images, strings.TrimSuffix(arrays.StringToArray(val)[0], ","))
+	}
+
+	return images
+}
+
 // Stores the configuration into the given path in `.yml` format.
 func (conf *Settings) Save(path string) (err error) {
 	// marshal the content of the configuration into a `.yaml` document
@@ -146,8 +155,12 @@ type ConfigRiotpot struct {
 	Emulators []string
 	// List of emulators that must be run at start
 	Start []string
-	// Varoable to check if the run is for local build or not
+	// Variable to check if the run is for local build or not
 	Local_build_on string
+	// Available docker images along with docker name
+	Images []string
+	// Available docker images without docker name
+	Images_to_run []string
 }
 
 // Database configuration structure. It gives an interface to load and access specific databases.
diff --git a/pkg/plugin/coapd/coapd.go b/pkg/plugin/coapd/coapd.go
@@ -21,6 +21,7 @@ import (
 	"github.com/plgd-dev/go-coap/v2/mux"
 	"github.com/riotpot/pkg/profiles"
 	"github.com/riotpot/pkg/services"
+	"github.com/riotpot/pkg/profiles/ports"
 )
 
 var Name string
@@ -32,7 +33,7 @@ func init() {
 func Coapd() services.Service {
 	mx := services.MixinService{
 		Name:     Name,
-		Port:     5683,
+		Port:     ports.GetPort("coapd"),
 		Running:  make(chan bool, 1),
 		Protocol: "udp",
 	}
diff --git a/pkg/profiles/ports/ports.go b/pkg/profiles/ports/ports.go
@@ -0,0 +1,13 @@
+package ports
+
+var ports = map[string]int {"coapd": 5683,
+							"sshd": 22,
+							"httpd": 8080,
+							"echod": 7,
+							"telnetd": 23,
+							"mqttd": 1883,
+							"modbusd": 502}
+
+func GetPort(service string) (int) {
+	return ports[service]
+}
diff --git a/tools/arrays/array.go b/tools/arrays/array.go
diff --git a/tools/environ/syscmd.go b/tools/environ/syscmd.go
