- Deploy.go (Source code to deploy)
- compile.sh (Cross compile to linux -> deploy.go)
- run.sh (Instruction of the remote machine to start the process)
- exit.sh (Instuction to kill on the remote machine the task)
- Index.html, style.css, <diagrams / pictures> (Static assets to transfer over)

-d string
        the directory of static file to host (default ".")
-daemon
        Starts the background process to learn about nodes in the network
-deploy
        Deploy the webpage to the designated machine
-kill
        Kills the deployed task
-ls
        List processes
-p string
        port to serve on (default "8034")
-update
        Updates the documentation content

func Daemon() error {
    _, err := os.Stat("Task.lock")
    if err != nil {
        err := natural_deploy.CreateTaskMachine("<Your worker machine name>", nil)
        if err != nil {
            return err
        }

        os.Create("Task.lock")
    }

    err = natural_deploy.RunDaemon()
    if err != nil {
        return err
    }

    return nil
}

// Name: Name of the task 
func Deploy(Name string) error {
    // Creating the task type
    var task natural_deploy.Task

    // Setting the name of the task
    task.Name = Name

    // Points to start the process on the worker node
    task.TaskFile = "run.sh"

    // Points to kill the process on the worker node
    task.KillTaskFile = "exit.sh"

    // To the worker machine you want to deploy the task in
    task.DeployMachine = "<Your worker machine name>"

    var err error

    // Allocate ports
    var port natural_deploy.Ports
    port.Port = "<TCP port in which your task will run>"
    port.DomainName = "<Domain name you want to exposed your task TCP port to>"
    task.ExposedPorts = append(task.ExposedPorts, &port)


    // ------------------------------------------------------------------------------
    // ------------------------------------------------------------------------------

    // In this example this binary will cross compile 
    // to the linux x86 architecture and deploy itself to worker node
    // as server running on the <TCP port in which your task will run>. 

    // Check if the linux binary to run is compiled
    _, err = os.Stat("Deploy-Linux")
    if err != nil {
        err = SelfCompileLinux()
        if err != nil {
            return err
        }
    }

    // ------------------------------------------------------------------------------
    // ------------------------------------------------------------------------------

    // Sends files for setup
    err = task.SendFile("<path of file you would want to send over>")
    if err != nil {
        return err
    }

    .... n number of files to send

    // Creates and runs the task on the worker node
    err = task.CreateTask()
    if err != nil {
        return err
    }

    // Print out the processes created
    ListProcess()

    return nil
}

// Name: <Task name>
func Update(Name string) error {
    task, avaliable := natural_deploy.ViewTasks(<Task name>)
    if !avaliable {
        return errors.New("task not found")
    }

    // Send the files you need to update or a new file
    // to send over.
    err := task.SendFile("<path of file you would want to send over>")
    if err != nil {
        return err
    }

    .... n number of files to send

    return nil
}

// Name: <Task name>
func KillProcess(Name string) error {
    task, avaliable := natural_deploy.ViewTasks(Name)
    if !avaliable {
        return errors.New("task not found")
    }

    err := task.KillTask()
    if err != nil {
        return err
    }

    return nil
}

func main() {
    // ------------------------- Defining the flags --------------------------------
    deploy := flag.Bool("deploy", false, "Deploy the webpage to the designated machine")
    kill := flag.Bool("kill", false, "Kills the deployed task")
    daemon := flag.Bool("daemon", false, "Starts the background process to learn about nodes in the network")
    update := flag.Bool("update", false, "Updates the documentation content")
    ls := flag.Bool("ls", false, "List processes")
    port := flag.String("p", "8034", "port to serve on")
    directory := flag.String("d", ".", "the directory of static file to host")
    flag.Parse()
    // ------------------------------------------------------------------------------

    // ------------------------ Handlers for the flags ------------------------------

    if *deploy {
        err := Deploy("<task name>")
        if err != nil {
            fmt.Println(err)
            return
        }
        return
    }

    if *update {
        err := Update("<task name>")
        if err != nil {
            fmt.Println(err)
            return
        }
        return
    }

    if *kill {
        err := KillProcess("<task name>")
        if err != nil {
            fmt.Println(err)
            return
        }
        return
    }

    if *daemon {
        err := Daemon()
        if err != nil {
            fmt.Println(err)
            return
        }
        for {

        }
    }

    if *ls {
        ListProcess()
        return
    }

    // ------------------------------------------------------------------------------

    // -------- part of the code executed on the task machine ------------

    http.Handle("/", http.FileServer(http.Dir(*directory)))

    log.Printf("Serving %s on HTTP port: %s\n", *directory, *port)
    log.Fatal(http.ListenAndServe(":"+*port, nil))

    // -------------------------------------------------------------------
}