Haskell bindings

Adds Alerts Markdown Support

.gitignore

@@ -21,6 +21,20 @@ generate/Test
 #ignore windows exe files
 *.exe
 dist/
+# Ignore any sort of logs
+logs/
 
 # ignore docker image files
 server/docker/containers/
+*.h
+*.so
+
+# generic folder to ignore
+export/
+
+# Any testing file
+test*
+
+# Ignore public and private keys
+p2prc.publicKey
+p2prc.privateKey

Bindings/Client.go

@@ -0,0 +1,170 @@
+package main
+
+import "C"
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/Akilan1999/p2p-rendering-computation/abstractions"
+	"github.com/Akilan1999/p2p-rendering-computation/p2p/frp"
+)
+
+// The Client package where data-types
+// are manually converted to the
+// to a string so that it can
+// be export
+
+// --------------------------------- Container Control ----------------------------------------
+
+//export StartContainer
+func StartContainer(IP *C.char) (output *C.char) {
+	container, err := abstractions.StartContainer(C.GoString(IP))
+	if err != nil {
+		return C.CString(err.Error())
+	}
+	return ConvertStructToJSONString(container)
+}
+
+//export RemoveContainer
+func RemoveContainer(IP *C.char, ID *C.char) (output *C.char) {
+	err := abstractions.RemoveContainer(C.GoString(IP), C.GoString(ID))
+	if err != nil {
+		return C.CString(err.Error())
+	}
+	return C.CString("Success")
+}
+
+// --------------------------------- Plugin Control ----------------------------------------
+
+// DEPRECATED
+////export ViewPlugin
+//func ViewPlugin() (output *C.char) {
+//	plugins, err := plugin.DetectPlugins()
+//	if err != nil {
+//		return C.CString(err.Error())
+//	}
+//	return ConvertStructToJSONString(plugins)
+//}
+//
+////export PullPlugin
+//func PullPlugin(pluginUrl string) (output *C.char) {
+//	err := plugin.DownloadPlugin(pluginUrl)
+//	if err != nil {
+//		return C.CString(err.Error())
+//	}
+//	return C.CString("Success")
+//}
+//
+////export DeletePlugin
+//func DeletePlugin(pluginName string) (output *C.char) {
+//	err := plugin.DeletePlugin(pluginName)
+//	if err != nil {
+//		return C.CString(err.Error())
+//	}
+//	return C.CString("Success")
+//}
+//
+////export ExecutePlugin
+//func ExecutePlugin(pluginname string, ContainerID string) (output *C.char) {
+//	err := plugin.RunPluginContainer(pluginname, ContainerID)
+//	if err != nil {
+//		return C.CString(err.Error())
+//	}
+//	return C.CString("Success")
+//}
+
+// --------------------------------- Get Specs ----------------------------------------
+
+//export GetSpecs
+func GetSpecs(IP *C.char) (output *C.char) {
+	specs, err := abstractions.GetSpecs(C.GoString(IP))
+	if err != nil {
+		return C.CString(err.Error())
+	}
+	return ConvertStructToJSONString(specs)
+}
+
+//export Init
+func Init(customConfig *C.char) (output *C.char) {
+	init, err := abstractions.Init(C.GoString(customConfig))
+	if err != nil {
+		return C.CString(err.Error())
+	}
+	return ConvertStructToJSONString(init)
+}
+
+// --------------------------------- P2P Controls -----------------------------------
+
+//export ViewIPTable
+func ViewIPTable() (output *C.char) {
+	table, err := abstractions.ViewIPTable()
+	if err != nil {
+		return C.CString(err.Error())
+	}
+	return ConvertStructToJSONString(table)
+}
+
+//export UpdateIPTable
+func UpdateIPTable() (output *C.char) {
+	err := abstractions.UpdateIPTable()
+	if err != nil {
+		return C.CString(err.Error())
+	}
+	return C.CString("Success")
+}
+
+//export EscapeFirewall
+func EscapeFirewall(HostOutsideNATIP *C.char, HostOutsideNATPort *C.char, internalPort *C.char) (output *C.char) {
+	// Get free port from P2PRC server node
+	serverPort, err := frp.GetFRPServerPort("http://" + C.GoString(HostOutsideNATIP) + ":" + C.GoString(HostOutsideNATPort))
+
+	if err != nil {
+		return C.CString(err.Error())
+	}
+
+	time.Sleep(5 * time.Second)
+
+	ExposedPort, err := frp.StartFRPClientForServer(C.GoString(HostOutsideNATIP)+":"+C.GoString(HostOutsideNATPort), serverPort, C.GoString(internalPort), "")
+	if err != nil {
+		return C.CString(err.Error())
+	}
+
+	return C.CString(ExposedPort)
+}
+
+//export MapPort
+func MapPort(Port *C.char) *C.char {
+	fmt.Println(C.GoString(Port))
+	entireAddress, _, err := abstractions.MapPort(C.GoString(Port))
+	if err != nil {
+		return C.CString(err.Error())
+	}
+	return C.CString(entireAddress)
+}
+
+// --------------------------------- Controlling Server  ----------------------------------------
+
+//export Server
+func Server() (output *C.char) {
+	_, err := abstractions.Start()
+	if err != nil {
+		return C.CString(err.Error())
+	}
+
+	return ConvertStructToJSONString("")
+}
+
+// --------------------------------- Helper Functions  ----------------------------------------
+
+func ConvertStructToJSONString(Struct interface{}) *C.char {
+	jsonBytes, err := json.Marshal(Struct)
+	if err != nil {
+		return C.CString(err.Error())
+	}
+
+	// Convert the JSON bytes to a string
+	return C.CString(string(jsonBytes))
+}
+
+func main() {}

Bindings/python/p2prc.py

@@ -0,0 +1,11 @@
+import ctypes
+
+p2prc = ctypes.CDLL("SharedOBjects/p2prc.so")
+
+p2prc.Init("")
+
+def StartServer():
+    # Starting P2PRC as a server mode
+    p2prc.Server()
+    for _ in iter(int, 1):
+        pass

CITATION.cff

@@ -5,5 +5,5 @@ authors:
     given-names: Akilan
 title: P2PRC
 license: "GPL-2.0"
-version: 1.0.0
-date-released: 2021-07-22
+version: 2.0.0
+date-released: 2023-06-08

Docs/Abstractions.md

@@ -1,6 +1,20 @@
 # Abstractions 
+
+| [◀ Previous](Installation.md) | [Next ▶](Implementation.md) |
+|:-----------:|---------|
+
 The Abstractions package consists of black-boxed functions for P2PRC.
 
 ## Functions
 - ```Init(<Project name>)```:  Initializes P2PRC with all the needed configurations. 
 - ```Start()```: Starts p2prc as a server and makes it possible to extend by adding other routes and functionality to P2PRC.
+- ```MapPort(<port no>)```: On the local machine the port you want to export to world. 
+- ```StartContainer(<ip address>)```: The machine on the p2p network where you want to spin up a docker container. 
+- ```RemoveContainer(<ip address>,<container id>)```: Terminate container based on the IP address and container name. 
+- ```GetSpecs(<ip address>)```: Get specs of a machine on the network based on the IP address.
+- ```ViewIPTable()```: View the IP table which about nodes in the network. 
+- ```UpdateIPTable()```: Force update IP table to learn about new nodes faster. 
+
+---
+
+### Next Chapter: [Implementation](Implementation.md)

Docs/Bindings.md

@@ -0,0 +1,139 @@
+# Language Bindings
+[Language bindings](https://en.wikipedia.org/wiki/Language_binding) refers to wrappers to bridge 2 programming languages. This is used in P2PRC to extend calling P2PRC functions in other programming languages. Currently this is done by generating ```.so``` and ```.h``` from the Go compiler.
+
+<br> 
+
+## How to build shared object files 
+#### The easier way
+```bash
+# Run
+make sharedObjects
+```
+#### Or the direct way
+```bash
+# Run
+cd Bindings && go build -buildmode=c-shared -o p2prc.so
+```
+#### If successfully built:
+```bash
+# Enter into the Bindings directory
+cd Bindings
+# List files
+ls
+# Find files
+p2prc.h p2prc.so
+```
+<br>
+
+## Workings under the hood 
+Below are a sample set of commands to 
+open the bindings implementation.
+```
+# run
+cd Bindings/
+# list files
+ls 
+# search for file
+Client.go
+```
+### In Client go
+There a few things to notice which are different from 
+your standard Go programs: 
+
+#### 1. We import "C" which means [Cgo](https://pkg.go.dev/cmd/cgo) is required. 
+```go
+import "C"
+```
+#### 2. All functions which are required to be called from other programming languages have comment such as.
+```go
+//export <function name>
+
+// ------------ Example ----------------
+// The function below allows to externally
+// to call the P2PRC function to start containers
+// in a specific node in the know list of nodes
+// in the p2p network.
+// Note: the comment "//export StartContainer".
+
+//export StartContainer
+func StartContainer(IP string) (output *C.char) {
+     container, err := client.StartContainer(IP, 0, false, "", "")
+     if err != nil {
+         return C.CString(err.Error())
+     }
+     return ConvertStructToJSONString(container)
+ }
+```
+#### 3. While looking through the file (If 2 files are compared it is pretty trivial to notice a common structure).
+```go
+// --------- Example ------------
+
+//export StartContainer
+func StartContainer(IP string) (output *C.char) {
+     container, err := client.StartContainer(IP, 0, false, "", "")
+     if err != nil {
+         return C.CString(err.Error())
+     }
+     return ConvertStructToJSONString(container)
+}
+
+//export ViewPlugin
+func ViewPlugin() (output *C.char) {
+	plugins, err := plugin.DetectPlugins()
+	if err != nil {
+		return C.CString(err.Error())
+	}
+	return ConvertStructToJSONString(plugins)
+}
+
+```
+#### It is easy to notice that:
+- ```ConvertStructToJSONString(<go object>)```: This is a helper function that convert
+  a go object to JSON string initially and converts it to ```CString```.
+- ```(output *C.char)```: This is the return type for most of the functions.
+
+#### A Pseudo code to refer to the common function implementation shape could be represented as:
+```
+func <Function name> (output *C.char) {
+      <response>,<error> := <P2PRC function name>(<parameters if needed>)
+      if <error> != nil {
+          return C.CString(<error>.Error())
+      }
+      return ConvertStructToJSONString(<response>)
+}
+```
+
+
+<br>
+
+
+## Current languages supported
+- Python
+
+### Build sample python program 
+The easier way
+```bash
+# Run
+make python
+# Expected ouput
+Output is in the Directory Bindings/python/export/
+# Run
+cd Bindings/python/export/
+# list files
+ls
+# Expected output
+SharedObjects/	p2prc.py
+```
+Above shows a generated folder which consists of a folder 
+called "SharedObjects/" which consists of ```p2prc.so```
+and ```p2prc.h``` files. ```p2prc.py``` refers to a 
+sample python script calling P2PRC go functions.
+To start an any project to extend P2PRC with python,
+This generated folder can copied and created as a new
+git repo for P2PRC extensions scripted or used a reference 
+point as proof of concept that P2PRC can be called from 
+other programming languages. 
+
+
+
+

Docs/CliImplementation.md

@@ -6,7 +6,7 @@ commands as possible. The cli was built using the library called urfave cli v2 .
 major files created named as flags.go and actions.go.
 ### Flags.go
 The flags .go file is responsible to create the appropriate flags for the cli. There are 2 types of flags
-called boolean and string as described in Fig 5.3.1. Each of the flags outputs are assigned to a
+called boolean and string. Each of the flags outputs are assigned to a
 variable to be handled. The flags can also detect environment variables set. This feature is useful
 because if the user wants to call certain flags in a repeated sequence it only has to be initialized
 once.

Docs/Client.md

@@ -1,25 +1,13 @@
 # Client Module 
 This module is incharge of communicating with the server and receiving the appropriate information back from the server. 
-Note: To [read more about the functions](https://pkg.go.dev/git.sr.ht/~akilan1999/p2p-rendering-computation@v0.0.0-20210404191839-6a046babcb02/client)
 
 ## Functions of the Client Module
-- [Interact with the Server Api](#functions-of-the-client-module)
+<!-- - [Interact with the Server Api](#functions-of-the-client-module) -->
 - [Decision maker on how the ip table is created or updated](#decision-maker-on-how-the-ip-table-is-created-or-updated)
 
-
-## Interact with the Server Api
-This sections talks about the functionality implemented till now. 
-- The client can start docker containers using the function StartContainer. 
-This functions calls the route:
-```
-http://<server IP address>:<server port>/startcontainer
-```
-TODO: Outputs and how it's printed 
-
 ## Decision maker on how the IP table is created or updated 
 - Does a local speedtest to verify and see if the server IP's in the IP table 
 are pingable.
-- Downloads the Servers IP table.
 - Tries to ping the servers IP Table addresses.
 - If it's pingable then it's added as a new entry in the IP table.
 - The following steps occurs in the clients IP table. 

Docs/ClientImplementation.md

@@ -1,5 +1,10 @@
 # Client Module Implementation
 
+The Client Module interacts with the P2P module and Server Module. It is responsible for interacting with the server module and appropriately updating the IP table on the client side. It connects to the server using the server's REST Apis. It is also the primary decision maker on how the IP table is updated is on the client side. This is because each user can have requirements like how many number of hops they would want to do to update their IP table. Hops is the number of times the client is going to download the IP table from different servers ,once it gets the IP tables from the previous servers.
+
+![Visual demonstration of hops](images/NumOfHops.png)
+![UML diagram of client module](images/clientmoduleArch.png)
+
 ## Topics
 1. [Updating the IP table](#updating-the-IP-table)
 2. [Reading server specifications](#reading-server-specifications)
@@ -78,8 +83,6 @@ show a sample structure of file ```grouptrackcontainer.json```.
 ```
 The default path to the container tracker is ```client/trackcontainers/grouptrackcontainer.json```. 
 
-### Note:
-The group id will be auto-generated and will have its own prefix  in the start which will mostly be ```grp<UUID>```.  
-When a container is removed using the command. ```p2prc --rm <IP Address> --id <Container id>```. It will be automatically deleted 
-from the groups it exists in. 
-
+> [!NOTE]
+> The group id will be auto-generated and will have its own prefix  in the start which will mostly be ```grp<UUID>```.  
+> When a container is removed using the command. ```p2prc --rm <IP Address> --id <Container id>```. It will be automatically deleted from the groups it exists in. 

Docs/ConfigImplementation.md

@@ -13,9 +13,19 @@ JSON format.
 
 ```json
 {
-  "dockerfile": "/<path>/p2p-rendering-computation/server/docker/containers/docker-ubuntu-sshd/",
-  "iptable": "/<path>/p2p-rendering-computation/p2p/ip_table.json",
-  "speedtestfile": "/<path>/p2p-rendering-computation/p2p/50.bin"
+ "MachineName": "pc-74-120.customer.ask4.lan",
+ "IPTable": "/Users/akilan/Documents/p2p-rendering-computation/p2p/iptable/ip_table.json",
+ "DockerContainers": "/Users/akilan/Documents/p2p-rendering-computation/server/docker/containers/",
+ "DefaultDockerFile": "/Users/akilan/Documents/p2p-rendering-computation/server/docker/containers/docker-ubuntu-sshd/",
+ "SpeedTestFile": "/Users/akilan/Documents/p2p-rendering-computation/p2p/50.bin",
+ "IPV6Address": "",
+ "PluginPath": "/Users/akilan/Documents/p2p-rendering-computation/plugin/deploy",
+ "TrackContainersPath": "/Users/akilan/Documents/p2p-rendering-computation/client/trackcontainers/trackcontainers.json",
+ "ServerPort": "8088",
+ "GroupTrackContainersPath": "/Users/akilan/Documents/p2p-rendering-computation/client/trackcontainers/grouptrackcontainers.json",
+ "FRPServerPort": "True",
+ "BehindNAT": "True",
+ "CustomConfig": null
 }
 ```
 

Docs/GenerateImplementation.md

@@ -1,116 +0,0 @@
-# Generate Module 
-P2PRC is a great layer of abstraction. This means that in many cases it is not an end product but rather 
-a tool that customized as an end product. An example would be writing your own billing module to monetize
-the computation power available. The generate module copies the current with the appropriate git histories 
-and keeps only the go files which would be useful to edit. To use the generate module the user will need 
-to have a go compiler present in his computer. Due to the introduction of this module there will 2 releases:
-
-- Regular Release (Consists of only the build binary and cli command cannot access the generate module)
-- Developer Release (Consists of important Go files and the cli can access the generate module)
-
-## How does this work ?
-
-### [Struct information](https://github.com/Akilan1999/p2p-rendering-computation/blob/9d69aed8ce0fe5273aaff2828f7d51c3d5ac2ce4/generate/generate.go#L19)
-- ### ```Generate.go```: 
-This file creates a local copy of P2PRC from where the CLI was called from.
-This go file also does various stuff like instruction of file should be ignored when copying and 
-which of should not be. Now let's understand this. Below is a sample code which does the following:
-
-```go
-	//----------------------------------------------------------------
-	// Action performed:
-	// - Ensuring main.go file exists
-	// - Skipping all .go files apart from the ones listed above
-	// - Skipping .idea/ directory
-	// - Skipping Makefile file
-	//----------------------------------------------------------------
-	Options.Skip = func(src string) (bool, error) {
-		switch {
-		case strings.HasSuffix(src, "main.go"):
-			return false, nil
-		case strings.HasSuffix(src, ".go"):
-			return true, nil
-		case strings.HasSuffix(src, ".idea"):
-			return true, nil
-		case strings.HasSuffix(src, "Makefile"):
-			return true, nil
-		default:
-			return false, nil
-		}
-	}
-	
-	// Doing the copy 
-	err = copy.Copy("<P2PRC folder you want to copy from>", "<PATH to the directory>", Options)
-```
-
-Unfortunately currently this will have to be manually edited in the ```Generate.go``` file. When using the generate 
-module the user also creates their own Go module which is the modified version of P2PRC. This means 
-if the 1 modified package is using another modified package then the appropriate import have to be modified 
-in the file where the import is called: 
-
-Ex:
-```go
- //Sample Project module name = Test 
- //Package names:
- //- Test/Genius
- //- Test/GeGeGenuis
- //
- // When we call the generate function with the new project with the module name = MicDrop 
- // The new package name would be:
- // - MicDrop/Genius 
- // - MicDrop/GeGeGenuis
- 
- // Test/Genius code depends on the package Test/GeGeGenuis
- import (
- 	"Test/GeGeGenuis"
- )
-
-// When we create a new module with the copy of the 
-// existing project we need change:
-import (
- "MicDrop/GeGeGenuis"
-)
-```
-
-To do this we have built functions which can modify import names in the Go file provided. 
-To customize the use case of your generate module you would need to manually add your own 
-imports which are supposed to be replaced and in which files they are supposed to be replaced 
-in. 
-
-```go
-// 1.0 - Test/Genius.go -> GeGeGenuis module
-// a is struct of type NewProject 
-	a.FileNameAST = "<path to project to copy from>/Test/Genius.go"
-	// Get AST information of the file
-	err := a.GetASTGoFile()
-	if err != nil {
-		return err
-	}
-	// Change the appropriate Go file
-	err = a.ChangeImports("Test/GeGeGenuis", "MicDrop/GeGeGenuis")
-	if err != nil {
-		return err
-	}
-	// Writes the change to the appropriate file
-	err = a.WriteGoAst()
-	if err != nil {
-		return err
-	}
-```
-
-Higher order of execution of ```Generate.go```:
-1. Copy entire P2PRC project and ignores files which are not meant to be copied 
-2. The folder name will be based on the new project name and the module name based on the new 
-   module name provided.
-3. Modifies the appropriate imports in the project as instructed in the code. 
-4. Creates a commit with the new changes in the new project. 
-
-
-- ### ``` modifyGenerate.go```: 
-  This a really simple implementation where we replace the imports 
-  in certain files as instructed from ```generate.go```. To do we create an AST (i.e Abstract Syntax tree)
-  from new file we want to change the imports in. AST create a tree structure of expression. To change the 
-  import we can just traverse to the appropriate expression and change the value of that expression in 
-  the case of modifying imports. This approach is more simple than using templates.
-
-

Docs/Implementation.md

@@ -1,20 +1,23 @@
 # Implementation
+| [◀ Previous](Introduction.md) | [Back to TOC](README.md) |
+|:-----------:|---------|
+
 This chapter describes how the project was built. It talks in depth of the implementation
 performed to give a better understanding of the project.
 
 ## Programming langauge used
-The programming language used for this project was Golang. The reason Go lang was chosen was
-because it is a compiled language.
+The programming language used for this project was [Golang](https://go.dev/). The reason Go lang was chosen was
+because it is a compiled language.<br>
 The entire codebase is just a single binary file. When
 distributing to other linux distributing the only requirement would be the binary file to run the
-code. It is easy to write independant modules and be monolithic at the sametime using Go. Using
-Go.mod makes it very easy to handle external libraries and modularise code. The go.mod name for
-the project is git.sr.ht/~akilan1999/p2p-rendering-computation.
+code. It is easy to write independant modules and be monolithic at the sametime using Go.<br>
+Using Go.mod makes it very easy to handle external libraries and modularise code. The go.mod name for
+the project is [git.sr.ht/~akilan1999/p2p-rendering-computation](https://git.sr.ht/~akilan1999/p2p-rendering-computation).
 
-## [Cli Module](CliImplementation.md)
-## [Config Module](ConfigImplementation.md)
-## [Server Module](ServerImplementation.md)
-## [Client Module](ClientImplementation.md)
-## [P2P Module](P2PImplementation.md)
-## [Plugin Module](PluginImplementation.md)
-## [Generate Module](GenerateImplementation.md)
+- ## [Cli Module](CliImplementation.md)
+- ## [Config Module](ConfigImplementation.md)
+- ## [Server Module](ServerImplementation.md)
+- ## [Client Module](ClientImplementation.md)
+- ## [P2P Module](P2PImplementation.md)
+- ## [Plugin Module](PluginImplementation.md)
+- ## [Generate Module](GenerateImplementation.md)

Docs/Installation.md

@@ -1,9 +1,12 @@
 # Installation
 
+| [◀ Previous](Introduction.md) | [Next ▶](Abstractions.md) |
+|:-----------:|---------|
+
 Over here we will cover the basic steps to get the server and client side running. 
 
-## Alpha release install 
-https://github.com/Akilan1999/p2p-rendering-computation/releases/tag/v1.0.0-alpha
+## Latest release install 
+https://github.com/Akilan1999/p2p-rendering-computation/releases
 
 ## Install from Github master branch 
 
@@ -39,7 +42,7 @@ To set up P2PRC on Windows, simply run this batch file.
 .\install.bat
 ```
 
-### Add appropriate paths to .bashrc
+### Add appropriate paths to `.bashrc`
 ```
 export P2PRC=/<PATH>/p2p-rendering-computation
 export PATH=/<PATH>/p2p-rendering-computation:${PATH}
@@ -65,7 +68,7 @@ USAGE:
    p2prc [global options] command [command options] [arguments...]
 
 VERSION:
-   1.0.0
+   2.0.0
 
 COMMANDS:
    help, h  Shows a list of commands or help for one command
@@ -78,7 +81,8 @@ GLOBAL OPTIONS:
    --ViewImages value, --vi value         View images available on the server IP address [$VIEW_IMAGES]
    --CreateVM value, --touch value        Creates Docker container on the selected server [$CREATE_VM]
    --ContainerName value, --cn value      Specifying the container run on the server side [$CONTAINER_NAME]
-   --RemoveVM value, --rm value           Stop and Remove Docker container [$REMOVE_VM]
+   --BaseImage value, --bi value          Specifying the docker base image to template the dockerfile [$CONTAINER_NAME]
+   --RemoveVM value, --rm value           Stop and Remove Docker container (IP:port) accompanied by container ID via --ID or --id [$REMOVE_VM]
    --ID value, --id value                 Docker Container ID [$ID]
    --Ports value, -p value                Number of ports to open for the Docker Container [$NUM_PORTS]
    --GPU, --gpu                           Create Docker Containers to access GPU (default: false) [$USE_GPU]
@@ -86,10 +90,23 @@ GLOBAL OPTIONS:
    --SetDefaultConfig, --dc               Sets a default configuration file (default: false) [$SET_DEFAULT_CONFIG]
    --NetworkInterfaces, --ni              Shows the network interface in your computer (default: false) [$NETWORK_INTERFACE]
    --ViewPlugins, --vp                    Shows plugins available to be executed (default: false) [$VIEW_PLUGIN]
-   --TrackedContainers, --tc              View containers which have been created from the client side  (default: false) [$TRACKED_CONTAINERS]
+   --TrackedContainers, --tc              View (currently running) containers which have been created from the client side  (default: false) [$TRACKED_CONTAINERS]
    --ExecutePlugin value, --plugin value  Plugin which needs to be executed [$EXECUTE_PLUGIN]
+   --CreateGroup, --cgroup                Creates a new group (default: false) [$CREATE_GROUP]
+   --Group value, --group value           group flag with argument group ID [$GROUP]
+   --Groups, --groups                     View all groups (default: false) [$GROUPS]
+   --RemoveContainerGroup, --rmcgroup     Remove specific container in the group (default: false) [$REMOVE_CONTAINER_GROUP]
+   --RemoveGroup value, --rmgroup value   Removes the entire group [$REMOVE_GROUP]
+   --MAPPort value, --mp value            Maps port for a specific port provided as the parameter [$MAPPORT]
+   --DomainName value, --dn value         While mapping ports allows to set a domain name to create a mapping in the proxy server [$DOMAINNAME]
+   --Generate value, --gen value          Generates a new copy of P2PRC which can be modified based on your needs [$GENERATE]
+   --ModuleName value, --mod value        New go project module name [$MODULENAME]
+   --PullPlugin value, --pp value         Pulls plugin from git repos [$PULLPLUGIN]
+   --RemovePlugin value, --rp value       Removes plugin [$REMOVEPLUGIN]
+   --AddMetaData value, --amd value       Adds metadata about the current node in the p2p network which is then propagated through the network [$ADDMETADATA]
    --help, -h                             show help (default: false)
    --version, -v                          print the version (default: false)
+
 ```
 
 <br>
@@ -101,7 +118,7 @@ GLOBAL OPTIONS:
 # Using basic commands 
 
 ### Start as a server 
-Do ensure you have docker installed for this 
+Do ensure you have Docker installed for this 
 ```
 p2prc -s 
 ```
@@ -195,6 +212,16 @@ p2prc --pp <repo link>
 p2prc --rp <plugin name> 
 ```
 
+### Added custom metadata about the current node
+```
+p2prc --amd "custom metadata"
+```
+
+### Map port
+```
+p2prc --mp <internal port no from your machine> --dn <domain name you want the port linked to>
+```
+
 <br>
 
 --------------
@@ -210,23 +237,17 @@ This feature is still Under Development:
   - Debian/ubuntu: ```sudo apt install ansible```
   - Others: [Installation link](https://ansible-tips-and-tricks.readthedocs.io/en/latest/ansible/install/)
   
-#### Set ansible host_key_checking to false 
-- On linux
-  - ```sudo nano /etc/ansible/ansible.cfg```: Open the following file. If this file is not found then where
-    ever the file ```ansible.cfg``` is located.
-  -  Add or uncomment ```host_key_checking = False```
-  
 #### Run Test Cases 
 - Generate Test Case Ansible file 
   - ```make testcases```
-- Enter inside plugin directory and run tests. 
-  Note: That docker needs to installed and needs to run without 
-  sudo. Refer the section install Docker. 
-  - ```cd plugin```
-  - ```go test .```
-  
-
-  
+- Enter inside plugin directory and run tests.<br>
 
+> [!NOTE]
+> That docker needs to installed and needs to run without
+> sudo. Refer the section [Install Docker](#install-docker). 
+> - ```cd plugin```
+> - ```go test .```
 
+---
   
+### Next Chapter: [Abstractions](Abstractions.md)

Docs/Introduction.md

@@ -1,5 +1,8 @@
 # Chapter 1: Introduction
 
+| [◀ Back to TOC](README.md) | [Next ▶](Installation.md) |
+|:-----------:|---------|
+
 ## Abstract
 This project focuses on creating a framework on running heavy tasks that a regular computer
 cannot run easily such as graphically demanding video games, rendering 3D animations , protein
@@ -21,7 +24,7 @@ run these heavy tasks can be really useful. Ethically speaking this is leading t
 computing power similar to what is happening in the web server area. By using peer to peer
 principles it is possible to remove the monopolisation factor and increase the bandwidth between
 the client and server.
-
+<!-- 
 ## Aim
 This project aims to create a peer to peer (p2p) network, where a user can use the p2p network to
 act as a client (i.e sending tasks) or the server (i.e executing the tasks). A prototype application will
@@ -33,4 +36,8 @@ or virtual environments across selected nodes.
 rendering tools and tools to batch any sort of tasks.
 - Creating p2p network
 - Server to create a containerised environment
-- The client node to run tasks on Server containerised node
+- The client node to run tasks on Server containerised node -->
+
+---
+
+### Next Chapter: [Installation](Installation.md)

Docs/P2P.md

@@ -19,11 +19,9 @@ In this repository the P2P module has been designed from sratch at the point of
 
 
 ## Responsibility 
-- To perform speed test to determine best node to connect 
 - To ensure the IP table has nodes which are pingable 
-- Using techniques such as [UPNP](https://en.wikipedia.org/wiki/Universal_Plug_and_Play). Still under development
-- Port Forwarding (To be introducted in a future release) 
+- Taking to nodes behind NAT. [More about the implementation](NAT-Traversal)...
 
 
-## Note:
-If you are running in server mode it is recommended to use [DMZ](https://routerguide.net/when-and-how-to-setup-dmz-host-for-home-use/) to bypass the [NAT](https://en.wikipedia.org/wiki/Network_address_translation). 
+> [!NOTE]
+> If you are running in server mode it is recommended to use [DMZ](https://routerguide.net/when-and-how-to-setup-dmz-host-for-home-use/) to bypass the [NAT](https://en.wikipedia.org/wiki/Network_address_translation). 

Docs/P2PImplementation.md

@@ -1,10 +1,20 @@
 # P2P Module Implementation 
+
+The P2P module (i.e Peer to Peer Module) is responsible for storing the IP table and interacting
+with the IP table. In the following implementation of the P2P module ,the IP table stores
+information about servers available in the network. The other functionality the P2P module takes
+care of is doing the appropriate speed tests to the servers in the IP table. This is for informing the
+users about nodes which are close by and nodes which have quicker uploads and downloads
+speeds. The module is responsible to ensure that there are no duplicate server IPs in the IP table
+and to remove all server IPs which are not pingable.
+
+![UML diagram of P2P module](images/p2pmoduleArch.png)
+
 The peer to peer implementation was built from scratch. This is because other peer to peer
 libraries were on the implementation of the Distributed hash table. At the current moment all
 those heavy features are not needed because the objective is to search and list all possible servers
 available. The limitation being that to be a part of the network the user has to know at least 1
-server and has to have DMZ enabled from the router if the user wants to act as a server out of the
-users local network. The advantage of building from scratch makes the module super light and
+server. The advantage of building from scratch makes the module super light and
 possibility for custom functions and structs. The sub topics below will mention the
 implementations of each functionality in depth.
 
@@ -23,27 +33,53 @@ path of the IP table json file is received from the configuration module.
       "latency": "<latency>",
       "download": "<download>",
       "upload": "<upload>"
-      "port no": "<server port no>"
+      "port no": "<server port no>",
     }
   ]
 }
 ```
 
-## Speed Test
-The speed test functions populate the fields which are latency, download, upload speed. Before the
-speed test begins for each server IP address. The p2p module ensures that each server IP address
-is pingable. If the server IP address is not pingable then it removes that IP address from the struct.
-
 ### Latency
 The latency is measured in milliseconds. The route /server_info is called from the
 server and time it takes to provide a json response is recorded.
 
-### Download speed 
-The download speed is measured as (<file size>/<time taken to
-download>)*8. This gives the result in megabits per second. The file downloaded is a 50 mb
-auto generated file.
+## NAT Traversal
+P2PRC currently supports TURN for NAT traversal. 
+
+
+
+## TURN 
+The current TURN implementation used is FRP. The TURN server is also required when 
+a P2PRC node is acting as a Server. The TURN server is determined based on the Node 
+with the least amount of latency based on the Nodes available on the IPTable. 
+Once a TURN server is determined there are 2 actions performed. The first one is 
+```/FRPPort``` to the TURN server to receive a port which is used to generate the external 
+port from the TURN server. The flow below describes the workflow.
+
+### Client mode
+- Call ```/FRPPort```
+```
+http://<turn server ip>:<server port no>/FRPport
+```
+- Call the TURN server in the following manner. The following is a sample code snippet below. 
+```go
+import (
+    "github.com/Akilan1999/p2p-rendering-computation/p2p/frp"
+)
+
+func main() {
+  serverPort, err := frp.GetFRPServerPort("http://" + <lowestLatencyIpAddress.Ipv4> + ":" + lowestLatencyIpAddress.ServerPort)
+   if err != nil {
+    return nil, err
+   }
+   // Create 1 second delay to allow FRP server to start
+   time.Sleep(1 * time.Second)
+   // Starts FRP as a client with
+   proxyPort, err := frp.StartFRPClientForServer(<lowestLatencyIpAddress.Ipv4>, serverPort, <the port you want to expose externally>)
+   if err != nil {
+     return nil, err
+   }
+}
+```
+
 
-### Upload speed 
-The upload speed is measured as (<file size>/<time taken to upload>)*8. This
-gives the results in megabits per second. The file uploaded is a 50 mb auto generated file.
-The route /upload is called from the server side to upload the file.

Docs/PluginImplementation.md

@@ -54,22 +54,23 @@ nodes to execute Ansible instructions. In this project this file needs to be set
 go code or binary will populate this file automatically with the appropriate information required to connect to local or 
 remote containers. 
 
-#### Note: Add as exactly specified below 
-```
-all:
-  vars:
-    ansible_python_interpreter: /usr/bin/python3 // Path to your python 3 interpreter 
-main:
-  hosts:
-    host1:
-      // Note: These values will be automatically overwritten 
-      // by the Go functions 
-      ansible_host: 0.0.0.0 
-      ansible_port: 39269
-      ansible_user: master
-      ansible_ssh_pass: password
-      ansible_sudo_pass: password
-```
+> [!NOTE]
+> Add as exactly specified below: 
+> ```
+>all:
+>  vars:
+>    ansible_python_interpreter: /usr/bin/python3 // Path to your python 3 interpreter 
+>main:
+>  hosts:
+>    host1:
+>      // Note: These values will be automatically overwritten 
+>      // by the Go functions 
+>      ansible_host: 0.0.0.0 
+>      ansible_port: 39269
+>      ansible_user: master
+>      ansible_ssh_pass: password
+>      ansible_sudo_pass: password
+>```
 
 ## Ports.json 
 The ```ports.json``` file is intended to mention the number of ports required 

Docs/Problems.md

@@ -1,35 +0,0 @@
-# Problems in implementation 
-
-### Number of Devices in the network: 
-The current implementation has the major flaw which is that 
-the server has to be in port 8088 to detected in the public 
-network. As we know most personal networks have a single IP 
-address. This means we cannot have duplicate ports. A fix can 
-be to mention the open port on the IP table file.
-(Ex: Possible feild to be added)
-```
-{
- "ip_address": [
-  {
-   "ipv4": "localhost",
-   "latency": 14981051,
-   "download": 8142.122540206258,
-   "upload": 3578.766512629995,
-   "port": 8088
-  }
- ]
-}
-```
-
-### Broadcast of container specs 
-At the moment the container specs are not broadcasted rather 
-just the machines specs and this module has yet to be tested 
-rigorously. 
-
-### Intergration with GPU
-Certain machines have GPUs present in them which provide a 
-huge advantage for those who want to do rendering and certain 
-sort of computation. The Aim is to only allow it to be compatible
-with Nvidia. But an better idea would be to provide compatability
-with multiple GPU providers. 
-

Docs/README.md

@@ -3,10 +3,10 @@
 1. [Introduction](Introduction.md)
 2. [Installation](Installation.md)
 3. [Abstractions](Abstractions.md)
-3. [Design Architecture](DesignArchtectureIntro.md)
+<!-- 3. [Design Architecture](DesignArchtectureIntro.md)
    1. [Client Module](ClientArchitecture.md)
    2. [P2P Module](P2PArchitecture.md)
-   3. [Server Module](ServerArchitecture.md)
+   3. [Server Module](ServerArchitecture.md) -->
 4. [Implementation](Implementation.md) 
    1. [Client Module](ClientImplementation.md)
    2. [P2P Module](P2PImplementation.md)
@@ -14,5 +14,6 @@
    4. [Config Module](ConfigImplementation.md)
    5. [Cli Module](CliImplementation.md)
    6. [Plugin Module](PluginImplementation.md)
-5. [Problems](https://github.com/Akilan1999/p2p-rendering-computation/issues)   
+   7. [Language bindings](Bindings.md)
+<!-- 5. [Problems](https://github.com/Akilan1999/p2p-rendering-computation/issues)    -->
 

Docs/ServerImplementation.md

@@ -4,6 +4,14 @@ This section focuses on an in-depth understanding of the server module implement
 understand the architecture of the server module refer. The server module can be split
 into various sections. Each section will provide information on how a certain feature works.
 
+The server module takes care of setting and removing the virtualization environment (i.e
+containers) for accessing and doing the appropriate computation. It also interacts with the peer to
+peer module to update the IP table on the server side. The server module
+accesses information regarding CPU and GPU specifications of the machine running the server
+module. To do Speed tests the server has routes which allows it to upload and download a 50mb.
+
+![UML diagram of server module](images/servermoduleArch.png)
+
 ## Web framework
 The web framework used for the server module is called Gin. The reason Gin was chosen is due to
 its wide use and strong documentation available on the official github repository. The default

Makefile

@@ -9,3 +9,12 @@ testcases:
 run:
 	go run main.go
 
+sharedObjects:
+	sh build-bindings.sh
+
+python:
+	sh build-python-package.sh
+
+clean:
+	go clean -modcache
+	rm -fr .go-build vendor result*

README.md

@@ -1,3 +1,6 @@
+> [!NOTE]
+> Fixing documentation to latest changes. If you have any questions setting up P2PRC either [create an issue](https://github.com/Akilan1999/p2p-rendering-computation/issues/new/choose) or send me an email (me AT akilan dot io).
+> Currently HEAD is always intended to stay on a working state. It is recommended to always use HEAD in your go.mod file.
 
 <h1 align="center">
   <br>
@@ -18,20 +21,40 @@ The main aim of this project was to create a custom peer to peer network. The us
 client has total flexibility on how to batch the tasks and the user acting as the server has complete
 flexibility on tracking the container's usages and killing the containers at any point of time. 
 
-## Gophers talk 
-[![IMAGE ALT TEXT](https://i.ytimg.com/vi/ovcZLEhQxWk/hqdefault.jpg)](https://www.youtube.com/watch?v=ovcZLEhQxWk "P2PRC - Gophers monthly talk")
+## Latest tutorial
+[![IMAGE ALT TEXT](https://i.ytimg.com/vi/OMwCpedu5cs/hqdefault.jpg)](https://www.youtube.com/watch?v=OMwCpedu5cs")
 
 <br>
 
-## Table of contents
+## Table of contents in the current README 
 1. [Introduction](#Introduction)
-2. [Installation](#Installation.md)
+2. [Installation](#extend-your-application-with-p2prc)
 3. [Design Architecture](#Design-Architecture)
 4. [Implementation](#Implementation) 
 5. [Find out more](#Find-out-more)
 
 <br>
 
+# Table of contents in the Docs folder 
+1. [Introduction](Docs/Introduction.md)
+2. [Installation](Docs/Installation.md)
+3. [Abstractions](Docs/Abstractions.md)
+<!-- 3. [Design Architecture](DesignArchtectureIntro.md)
+   1. [Client Module](ClientArchitecture.md)
+   2. [P2P Module](P2PArchitecture.md)
+   3. [Server Module](ServerArchitecture.md) -->
+4. [Implementation](Docs/Implementation.md) 
+   1. [Client Module](Docs/ClientImplementation.md)
+   2. [P2P Module](Docs/P2PImplementation.md)
+   3. [Server Module](Docs/ServerImplementation.md)
+   4. [Config Module](Docs/ConfigImplementation.md)
+   5. [Cli Module](Docs/CliImplementation.md)
+   6. [Plugin Module](Docs/PluginImplementation.md)
+   7. [Language Bindings](Docs/Bindings.md)
+<!-- 5. [Problems](https://github.com/Akilan1999/p2p-rendering-computation/issues)    -->
+
+<br>
+
 ## Introduction
 This project aims to create a peer to peer (p2p) network, where a user can use the p2p network to act as a client (i.e sending tasks) or the server (i.e executing the tasks). A prototype application will be developed, which comes bundled with a p2p module and possible to execute docker containers or virtual environments across selected nodes.
 
@@ -49,21 +72,37 @@ This project aims to create a peer to peer (p2p) network, where a user can use t
 ```go
 package main
 
-import "github.com/Akilan1999/p2p-rendering-computation/abstractions"
+import (
+	"fmt"
+	"github.com/Akilan1999/p2p-rendering-computation/abstractions"
+)
 
 func main() {
-    // Initialize with base p2prc config files
-    err := abstractions.Init("TEST")
-    if err != nil {
-        return
-    }
+	_, err := abstractions.Init(nil)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
 
-    // start p2prc
-    _, err = abstractions.Start()
-    if err != nil {
-        return
-    }
+	// start p2prc
+	_, err = abstractions.Start()
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	// Run server till termination
+	for {
+
+	}
 }
+
+```
+
+### Export once this is added export P2PRC as environment paths 
+```
+export P2PRC=<PROJECT PATH>
+export PATH=<PROJECT PATH>:${PATH}
 ```
 [Read more](Docs/Abstractions.md) ...
 
@@ -123,4 +162,3 @@ or just providing feedback on new features to build  or even just curious about
 [![Support Server](https://discordapp.com/api/guilds/854397492795277322/widget.png?style=banner2)](https://discord.gg/b4nRGTjYqy)
 
 [![Star History Chart](https://api.star-history.com/svg?repos=Akilan1999/p2p-rendering-computation&type=Date)](https://github.com/Gaurav-Gosain)
-

abstractions/base.go

@@ -0,0 +1,88 @@
+package abstractions
+
+import "C"
+import (
+	"github.com/Akilan1999/p2p-rendering-computation/client"
+	"github.com/Akilan1999/p2p-rendering-computation/client/clientIPTable"
+	Config "github.com/Akilan1999/p2p-rendering-computation/config"
+	"github.com/Akilan1999/p2p-rendering-computation/config/generate"
+	"github.com/Akilan1999/p2p-rendering-computation/p2p"
+	"github.com/Akilan1999/p2p-rendering-computation/server"
+	"github.com/Akilan1999/p2p-rendering-computation/server/docker"
+	"github.com/gin-gonic/gin"
+	"os"
+)
+
+// Init Initialises p2prc
+func Init(customConfig interface{}) (config *Config.Config, err error) {
+
+	// Get config file path
+	// Checks P2PRC path initially
+	// - Get PATH if environment varaible
+	path, err := Config.GetPathP2PRC("P2PRC")
+	if err != nil {
+		return
+	}
+	// check if the config file exists
+	if _, err = os.Stat(path + "config.json"); err != nil {
+		// Initialize with base p2prc config files
+		// set the config file with default paths
+		config, err = generate.SetDefaults("P2PRC", false, customConfig, false)
+		if err != nil {
+			return
+		}
+	} else {
+		// If the configs are available then use them over generating new ones.
+		config, err = Config.ConfigInit(nil, nil)
+		if err != nil {
+			return
+		}
+	}
+
+	return
+}
+
+// Start p2prc in a server mode
+func Start() (*gin.Engine, error) {
+	engine, err := server.Server()
+	if err != nil {
+		return nil, err
+	}
+	return engine, nil
+}
+
+// MapPort Creates a reverse proxy connection and maps the appropriate port
+func MapPort(port string) (entireAddres string, mapPort string, err error) {
+	entireAddres, mapPort, err = server.MapPort(port)
+	return
+}
+
+// StartContainer Starts docker container on the remote machine
+func StartContainer(IP string) (container *docker.DockerVM, err error) {
+	container, err = client.StartContainer(IP, 0, false, "", "")
+	return
+}
+
+// RemoveContainer Removes docker container based on the IP address and ID
+// provided
+func RemoveContainer(IP string, ID string) error {
+	return client.RemoveContianer(IP, ID)
+}
+
+// GetSpecs Get spec information about the remote server
+func GetSpecs(IP string) (specs *server.SysInfo, err error) {
+	specs, err = client.GetSpecs(IP)
+	return
+}
+
+// ViewIPTable View information of nodes in the network
+func ViewIPTable() (table *p2p.IpAddresses, err error) {
+	table, err = p2p.ReadIpTable()
+	return
+}
+
+// UpdateIPTable Force updates IP tables based on new
+// new nodes discovered in the network
+func UpdateIPTable() (err error) {
+	return clientIPTable.UpdateIpTableListClient()
+}

abstractions/init.go

@@ -1,27 +0,0 @@
-package abstractions
-
-import (
-	"github.com/Akilan1999/p2p-rendering-computation/config"
-	"github.com/Akilan1999/p2p-rendering-computation/config/generate"
-	"github.com/Akilan1999/p2p-rendering-computation/server"
-	"github.com/gin-gonic/gin"
-)
-
-// Init Initialises p2prc
-func Init(name string, customConfig interface{}) (config *config.Config, err error) {
-	// set the config file with default paths
-	config, err = generate.SetDefaults(name, false, customConfig, false)
-	if err != nil {
-		return
-	}
-	return
-}
-
-// Start p2prc in a server mode
-func Start() (*gin.Engine, error) {
-	engine, err := server.Server()
-	if err != nil {
-		return nil, err
-	}
-	return engine, nil
-}

artwork/README.md

@@ -4,13 +4,11 @@
 ## Pure HTML Version of the p2prc Logo :)
 ![p2prc Logo](https://user-images.githubusercontent.com/55647468/204634868-07e94b6d-65f5-4446-a11f-7a14f11edff9.png)
 
-> Note: To change the size of the logo simply edit the CSS variable of `--size` under the `style` tag!
+> [!NOTE]
+> To change the size of the logo simply edit the CSS variable of `--size` under the `style` tag!
 
 ---
 
 ### Embedding the HTML as a `foreignObject` element inside an SVG directly
 
 ![](embed.svg)
-
-
-

build-bindings.sh

@@ -0,0 +1 @@
+cd Bindings && go build -buildmode=c-shared -o p2prc.so

build-python-package.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/bash
+
+# Create export directory for python
+mkdir Bindings/python/export
+
+# Creating SharedObjects directory for python
+mkdir Bindings/python/export/SharedObjects
+
+sh build-bindings.sh
+
+cp Bindings/p2prc.h Bindings/python/export/SharedObjects/
+cp Bindings/p2prc.so Bindings/python/export/SharedObjects/
+
+cp Bindings/python/p2prc.py Bindings/python/export/
+
+echo "Output is in the Directory Bindings/python/export/"
+
+# Architectures for Linux
+#archs=(amd64 arm64)
+#
+#for arch in ${archs[@]}
+#do
+#  mkdir Bindings/python/export/SharedObjects/linux-${arch}
+#  cd Bindings/
+#	env GOOS=linux GOARCH=${arch} go build -buildmode=c-shared -o python/export/SharedObjects/linux-${arch}/p2prc.so
+#	echo "GOOS=linux GOARCH=${arch} go build -buildmode=c-shared -o python/export/SharedObjects/linux-${arch}/p2prc.so"
+#	cd ..
+#done

client/MAPPort.go

@@ -0,0 +1,32 @@
+package client
+
+import (
+	"github.com/Akilan1999/p2p-rendering-computation/config"
+	"io/ioutil"
+	"net/http"
+)
+
+func MAPPort(port string) (string, error) {
+	Config, err := config.ConfigInit(nil, nil)
+	if err != nil {
+		return "", err
+	}
+
+	//if version == "version 6" {
+	URL := "http://0.0.0.0:" + Config.ServerPort + "/MAPPort?port=" + port
+	//} else {
+	//	URL = "http://" + IP + ":" + serverPort + "/server_info"
+	//}
+	resp, err := http.Get(URL)
+	if err != nil {
+		return "", err
+	}
+
+	// Convert response to byte value
+	byteValue, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	return string(byteValue), nil
+}

client/clientIPTable/AddCustomInformationToIPTable.go

@@ -0,0 +1,40 @@
+package clientIPTable
+
+import (
+	"errors"
+	"github.com/Akilan1999/p2p-rendering-computation/config"
+	"github.com/Akilan1999/p2p-rendering-computation/p2p"
+)
+
+func AddCustomInformationToIPTable(text string) error {
+	// Get config information
+	Config, err := config.ConfigInit(nil, nil)
+	if err != nil {
+		return err
+	}
+
+	// Get IPTable information
+	table, err := p2p.ReadIpTable()
+	if err != nil {
+		return err
+	}
+
+	found := false
+
+	for i, _ := range table.IpAddress {
+		if table.IpAddress[i].Name == Config.MachineName {
+			table.IpAddress[i].CustomInformation = text
+			found = true
+		}
+	}
+
+	if found {
+		table.WriteIpTable()
+		// update IPTable after modified entry
+		UpdateIpTableListClient()
+	} else {
+		return errors.New("start server with p2prc -s as the server is currently not running")
+	}
+
+	return nil
+}

client/clientIPTable/Iptable.go

@@ -150,6 +150,15 @@ func UpdateIpTableListClient() error {
     return nil
 }
 
+func RemoveOfflineNodes() error {
+    // Ensure that the IP Table has Node pingable
+    err := p2p.LocalSpeedTestIpTable()
+    if err != nil {
+        return err
+    }
+    return nil
+}
+
 // SendPostRequest Sends a file as a
 //POST request.
 // Reference (https://stackoverflow.com/questions/51234464/upload-a-file-with-post-request-golang)

client/container.go

@@ -1,8 +1,10 @@
 package client
 
 import (
+	b64 "encoding/base64"
 	"encoding/json"
 	"fmt"
+	"github.com/Akilan1999/p2p-rendering-computation/config"
 	"github.com/Akilan1999/p2p-rendering-computation/p2p"
 	"github.com/Akilan1999/p2p-rendering-computation/server/docker"
 	"io/ioutil"
@@ -19,7 +21,7 @@ var (
 // From the selected server IP address
 // TODO: Test cases for this function
 // Calls URL ex: http://0.0.0.0:8088/startcontainer?ports=0&GPU=false&ContainerName=docker-ubuntu-sshd
-func StartContainer(IP string, NumPorts int, GPU bool, ContainerName string) (*docker.DockerVM, error) {
+func StartContainer(IP string, NumPorts int, GPU bool, ContainerName string, baseImage string) (*docker.DockerVM, error) {
 	// Passes URL with number of TCP ports to allocated and to give GPU access to the docker container
 	var URL string
 	//version := p2p.Ip4or6(IP)
@@ -33,9 +35,22 @@ func StartContainer(IP string, NumPorts int, GPU bool, ContainerName string) (*d
 	//if version == "version 6" {
 	//	URL = "http://[" + IP + "]:" + serverPort + "/startcontainer?ports=" + fmt.Sprint(NumPorts) + "&GPU=" + strconv.FormatBool(GPU) + "&ContainerName=" + ContainerName
 	//} else {
-	URL = "http://" + IP + "/startcontainer?ports=" + fmt.Sprint(NumPorts) + "&GPU=" + strconv.FormatBool(GPU) + "&ContainerName=" + ContainerName
-	//}
+	// Get config information
+	Config, err := config.ConfigInit(nil, nil)
+	if err != nil {
+		return nil, err
+	}
 
+	// Get public key
+	PublicKey, err := Config.GetPublicKey()
+	if err != nil {
+		return nil, err
+	}
+
+	// Used in URL to pass public key -> b64.StdEncoding.EncodeToString([]byte(PublicKey))
+	URL = `http://` + IP + `/startcontainer?ports=` + fmt.Sprint(NumPorts) + `&GPU=` + strconv.FormatBool(GPU) + `&ContainerName=` + ContainerName + `&BaseImage=` + baseImage + `&PublicKey=` + b64.StdEncoding.EncodeToString([]byte(PublicKey))
+
+	// Encode URL due to public key passed.
 	resp, err := http.Get(URL)
 	if err != nil {
 		return nil, err

cmd/action.go

@@ -1,277 +1,298 @@
 package cmd
 
 import (
-    "fmt"
-    "github.com/Akilan1999/p2p-rendering-computation/client"
-    "github.com/Akilan1999/p2p-rendering-computation/client/clientIPTable"
-    "github.com/Akilan1999/p2p-rendering-computation/config/generate"
-    "github.com/Akilan1999/p2p-rendering-computation/p2p"
-    "github.com/Akilan1999/p2p-rendering-computation/plugin"
-    "github.com/Akilan1999/p2p-rendering-computation/server"
-    "github.com/urfave/cli/v2"
+	"fmt"
+	"github.com/Akilan1999/p2p-rendering-computation/client"
+	"github.com/Akilan1999/p2p-rendering-computation/client/clientIPTable"
+	"github.com/Akilan1999/p2p-rendering-computation/config/generate"
+	"github.com/Akilan1999/p2p-rendering-computation/p2p"
+	"github.com/Akilan1999/p2p-rendering-computation/plugin"
+	"github.com/Akilan1999/p2p-rendering-computation/server"
+	"github.com/urfave/cli/v2"
 )
 
 var CliAction = func(ctx *cli.Context) error {
-    if Server {
-        _, err := server.Server()
-        if err != nil {
-            fmt.Print(err)
-        }
-        //server.Rpc()
-        for {
+	if Server {
+		_, err := server.Server()
+		if err != nil {
+			fmt.Print(err)
+		}
+		//server.Rpc()
+		for {
 
-        }
-    }
+		}
+	}
 
-    //Listing servers and also updates IP tables (Default 3 hops)
-    if UpdateServerList {
-        err := clientIPTable.UpdateIpTableListClient()
-        if err != nil {
-            fmt.Print(err)
-        }
-        // Reads from ip table and passes it
-        // on to struct print function
-        //Servers, err := p2p.ReadIpTable()
-        //if err != nil {
-        //	return err
-        //}
-        //client.PrettyPrint(Servers)
-        p2p.PrintIpTable()
-    }
+	//Listing servers and also updates IP tables (Default 3 hops)
+	if UpdateServerList {
+		err := clientIPTable.UpdateIpTableListClient()
+		if err != nil {
+			fmt.Print(err)
+		}
+		// Reads from ip table and passes it
+		// on to struct print function
+		//Servers, err := p2p.ReadIpTable()
+		//if err != nil {
+		//	return err
+		//}
+		//client.PrettyPrint(Servers)
+		p2p.PrintIpTable()
+	}
 
-    // Displays the IP table
-    if ServerList {
-        // Reads from ip table and passes it
-        // on to struct print function
-        //Servers, err := p2p.ReadIpTable()
-        //if err != nil {
-        //	return err
-        //}
-        p2p.PrintIpTable()
-    }
+	// Displays the IP table
+	if ServerList {
+		// Reads from ip table and passes it
+		// on to struct print function
+		//Servers, err := p2p.ReadIpTable()
+		//if err != nil {
+		//	return err
+		//}
+		p2p.PrintIpTable()
+	}
 
-    // Add provided IP to the IP table
-    if AddServer != "" {
-        res, err := p2p.ReadIpTable()
-        if err != nil {
-            fmt.Println(err)
-        }
+	// Add provided IP to the IP table
+	if AddServer != "" {
+		res, err := p2p.ReadIpTable()
+		if err != nil {
+			fmt.Println(err)
+		}
 
-        //Create variable of type IpAddress and set IP address
-        // to it
-        var IpAddr p2p.IpAddress
+		//Create variable of type IpAddress and set IP address
+		// to it
+		var IpAddr p2p.IpAddress
 
-        //Checking if the address is a ipv4
-        // or ipv6 address
-        ip4Orip6 := p2p.Ip4or6(AddServer)
-        if ip4Orip6 == "version 6" {
-            IpAddr.Ipv6 = AddServer
-        } else {
-            IpAddr.Ipv4 = AddServer
-        }
+		//Checking if the address is a ipv4
+		// or ipv6 address
+		ip4Orip6 := p2p.Ip4or6(AddServer)
+		if ip4Orip6 == "version 6" {
+			IpAddr.Ipv6 = AddServer
+		} else {
+			IpAddr.Ipv4 = AddServer
+		}
 
-        // If a server port is provided then set it
-        if Ports != "" {
-            IpAddr.ServerPort = Ports
-        } else {
-            IpAddr.ServerPort = "8088"
-        }
-        // Append IP address to variable result which
-        // is a list
-        res.IpAddress = append(res.IpAddress, IpAddr)
-        // Adds the new server IP to the iptable
-        res.WriteIpTable()
+		// If a server port is provided then set it
+		if Ports != "" {
+			IpAddr.ServerPort = Ports
+		} else {
+			IpAddr.ServerPort = "8088"
+		}
+		// Append IP address to variable result which
+		// is a list
+		res.IpAddress = append(res.IpAddress, IpAddr)
+		// Adds the new server IP to the iptable
+		res.WriteIpTable()
 
-    }
+	}
 
-    // Displays all images available on the server side
-    if ViewImages != "" {
-        imageRes, err := client.ViewContainers(ViewImages)
+	// Displays all images available on the server side
+	if ViewImages != "" {
+		imageRes, err := client.ViewContainers(ViewImages)
 
-        if err != nil {
-            fmt.Print(err)
-        }
-        client.PrettyPrint(imageRes)
-    }
+		if err != nil {
+			fmt.Print(err)
+		}
+		client.PrettyPrint(imageRes)
+	}
 
-    // Function called to stop and remove server from Docker
-    if RemoveVM != "" {
-        if ID == "" {
-            fmt.Println("provide container ID via --ID or --id")
-        } else {
-            err := client.RemoveContianer(RemoveVM, ID)
-            if err != nil {
-                fmt.Print(err)
-            }
-        }
-    }
+	// Function called to stop and remove server from Docker
+	if RemoveVM != "" {
+		if ID == "" {
+			fmt.Println("provide container ID via --ID or --id")
+		} else {
+			err := client.RemoveContianer(RemoveVM, ID)
+			if err != nil {
+				fmt.Print(err)
+			}
+		}
+	}
 
-    //Call function to create Docker container
-    if CreateVM != "" {
+	//Call function to create Docker container
+	if CreateVM != "" {
 
-        var PortsInt int
+		var PortsInt int
 
-        if Ports != "" {
-            // Convert Get Request value to int
-            fmt.Sscanf(Ports, "%d", &PortsInt)
-        }
+		if Ports != "" {
+			// Convert Get Request value to int
+			fmt.Sscanf(Ports, "%d", &PortsInt)
+		}
 
-        // Calls function to do Api call to start the container on the server side
-        imageRes, err := client.StartContainer(CreateVM, PortsInt, GPU, ContainerName)
+		// Calls function to do Api call to start the container on the server side
+		imageRes, err := client.StartContainer(CreateVM, PortsInt, GPU, ContainerName, BaseImage)
 
-        if err != nil {
-            fmt.Print(err)
-        }
-        client.PrettyPrint(imageRes)
-    }
+		if err != nil {
+			fmt.Print(err)
+		}
+		client.PrettyPrint(imageRes)
+	}
 
-    //Call if specs flag is called
-    if Specs != "" {
-        specs, err := client.GetSpecs(Specs)
-        if err != nil {
-            return err
-        }
+	//Call if specs flag is called
+	if Specs != "" {
+		specs, err := client.GetSpecs(Specs)
+		if err != nil {
+			return err
+		}
 
-        // Pretty print
-        client.PrettyPrint(specs)
-    }
+		// Pretty print
+		client.PrettyPrint(specs)
+	}
 
-    //Sets default paths to the config file
-    if SetDefaultConfig {
-        _, err := generate.SetDefaults("P2PRC", false, nil, false)
-        if err != nil {
-            fmt.Print(err)
-        }
-    }
+	//Sets default paths to the config file
+	if SetDefaultConfig {
+		_, err := generate.SetDefaults("P2PRC", false, nil, false)
+		if err != nil {
+			fmt.Print(err)
+		}
+	}
 
-    //If the network interface flag is called
-    // Then all the network interfaces are displayed
-    if NetworkInterface {
-        err := p2p.ViewNetworkInterface()
-        if err != nil {
-            fmt.Print(err)
-        }
-    }
+	//If the network interface flag is called
+	// Then all the network interfaces are displayed
+	if NetworkInterface {
+		err := p2p.ViewNetworkInterface()
+		if err != nil {
+			fmt.Print(err)
+		}
+	}
 
-    // If the view plugin flag is called then display all
-    // plugins available
-    if ViewPlugin {
-        plugins, err := plugin.DetectPlugins()
-        if err != nil {
-            fmt.Print(err)
-        }
-        client.PrettyPrint(plugins)
-    }
+	// If the view plugin flag is called then display all
+	// plugins available
+	if ViewPlugin {
+		plugins, err := plugin.DetectPlugins()
+		if err != nil {
+			fmt.Print(err)
+		}
+		client.PrettyPrint(plugins)
+	}
 
-    // If the flag Tracked Container is called or the flag
-    // --tc
-    if TrackedContainers {
-        err, trackedContainers := client.ViewTrackedContainers()
-        if err != nil {
-            fmt.Print(err)
-        }
-        client.PrettyPrint(trackedContainers)
-    }
+	// If the flag Tracked Container is called or the flag
+	// --tc
+	if TrackedContainers {
+		err, trackedContainers := client.ViewTrackedContainers()
+		if err != nil {
+			fmt.Print(err)
+		}
+		client.PrettyPrint(trackedContainers)
+	}
 
-    //Executing plugin when the plugin flag is called
-    // --plugin
-    if ExecutePlugin != "" {
-        // To execute plugin requires the container ID or group ID provided when being executed
-        if ID != "" {
-            err := plugin.CheckRunPlugin(ExecutePlugin, ID)
-            if err != nil {
-                fmt.Println(err)
-            } else {
-                fmt.Println("Success")
-            }
-        } else {
-            fmt.Println("provide container ID via --ID or --id")
-        }
+	//Executing plugin when the plugin flag is called
+	// --plugin
+	if ExecutePlugin != "" {
+		// To execute plugin requires the container ID or group ID provided when being executed
+		if ID != "" {
+			err := plugin.CheckRunPlugin(ExecutePlugin, ID)
+			if err != nil {
+				fmt.Println(err)
+			} else {
+				fmt.Println("Success")
+			}
+		} else {
+			fmt.Println("provide container ID via --ID or --id")
+		}
 
-    }
+	}
 
-    // Executing function to create new group
-    // Creates new group and outputs JSON file
-    if CreateGroup {
-        group, err := client.CreateGroup()
-        if err != nil {
-            return err
-        }
-        client.PrettyPrint(group)
-    }
+	// Executing function to create new group
+	// Creates new group and outputs JSON file
+	if CreateGroup {
+		group, err := client.CreateGroup()
+		if err != nil {
+			return err
+		}
+		client.PrettyPrint(group)
+	}
 
-    // Actions to be performed when the
-    // group flag is called
-    // --group <Group ID>
-    if Group != "" {
-        // Remove container from group based on group ID provided
-        // --rmcgroup --id <contianer id>
-        if RemoveContainerGroup && ID != "" {
-            group, err := client.RemoveContainerGroup(ID, Group)
-            if err != nil {
-                fmt.Println(err)
-            } else {
-                client.PrettyPrint(group)
-            }
-        } else if ID != "" { // Add container to group based on group ID provided
-            // --id <Container ID>
-            group, err := client.AddContainerToGroup(ID, Group)
-            if err != nil {
-                fmt.Println(err)
-            } else {
-                client.PrettyPrint(group)
-            }
-        } else { // View all information about current group
-            group, err := client.GetGroup(Group)
-            if err != nil {
-                fmt.Println(err)
-            } else {
-                client.PrettyPrint(group)
-            }
-        }
-    }
+	// Actions to be performed when the
+	// group flag is called
+	// --group <Group ID>
+	if Group != "" {
+		// Remove container from group based on group ID provided
+		// --rmcgroup --id <contianer id>
+		if RemoveContainerGroup && ID != "" {
+			group, err := client.RemoveContainerGroup(ID, Group)
+			if err != nil {
+				fmt.Println(err)
+			} else {
+				client.PrettyPrint(group)
+			}
+		} else if ID != "" { // Add container to group based on group ID provided
+			// --id <Container ID>
+			group, err := client.AddContainerToGroup(ID, Group)
+			if err != nil {
+				fmt.Println(err)
+			} else {
+				client.PrettyPrint(group)
+			}
+		} else { // View all information about current group
+			group, err := client.GetGroup(Group)
+			if err != nil {
+				fmt.Println(err)
+			} else {
+				client.PrettyPrint(group)
+			}
+		}
+	}
 
-    // Execute function to remove entire group
-    // when remove group flag is called
-    // --rmgroup
-    if RemoveGroup != "" {
-        err := client.RemoveGroup(RemoveGroup)
-        if err != nil {
-            fmt.Println(err)
-        } else {
-            fmt.Println("Group Removed")
-        }
-    }
+	// Execute function to remove entire group
+	// when remove group flag is called
+	// --rmgroup
+	if RemoveGroup != "" {
+		err := client.RemoveGroup(RemoveGroup)
+		if err != nil {
+			fmt.Println(err)
+		} else {
+			fmt.Println("Group Removed")
+		}
+	}
 
-    // Execute Function to view all groups
-    if Groups {
-        groups, err := client.ReadGroup()
-        if err != nil {
-            fmt.Println(err)
-        } else {
-            client.PrettyPrint(groups)
-        }
-    }
+	// Execute Function to view all groups
+	if Groups {
+		groups, err := client.ReadGroup()
+		if err != nil {
+			fmt.Println(err)
+		} else {
+			client.PrettyPrint(groups)
+		}
+	}
 
-    //--------------------------------
+	//--------------------------------
 
-    if PullPlugin != "" {
-        err := plugin.DownloadPlugin(PullPlugin)
-        if err != nil {
-            fmt.Println(err)
-        } else {
-            fmt.Println("Success")
-        }
-    }
+	if PullPlugin != "" {
+		err := plugin.DownloadPlugin(PullPlugin)
+		if err != nil {
+			fmt.Println(err)
+		} else {
+			fmt.Println("Success")
+		}
+	}
 
-    if RemovePlugin != "" {
-        err := plugin.DeletePlugin(RemovePlugin)
-        if err != nil {
-            fmt.Println(err)
-        } else {
-            fmt.Println("Success")
-        }
-    }
+	if RemovePlugin != "" {
+		err := plugin.DeletePlugin(RemovePlugin)
+		if err != nil {
+			fmt.Println(err)
+		} else {
+			fmt.Println("Success")
+		}
+	}
 
-    return nil
+	if AddMetaData != "" {
+		err := clientIPTable.AddCustomInformationToIPTable(AddMetaData)
+		if err != nil {
+			fmt.Println(err)
+		} else {
+			fmt.Println("Success")
+		}
+	}
+
+	if MAPPort != "" {
+		address, err := client.MAPPort(MAPPort)
+		if err != nil {
+			return err
+		}
+		if err != nil {
+			fmt.Println(err)
+		} else {
+			fmt.Println(address)
+		}
+	}
+
+	return nil
 }

cmd/flags.go

@@ -10,6 +10,7 @@ var (
 	ViewImages           string
 	CreateVM             string
 	ContainerName        string
+	BaseImage            string
 	Ports                string
 	Server               bool
 	RemoveVM             string
@@ -28,6 +29,7 @@ var (
 	Groups               bool
 	RemoveContainerGroup bool
 	RemoveGroup          string
+	MAPPort              string
 	//FRPProxy             bool
 	// Generate only allowed in dev release
 	// -- REMOVE ON REGULAR RELEASE --
@@ -36,6 +38,7 @@ var (
 	//--------------------------------
 	PullPlugin   string
 	RemovePlugin string
+	AddMetaData  string
 )
 
 var AppConfigFlags = []cli.Flag{
@@ -89,6 +92,13 @@ var AppConfigFlags = []cli.Flag{
 		EnvVars:     []string{"CONTAINER_NAME"},
 		Destination: &ContainerName,
 	},
+	&cli.StringFlag{
+		Name:        "BaseImage",
+		Aliases:     []string{"bi"},
+		Usage:       "Specifying the docker base image to template the dockerfile",
+		EnvVars:     []string{"CONTAINER_NAME"},
+		Destination: &BaseImage,
+	},
 	&cli.StringFlag{
 		Name:        "RemoveVM",
 		Aliases:     []string{"rm"},
@@ -195,6 +205,13 @@ var AppConfigFlags = []cli.Flag{
 		EnvVars:     []string{"REMOVE_GROUP"},
 		Destination: &RemoveGroup,
 	},
+	&cli.StringFlag{
+		Name:        "MAPPort",
+		Aliases:     []string{"mp"},
+		Usage:       "Maps port for a specific port provided as the parameter",
+		EnvVars:     []string{"MAPPORT"},
+		Destination: &MAPPort,
+	},
 	// Generate only allowed in dev release
 	// -- REMOVE ON REGULAR RELEASE --
 	&cli.StringFlag{
@@ -233,4 +250,11 @@ var AppConfigFlags = []cli.Flag{
 		EnvVars:     []string{"REMOVEPLUGIN"},
 		Destination: &RemovePlugin,
 	},
+	&cli.StringFlag{
+		Name:        "AddMetaData",
+		Aliases:     []string{"amd"},
+		Usage:       "Adds metadata about the current node in the p2p network which is then propagated through the network",
+		EnvVars:     []string{"ADDMETADATA"},
+		Destination: &AddMetaData,
+	},
 }

config/config.go

@@ -1,52 +1,66 @@
 package config
 
 import (
-    "encoding/json"
-    "io/ioutil"
-    "os"
+	"encoding/json"
+	"io/ioutil"
+	"os"
 )
 
 var (
-    //defaultPath    string
-    defaults       = map[string]interface{}{}
-    configName     = "config"
-    configType     = "json"
-    configFile     = "config.json"
-    configPaths    []string
-    defaultEnvName = "P2PRC"
+	//defaultPath    string
+	defaults       = map[string]interface{}{}
+	configName     = "config"
+	configType     = "json"
+	configFile     = "config.json"
+	configPaths    []string
+	defaultEnvName = "P2PRC"
 )
 
 type Config struct {
-    MachineName              string
-    IPTable                  string
-    DockerContainers         string
-    DefaultDockerFile        string
-    SpeedTestFile            string
-    IPV6Address              string
-    PluginPath               string
-    TrackContainersPath      string
-    ServerPort               string
-    GroupTrackContainersPath string
-    FRPServerPort            string
-    BehindNAT                string
-    CustomConfig             interface{}
-    //NetworkInterface  string
-    //NetworkInterfaceIPV6Index int
+	MachineName              string
+	IPTable                  string
+	DockerContainers         string
+	DefaultDockerFile        string
+	DockerRunLogs            string
+	SpeedTestFile            string
+	IPV6Address              string
+	PluginPath               string
+	TrackContainersPath      string
+	ServerPort               string
+	GroupTrackContainersPath string
+	FRPServerPort            string
+	BehindNAT                string
+	IPTableKey               string
+	PublicKeyFile            string
+	PrivateKeyFile           string
+	BareMetal                string
+	CustomConfig             interface{}
+	//NetworkInterface  string
+	//NetworkInterfaceIPV6Index int
+}
+
+// GetCurrentPath Getting P2PRC Directory from environment variable
+func GetCurrentPath() (string, error) {
+	curDir := os.Getenv("PWD")
+	return curDir + "/", nil
 }
 
 // GetPathP2PRC Getting P2PRC Directory from environment variable
 func GetPathP2PRC(Envname string) (string, error) {
-    if Envname != "" {
-        err := SetEnvName(Envname)
-        if err != nil {
-            return "", err
-        }
-    }
-    curDir := os.Getenv(defaultEnvName)
-    if curDir == "" {
-        return curDir, nil
-    }
-    return curDir + "/", nil
+	if Envname != "" {
+		err := SetEnvName(Envname)
+		if err != nil {
+			return "", err
+		}
+	}
+	curDir := os.Getenv(defaultEnvName)
+	if curDir == "" {
+		// if the OS env path is not found then you use
+		// the current directory path.
+		currentPath, _ := GetCurrentPath()
+		return currentPath, nil
+	}
+	return curDir + "/", nil
 }
 
 // SetEnvName Sets the environment name
@@ -54,103 +68,114 @@ func GetPathP2PRC(Envname string) (string, error) {
 // your environment variable
 // This is useful when extending the use case of P2PRC
 func SetEnvName(EnvName string) error {
-    defaultEnvName = EnvName
-    // Handling error to be implemented only if needed
-    return nil
+	defaultEnvName = EnvName
+	// Handling error to be implemented only if needed
+	return nil
 }
 
 func GetEnvName() string {
-    return defaultEnvName
+	return defaultEnvName
 }
 
 // ConfigInit Pass environment name as an optional parameter
 func ConfigInit(defaultsParameter map[string]interface{}, CustomConfig interface{}, envNameOptional ...string) (*Config, error) {
-    if len(envNameOptional) > 0 {
-        defaultEnvName = envNameOptional[0]
-    }
-    //
-    ////Setting current directory to default path
-    //defaultPath, err := GetPathP2PRC(defaultEnvName)
-    //if err != nil {
-    //    return nil, err
-    //}
-    ////Paths to search for config file
-    //configPaths = append(configPaths, defaultPath)
-    //
-    ////Add all possible configurations paths
-    //for _, v := range configPaths {
-    //    viper.AddConfigPath(v)
-    //}
-    //
-    ////Read config file
-    //if err := viper.ReadInConfig(); err != nil {
-    //    // If the error thrown is config file not found
-    //    //Sets default configuration to viper
-    //    for k, v := range defaults {
-    //        viper.SetDefault(k, v)
-    //    }
-    //    viper.SetConfigName(configName)
-    //    viper.SetConfigFile(configFile)
-    //    viper.SetConfigType(configType)
-    //
-    //    if err = viper.WriteConfig(); err != nil {
-    //        return nil, err
-    //    }
-    //}
-    //
-    //// Adds configuration to the struct
-    //var config Config
-    //if err := viper.Unmarshal(&config); err != nil {
-    //    return nil, err
-    //}
-    //
-    //return &config, nil
+	if len(envNameOptional) > 0 {
+		defaultEnvName = envNameOptional[0]
+	}
+	//
+	////Setting current directory to default path
+	//defaultPath, err := GetPathP2PRC(defaultEnvName)
+	//if err != nil {
+	//    return nil, err
+	//}
+	////Paths to search for config file
+	//configPaths = append(configPaths, defaultPath)
+	//
+	////Add all possible configurations paths
+	//for _, v := range configPaths {
+	//    viper.AddConfigPath(v)
+	//}
+	//
+	////Read config file
+	//if err := viper.ReadInConfig(); err != nil {
+	//    // If the error thrown is config file not found
+	//    //Sets default configuration to viper
+	//    for k, v := range defaults {
+	//        viper.SetDefault(k, v)
+	//    }
+	//    viper.SetConfigName(configName)
+	//    viper.SetConfigFile(configFile)
+	//    viper.SetConfigType(configType)
+	//
+	//    if err = viper.WriteConfig(); err != nil {
+	//        return nil, err
+	//    }
+	//}
+	//
+	//// Adds configuration to the struct
+	//var config Config
+	//if err := viper.Unmarshal(&config); err != nil {
+	//    return nil, err
+	//}
+	//
+	//return &config, nil
 
-    defaultPath, err := GetPathP2PRC(defaultEnvName)
-    if err != nil {
-        return nil, err
-    }
+	defaultPath, err := GetPathP2PRC(defaultEnvName)
+	if err != nil {
+		return nil, err
+	}
 
-    // Open our jsonFile
-    jsonFile, err := os.Open(defaultPath + configFile)
-    // if we os.Open returns an error then handle it
-    if err != nil {
-        return nil, err
-    }
+	// Open our jsonFile
+	jsonFile, err := os.Open(defaultPath + configFile)
+	// if we os.Open returns an error then handle it
+	if err != nil {
+		return nil, err
+	}
 
-    // defer the closing of our jsonFile so that we can parse it later on
-    defer jsonFile.Close()
+	// defer the closing of our jsonFile so that we can parse it later on
+	defer jsonFile.Close()
 
-    byteValue, _ := ioutil.ReadAll(jsonFile)
+	byteValue, _ := ioutil.ReadAll(jsonFile)
 
-    var config Config
-    json.Unmarshal(byteValue, &config)
+	var config Config
+	json.Unmarshal(byteValue, &config)
 
-    if CustomConfig != nil {
-        // Convert Custom Config to byte
-        customConfigByte, err := json.Marshal(config.CustomConfig)
-        if err != nil {
-            return nil, err
-        }
+	if CustomConfig != nil {
+		// Convert Custom Config to byte
+		customConfigByte, err := json.Marshal(config.CustomConfig)
+		if err != nil {
+			return nil, err
+		}
 
-        // Again map the byte to the CustomConfig interface
-        json.Unmarshal(customConfigByte, &CustomConfig)
-    }
+		// Again map the byte to the CustomConfig interface
+		json.Unmarshal(customConfigByte, &CustomConfig)
+	}
 
-    return &config, nil
+	return &config, nil
 }
 
 func (c *Config) WriteConfig() error {
-    //Getting Current Directory from environment variable
-    //curDir := os.Getenv("REMOTEGAMING")
+	//Getting Current Directory from environment variable
+	//curDir := os.Getenv("REMOTEGAMING")
 
-    defaultPath, err := GetPathP2PRC(defaultEnvName)
-    if err != nil {
-        return err
-    }
+	defaultPath, err := GetPathP2PRC(defaultEnvName)
+	if err != nil {
+		return err
+	}
 
-    file, _ := json.MarshalIndent(c, "", " ")
+	file, _ := json.MarshalIndent(c, "", " ")
 
-    _ = ioutil.WriteFile(defaultPath+"config.json", file, 0644)
-    return nil
+	_ = ioutil.WriteFile(defaultPath+"config.json", file, 0644)
+	return nil
+}
+
+// GetPublicKey Gets public key of the current machine
+// based on the path provided on the
+// config file
+func (c *Config) GetPublicKey() (string, error) {
+	publicKey, err := ioutil.ReadFile(c.PublicKeyFile) // just pass the file name
+	if err != nil {
+		return "", err
+	}
+	return string(publicKey), nil
 }

config/generate/generate.go

@@ -1,20 +1,22 @@
 package generate
 
 import (
-    "github.com/Akilan1999/p2p-rendering-computation/config"
-    "os"
+	"github.com/Akilan1999/p2p-rendering-computation/config"
+	"math/rand"
+	"os"
+	"time"
 )
 
 var (
-    defaults       = map[string]interface{}{}
-    configPaths    []string
-    defaultEnvName = "P2PRC"
+	defaults       = map[string]interface{}{}
+	configPaths    []string
+	defaultEnvName = "P2PRC"
 )
 
 // GetPathP2PRC Getting P2PRC Directory from environment variable
 func GetPathP2PRC() (string, error) {
-    curDir := os.Getenv(defaultEnvName)
-    return curDir + "/", nil
+	curDir := os.Getenv(defaultEnvName)
+	return curDir + "/", nil
 }
 
 // SetEnvName Sets the environment name
@@ -22,110 +24,144 @@ func GetPathP2PRC() (string, error) {
 // your environment variable
 // This is useful when extending the use case of P2PRC
 func SetEnvName(EnvName string) error {
-    if EnvName != "" {
-        defaultEnvName = EnvName
-    }
-    // Handling error to be implemented only if needed
-    return nil
-}
-
-// GetCurrentPath Getting P2PRC Directory from environment variable
-func GetCurrentPath() (string, error) {
-    curDir := os.Getenv("PWD")
-    return curDir + "/", nil
+	if EnvName != "" {
+		defaultEnvName = EnvName
+	}
+	// Handling error to be implemented only if needed
+	return nil
 }
 
 // SetDefaults This function to be called only during a
 // make install
 func SetDefaults(envName string, forceDefault bool, CustomConfig interface{}, NoBoilerPlate bool, ConfigUpdate ...*config.Config) (*config.Config, error) {
-    //Setting current directory to default path
-    defaultPath, err := GetCurrentPath()
-    if err != nil {
-        return nil, err
-    }
+	//Setting current directory to default path
+	defaultPath, err := config.GetCurrentPath()
+	if err != nil {
+		return nil, err
+	}
 
-    // Set Env name
-    err = config.SetEnvName(envName)
-    if err != nil {
-        return nil, err
-    }
+	// Set Env name
+	err = config.SetEnvName(envName)
+	if err != nil {
+		return nil, err
+	}
 
-    ////Creates ip_table.json in the json directory
-    //err = Copy("p2p/ip_table.json", "p2p/iptable/ip_table.json")
-    //if err != nil {
-    //    return err
-    //}
-    //
-    ////Creates a copy of trackcontainers.json in the appropriate directory
-    //err = Copy("client/trackcontainers.json", "client/trackcontainers/trackcontainers.json")
-    //if err != nil {
-    //    return err
-    //}
-    //
-    ////Creates a copy of trackcontainers.json in the appropriate directory
-    //err = Copy("client/grouptrackcontainers.json", "client/trackcontainers/grouptrackcontainers.json")
-    //if err != nil {
-    //    return err
-    //}
+	////Creates ip_table.json in the json directory
+	//err = Copy("p2p/ip_table.json", "p2p/iptable/ip_table.json")
+	//if err != nil {
+	//    return err
+	//}
+	//
+	////Creates a copy of trackcontainers.json in the appropriate directory
+	//err = Copy("client/trackcontainers.json", "client/trackcontainers/trackcontainers.json")
+	//if err != nil {
+	//    return err
+	//}
+	//
+	////Creates a copy of trackcontainers.json in the appropriate directory
+	//err = Copy("client/grouptrackcontainers.json", "client/trackcontainers/grouptrackcontainers.json")
+	//if err != nil {
+	//    return err
+	//}
 
-    var Defaults config.Config
+	var Defaults config.Config
 
-    if len(ConfigUpdate) == 0 {
-        //Setting default paths for the config file
-        Defaults.IPTable = defaultPath + "p2p/iptable/ip_table.json"
-        Defaults.DefaultDockerFile = defaultPath + "server/docker/containers/docker-ubuntu-sshd/"
-        Defaults.DockerContainers = defaultPath + "server/docker/containers/"
-        Defaults.SpeedTestFile = defaultPath + "p2p/50.bin"
-        Defaults.IPV6Address = ""
-        Defaults.PluginPath = defaultPath + "plugin/deploy"
-        Defaults.TrackContainersPath = defaultPath + "client/trackcontainers/trackcontainers.json"
-        Defaults.GroupTrackContainersPath = defaultPath + "client/trackcontainers/grouptrackcontainers.json"
-        Defaults.ServerPort = "8088"
-        Defaults.FRPServerPort = "True"
-        Defaults.CustomConfig = CustomConfig
-        Defaults.BehindNAT = "True"
-        // Random name generator
-        hostname, err := os.Hostname()
-        if err != nil {
-            return nil, err
-        }
+	if len(ConfigUpdate) == 0 {
+		//Setting default paths for the config file
+		Defaults.IPTable = defaultPath + "p2p/iptable/ip_table.json"
+		Defaults.DefaultDockerFile = defaultPath + "server/docker/containers/docker-ubuntu-sshd/"
+		Defaults.DockerContainers = defaultPath + "server/docker/containers/"
+		Defaults.SpeedTestFile = defaultPath + "p2p/50.bin"
+		Defaults.IPV6Address = ""
+		Defaults.PluginPath = defaultPath + "plugin/deploy"
+		Defaults.TrackContainersPath = defaultPath + "client/trackcontainers/trackcontainers.json"
+		Defaults.GroupTrackContainersPath = defaultPath + "client/trackcontainers/grouptrackcontainers.json"
+		Defaults.ServerPort = "8088"
+		Defaults.FRPServerPort = "True"
+		Defaults.CustomConfig = CustomConfig
+		Defaults.BehindNAT = "True"
+		Defaults.DockerRunLogs = "/tmp/"
+		// Generate a random key to be added to IPTable
+		Defaults.IPTableKey = String(12)
+		// Random name generator
+		hostname, err := os.Hostname()
+		if err != nil {
+			return nil, err
+		}
 
-        Defaults.MachineName = hostname
-    } else {
-        Defaults = *ConfigUpdate[0]
-    }
+		// Generate Public and private keys and set path
+		Defaults.PublicKeyFile = defaultPath + "p2prc.PublicKeyBareMetal"
+		Defaults.PrivateKeyFile = defaultPath + "p2prc.privateKey"
+		Defaults.BareMetal = "False"
 
-    //defaults["NetworkInterface"] = "wlp0s20f3"
-    //defaults["NetworkInterfaceIPV6Index"] = "2"
+		PrivateKeyExists, err := FileExists(Defaults.PrivateKeyFile)
+		if err != nil {
+			return nil, err
+		}
 
-    //Paths to search for config file
-    configPaths = append(configPaths, defaultPath)
+		if !PrivateKeyExists {
+			// Generate SSH keys
+			err = MakeSSHKeyPair(Defaults.PublicKeyFile, Defaults.PrivateKeyFile)
+			if err != nil {
+				return nil, err
+			}
+		}
 
-    if fileExists(defaultPath+"config.json") && forceDefault {
-        err := os.Remove(defaultPath + "config.json")
-        if err != nil {
-            return nil, err
-        }
-    }
+		Defaults.MachineName = hostname + "-" + String(7)
+	} else {
+		Defaults = *ConfigUpdate[0]
+	}
 
-    // write defaults to the config file
-    err = Defaults.WriteConfig()
-    if err != nil {
-        return nil, err
-    }
+	//defaults["NetworkInterface"] = "wlp0s20f3"
+	//defaults["NetworkInterfaceIPV6Index"] = "2"
 
-    //Calling configuration file
-    Config, err := config.ConfigInit(defaults, nil, envName)
-    if err != nil {
-        return nil, err
-    }
+	//Paths to search for config file
+	configPaths = append(configPaths, defaultPath)
 
-    if !NoBoilerPlate {
-        err = GenerateFiles()
-        if err != nil {
-            return nil, err
-        }
-    }
+	if fileExists(defaultPath+"config.json") && forceDefault {
+		err := os.Remove(defaultPath + "config.json")
+		if err != nil {
+			return nil, err
+		}
+	}
 
-    return Config, nil
+	// write defaults to the config file
+	err = Defaults.WriteConfig()
+	if err != nil {
+		return nil, err
+	}
+
+	//Calling configuration file
+	Config, err := config.ConfigInit(defaults, nil, envName)
+	if err != nil {
+		return nil, err
+	}
+
+	if !NoBoilerPlate {
+		err = GenerateFiles()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return Config, nil
+}
+
+// Generating a random string
+const charset = "abcdefghijklmnopqrstuvwxyz" +
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+
+var seededRand *rand.Rand = rand.New(
+	rand.NewSource(time.Now().UnixNano()))
+
+func StringWithCharset(length int, charset string) string {
+	b := make([]byte, length)
+	for i := range b {
+		b[i] = charset[seededRand.Intn(len(charset))]
+	}
+	return string(b)
+}
+
+func String(length int) string {
+	return StringWithCharset(length, charset)
 }

config/generate/generateFiles.go

@@ -1,16 +1,32 @@
 package generate
 
 import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/pem"
+	"github.com/Akilan1999/p2p-rendering-computation/config"
 	"github.com/Akilan1999/p2p-rendering-computation/p2p"
 	"github.com/go-git/go-git/v5"
+	"golang.org/x/crypto/ssh"
+	"io/ioutil"
 	"os"
 )
 
 // GenerateFiles Generates all the files needed to setup P2PRC
 func GenerateFiles(rootNodes ...p2p.IpAddress) (err error) {
 	err = GenerateIPTableFile(rootNodes)
+	if err != nil {
+		return err
+	}
 	err = GenerateDockerFiles()
+	if err != nil {
+		return err
+	}
 	err = GeneratePluginDirectory()
+	if err != nil {
+		return err
+	}
 	err = GenerateClientTrackContainers()
 	return
 }
@@ -28,9 +44,9 @@ func GenerateIPTableFile(rootNodes []p2p.IpAddress) (err error) {
 	// If root node addresses are not provided as optional parameters
 	if len(rootNodes) <= 0 {
 		rootnode.Name = "Node1"
-		rootnode.ServerPort = "8088"
+		rootnode.ServerPort = "8078"
 		rootnode.NAT = "False"
-		rootnode.Ipv4 = "64.227.168.102"
+		rootnode.Ipv4 = "217.76.63.222"
 
 		rootnodes.IpAddress = append(rootnodes.IpAddress, rootnode)
 	} else {
@@ -46,7 +62,7 @@ func GenerateIPTableFile(rootNodes []p2p.IpAddress) (err error) {
 
 // CreateIPTableFolderStructure Create folder structure for IPTable
 func CreateIPTableFolderStructure() (err error) {
-	path, err := GetCurrentPath()
+	path, err := config.GetCurrentPath()
 	if err != nil {
 		return err
 	}
@@ -72,7 +88,7 @@ func CreateIPTableFolderStructure() (err error) {
 
 // GenerateDockerFiles Generate default docker files
 func GenerateDockerFiles() (err error) {
-	path, err := GetCurrentPath()
+	path, err := config.GetCurrentPath()
 	if err != nil {
 		return err
 	}
@@ -117,7 +133,7 @@ func GenerateDockerFiles() (err error) {
 
 // GeneratePluginDirectory Generates plugin directory structure
 func GeneratePluginDirectory() (err error) {
-	path, err := GetCurrentPath()
+	path, err := config.GetCurrentPath()
 	if err != nil {
 		return err
 	}
@@ -135,7 +151,7 @@ func GeneratePluginDirectory() (err error) {
 }
 
 func GenerateClientTrackContainers() (err error) {
-	path, err := GetCurrentPath()
+	path, err := config.GetCurrentPath()
 	if err != nil {
 		return err
 	}
@@ -143,16 +159,16 @@ func GenerateClientTrackContainers() (err error) {
 		if err = os.Mkdir(path+"client", os.ModePerm); err != nil {
 			return err
 		}
+		if err = os.Mkdir(path+"client/trackcontainers", os.ModePerm); err != nil {
+			return err
+		}
 
-		if _, err = os.Stat(path + "client/trackcontainers.json"); os.IsNotExist(err) {
-			_, err = os.Create(path + "client/trackcontainers.json")
+		if _, err = os.Stat(path + "client/trackcontainers/trackcontainers.json"); os.IsNotExist(err) {
+			_, err = os.Create(path + "client/trackcontainers/trackcontainers.json")
 			if err != nil {
 				return err
 			}
-		}
-
-		if _, err = os.Stat(path + "client/grouptrackcontainers.json"); os.IsNotExist(err) {
-			_, err = os.Create(path + "client/grouptrackcontainers.json")
+			_, err = os.Create(path + "client/trackcontainers/grouptrackcontainers.json")
 			if err != nil {
 				return err
 			}
@@ -161,3 +177,114 @@ func GenerateClientTrackContainers() (err error) {
 	}
 	return
 }
+
+// MakeSSHKeyPair make a pair of public and private keys for SSH access.
+// Public key is encoded in the format for inclusion in an OpenSSH authorized_keys file.
+// Private Key generated is PEM encoded
+// source: https://gist.github.com/goliatone/e9c13e5f046e34cef6e150d06f20a34c
+func MakeSSHKeyPair(pubKeyPath, privateKeyPath string) error {
+	privateKey, err := rsa.GenerateKey(rand.Reader, 1024)
+	if err != nil {
+		return err
+	}
+	// generate and write private key as PEM
+	privateKeyFile, err := os.Create(privateKeyPath)
+	defer privateKeyFile.Close()
+	if err != nil {
+		return err
+	}
+
+	// Set permission to private key to SSH into docker machine
+	err = os.Chmod(privateKeyPath, 600)
+	if err != nil {
+		return err
+	}
+
+	privateKeyPEM := &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(privateKey)}
+	if err := pem.Encode(privateKeyFile, privateKeyPEM); err != nil {
+		return err
+	}
+	// generate and write public key
+	pub, err := ssh.NewPublicKey(&privateKey.PublicKey)
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile(pubKeyPath, ssh.MarshalAuthorizedKey(pub), 0655)
+}
+
+// FileExists exists returns whether the given file or directory exists
+// source: https://stackoverflow.com/questions/10510691/how-to-check-whether-a-file-or-directory-exists
+func FileExists(path string) (bool, error) {
+	_, err := os.Stat(path)
+	if err == nil {
+		return true, nil
+	}
+	if os.IsNotExist(err) {
+		return false, nil
+	}
+	return false, err
+}
+
+// AuthorizedKey struct represents the structure of an authorized key
+type AuthorizedKey struct {
+	Username string
+	Key      string
+}
+
+// AddPublicKeyBareMetal Adds the parameter public key to the auth list
+// Generated by ChatGPT
+// Prompts:
+//   - Generate a go program to read authorised key and map it to a struct and write it back to the same location.
+//   - Can you follow the original format
+//   (TURNED OUT TO BE PRETTY SHITTY GENERATED CODE)
+//func AddPublicKeyBareMetal(PublicKey string) error {
+//    // Specify the path to the authorized_keys file
+//    dirname, err := os.UserHomeDir()
+//    if err != nil {
+//        return err
+//    }
+//
+//    authorizedKeysPath := dirname + "/.ssh/" + "authorized_keys"
+//
+//    // Read the contents of the authorized_keys file
+//    file, err := os.Open(authorizedKeysPath)
+//    if err != nil {
+//        return err
+//    }
+//    defer file.Close()
+//
+//    // Create a slice to store AuthorizedKey structs
+//    var authorizedKeys []AuthorizedKey
+//
+//    // Read each line of the file and parse the data
+//    scanner := bufio.NewScanner(file)
+//    for scanner.Scan() {
+//        line := scanner.Text()
+//        parts := strings.Fields(line)
+//        if len(parts) >= 2 {
+//            authorizedKey := AuthorizedKey{
+//                Username: parts[0],
+//                Key:      parts[1],
+//            }
+//            authorizedKeys = append(authorizedKeys, authorizedKey)
+//        }
+//    }
+//
+//    if err := scanner.Err(); err != nil {
+//        return err
+//    }
+//
+//    // Modify the slice of structs if needed
+//    // authorizedKeys[0].Username = "newUsername"
+//    // authorizedKeys[0].Key = "newKey"
+//    authorizedKeys = append(authorizedKeys, AuthorizedKey{Username: "", Key: PublicKey})
+//
+//    // Write the modified data back to the authorized_keys file
+//    newFile, err := os.Create(authorizedKeysPath)
+//    if err != nil {
+//        return err
+//    }
+//    defer newFile.Close()
+//
+//    return nil
+//}

config/generate/gernerate_test.go

@@ -1,35 +1,40 @@
 package generate
 
 import (
-    "fmt"
-    "github.com/Akilan1999/p2p-rendering-computation/config"
-    "testing"
+	"fmt"
+	"github.com/Akilan1999/p2p-rendering-computation/config"
+	"testing"
 )
 
 type CustomConfig struct {
-    Test string
+	Test string
 }
 
 // Test case to generate defaults with custom data-structure
 func TestSetDefaults(t *testing.T) {
-    setDefaults, err := SetDefaults("", true, &CustomConfig{Test: "lol"}, true)
-    if err != nil {
-        fmt.Println(err)
-        t.Fail()
-        return
-    }
+	setDefaults, err := SetDefaults("", true, &CustomConfig{Test: "lol"}, true)
+	if err != nil {
+		fmt.Println(err)
+		t.Fail()
+		return
+	}
 
-    fmt.Println(setDefaults)
+	fmt.Println(setDefaults)
 
-    var c CustomConfig
+	var c CustomConfig
 
-    _, err = config.ConfigInit(nil, &c)
-    if err != nil {
-        fmt.Println(err)
-        t.Fail()
-        return
-    }
+	_, err = config.ConfigInit(nil, &c)
+	if err != nil {
+		fmt.Println(err)
+		t.Fail()
+		return
+	}
 
-    fmt.Println(c)
+	fmt.Println(c)
 
 }
+
+// Test case to generate public and private keys
+func TestGeneratePublicAndPrivateKeys(t *testing.T) {
+	MakeSSHKeyPair("test.pub", "test.prv")
+}

default.nix

@@ -0,0 +1,22 @@
+{ nixpkgs ? import <nixpkgs> {  } }:
+
+let
+  pkgs = [
+    nixpkgs.go
+    nixpkgs.tmux
+    nixpkgs.docker
+    nixpkgs.vim
+  ];
+
+in
+  nixpkgs.stdenv.mkDerivation {
+    name = "env";
+    buildInputs = pkgs;
+    pure-eval = true;
+    shellHook =
+    ''
+        make
+        export P2PRC=$PWD
+        export PATH=$PWD:$PATH
+    '';
+  }

go.mod

@@ -3,17 +3,16 @@ module github.com/Akilan1999/p2p-rendering-computation
 go 1.15
 
 require (
-	github.com/Microsoft/hcsshim v0.8.15 // indirect
+	github.com/Microsoft/go-winio v0.4.17-0.20210211115548-6eac466e5fa3 // indirect
 	github.com/apenella/go-ansible v1.1.0
-	github.com/containerd/continuity v0.0.0-20210315143101-93e15499afd5 // indirect
+	github.com/containerd/containerd v1.5.0-beta.1 // indirect
 	github.com/docker/docker v20.10.0-beta1.0.20201113105859-b6bfff2a628f+incompatible
-	github.com/docker/go-connections v0.4.0
+	github.com/docker/go-connections v0.4.0 // indirect
 	github.com/fatedier/frp v0.45.0
 	github.com/gin-gonic/gin v1.6.3
 	github.com/go-git/go-git/v5 v5.4.2
 	github.com/google/uuid v1.3.0
 	github.com/lithammer/shortuuid v3.0.0+incompatible
-	github.com/moby/sys/mount v0.2.0 // indirect
 	github.com/moby/term v0.0.0-20201110203204-bea5bbe245bf // indirect
 	github.com/morikuni/aec v1.0.0 // indirect
 	github.com/otiai10/copy v1.6.0
@@ -22,6 +21,7 @@ require (
 	github.com/urfave/cli/v2 v2.3.0
 	gitlab.com/NebulousLabs/fastrand v0.0.0-20181126182046-603482d69e40 // indirect
 	gitlab.com/NebulousLabs/go-upnp v0.0.0-20181011194642-3a71999ed0d3
+	golang.org/x/crypto v0.16.0
 	gopkg.in/yaml.v2 v2.4.0
 	gotest.tools/v3 v3.0.3 // indirect
 )

go.sum

@@ -79,8 +79,6 @@ github.com/Microsoft/hcsshim v0.8.7-0.20190325164909-8abdbb8205e4/go.mod h1:Op3h
 github.com/Microsoft/hcsshim v0.8.7/go.mod h1:OHd7sQqRFrYd3RmSgbgji+ctCwkbq2wbEYNSzOYtcBQ=
 github.com/Microsoft/hcsshim v0.8.9/go.mod h1:5692vkUqntj1idxauYlpoINNKeqCiG6Sg38RRsjT5y8=
 github.com/Microsoft/hcsshim v0.8.14/go.mod h1:NtVKoYxQuTLx6gEq0L96c9Ju4JbRJ4nY2ow3VK6a9Lg=
-github.com/Microsoft/hcsshim v0.8.15 h1:Aof83YILRs2Vx3GhHqlvvfyx1asRJKMFIMeVlHsZKtI=
-github.com/Microsoft/hcsshim v0.8.15/go.mod h1:x38A4YbHbdxJtc0sF6oIz+RG0npwSCAvn69iY6URG00=
 github.com/Microsoft/hcsshim/test v0.0.0-20201218223536-d3e5debf77da/go.mod h1:5hlzMzRKMLyo42nCZ9oml8AdTlq/0cvIaBv6tK1RehU=
 github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb06e3pkSAbeQ52E9H9iFoQsEEwGN64994WTCIhntQ=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
@@ -155,7 +153,6 @@ github.com/containerd/cgroups v0.0.0-20190717030353-c4b9ac5c7601/go.mod h1:X9rLE
 github.com/containerd/cgroups v0.0.0-20190919134610-bf292b21730f/go.mod h1:OApqhQ4XNSNC13gXIwDjhOQxjWa/NxkwZXJ1EvqT0ko=
 github.com/containerd/cgroups v0.0.0-20200531161412-0dbf7f05ba59/go.mod h1:pA0z1pT8KYB3TCXK/ocprsh7MAkoW8bZVzPdih9snmM=
 github.com/containerd/cgroups v0.0.0-20200710171044-318312a37340/go.mod h1:s5q4SojHctfxANBDvMeIaIovkq29IP48TKAxnhYRxvo=
-github.com/containerd/cgroups v0.0.0-20200824123100-0b889c03f102 h1:Qf4HiqfvmB7zS6scsmNgTLmByHbq8n9RTF39v+TzP7A=
 github.com/containerd/cgroups v0.0.0-20200824123100-0b889c03f102/go.mod h1:s5q4SojHctfxANBDvMeIaIovkq29IP48TKAxnhYRxvo=
 github.com/containerd/console v0.0.0-20180822173158-c12b1e7919c1/go.mod h1:Tj/on1eG8kiEhd0+fhSDzsPAFESxzBBvdyEgyryXffw=
 github.com/containerd/console v0.0.0-20181022165439-0650fd9eeb50/go.mod h1:Tj/on1eG8kiEhd0+fhSDzsPAFESxzBBvdyEgyryXffw=
@@ -174,8 +171,6 @@ github.com/containerd/continuity v0.0.0-20190815185530-f2a389ac0a02/go.mod h1:GL
 github.com/containerd/continuity v0.0.0-20191127005431-f65d91d395eb/go.mod h1:GL3xCUCBDV3CZiTSEKksMWbLE66hEyuu9qyDOOqM47Y=
 github.com/containerd/continuity v0.0.0-20200710164510-efbc4488d8fe/go.mod h1:cECdGN1O8G9bgKTlLhuPJimka6Xb/Gg7vYzCTNVxhvo=
 github.com/containerd/continuity v0.0.0-20201208142359-180525291bb7/go.mod h1:kR3BEg7bDFaEddKm54WSmrol1fKWDU1nKYkgrcgZT7Y=
-github.com/containerd/continuity v0.0.0-20210315143101-93e15499afd5 h1:k6Dn7shF+i1q4utvCyW4+o9REsCMAeRyORM5IhXMCnw=
-github.com/containerd/continuity v0.0.0-20210315143101-93e15499afd5/go.mod h1:ICJu0PwR54nI0yPEnJ6jcS+J7CZAUXrLh8lPo2knzsM=
 github.com/containerd/fifo v0.0.0-20180307165137-3d5202aec260/go.mod h1:ODA38xgv3Kuk8dQz2ZQXpnv/UZZUHUCL7pnLehbXgQI=
 github.com/containerd/fifo v0.0.0-20190226154929-a9fb20d87448/go.mod h1:ODA38xgv3Kuk8dQz2ZQXpnv/UZZUHUCL7pnLehbXgQI=
 github.com/containerd/fifo v0.0.0-20200410184934-f15a3290365b/go.mod h1:jPQ2IAeZRCYxpS/Cm1495vGFww6ecHmMk1YJH2Q5ln0=
@@ -367,7 +362,6 @@ github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4er
 github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
 github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
@@ -586,9 +580,6 @@ github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:F
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/osext v0.0.0-20151018003038-5e2d6d41470f/go.mod h1:OkQIRizQZAeMln+1tSwduZz7+Af5oFlKirV/MSYes2A=
 github.com/moby/spdystream v0.2.0/go.mod h1:f7i0iNDQJ059oMTcWxx8MA/zKFIuD/lY+0GqbN2Wy8c=
-github.com/moby/sys/mount v0.2.0 h1:WhCW5B355jtxndN5ovugJlMFJawbUODuW8fSnEH6SSM=
-github.com/moby/sys/mount v0.2.0/go.mod h1:aAivFE2LB3W4bACsUXChRHQ0qKWsetY4Y9V7sxOougM=
-github.com/moby/sys/mountinfo v0.4.0 h1:1KInV3Huv18akCu58V7lzNlt+jFmqlu1EaErnEHE/VM=
 github.com/moby/sys/mountinfo v0.4.0/go.mod h1:rEr8tzG/lsIZHBtN/JjGG+LMYx9eXgW2JI+6q0qou+A=
 github.com/moby/sys/symlink v0.1.0/go.mod h1:GGDODQmbFOjFsXvfLVn3+ZRxkch54RkSiGqsZeMYowQ=
 github.com/moby/term v0.0.0-20200312100748-672ec06f55cd/go.mod h1:DdlQx2hp0Ss5/fLikoLlEeIYiATotOjgB//nb973jeo=
@@ -648,7 +639,6 @@ github.com/opencontainers/runc v0.0.0-20190115041553-12f6a991201f/go.mod h1:qT5X
 github.com/opencontainers/runc v0.1.1/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U=
 github.com/opencontainers/runc v1.0.0-rc8.0.20190926000215-3e425f80a8c9/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U=
 github.com/opencontainers/runc v1.0.0-rc9/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U=
-github.com/opencontainers/runc v1.0.0-rc93 h1:x2UMpOOVf3kQ8arv/EsDGwim8PTNqzL1/EYDr/+scOM=
 github.com/opencontainers/runc v1.0.0-rc93/go.mod h1:3NOsor4w32B2tC0Zbl8Knk4Wg84SM2ImC1fxBuqJ/H0=
 github.com/opencontainers/runtime-spec v0.1.2-0.20190507144316-5b71a03e2700/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
 github.com/opencontainers/runtime-spec v1.0.1/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
@@ -864,7 +854,6 @@ go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
-go.opencensus.io v0.23.0 h1:gqCw0LfLxScz8irSi8exQc7fyQ0fKQU/qnC/X8+V/1M=
 go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
 go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
 go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
@@ -889,8 +878,9 @@ golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.0.0-20220315160706-3147a52a75dd h1:XcWmESyNjXJMLahc3mqVQJcgSTDxFxhETVlfk9uGc38=
 golang.org/x/crypto v0.0.0-20220315160706-3147a52a75dd/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.16.0 h1:mMMrFzRSCF0GvB7Ne27XVtVAaXLrPmgPC7/v0tkwHaY=
+golang.org/x/crypto v0.16.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -928,6 +918,7 @@ golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -986,8 +977,10 @@ golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qx
 golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
 golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
 golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b h1:PxfKdU9lEEDYjdIzOtC4qFWgkU2rGHdKlKowJSMN9h0=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -1018,8 +1011,8 @@ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4 h1:uVc8UZUe6tr40fFVnUP5Oj+veunVezqYl9z7DYw9xzw=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -1115,11 +1108,17 @@ golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220319134239-a9b59b0215f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220422013727-9388b58f7150/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f h1:v4INt8xihDGvnrfjMDVXGxw9wrfxYyCjk0KbXjhR55s=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
+golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.15.0 h1:y/Oo/a/q3IXu26lQgl04j/gjuBDOBlx7X6Om1j2CPW4=
+golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -1128,8 +1127,11 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -1200,6 +1202,7 @@ golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.10/go.mod h1:Uh6Zz+xoGYZom868N8YTex3t7RhtHDBrE8Gzo9bV56E=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

install-binary.bat

@@ -0,0 +1,4 @@
+setx PATH "%PATH%;%cd%"
+setx P2PRC "%cd%"
+
+p2p-rendering-computation.exe --dc

install-binary.sh

@@ -0,0 +1,8 @@
+# This script setups up the project P2PRC
+echo '# Add the following paths to .bashrc or .zshrc based on the configuration you have set'
+echo export P2PRC=$PWD
+echo export PATH=$PWD:\${PATH}
+export P2PRC=${PWD}
+export PATH=${PWD}:${PATH}
+
+./p2p-rendering-computation --dc

main.go

@@ -1,15 +1,15 @@
 package main
 
 import (
-	"log"
-	"os"
+    "log"
+    "os"
 
-	"github.com/Akilan1999/p2p-rendering-computation/cmd"
-	"github.com/urfave/cli/v2"
+    "github.com/Akilan1999/p2p-rendering-computation/cmd"
+    "github.com/urfave/cli/v2"
 )
 
 // VERSION specifies the version of the platform
-var VERSION = "1.5.0"
+var VERSION = "2.0.0"
 var mode string
 
 // Varaibles if mode is client
@@ -17,15 +17,15 @@ var OS, Pull_location, Run_script string
 var List_servers, Ip_table bool
 
 func main() {
-	app := cli.NewApp()
-	app.Name = "p2p-rendering-computation"
-	app.Usage = "p2p cli application to create and access VMs in other servers"
-	app.Version = VERSION
-	app.Flags = cmd.AppConfigFlags
-	app.Action = cmd.CliAction
+    app := cli.NewApp()
+    app.Name = "p2p-rendering-computation"
+    app.Usage = "p2p cli application to create and access VMs in other servers"
+    app.Version = VERSION
+    app.Flags = cmd.AppConfigFlags
+    app.Action = cmd.CliAction
 
-	err := app.Run(os.Args)
-	if err != nil {
-		log.Fatal(err)
-	}
+    err := app.Run(os.Args)
+    if err != nil {
+        log.Fatal(err)
+    }
 }

p2p/ip_table.json

@@ -1,13 +1,16 @@
 {
- "ip_address": [
-  {
-   "Name": "Node1",
-   "IPV4": "64.227.168.102",
-   "IPV6": "",
-   "Latency": 0,
-   "ServerPort": "8088",
-   "NAT": "False",
-   "EscapeImplementation": "None"
-  }
- ]
+  "ip_address": [
+    {
+      "Name": "Node1",
+      "IPV4": "139.59.162.154",
+      "IPV6": "",
+      "Latency": 0,
+      "Download": 0,
+      "Upload": 0,
+      "ServerPort": "8078",
+      "NAT": "False",
+      "EscapeImplementation": "",
+      "CustomInformation": null
+    }
+  ]
 }

p2p/iptable.go

@@ -1,267 +1,294 @@
 package p2p
 
 import (
-    "encoding/json"
-    "fmt"
-    "github.com/Akilan1999/p2p-rendering-computation/config"
-    "io/ioutil"
-    "net"
-    "net/http"
-    "os"
-    "time"
+	"bytes"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"github.com/Akilan1999/p2p-rendering-computation/config"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"os"
+	"time"
 )
 
 // Get IP table Data
 
 type IpAddresses struct {
-    IpAddress []IpAddress `json:"ip_address"`
+	IpAddress []IpAddress `json:"ip_address"`
 }
 
 type IpAddress struct {
-    Name                 string        `json:"Name"`
-    Ipv4                 string        `json:"IPV4"`
-    Ipv6                 string        `json:"IPV6"`
-    Latency              time.Duration `json:"Latency"`
-    Download             float64       `json:"Download"`
-    Upload               float64       `json:"Upload"`
-    ServerPort           string        `json:"ServerPort"`
-    NAT                  string        `json:"NAT"`
-    EscapeImplementation string        `json:"EscapeImplementation"`
-    CustomInformation    []byte
+	Name                 string        `json:"Name"`
+	Ipv4                 string        `json:"IPV4"`
+	Ipv6                 string        `json:"IPV6"`
+	Latency              time.Duration `json:"Latency"`
+	Download             float64       `json:"Download"`
+	Upload               float64       `json:"Upload"`
+	ServerPort           string        `json:"ServerPort"`
+	BareMetalSSHPort     string        `json:"BareMetalSSHPort"`
+	NAT                  string        `json:"NAT"`
+	EscapeImplementation string        `json:"EscapeImplementation"`
+	CustomInformation    string        `json:"CustomInformation"`
+	//CustomInformationKey []byte        `json:"CustomInformationKey"`
 }
 
 type IP struct {
-    Query string
+	Query string
 }
 
 // ReadIpTable Read data from Ip tables from json file
 func ReadIpTable() (*IpAddresses, error) {
-    // Get Path from config
-    config, err := config.ConfigInit(nil, nil)
-    if err != nil {
-        return nil, err
-    }
-    jsonFile, err := os.Open(config.IPTable)
-    // if we os.Open returns an error then handle it
-    if err != nil {
-        return nil, err
-    }
+	// Get Path from config
+	config, err := config.ConfigInit(nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	jsonFile, err := os.Open(config.IPTable)
+	// if we os.Open returns an error then handle it
+	if err != nil {
+		return nil, err
+	}
 
-    // defer the closing of our jsonFile so that we can parse it later on
-    defer jsonFile.Close()
+	// defer the closing of our jsonFile so that we can parse it later on
+	defer jsonFile.Close()
 
-    // read our opened xmlFile as a byte array.
-    byteValue, _ := ioutil.ReadAll(jsonFile)
+	// read our opened xmlFile as a byte array.
+	byteValue, _ := ioutil.ReadAll(jsonFile)
 
-    // we initialize our Users array
-    var ipAddresses IpAddresses
+	// we initialize our Users array
+	var ipAddresses IpAddresses
 
-    // we unmarshal our byteArray which contains our
-    // jsonFile's content into 'users' which we defined above
-    json.Unmarshal(byteValue, &ipAddresses)
+	// we unmarshal our byteArray which contains our
+	// jsonFile's content into 'users' which we defined above
+	json.Unmarshal(byteValue, &ipAddresses)
 
-    var PublicIP IpAddress
+	var PublicIP IpAddress
 
-    ipv6, err := GetCurrentIPV6()
-    if err != nil {
-        return nil, err
-    }
+	ipv6, err := GetCurrentIPV6()
+	if err != nil {
+		return nil, err
+	}
 
-    ip, err := CurrentPublicIP()
-    if err != nil {
-        return nil, err
-    }
-    PublicIP.Ipv4 = ip
-    PublicIP.Ipv6 = ipv6
-    PublicIP.ServerPort = config.ServerPort
-    PublicIP.Name = config.MachineName
-    PublicIP.NAT = config.BehindNAT
-    PublicIP.EscapeImplementation = "None"
+	ip, err := CurrentPublicIP()
+	if err != nil {
+		return nil, err
+	}
+	PublicIP.Ipv4 = ip
+	PublicIP.Ipv6 = ipv6
+	PublicIP.ServerPort = config.ServerPort
+	PublicIP.Name = config.MachineName
+	PublicIP.NAT = config.BehindNAT
+	PublicIP.EscapeImplementation = "None"
 
-    // Updates current machine IP address to the IP table
-    ipAddresses.IpAddress = append(ipAddresses.IpAddress, PublicIP)
+	// Updates current machine IP address to the IP table
+	ipAddresses.IpAddress = append(ipAddresses.IpAddress, PublicIP)
 
-    //before writing to iptable ensures the duplicates are removed
-    if err = ipAddresses.RemoveDuplicates(); err != nil {
-        return nil, err
-    }
+	//before writing to iptable ensures the duplicates are removed
+	if err = ipAddresses.RemoveDuplicates(); err != nil {
+		return nil, err
+	}
 
-    return &ipAddresses, nil
+	return &ipAddresses, nil
 }
 
 // WriteIpTable Write to IP table json file
 func (i *IpAddresses) WriteIpTable() error {
-    //before writing to iptable ensures the duplicates are removed
-    if err := i.RemoveDuplicates(); err != nil {
-        return err
-    }
+	//before writing to iptable ensures the duplicates are removed
+	if err := i.RemoveDuplicates(); err != nil {
+		return err
+	}
 
-    file, err := json.MarshalIndent(i, "", " ")
-    if err != nil {
-        return err
-    }
+	file, err := json.MarshalIndent(i, "", " ")
+	if err != nil {
+		return err
+	}
 
-    // Get Path from config
-    config, err := config.ConfigInit(nil, nil)
-    if err != nil {
-        return err
-    }
+	// Get Path from config
+	config, err := config.ConfigInit(nil, nil)
+	if err != nil {
+		return err
+	}
 
-    err = ioutil.WriteFile(config.IPTable, file, 0644)
-    if err != nil {
-        return err
-    }
+	err = ioutil.WriteFile(config.IPTable, file, 0644)
+	if err != nil {
+		return err
+	}
 
-    return nil
+	return nil
 }
 
 // PrintIpTable Print Ip table data for Cli
 func PrintIpTable() error {
-    table, err := ReadIpTable()
+	table, err := ReadIpTable()
+	//
+	if err != nil {
+		return err
+	}
+	//
+	//for i := 0; i < len(table.IpAddress); i++ {
+	//    fmt.Printf("\nMachine Name: %s\nIP Address: %s\nIPV6: %s\nLatency: %s\nServerPort: %s\nbehindNAT: %s\nEscapeImplementation: %s\n-----------"+
+	//        "-----------------\n", table.IpAddress[i].Name, table.IpAddress[i].Ipv4, table.IpAddress[i].Ipv6,
+	//        table.IpAddress[i].Latency, table.IpAddress[i].ServerPort, table.IpAddress[i].NAT, table.IpAddress[i].EscapeImplementation)
+	//}
+	PrettyPrint(table)
 
-    if err != nil {
-        return err
-    }
-
-    for i := 0; i < len(table.IpAddress); i++ {
-        fmt.Printf("\nMachine Name: %s\nIP Address: %s\nIPV6: %s\nLatency: %s\nServerPort: %s\nbehindNAT: %s\nEscapeImplementation: %s\n-----------"+
-            "-----------------\n", table.IpAddress[i].Name, table.IpAddress[i].Ipv4, table.IpAddress[i].Ipv6,
-            table.IpAddress[i].Latency, table.IpAddress[i].ServerPort, table.IpAddress[i].NAT, table.IpAddress[i].EscapeImplementation)
-    }
-    //PrettyPrint(table)
-
-    return nil
+	return nil
 }
 
 // RemoveDuplicates This is a temporary fix current functions failing to remove
 // Duplicate IP addresses from local IP table
 func (table *IpAddresses) RemoveDuplicates() error {
 
-    var NoDuplicates IpAddresses
-    for i, _ := range table.IpAddress {
-        Exists := false
-        for k := range NoDuplicates.IpAddress {
-            // Statements checked for
-            // - duplicate IPV4 addresses [<IPV4>:<Port No>]
-            // - duplicate IPV6 addresses [<IPV6>]
-            // - Node is behind NAT and no escape implementation provided
-            if (NoDuplicates.IpAddress[k].Ipv4 != "" && NoDuplicates.IpAddress[k].Ipv4 == table.IpAddress[i].Ipv4 &&
-                NoDuplicates.IpAddress[k].ServerPort == table.IpAddress[i].ServerPort) ||
-                (NoDuplicates.IpAddress[k].Ipv6 != "" && NoDuplicates.IpAddress[k].Ipv6 == table.IpAddress[i].Ipv6) {
-                Exists = true
-                break
-            }
-        }
+	var NoDuplicates IpAddresses
+	for i, _ := range table.IpAddress {
+		Exists := false
+		for k := range NoDuplicates.IpAddress {
+			// Statements checked for
+			// - duplicate IPV4 addresses [<IPV4>:<Port No>]
+			// - duplicate IPV6 addresses [<IPV6>]
+			// - Node is behind NAT and no escape implementation provided
+			if (NoDuplicates.IpAddress[k].Ipv4 != "" && NoDuplicates.IpAddress[k].Ipv4 == table.IpAddress[i].Ipv4 &&
+				NoDuplicates.IpAddress[k].ServerPort == table.IpAddress[i].ServerPort) ||
+				(NoDuplicates.IpAddress[k].Ipv6 != "" && NoDuplicates.IpAddress[k].Ipv6 == table.IpAddress[i].Ipv6) {
+				Exists = true
+				break
+			}
+		}
 
-        if table.IpAddress[i].NAT == "True" && table.IpAddress[i].EscapeImplementation == "None" {
-            Exists = true
-        }
+		if table.IpAddress[i].NAT == "True" && table.IpAddress[i].EscapeImplementation == "None" {
+			Exists = true
+		}
 
-        if Exists {
-            continue
-        }
-        NoDuplicates.IpAddress = append(NoDuplicates.IpAddress, table.IpAddress[i])
-    }
+		if Exists {
+			continue
+		}
+		NoDuplicates.IpAddress = append(NoDuplicates.IpAddress, table.IpAddress[i])
+	}
 
-    table.IpAddress = NoDuplicates.IpAddress
+	table.IpAddress = NoDuplicates.IpAddress
 
-    return nil
+	return nil
 }
 
 // CurrentPublicIP Get Current Public IP address
 func CurrentPublicIP() (string, error) {
-    req, err := http.Get("http://ip-api.com/json/")
-    if err != nil {
-        return "", err
-    }
-    defer req.Body.Close()
+	req, err := http.Get("http://ip-api.com/json/")
+	if err != nil {
+		return "", err
+	}
+	defer req.Body.Close()
 
-    body, err := ioutil.ReadAll(req.Body)
-    if err != nil {
-        return "", err
-    }
+	body, err := ioutil.ReadAll(req.Body)
+	if err != nil {
+		return "", err
+	}
 
-    var ip IP
-    json.Unmarshal(body, &ip)
+	var ip IP
+	json.Unmarshal(body, &ip)
 
-    return ip.Query, nil
+	return ip.Query, nil
 }
 
 // GetCurrentIPV6 gets the current IPV6	address based on the interface
 // specified in the config file
 func GetCurrentIPV6() (string, error) {
-    Config, err := config.ConfigInit(nil, nil)
-    if err != nil {
-        return "", err
-    }
+	Config, err := config.ConfigInit(nil, nil)
+	if err != nil {
+		return "", err
+	}
 
-    // Fix in future release
-    //byNameInterface, err := net.InterfaceByName(Config.NetworkInterface)
-    //if err != nil {
-    //	return "",err
-    //}
-    //addresses, err := byNameInterface.Addrs()
-    //if err != nil {
-    //	return "",err
-    //}
-    //if addresses[1].String() == "" {
-    //	return "",errors.New("IPV6 address not detected")
-    //}
-    //IP,_,err := net.ParseCIDR(addresses[Config.NetworkInterfaceIPV6Index].String())
-    //if err != nil {
-    //	return "",err
-    //}
+	// Fix in future release
+	//byNameInterface, err := net.InterfaceByName(Config.NetworkInterface)
+	//if err != nil {
+	//	return "",err
+	//}
+	//addresses, err := byNameInterface.Addrs()
+	//if err != nil {
+	//	return "",err
+	//}
+	//if addresses[1].String() == "" {
+	//	return "",errors.New("IPV6 address not detected")
+	//}
+	//IP,_,err := net.ParseCIDR(addresses[Config.NetworkInterfaceIPV6Index].String())
+	//if err != nil {
+	//	return "",err
+	//}
 
-    return Config.IPV6Address, nil
+	return Config.IPV6Address, nil
 }
 
 // ViewNetworkInterface This function is created to view the network interfaces available
 func ViewNetworkInterface() error {
-    ifaces, err := net.Interfaces()
-    if err != nil {
-        return err
-    }
-    for _, i := range ifaces {
-        addrs, err := i.Addrs()
-        if err != nil {
-            return err
-        }
-        for index, a := range addrs {
-            switch v := a.(type) {
-            case *net.IPAddr:
-                fmt.Printf("(%v) %v : %s (%s)\n", index, i.Name, v, v.IP.DefaultMask())
+	ifaces, err := net.Interfaces()
+	if err != nil {
+		return err
+	}
+	for _, i := range ifaces {
+		addrs, err := i.Addrs()
+		if err != nil {
+			return err
+		}
+		for index, a := range addrs {
+			switch v := a.(type) {
+			case *net.IPAddr:
+				fmt.Printf("(%v) %v : %s (%s)\n", index, i.Name, v, v.IP.DefaultMask())
 
-            case *net.IPNet:
-                fmt.Printf("(%v) %v : %s \n", index, i.Name, v)
-            }
+			case *net.IPNet:
+				fmt.Printf("(%v) %v : %s \n", index, i.Name, v)
+			}
 
-        }
-    }
-    return nil
+		}
+	}
+	return nil
 }
 
 // Ip4or6 Helper function to check if the IP address is IPV4 or
 // IPV6 (https://socketloop.com/tutorials/golang-check-if-ip-address-is-version-4-or-6)
 func Ip4or6(s string) string {
-    for i := 0; i < len(s); i++ {
-        switch s[i] {
-        case '.':
-            return "version 4"
-        case ':':
-            return "version 6"
-        }
-    }
-    return "version 6"
+	for i := 0; i < len(s); i++ {
+		switch s[i] {
+		case '.':
+			return "version 4"
+		case ':':
+			return "version 6"
+		}
+	}
+	return "version 6"
 
 }
 
-//func PrettyPrint(data interface{}) {
-//	var p []byte
-//	//    var err := error
-//	p, err := json.MarshalIndent(data, "", "\t")
-//	if err != nil {
-//		fmt.Println(err)
-//		return
-//	}
-//	fmt.Printf("%s \n", p)
-//}
+func PrettyPrint(data interface{}) {
+	var p []byte
+	//    var err := error
+	p, err := json.MarshalIndent(data, "", "\t")
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Printf("%s \n", p)
+}
+
+func GenerateHashSHA256(text string) []byte {
+	h := sha256.New()
+	h.Write([]byte(text))
+
+	return h.Sum(nil)
+}
+
+// ValidateHashSHA256 CustomInformationKey the text and check if the text and
+// the hash are the same, if they are
+// then return true
+// SHA256 is the current hashing algorthm
+// used.
+func ValidateHashSHA256(text string, Hash []byte) bool {
+	h := sha256.New()
+	h.Write([]byte(text))
+
+	textHash := h.Sum(nil)
+	if bytes.Equal(textHash, Hash) {
+		return true
+	}
+	return false
+}

server/docker/docker.go

@@ -1,202 +1,233 @@
 package docker
 
 import (
-    "bufio"
-    "bytes"
-    "context"
-    "encoding/json"
-    "errors"
-    "fmt"
-    "github.com/Akilan1999/p2p-rendering-computation/config"
-    "github.com/docker/docker/api/types"
-    "github.com/docker/docker/api/types/container"
-    "github.com/docker/docker/client"
-    "github.com/docker/docker/pkg/archive"
-    "github.com/docker/go-connections/nat"
-    "github.com/lithammer/shortuuid"
-    "github.com/phayes/freeport"
-    "io"
-    "io/ioutil"
-    "os/exec"
-    "time"
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/Akilan1999/p2p-rendering-computation/config"
+	"github.com/docker/docker/client"
+	"github.com/google/uuid"
+	"github.com/lithammer/shortuuid"
+	"github.com/otiai10/copy"
+	"github.com/phayes/freeport"
+	"io"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"text/template"
 )
 
 type DockerVM struct {
-    SSHUsername string `json:"SSHUsername"`
-    SSHPassword string `json:"SSHPassword"`
-    ID          string `json:"ID"`
-    TagName     string `json:"TagName"`
-    ImagePath   string `json:"ImagePath"`
-    Ports       Ports  `json:"Ports"`
-    GPU         string `json:"GPU"`
+	SSHUsername string `json:"SSHUsername"`
+	SSHPublcKey string `json:"SSHPublicKey"`
+	ID          string `json:"ID"`
+	TagName     string `json:"TagName"`
+	ImagePath   string `json:"ImagePath"`
+	Ports       Ports  `json:"Ports"`
+	GPU         string `json:"GPU"`
+	TempPath    string
+	BaseImage   string
+	LogsPath    string
+	SSHCommand  string `json:"SSHCommand"`
 }
 
 type DockerContainers struct {
-    DockerContainer []DockerContainer `json:"DockerContainer"`
+	DockerContainer []DockerContainer `json:"DockerContainer"`
 }
 
 type DockerContainer struct {
-    ContainerName        string `json:"DockerContainerName"`
-    ContainerDescription string `json:"ContainerDescription"`
+	ContainerName        string `json:"DockerContainerName"`
+	ContainerDescription string `json:"ContainerDescription"`
 }
 
 type Ports struct {
-    PortSet []Port `json:"Port"`
+	PortSet []Port `json:"Port"`
 }
 type Port struct {
-    PortName     string `json:"PortName"`
-    InternalPort int    `json:"InternalPort"`
-    Type         string `json:"Type"`
-    ExternalPort int    `json:"ExternalPort"`
-    IsUsed       bool   `json:"IsUsed"`
-    Description  string `json:"Description"`
+	PortName     string `json:"PortName"`
+	InternalPort int    `json:"InternalPort"`
+	Type         string `json:"Type"`
+	ExternalPort int    `json:"ExternalPort"`
+	IsUsed       bool   `json:"IsUsed"`
+	Description  string `json:"Description"`
 }
 
 type ErrorLine struct {
-    Error       string      `json:"error"`
-    ErrorDetail ErrorDetail `json:"errorDetail"`
+	Error       string      `json:"error"`
+	ErrorDetail ErrorDetail `json:"errorDetail"`
 }
 
 type ErrorDetail struct {
-    Message string `json:"message"`
+	Message string `json:"message"`
 }
 
 var dockerRegistryUserID = ""
 
 // BuildRunContainer Function is incharge to invoke building and running contianer and also allocating external
 // ports
-func BuildRunContainer(NumPorts int, GPU string, ContainerName string) (*DockerVM, error) {
-    //Docker Struct Variable
-    var RespDocker *DockerVM = new(DockerVM)
+func BuildRunContainer(NumPorts int, GPU string, ContainerName string, baseImage string, publicKey string) (*DockerVM, error) {
+	//Docker Struct Variable
+	var RespDocker *DockerVM = new(DockerVM)
 
-    // Sets if GPU is selected or not
-    RespDocker.GPU = GPU
+	// Sets if GPU is selected or not
+	RespDocker.GPU = GPU
 
-    // Sets Free port to Struct
-    //RespDocker.SSHPort = Ports[0]
-    //RespDocker.VNCPort = Ports[1]
-    // Sets appropriate username and password to the
-    // variables in the struct
-    RespDocker.SSHUsername = "master"
-    RespDocker.SSHPassword = "password"
-    //RespDocker.VNCPassword = "vncpassword"
+	// Get config informatopn
 
-    //Default parameters
-    RespDocker.TagName = "p2p-ubuntu"
-    // Get Path from config
-    config, err := config.ConfigInit(nil, nil)
-    if err != nil {
-        return nil, err
-    }
-    RespDocker.ImagePath = config.DefaultDockerFile
+	// Sets Free port to Struct
+	//RespDocker.SSHPort = Ports[0]
+	//RespDocker.VNCPort = Ports[1]
+	// Sets appropriate username and password to the
+	// variables in the struct
+	RespDocker.SSHUsername = "root"
+	//RespDocker.BaseImage = "ubuntu:20.04"
+	//RespDocker.VNCPassword = "vncpassword"
 
-    // We are checking if the container name is not nil and not equal to the default one used
-    // which is docker-ubuntu-sshd
-    if ContainerName != "" && ContainerName != "docker-ubuntu-sshd" {
-        Containers, err := ViewAllContainers()
-        if err != nil {
-            return nil, err
-        }
+	//Default parameters
+	RespDocker.TagName = "p2p-ubuntu"
+	// Get Path from config
+	config, err := config.ConfigInit(nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	RespDocker.ImagePath = config.DefaultDockerFile
+	RespDocker.LogsPath = config.DockerRunLogs
+	RespDocker.SSHPublcKey = publicKey
 
-        for _, dockerContainer := range Containers.DockerContainer {
-            if dockerContainer.ContainerName == ContainerName {
-                RespDocker.ImagePath = config.DockerContainers + ContainerName + "/"
-                RespDocker.TagName = ContainerName
-                break
-            }
-        }
-        if RespDocker.ImagePath == config.DefaultDockerFile {
-            return nil, errors.New("Container " + ContainerName + " does not exist in the server")
-        }
-    }
+	// We are checking if the container name is not nil and not equal to the default one used
+	// which is docker-ubuntu-sshd
+	if ContainerName != "" && ContainerName != "docker-ubuntu-sshd" {
+		Containers, err := ViewAllContainers()
+		if err != nil {
+			return nil, err
+		}
 
-    PortsInformation, err := OpenPortsFile(RespDocker.ImagePath + "/ports.json")
-    if err != nil {
-        return nil, err
-    }
+		for _, dockerContainer := range Containers.DockerContainer {
+			if dockerContainer.ContainerName == ContainerName {
+				RespDocker.ImagePath = config.DockerContainers + ContainerName + "/"
+				RespDocker.TagName = ContainerName
+				break
+			}
+		}
+		if RespDocker.ImagePath == config.DefaultDockerFile {
+			return nil, errors.New("Container " + ContainerName + " does not exist in the server")
+		}
+	}
 
-    // Number of perts we want to open + number of ports required inside the
-    // docker container
-    count := NumPorts + len(PortsInformation.PortSet)
-    // Creates number of ports
-    OpenPorts, err := freeport.GetFreePorts(count)
-    if err != nil {
-        return nil, err
-    }
-    // Allocate external ports to ports available in the ports.json file
-    for i := range PortsInformation.PortSet {
-        // Setting external ports
-        PortsInformation.PortSet[i].ExternalPort = OpenPorts[i]
-        PortsInformation.PortSet[i].IsUsed = true
-    }
-    //Length of Ports allocated from thr port file
-    portFileLength := len(PortsInformation.PortSet)
-    // Allocate New ports the user wants to generate
-    for i := 0; i < NumPorts; i++ {
-        var TempPort Port
-        TempPort.PortName = "AutoGen Port"
-        TempPort.Type = "tcp"
-        TempPort.InternalPort = OpenPorts[portFileLength+i]
-        TempPort.ExternalPort = OpenPorts[portFileLength+i]
-        TempPort.Description = "Auto generated TCP port"
-        TempPort.IsUsed = false
-        //Append temp port to port information
-        PortsInformation.PortSet = append(PortsInformation.PortSet, TempPort)
-    }
-    // Setting ports to the docker VM struct
-    RespDocker.Ports = *PortsInformation
+	// Checking if the base image is provided
+	if baseImage != "" {
+		RespDocker.BaseImage = baseImage
+	} else {
+		RespDocker.BaseImage = "ubuntu:20.04"
+	}
 
-    // Gets docker information from env variables
-    cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
-    if err != nil {
-        return nil, err
-    }
+	// Template docker with the base image provided
+	err = RespDocker.TemplateDockerContainer()
+	if err != nil {
+		return nil, err
+	}
 
-    // Builds docker image
-    err = RespDocker.imageBuild(cli)
-    if err != nil {
-        return nil, err
-    }
+	// Template the DockerFile and point to the temp location
 
-    // Runs docker contianer
-    err = RespDocker.runContainer(cli)
+	PortsInformation, err := OpenPortsFile(RespDocker.ImagePath + "/" + RespDocker.TagName + "/ports.json")
+	if err != nil {
+		return nil, err
+	}
 
-    if err != nil {
-        return nil, err
-    }
+	// Number of perts we want to open + number of ports required inside the
+	// docker container
+	count := NumPorts + len(PortsInformation.PortSet)
+	// Creates number of ports
+	OpenPorts, err := freeport.GetFreePorts(count)
+	if err != nil {
+		return nil, err
+	}
+	// Allocate external ports to ports available in the ports.json file
+	for i := range PortsInformation.PortSet {
+		// Setting external ports
+		PortsInformation.PortSet[i].ExternalPort = OpenPorts[i]
+		PortsInformation.PortSet[i].IsUsed = true
+	}
+	//Length of Ports allocated from thr port file
+	portFileLength := len(PortsInformation.PortSet)
+	// Allocate New ports the user wants to generate
+	for i := 0; i < NumPorts; i++ {
+		var TempPort Port
+		TempPort.PortName = "AutoGen Port"
+		TempPort.Type = "tcp"
+		TempPort.InternalPort = OpenPorts[portFileLength+i]
+		TempPort.ExternalPort = OpenPorts[portFileLength+i]
+		TempPort.Description = "Auto generated TCP port"
+		TempPort.IsUsed = false
+		//Append temp port to port information
+		PortsInformation.PortSet = append(PortsInformation.PortSet, TempPort)
+	}
+	// Setting ports to the docker VM struct
+	RespDocker.Ports = *PortsInformation
 
-    return RespDocker, nil
+	// Gets docker information from env variables
+	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
+	if err != nil {
+		return nil, err
+	}
+
+	// Builds docker image
+	err = RespDocker.imageBuild(cli)
+	if err != nil {
+		return nil, err
+	}
+
+	// Runs docker contianer
+	err = RespDocker.runContainer(cli)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return RespDocker, nil
 
 }
 
 // Builds docker image (TODO: relative path for Dockerfile deploy)
 func (d *DockerVM) imageBuild(dockerClient *client.Client) error {
-    ctx, _ := context.WithTimeout(context.Background(), time.Second*2000)
-    //defer cancel()
+	//ctx, _ := context.WithTimeout(context.Background(), time.Second*2000)
+	//defer cancel()
 
-    tar, err := archive.TarWithOptions(d.ImagePath, &archive.TarOptions{})
-    if err != nil {
-        return err
-    }
+	var cmd bytes.Buffer
+	cmd.WriteString("docker build -t " + d.TagName + " " + d.ImagePath + "/" + d.TagName + ` --build-arg SSH_KEY="` + d.SSHPublcKey + `"`)
+	//"-v=/opt/data:/data p2p-ubuntu /start > /dev/null"
+	cmdStr := cmd.String()
+	output, err := exec.Command("/bin/sh", "-c", cmdStr).Output()
+	fmt.Printf("%s", output)
+	if err != nil {
+		return err
+	}
 
-    opts := types.ImageBuildOptions{
-        Dockerfile: "Dockerfile",
-        Tags:       []string{d.TagName},
-        Remove:     true,
-    }
-    res, err := dockerClient.ImageBuild(ctx, tar, opts)
-    if err != nil {
-        return err
-    }
+	//tar, err := archive.TarWithOptions(d.ImagePath+"/"+d.TagName, &archive.TarOptions{})
+	//if err != nil {
+	//	return err
+	//}
+	//
+	//opts := types.ImageBuildOptions{
+	//	Dockerfile: "Dockerfile",
+	//	Tags:       []string{d.TagName},
+	//	Remove:     true,
+	//}
+	//res, err := dockerClient.ImageBuild(ctx, tar, opts)
+	//if err != nil {
+	//	return err
+	//}
+	//
+	//defer res.Body.Close()
+	//
+	//err = print(res.Body)
+	//if err != nil {
+	//	return err
+	//}
 
-    defer res.Body.Close()
-
-    err = print(res.Body)
-    if err != nil {
-        return err
-    }
-
-    return nil
+	return nil
 }
 
 // Starts container and assigns port numbers
@@ -205,200 +236,273 @@ func (d *DockerVM) imageBuild(dockerClient *client.Client) error {
 // -p 3443:6901 -p 3453:22 -p 3434:3434 -p 3245:3245 -v=/opt/data:/data
 // p2p-ubuntu /start > /dev/null
 func (d *DockerVM) runContainer(dockerClient *client.Client) error {
-    ctx, _ := context.WithTimeout(context.Background(), time.Second*2000)
+	//ctx, _ := context.WithTimeout(context.Background(), time.Second*2000)
 
-    // The first mode runs using the Docker Api. As the API supports using
-    // CPU and uses a shell script for GPU call because till this point of
-    // implementation docker api does not support the flag "--gpu all"
-    if d.GPU != "true" {
-        //Exposed ports for docker config file
-        var ExposedPort nat.PortSet
+	// The first mode runs using the Docker Api. As the API supports using
+	// CPU and uses a shell script for GPU call because till this point of
+	// implementation docker api does not support the flag "--gpu all"
+	//if d.GPU != "true" {
+	//	//Exposed ports for docker config file
+	//	var ExposedPort nat.PortSet
+	//
+	//	ExposedPort = nat.PortSet{
+	//		"22/tcp": struct{}{},
+	//		//"6901/tcp": struct{}{},
+	//	}
+	//
+	//	// Port forwarding for VNC and SSH ports
+	//	PortForwarding := nat.PortMap{
+	//		//"22/tcp": []nat.PortBinding{
+	//		//	{
+	//		//		HostIP: "0.0.0.0",
+	//		//		HostPort: fmt.Sprint(d.SSHPort),
+	//		//	},
+	//		//},
+	//		//"6901/tcp": []nat.PortBinding{
+	//		//	{
+	//		//		HostIP: "0.0.0.0",
+	//		//		HostPort: fmt.Sprint(d.VNCPort),
+	//		//	},
+	//		//},
+	//	}
+	//
+	//	for i := range d.Ports.PortSet {
+	//		// Parameters "tcp or udp", external port
+	//		Port, err := nat.NewPort(d.Ports.PortSet[i].Type, fmt.Sprint(d.Ports.PortSet[i].InternalPort))
+	//		if err != nil {
+	//			return err
+	//		}
+	//
+	//		// Exposed Ports
+	//		ExposedPort[Port] = struct{}{}
+	//
+	//		PortForwarding[Port] = []nat.PortBinding{
+	//			{
+	//				HostIP:   "0.0.0.0",
+	//				HostPort: fmt.Sprint(d.Ports.PortSet[i].ExternalPort),
+	//			},
+	//		}
+	//	}
+	//
+	//	config := &container.Config{
+	//		Image:        d.TagName,
+	//		Entrypoint:   []string{"/start"},
+	//		Volumes:      map[string]struct{}{"/opt/data:/data": {}},
+	//		ExposedPorts: ExposedPort,
+	//	}
+	//	hostConfig := &container.HostConfig{
+	//		PortBindings: PortForwarding,
+	//	}
+	//
+	//	res, err := dockerClient.ContainerCreate(ctx, config, hostConfig,
+	//		nil, nil, "")
+	//
+	//	// Set response ID
+	//	d.ID = res.ID
+	//
+	//	if err != nil {
+	//		return err
+	//	}
+	//
+	//	err = dockerClient.ContainerStart(ctx, res.ID, types.ContainerStartOptions{})
+	//
+	//	if err != nil {
+	//		return err
+	//	}
+	//} else {
+	// Generate Random ID
+	id := shortuuid.New()
+	d.ID = id
 
-        ExposedPort = nat.PortSet{
-            "22/tcp": struct{}{},
-            //"6901/tcp": struct{}{},
-        }
+	var cmd bytes.Buffer
+	cmd.WriteString("docker run -d=true --name=" + id + " --restart=always ")
+	if d.GPU == "true" {
+		cmd.WriteString("--gpus all ")
+	}
 
-        // Port forwarding for VNC and SSH ports
-        PortForwarding := nat.PortMap{
-            //"22/tcp": []nat.PortBinding{
-            //	{
-            //		HostIP: "0.0.0.0",
-            //		HostPort: fmt.Sprint(d.SSHPort),
-            //	},
-            //},
-            //"6901/tcp": []nat.PortBinding{
-            //	{
-            //		HostIP: "0.0.0.0",
-            //		HostPort: fmt.Sprint(d.VNCPort),
-            //	},
-            //},
-        }
-
-        for i := range d.Ports.PortSet {
-            // Parameters "tcp or udp", external port
-            Port, err := nat.NewPort(d.Ports.PortSet[i].Type, fmt.Sprint(d.Ports.PortSet[i].InternalPort))
-            if err != nil {
-                return err
-            }
-
-            // Exposed Ports
-            ExposedPort[Port] = struct{}{}
-
-            PortForwarding[Port] = []nat.PortBinding{
-                {
-                    HostIP:   "0.0.0.0",
-                    HostPort: fmt.Sprint(d.Ports.PortSet[i].ExternalPort),
-                },
-            }
-        }
-
-        config := &container.Config{
-            Image:        d.TagName,
-            Entrypoint:   []string{"/start"},
-            Volumes:      map[string]struct{}{"/opt/data:/data": {}},
-            ExposedPorts: ExposedPort,
-        }
-        hostConfig := &container.HostConfig{
-            PortBindings: PortForwarding,
-        }
-
-        res, err := dockerClient.ContainerCreate(ctx, config, hostConfig,
-            nil, nil, "")
-
-        // Set response ID
-        d.ID = res.ID
-
-        if err != nil {
-            return err
-        }
-
-        err = dockerClient.ContainerStart(ctx, res.ID, types.ContainerStartOptions{})
-
-        if err != nil {
-            return err
-        }
-    } else {
-        // Generate Random ID
-        id := shortuuid.New()
-        d.ID = id
-
-        var cmd bytes.Buffer
-        cmd.WriteString("docker run -d=true --name=" + id + " --restart=always --gpus all ")
-        for i := range d.Ports.PortSet {
-            cmd.WriteString("-p " + fmt.Sprint(d.Ports.PortSet[i].ExternalPort) + ":" + fmt.Sprint(d.Ports.PortSet[i].InternalPort) + " ")
-        }
-        cmd.WriteString("-v=/opt/data:/data " + d.TagName + " /start > /dev/null")
-        //"-v=/opt/data:/data p2p-ubuntu /start > /dev/null"
-        cmdStr := cmd.String()
-        _, err := exec.Command("/bin/sh", "-c", cmdStr).Output()
-        if err != nil {
-            return err
-        }
-    }
-    return nil
+	for i := range d.Ports.PortSet {
+		cmd.WriteString("-p " + fmt.Sprint(d.Ports.PortSet[i].ExternalPort) + ":" + fmt.Sprint(d.Ports.PortSet[i].InternalPort) + " ")
+	}
+	cmd.WriteString("-v=/tmp:/data " + d.TagName + " > /dev/null")
+	//"-v=/opt/data:/data p2p-ubuntu /start > /dev/null"
+	cmdStr := cmd.String()
+	_, err := exec.Command("/bin/sh", "-c", cmdStr).Output()
+	if err != nil {
+		return err
+	}
+	//}
+	return nil
 }
 
 // StopAndRemoveContainer
 // Stop and remove a container
 // Reference (https://gist.github.com/frikky/e2efcea6c733ea8d8d015b7fe8a91bf6)
 func StopAndRemoveContainer(containername string) error {
-    ctx := context.Background()
+	//ctx := context.Background()
+	//
+	//// Gets docker information from env variables
+	//client, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
+	//if err != nil {
+	//	return err
+	//}
+	//
+	//if err = client.ContainerStop(ctx, containername, nil); err != nil {
+	//	return err
+	//}
+	//
+	//removeOptions := types.ContainerRemoveOptions{
+	//	RemoveVolumes: true,
+	//	Force:         true,
+	//}
+	//
+	//if err = client.ContainerRemove(ctx, containername, removeOptions); err != nil {
+	//	return err
+	//}
 
-    // Gets docker information from env variables
-    client, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
-    if err != nil {
-        return err
-    }
+	// stop docker container
+	var stop bytes.Buffer
+	stop.WriteString("docker stop " + containername)
 
-    if err = client.ContainerStop(ctx, containername, nil); err != nil {
-        return err
-    }
+	cmdStr := stop.String()
+	_, err := exec.Command("/bin/sh", "-c", cmdStr).Output()
+	if err != nil {
+		return err
+	}
 
-    removeOptions := types.ContainerRemoveOptions{
-        RemoveVolumes: true,
-        Force:         true,
-    }
+	// remove docker container
+	var remove bytes.Buffer
+	remove.WriteString("docker remove " + containername)
 
-    if err = client.ContainerRemove(ctx, containername, removeOptions); err != nil {
-        return err
-    }
+	cmdStr = remove.String()
 
-    return nil
+	_, err = exec.Command("/bin/sh", "-c", cmdStr).Output()
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 // ViewAllContainers returns all containers runnable and which can be built
 func ViewAllContainers() (*DockerContainers, error) {
-    // Traverse the deploy path as per given in the config file
-    config, err := config.ConfigInit(nil, nil)
-    if err != nil {
-        return nil, err
-    }
+	// Traverse the deploy path as per given in the config file
+	config, err := config.ConfigInit(nil, nil)
+	if err != nil {
+		return nil, err
+	}
 
-    folders, err := ioutil.ReadDir(config.DockerContainers)
-    if err != nil {
-        return nil, err
-    }
+	folders, err := ioutil.ReadDir(config.DockerContainers)
+	if err != nil {
+		return nil, err
+	}
 
-    //Declare variable DockerContainers of type struct
-    var Containers *DockerContainers = new(DockerContainers)
+	//Declare variable DockerContainers of type struct
+	var Containers *DockerContainers = new(DockerContainers)
 
-    for _, f := range folders {
-        if f.IsDir() {
-            //Declare variable DockerContainer of type struct
-            var Container DockerContainer
+	for _, f := range folders {
+		if f.IsDir() {
+			//Declare variable DockerContainer of type struct
+			var Container DockerContainer
 
-            // Setting container name to deploy name
-            Container.ContainerName = f.Name()
-            // Getting Description from file description.txt
-            Description, err := ioutil.ReadFile(config.DockerContainers + "/" + Container.ContainerName + "/description.txt")
-            // if we os.Open returns an error then handle it
-            if err != nil {
-                return nil, err
-            }
+			// Setting container name to deploy name
+			Container.ContainerName = f.Name()
+			// Getting Description from file description.txt
+			Description, err := ioutil.ReadFile(config.DockerContainers + "/" + Container.ContainerName + "/description.txt")
+			// if we os.Open returns an error then handle it
+			if err != nil {
+				return nil, err
+			}
 
-            // Get Description from description.txt
-            Container.ContainerDescription = string(Description)
+			// Get Description from description.txt
+			Container.ContainerDescription = string(Description)
 
-            Containers.DockerContainer = append(Containers.DockerContainer, Container)
-        }
-    }
+			Containers.DockerContainer = append(Containers.DockerContainer, Container)
+		}
+	}
 
-    return Containers, nil
+	return Containers, nil
 }
 
 func print(rd io.Reader) error {
-    var lastLine string
+	var lastLine string
 
-    scanner := bufio.NewScanner(rd)
-    for scanner.Scan() {
-        lastLine = scanner.Text()
-    }
+	scanner := bufio.NewScanner(rd)
+	for scanner.Scan() {
+		lastLine = scanner.Text()
+	}
 
-    errLine := &ErrorLine{}
-    json.Unmarshal([]byte(lastLine), errLine)
-    if errLine.Error != "" {
-        return errors.New(errLine.Error)
-    }
+	errLine := &ErrorLine{}
+	json.Unmarshal([]byte(lastLine), errLine)
+	if errLine.Error != "" {
+		return errors.New(errLine.Error)
+	}
 
-    if err := scanner.Err(); err != nil {
-        return err
-    }
+	if err := scanner.Err(); err != nil {
+		return err
+	}
 
-    return nil
+	return nil
 }
 
 func OpenPortsFile(filename string) (*Ports, error) {
-    buf, err := ioutil.ReadFile(filename)
-    if err != nil {
-        return nil, err
-    }
+	buf, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
 
-    c := &Ports{}
-    err = json.Unmarshal(buf, c)
-    if err != nil {
-        return nil, fmt.Errorf("in file %q: %v", filename, err)
-    }
+	c := &Ports{}
+	err = json.Unmarshal(buf, c)
+	if err != nil {
+		return nil, fmt.Errorf("in file %q: %v", filename, err)
+	}
 
-    return c, nil
+	return c, nil
+}
+
+// TemplateDockerContainer This function templates the docker container
+// with the base docker image to use
+func (d *DockerVM) TemplateDockerContainer() error {
+	err := d.CopyToTmpContainer()
+	if err != nil {
+		return err
+	}
+
+	// parses the site.yml file in the tmp directory
+	t, err := template.ParseFiles(d.ImagePath + "/" + d.TagName + "/Dockerfile")
+	if err != nil {
+		return err
+	}
+	// opens the output file
+	f, err := os.Create(d.ImagePath + "/" + d.TagName + "/Dockerfile")
+	if err != nil {
+		return err
+	}
+
+	image := d.BaseImage
+
+	// Pass in Docker Base Image
+	err = t.Execute(f, image)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// CopyToTmpContainer Creates a copy of the docker folder
+func (d *DockerVM) CopyToTmpContainer() error {
+	// generate rand to UUID this is debug the ansible file if needed
+	id := uuid.New()
+	// copies the plugin to the tmp directory
+	err := copy.Copy(d.ImagePath+"/", d.LogsPath+id.String()+"_"+d.TagName)
+	if err != nil {
+		return err
+	}
+
+	// Set the plugin execution to the tmp location
+	d.TagName = id.String() + "_" + d.TagName
+	// removing slash
+	d.ImagePath = d.LogsPath[:len(d.LogsPath)-1]
+
+	return nil
 }

server/docker/dockprom/README.md

@@ -99,7 +99,8 @@ The Docker Containers Dashboard shows key metrics for monitoring running contain
 * Container network inbound usage graph
 * Container network outbound usage graph
 
-Note that this dashboard doesn't show the containers that are part of the monitoring stack.
+> [!NOTE]
+> This dashboard doesn't show the containers that are part of the monitoring stack.
 
 ***Monitor Services Dashboard***
 

server/docker/dockprom/helpers/aws/README.md

@@ -14,9 +14,9 @@ To get started on AWS ECS and EC2:
 - Copy prometheus.yml configuration present here to base prometheus configuration to enable EC2 service discovery
 - `docker compose up -d`
 
-**Note**:
-Set query.staleness-delta to 1m make metrics more realtime
+> [!NOTE]  
+> Set query.staleness-delta to 1m make metrics more realtime
 
 
 ### TODO
-- Add alerting rules based on ECS
+- [ ] Add alerting rules based on ECS

server/rpc.go

@@ -1,43 +0,0 @@
-package server
-
-import (
-	"fmt"
-	"github.com/Akilan1999/p2p-rendering-computation/server/docker"
-	"net"
-	"net/rpc"
-)
-
-const (
-	port = "8089"
-)
-
-type Listener int
-
-type Docker struct {
-	docker *docker.DockerVM
-}
-
-// Starts container using RPC calls
-func (l *Listener) StartContainer(reply *Docker) error {
-	vm, err := docker.BuildRunContainer(3, "false", "")
-	if err != nil {
-		return err
-	}
-	fmt.Printf("Receive: %v\n", vm)
-	*reply = Docker{vm}
-	return nil
-}
-
-func Rpc() {
-	rpcServer, err := net.ResolveTCPAddr("tcp", "0.0.0.0:"+port)
-	if err != nil {
-		fmt.Print(err)
-	}
-	inbound, err := net.ListenTCP("tcp", rpcServer)
-	if err != nil {
-		fmt.Print(err)
-	}
-	listener := new(Listener)
-	rpc.Register(listener)
-	rpc.Accept(inbound)
-}

server/server.go

@@ -1,226 +1,333 @@
 package server
 
 import (
-    "encoding/json"
-    "fmt"
-    "github.com/Akilan1999/p2p-rendering-computation/client/clientIPTable"
-    "github.com/Akilan1999/p2p-rendering-computation/config"
-    "github.com/Akilan1999/p2p-rendering-computation/p2p"
-    "github.com/Akilan1999/p2p-rendering-computation/p2p/frp"
-    "github.com/Akilan1999/p2p-rendering-computation/server/docker"
-    "github.com/gin-gonic/gin"
-    "io/ioutil"
-    "net/http"
-    "strconv"
-    "time"
+	b64 "encoding/base64"
+	"encoding/json"
+	"fmt"
+	"github.com/Akilan1999/p2p-rendering-computation/client/clientIPTable"
+	"github.com/Akilan1999/p2p-rendering-computation/config"
+	"github.com/Akilan1999/p2p-rendering-computation/p2p"
+	"github.com/Akilan1999/p2p-rendering-computation/p2p/frp"
+	"github.com/Akilan1999/p2p-rendering-computation/server/docker"
+	"github.com/gin-gonic/gin"
+	"io/ioutil"
+	"net/http"
+	"strconv"
+	"time"
 )
 
 func Server() (*gin.Engine, error) {
-    r := gin.Default()
+	r := gin.Default()
 
-    //Get Server port based on the config file
-    config, err := config.ConfigInit(nil, nil)
-    if err != nil {
-        return nil, err
-    }
+	//Get Server port based on the config file
+	config, err := config.ConfigInit(nil, nil)
+	if err != nil {
+		return nil, err
+	}
 
-    // update IPTable with new port and ip address and update ip table
-    var ProxyIpAddr p2p.IpAddress
-    var lowestLatencyIpAddress p2p.IpAddress
+	// update IPTable with new port and ip address and update ip table
+	var ProxyIpAddr p2p.IpAddress
+	var lowestLatencyIpAddress p2p.IpAddress
 
-    // Gets default information of the server
-    r.GET("/server_info", func(c *gin.Context) {
-        c.JSON(http.StatusOK, ServerInfo())
-    })
+	// Gets default information of the server
+	r.GET("/server_info", func(c *gin.Context) {
+		c.JSON(http.StatusOK, ServerInfo())
+	})
 
-    // Speed test with 50 mbps
-    r.GET("/50", func(c *gin.Context) {
-        // Get Path from config
-        c.File(config.SpeedTestFile)
-    })
+	// Speed test with 50 mbps
+	r.GET("/50", func(c *gin.Context) {
+		// Get Path from config
+		c.File(config.SpeedTestFile)
+	})
 
-    // Route build to do a speed test
-    r.GET("/upload", func(c *gin.Context) {
-        file, _ := c.FormFile("file")
+	// Route build to do a speed test
+	r.GET("/upload", func(c *gin.Context) {
+		file, _ := c.FormFile("file")
 
-        // Upload the file to specific dst.
-        // c.SaveUploadedFile(file, dst)
+		// Upload the file to specific dst.
+		// c.SaveUploadedFile(file, dst)
 
-        c.String(http.StatusOK, fmt.Sprintf("'%s' uploaded!", file.Filename))
-    })
+		c.String(http.StatusOK, fmt.Sprintf("'%s' uploaded!", file.Filename))
+	})
 
-    //Gets Ip Table from server node
-    r.POST("/IpTable", func(c *gin.Context) {
-        // Getting IPV4 address of client
-        var ClientHost p2p.IpAddress
+	//Gets Ip Table from server node
+	r.POST("/IpTable", func(c *gin.Context) {
+		// Getting IPV4 address of client
+		var ClientHost p2p.IpAddress
 
-        if p2p.Ip4or6(c.ClientIP()) == "version 6" {
-            ClientHost.Ipv6 = c.ClientIP()
-        } else {
-            ClientHost.Ipv4 = c.ClientIP()
-        }
+		if p2p.Ip4or6(c.ClientIP()) == "version 6" {
+			ClientHost.Ipv6 = c.ClientIP()
+		} else {
+			ClientHost.Ipv4 = c.ClientIP()
+		}
 
-        // Variable to store IP table information
-        var IPTable p2p.IpAddresses
+		// Variable to store IP table information
+		var IPTable p2p.IpAddresses
 
-        // Receive file from POST request
-        body, err := c.FormFile("json")
-        if err != nil {
-            c.String(http.StatusOK, fmt.Sprint(err))
-        }
+		// Receive file from POST request
+		body, err := c.FormFile("json")
+		if err != nil {
+			c.String(http.StatusOK, fmt.Sprint(err))
+		}
 
-        // Open file
-        open, err := body.Open()
-        if err != nil {
-            c.String(http.StatusOK, fmt.Sprint(err))
-        }
+		// Open file
+		open, err := body.Open()
+		if err != nil {
+			c.String(http.StatusOK, fmt.Sprint(err))
+		}
 
-        // Open received file
-        file, err := ioutil.ReadAll(open)
-        if err != nil {
-            c.String(http.StatusOK, fmt.Sprint(err))
-        }
+		// Open received file
+		file, err := ioutil.ReadAll(open)
+		if err != nil {
+			c.String(http.StatusOK, fmt.Sprint(err))
+		}
 
-        json.Unmarshal(file, &IPTable)
+		json.Unmarshal(file, &IPTable)
 
-        //Add Client IP address to IPTable struct
-        IPTable.IpAddress = append(IPTable.IpAddress, ClientHost)
+		//Add Client IP address to IPTable struct
+		IPTable.IpAddress = append(IPTable.IpAddress, ClientHost)
 
-        // Runs speed test to return only servers in the IP table pingable
-        err = IPTable.SpeedTestUpdatedIPTable()
-        if err != nil {
-            c.String(http.StatusOK, fmt.Sprint(err))
-        }
+		// Runs speed test to return only servers in the IP table pingable
+		err = IPTable.SpeedTestUpdatedIPTable()
+		if err != nil {
+			c.String(http.StatusOK, fmt.Sprint(err))
+		}
 
-        // Reads IP addresses from ip table
-        IpAddresses, err := p2p.ReadIpTable()
-        if err != nil {
-            c.String(http.StatusOK, fmt.Sprint(err))
-        }
+		// Reads IP addresses from ip table
+		IpAddresses, err := p2p.ReadIpTable()
+		if err != nil {
+			c.String(http.StatusOK, fmt.Sprint(err))
+		}
 
-        c.JSON(http.StatusOK, IpAddresses)
-    })
+		c.JSON(http.StatusOK, IpAddresses)
+	})
 
-    // Starts docker container in server
-    r.GET("/startcontainer", func(c *gin.Context) {
-        // Get Number of ports to open and whether to use GPU or not
-        Ports := c.DefaultQuery("ports", "0")
-        GPU := c.DefaultQuery("GPU", "false")
-        ContainerName := c.DefaultQuery("ContainerName", "")
-        var PortsInt int
+	// Starts docker container in server
+	r.GET("/startcontainer", func(c *gin.Context) {
+		// Get Number of ports to open and whether to use GPU or not
+		Ports := c.DefaultQuery("ports", "0")
+		GPU := c.DefaultQuery("GPU", "false")
+		ContainerName := c.DefaultQuery("ContainerName", "")
+		BaseImage := c.DefaultQuery("BaseImage", "")
+		PublicKey := c.DefaultQuery("PublicKey", "")
+		var PortsInt int
 
-        // Convert Get Request value to int
-        fmt.Sscanf(Ports, "%d", &PortsInt)
+		if PublicKey == "" {
+			c.String(http.StatusInternalServerError, fmt.Sprintf("error: %s", "Publickey not passed"))
+		}
 
-        // Creates container and returns-back result to
-        // access container
-        resp, err := docker.BuildRunContainer(PortsInt, GPU, ContainerName)
+		PublicKeyDecoded, err := b64.StdEncoding.DecodeString(PublicKey)
+		if err != nil {
+			c.String(http.StatusInternalServerError, fmt.Sprintf("error: %s", err))
+		}
 
-        if err != nil {
-            c.String(http.StatusInternalServerError, fmt.Sprintf("error: %s", err))
-        }
+		// Convert Get Request value to int
+		fmt.Sscanf(Ports, "%d", &PortsInt)
 
-        // Ensures that FRP is triggered only if a proxy address is provided
-        if ProxyIpAddr.Ipv4 != "" && c.Request.Host != "localhost:"+config.ServerPort && c.Request.Host != "0.0.0.0:"+config.ServerPort {
-            resp, err = frp.StartFRPCDockerContainer(ProxyIpAddr.Ipv4, lowestLatencyIpAddress.ServerPort, resp)
-            if err != nil {
-                c.String(http.StatusInternalServerError, fmt.Sprintf("error: %s", err))
-            }
-            fmt.Println(resp)
-        }
+		fmt.Println(string(PublicKeyDecoded[:]))
 
-        c.JSON(http.StatusOK, resp)
-    })
+		// Creates container and returns-back result to
+		// access container
+		resp, err := docker.BuildRunContainer(PortsInt, GPU, ContainerName, BaseImage, string(PublicKeyDecoded[:]))
 
-    //Remove container
-    r.GET("/RemoveContainer", func(c *gin.Context) {
-        ID := c.DefaultQuery("id", "0")
-        if err := docker.StopAndRemoveContainer(ID); err != nil {
-            c.String(http.StatusInternalServerError, fmt.Sprintf("error: %s", err))
-        }
-        c.String(http.StatusOK, "success")
-    })
+		if err != nil {
+			c.String(http.StatusInternalServerError, fmt.Sprintf("error: %s", err))
+		}
 
-    //Show images available
-    r.GET("/ShowImages", func(c *gin.Context) {
-        resp, err := docker.ViewAllContainers()
-        if err != nil {
-            c.String(http.StatusInternalServerError, fmt.Sprintf("error: %s", err))
-        }
-        c.JSON(http.StatusOK, resp)
-    })
+		// Ensures that FRP is triggered only if a proxy address is provided
+		if ProxyIpAddr.Ipv4 != "" && c.Request.Host != "localhost:"+config.ServerPort && c.Request.Host != "0.0.0.0:"+config.ServerPort {
+			resp, err = frp.StartFRPCDockerContainer(ProxyIpAddr.Ipv4, lowestLatencyIpAddress.ServerPort, resp)
+			if err != nil {
+				c.String(http.StatusInternalServerError, fmt.Sprintf("error: %s", err))
+			}
+		}
 
-    // Request for port no from Server with address
-    r.GET("/FRPPort", func(c *gin.Context) {
-        port, err := frp.StartFRPProxyFromRandom()
-        if err != nil {
-            c.String(http.StatusInternalServerError, fmt.Sprintf("error: %s", err))
-        }
+		c.JSON(http.StatusOK, resp)
+	})
 
-        c.String(http.StatusOK, strconv.Itoa(port))
-    })
+	//Remove container
+	r.GET("/RemoveContainer", func(c *gin.Context) {
+		ID := c.DefaultQuery("id", "0")
+		if err := docker.StopAndRemoveContainer(ID); err != nil {
+			c.String(http.StatusInternalServerError, fmt.Sprintf("error: %s", err))
+		}
+		c.String(http.StatusOK, "success")
+	})
 
-    // If there is a proxy port specified
-    // then starts the FRP server
-    //if config.FRPServerPort != "0" {
-    //	go frp.StartFRPProxyFromRandom()
-    //}
+	//Show images available
+	r.GET("/ShowImages", func(c *gin.Context) {
+		resp, err := docker.ViewAllContainers()
+		if err != nil {
+			c.String(http.StatusInternalServerError, fmt.Sprintf("error: %s", err))
+		}
+		c.JSON(http.StatusOK, resp)
+	})
 
-    // TODO check if IPV6 or Proxy port is specified
-    // if not update current entry as proxy address
-    // with appropriate port on IP Table
-    if config.BehindNAT == "True" {
-        table, err := p2p.ReadIpTable()
-        if err != nil {
-            return nil, err
-        }
+	// Request for port no from Server with address
+	r.GET("/FRPPort", func(c *gin.Context) {
+		port, err := frp.StartFRPProxyFromRandom()
+		if err != nil {
+			c.String(http.StatusInternalServerError, fmt.Sprintf("error: %s", err))
+		}
 
-        var lowestLatency int64
-        // random large number
-        lowestLatency = 10000000
+		c.String(http.StatusOK, strconv.Itoa(port))
+	})
 
-        for i, _ := range table.IpAddress {
-            // Checks if the ping is the lowest and if the following node is acting as a proxy
-            //if table.IpAddress[i].Latency.Milliseconds() < lowestLatency && table.IpAddress[i].ProxyPort != "" {
-            if table.IpAddress[i].Latency.Milliseconds() < lowestLatency {
-                lowestLatency = table.IpAddress[i].Latency.Milliseconds()
-                lowestLatencyIpAddress = table.IpAddress[i]
-            }
-        }
+	r.GET("/MAPPort", func(c *gin.Context) {
+		Ports := c.DefaultQuery("port", "0")
+		url, _, err := MapPort(Ports)
+		if err != nil {
+			c.String(http.StatusInternalServerError, fmt.Sprintf("error: %s", err))
+		}
 
-        // If there is an identified node
-        if lowestLatency != 10000000 {
-            serverPort, err := frp.GetFRPServerPort("http://" + lowestLatencyIpAddress.Ipv4 + ":" + lowestLatencyIpAddress.ServerPort)
-            if err != nil {
-                return nil, err
-            }
-            // Create 3 second delay to allow FRP server to start
-            time.Sleep(1 * time.Second)
-            // Starts FRP as a client with
-            proxyPort, err := frp.StartFRPClientForServer(lowestLatencyIpAddress.Ipv4, serverPort, config.ServerPort, "")
-            if err != nil {
-                return nil, err
-            }
+		c.String(http.StatusOK, url)
+	})
 
-            // updating with the current proxy address
-            ProxyIpAddr.Ipv4 = lowestLatencyIpAddress.Ipv4
-            ProxyIpAddr.ServerPort = proxyPort
-            ProxyIpAddr.Name = config.MachineName
-            ProxyIpAddr.NAT = "False"
-            ProxyIpAddr.EscapeImplementation = "FRP"
+	// If there is a proxy port specified
+	// then starts the FRP server
+	//if config.FRPServerPort != "0" {
+	//	go frp.StartFRPProxyFromRandom()
+	//}
 
-            // append the following to the ip table
-            table.IpAddress = append(table.IpAddress, ProxyIpAddr)
-            // write information back to the IP Table
-            table.WriteIpTable()
-            // update ip table
-            go clientIPTable.UpdateIpTableListClient()
-        }
+	// TODO check if IPV6 or Proxy port is specified
+	// if not update current entry as proxy address
+	// with appropriate port on IP Table
+	if config.BehindNAT == "True" {
+		// Remove nodes currently not pingable
+		clientIPTable.RemoveOfflineNodes()
 
-    }
+		table, err := p2p.ReadIpTable()
+		if err != nil {
+			return nil, err
+		}
 
-    // Run gin server on the specified port
-    go r.Run(":" + config.ServerPort)
+		var lowestLatency int64
+		// random large number
+		lowestLatency = 10000000
 
-    return r, nil
+		for i, _ := range table.IpAddress {
+			// Checks if the ping is the lowest and if the following node is acting as a proxy
+			//if table.IpAddress[i].Latency.Milliseconds() < lowestLatency && table.IpAddress[i].ProxyPort != "" {
+			if table.IpAddress[i].Latency.Milliseconds() < lowestLatency && table.IpAddress[i].NAT != "" {
+				lowestLatency = table.IpAddress[i].Latency.Milliseconds()
+				lowestLatencyIpAddress = table.IpAddress[i]
+			}
+		}
+
+		// If there is an identified node
+		if lowestLatency != 10000000 {
+			serverPort, err := frp.GetFRPServerPort("http://" + lowestLatencyIpAddress.Ipv4 + ":" + lowestLatencyIpAddress.ServerPort)
+			if err != nil {
+				return nil, err
+			}
+			// Create 3 second delay to allow FRP server to start
+			time.Sleep(1 * time.Second)
+			// Starts FRP as a client with
+			proxyPort, err := frp.StartFRPClientForServer(lowestLatencyIpAddress.Ipv4, serverPort, config.ServerPort, "")
+			if err != nil {
+				return nil, err
+			}
+
+			// updating with the current proxy address
+			ProxyIpAddr.Ipv4 = lowestLatencyIpAddress.Ipv4
+			ProxyIpAddr.ServerPort = proxyPort
+			ProxyIpAddr.Name = config.MachineName
+			ProxyIpAddr.NAT = "False"
+			ProxyIpAddr.EscapeImplementation = "FRP"
+
+			// Sorry Jan it's a string
+			// Yes I could convert it
+			// to a boolean operator
+			// But I am way too tired
+			if config.BareMetal == "True" {
+				_, SSHPort, err := MapPort("22")
+				if err != nil {
+					return nil, err
+				}
+				ProxyIpAddr.BareMetalSSHPort = SSHPort
+			}
+
+			//ProxyIpAddr.CustomInformationKey = p2p.GenerateHashSHA256(config.IPTableKey)
+
+			// append the following to the ip table
+			table.IpAddress = append(table.IpAddress, ProxyIpAddr)
+			// write information back to the IP Table
+			err = table.WriteIpTable()
+			if err != nil {
+				return nil, err
+			}
+			// update ip table
+			go func() error {
+				err := clientIPTable.UpdateIpTableListClient()
+				if err != nil {
+					fmt.Println(err)
+					return err
+				}
+				return nil
+			}()
+		}
+
+	}
+
+	// Run gin server on the specified port
+	go r.Run(":" + config.ServerPort)
+
+	return r, nil
+}
+
+func MapPort(port string) (string, string, error) {
+	//Get Server port based on the config file
+	config, err := config.ConfigInit(nil, nil)
+	if err != nil {
+		return "", "", err
+	}
+
+	// update IPTable with new port and ip address and update ip table
+	var ProxyIpAddr p2p.IpAddress
+	var lowestLatencyIpAddress p2p.IpAddress
+
+	clientIPTable.RemoveOfflineNodes()
+
+	table, err := p2p.ReadIpTable()
+	if err != nil {
+		return "", "", err
+	}
+
+	var lowestLatency int64
+	// random large number
+	lowestLatency = 10000000
+
+	for i, _ := range table.IpAddress {
+		// Checks if the ping is the lowest and if the following node is acting as a proxy
+		//if table.IpAddress[i].Latency.Milliseconds() < lowestLatency && table.IpAddress[i].ProxyPort != "" {
+		if table.IpAddress[i].Latency.Milliseconds() < lowestLatency && table.IpAddress[i].NAT != "" {
+			lowestLatency = table.IpAddress[i].Latency.Milliseconds()
+			lowestLatencyIpAddress = table.IpAddress[i]
+		}
+	}
+
+	// If there is an identified node
+	if lowestLatency != 10000000 {
+		serverPort, err := frp.GetFRPServerPort("http://" + lowestLatencyIpAddress.Ipv4 + ":" + lowestLatencyIpAddress.ServerPort)
+		if err != nil {
+			return "", "", err
+		}
+		// Create 3 second delay to allow FRP server to start
+		time.Sleep(1 * time.Second)
+		// Starts FRP as a client with
+		proxyPort, err := frp.StartFRPClientForServer(lowestLatencyIpAddress.Ipv4, serverPort, port, "")
+		if err != nil {
+			return "", "", err
+		}
+
+		// updating with the current proxy address
+		ProxyIpAddr.Ipv4 = lowestLatencyIpAddress.Ipv4
+		ProxyIpAddr.ServerPort = proxyPort
+		ProxyIpAddr.Name = config.MachineName
+		ProxyIpAddr.NAT = "False"
+		ProxyIpAddr.EscapeImplementation = "FRP"
+		//ProxyIpAddr.CustomInformationKey = p2p.GenerateHashSHA256(config.IPTableKey)
+	}
+
+	return ProxyIpAddr.Ipv4 + ":" + ProxyIpAddr.ServerPort, ProxyIpAddr.ServerPort, nil
 }