506 lines
13 KiB
Go
506 lines
13 KiB
Go
package docker
|
|
|
|
import (
|
|
"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"`
|
|
TempPath string
|
|
BaseImage string
|
|
LogsPath string
|
|
}
|
|
|
|
type DockerContainers struct {
|
|
DockerContainer []DockerContainer `json:"DockerContainer"`
|
|
}
|
|
|
|
type DockerContainer struct {
|
|
ContainerName string `json:"DockerContainerName"`
|
|
ContainerDescription string `json:"ContainerDescription"`
|
|
}
|
|
|
|
type Ports struct {
|
|
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"`
|
|
}
|
|
|
|
type ErrorLine struct {
|
|
Error string `json:"error"`
|
|
ErrorDetail ErrorDetail `json:"errorDetail"`
|
|
}
|
|
|
|
type ErrorDetail struct {
|
|
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, baseImage string) (*DockerVM, error) {
|
|
//Docker Struct Variable
|
|
var RespDocker *DockerVM = new(DockerVM)
|
|
|
|
// 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.BaseImage = "ubuntu:20.04"
|
|
//RespDocker.VNCPassword = "vncpassword"
|
|
|
|
//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
|
|
|
|
// 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
|
|
}
|
|
|
|
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")
|
|
}
|
|
}
|
|
|
|
// Checking if the base image is provided
|
|
if baseImage != "" {
|
|
RespDocker.BaseImage = baseImage
|
|
} else {
|
|
RespDocker.BaseImage = "ubuntu:20.04"
|
|
}
|
|
|
|
// Template docker with the base image provided
|
|
err = RespDocker.TemplateDockerContainer()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Template the DockerFile and point to the temp location
|
|
|
|
PortsInformation, err := OpenPortsFile(RespDocker.ImagePath + "/" + RespDocker.TagName + "/ports.json")
|
|
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
|
|
|
|
// 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()
|
|
|
|
var cmd bytes.Buffer
|
|
|
|
cmd.WriteString("docker build -t " + d.TagName + " " + d.ImagePath + "/" + d.TagName)
|
|
//"-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
|
|
}
|
|
|
|
//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
|
|
//}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Starts container and assigns port numbers
|
|
// Sample Docker run Command
|
|
// docker run -d=true --name=Test123 --restart=always --gpus all
|
|
// -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)
|
|
|
|
// 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
|
|
|
|
var cmd bytes.Buffer
|
|
cmd.WriteString("docker run -d=true --name=" + id + " --restart=always ")
|
|
if d.GPU == "true" {
|
|
cmd.WriteString("--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=/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()
|
|
//
|
|
//// 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
|
|
//}
|
|
|
|
// stop docker container
|
|
var stop bytes.Buffer
|
|
stop.WriteString("docker stop " + containername)
|
|
|
|
cmdStr := stop.String()
|
|
_, err := exec.Command("/bin/sh", "-c", cmdStr).Output()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// remove docker container
|
|
var remove bytes.Buffer
|
|
remove.WriteString("docker remove " + containername)
|
|
|
|
cmdStr = remove.String()
|
|
|
|
_, 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
|
|
}
|
|
|
|
folders, err := ioutil.ReadDir(config.DockerContainers)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
//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
|
|
|
|
// 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)
|
|
|
|
Containers.DockerContainer = append(Containers.DockerContainer, Container)
|
|
}
|
|
}
|
|
|
|
return Containers, nil
|
|
}
|
|
|
|
func print(rd io.Reader) error {
|
|
var lastLine string
|
|
|
|
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)
|
|
}
|
|
|
|
if err := scanner.Err(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func OpenPortsFile(filename string) (*Ports, error) {
|
|
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)
|
|
}
|
|
|
|
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
|
|
}
|