401 lines
9.1 KiB
Go
401 lines
9.1 KiB
Go
package main
|
|
|
|
import (
|
|
"archive/tar"
|
|
"bytes"
|
|
"compress/gzip"
|
|
_ "embed"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"mime/multipart"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/briandowns/spinner"
|
|
"github.com/juls0730/fluxd/models"
|
|
)
|
|
|
|
//go:embed config.json
|
|
var config []byte
|
|
|
|
var configPath = filepath.Join(os.Getenv("HOME"), "/.config/flux")
|
|
|
|
type Config struct {
|
|
DeamonURL string `json:"deamon_url"`
|
|
}
|
|
|
|
func compressDirectory() ([]byte, error) {
|
|
var buf bytes.Buffer
|
|
gzWriter := gzip.NewWriter(&buf)
|
|
tarWriter := tar.NewWriter(gzWriter)
|
|
|
|
err := filepath.Walk(".", func(path string, info os.FileInfo, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if path == "flux.json" || info.IsDir() {
|
|
return nil
|
|
}
|
|
|
|
header, err := tar.FileInfoHeader(info, "")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
header.Name = path
|
|
|
|
if err := tarWriter.WriteHeader(header); err != nil {
|
|
return err
|
|
}
|
|
|
|
if !info.IsDir() {
|
|
file, err := os.Open(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer file.Close()
|
|
|
|
if _, err := io.Copy(tarWriter, file); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := tarWriter.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := gzWriter.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return buf.Bytes(), nil
|
|
}
|
|
|
|
func getProjectName() string {
|
|
var projectName string
|
|
|
|
if len(os.Args) < 3 {
|
|
if _, err := os.Stat("flux.json"); err != nil {
|
|
fmt.Printf("Usage: flux %[1]s <app name>, or run flux %[1]s in the project directory\n", os.Args[1])
|
|
os.Exit(1)
|
|
}
|
|
|
|
fluxConfigFile, err := os.Open("flux.json")
|
|
if err != nil {
|
|
fmt.Printf("Failed to open flux.json: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
defer fluxConfigFile.Close()
|
|
|
|
var config models.ProjectConfig
|
|
if err := json.NewDecoder(fluxConfigFile).Decode(&config); err != nil {
|
|
fmt.Printf("Failed to decode flux.json: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
projectName = config.Name
|
|
} else {
|
|
projectName = os.Args[2]
|
|
}
|
|
|
|
return projectName
|
|
}
|
|
|
|
func main() {
|
|
if len(os.Args) < 2 {
|
|
fmt.Println("Usage: flux <command>")
|
|
os.Exit(1)
|
|
}
|
|
|
|
command := os.Args[1]
|
|
|
|
if _, err := os.Stat(filepath.Join(configPath, "config.json")); err != nil {
|
|
if err := os.MkdirAll(configPath, 0755); err != nil {
|
|
fmt.Printf("Failed to create config directory: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if err = os.WriteFile(filepath.Join(configPath, "config.json"), config, 0644); err != nil {
|
|
fmt.Printf("Failed to write config file: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
var config Config
|
|
configBytes, err := os.ReadFile(filepath.Join(configPath, "config.json"))
|
|
if err != nil {
|
|
fmt.Printf("Failed to read config file: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if err := json.Unmarshal(configBytes, &config); err != nil {
|
|
fmt.Printf("Failed to parse config file: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
switch command {
|
|
case "deploy":
|
|
if _, err := os.Stat("flux.json"); err != nil {
|
|
fmt.Printf("No flux.json found, please run flux init first\n")
|
|
os.Exit(1)
|
|
}
|
|
|
|
loadingSpinner := spinner.New(spinner.CharSets[14], 100*time.Millisecond)
|
|
loadingSpinner.Suffix = " Deploying"
|
|
loadingSpinner.Start()
|
|
|
|
buf, err := compressDirectory()
|
|
if err != nil {
|
|
loadingSpinner.Stop()
|
|
|
|
fmt.Printf("Failed to compress directory: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
body := &bytes.Buffer{}
|
|
writer := multipart.NewWriter(body)
|
|
configPart, err := writer.CreateFormFile("config", "flux.json")
|
|
|
|
if err != nil {
|
|
loadingSpinner.Stop()
|
|
|
|
fmt.Printf("Failed to create config part: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
fluxConfigFile, err := os.Open("flux.json")
|
|
if err != nil {
|
|
loadingSpinner.Stop()
|
|
|
|
fmt.Printf("Failed to open flux.json: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
defer fluxConfigFile.Close()
|
|
|
|
if _, err := io.Copy(configPart, fluxConfigFile); err != nil {
|
|
loadingSpinner.Stop()
|
|
|
|
fmt.Printf("Failed to write config part: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
codePart, err := writer.CreateFormFile("code", "code.tar.gz")
|
|
if err != nil {
|
|
loadingSpinner.Stop()
|
|
|
|
fmt.Printf("Failed to create code part: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if _, err := codePart.Write(buf); err != nil {
|
|
loadingSpinner.Stop()
|
|
|
|
fmt.Printf("Failed to write code part: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if err := writer.Close(); err != nil {
|
|
loadingSpinner.Stop()
|
|
|
|
fmt.Printf("Failed to close writer: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
resp, err := http.Post(config.DeamonURL+"/deploy", "multipart/form-data; boundary="+writer.Boundary(), body)
|
|
if err != nil {
|
|
loadingSpinner.Stop()
|
|
|
|
fmt.Printf("Failed to send request: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
loadingSpinner.Stop()
|
|
|
|
responseBody, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
fmt.Printf("error reading response body: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if len(responseBody) > 0 && responseBody[len(responseBody)-1] == '\n' {
|
|
responseBody = responseBody[:len(responseBody)-1]
|
|
}
|
|
|
|
fmt.Printf("Deploy failed: %s\n", responseBody)
|
|
os.Exit(1)
|
|
}
|
|
|
|
loadingSpinner.Stop()
|
|
fmt.Println("Deployed successfully!")
|
|
case "stop":
|
|
projectName := getProjectName()
|
|
|
|
req, err := http.Post(config.DeamonURL+"/stop/"+projectName, "application/json", nil)
|
|
if err != nil {
|
|
fmt.Printf("Failed to stop app: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
defer req.Body.Close()
|
|
|
|
if req.StatusCode != http.StatusOK {
|
|
responseBody, err := io.ReadAll(req.Body)
|
|
if err != nil {
|
|
fmt.Printf("error reading response body: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if len(responseBody) > 0 && responseBody[len(responseBody)-1] == '\n' {
|
|
responseBody = responseBody[:len(responseBody)-1]
|
|
}
|
|
|
|
fmt.Printf("Stop failed: %s\n", responseBody)
|
|
os.Exit(1)
|
|
}
|
|
|
|
fmt.Printf("Successfully stopped %s\n", projectName)
|
|
case "start":
|
|
projectName := getProjectName()
|
|
|
|
req, err := http.Post(config.DeamonURL+"/start/"+projectName, "application/json", nil)
|
|
if err != nil {
|
|
fmt.Printf("Failed to start app: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
defer req.Body.Close()
|
|
|
|
if req.StatusCode != http.StatusOK {
|
|
responseBody, err := io.ReadAll(req.Body)
|
|
if err != nil {
|
|
fmt.Printf("error reading response body: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if len(responseBody) > 0 && responseBody[len(responseBody)-1] == '\n' {
|
|
responseBody = responseBody[:len(responseBody)-1]
|
|
}
|
|
|
|
fmt.Printf("Start failed: %s\n", responseBody)
|
|
os.Exit(1)
|
|
}
|
|
|
|
fmt.Printf("Successfully started %s\n", projectName)
|
|
case "delete":
|
|
projectName := getProjectName()
|
|
|
|
// ask for confirmation
|
|
fmt.Printf("Are you sure you want to delete %s? this will delete all volumes and containers associated with the deployment, and cannot be undone. \n[y/N]", projectName)
|
|
var response string
|
|
fmt.Scanln(&response)
|
|
|
|
if strings.ToLower(response) != "y" {
|
|
fmt.Println("Aborting...")
|
|
os.Exit(0)
|
|
}
|
|
|
|
req, err := http.NewRequest("DELETE", config.DeamonURL+"/deploy/"+projectName, nil)
|
|
if err != nil {
|
|
fmt.Printf("Failed to delete app: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
fmt.Printf("Failed to delete app: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
responseBody, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
fmt.Printf("error reading response body: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if len(responseBody) > 0 && responseBody[len(responseBody)-1] == '\n' {
|
|
responseBody = responseBody[:len(responseBody)-1]
|
|
}
|
|
|
|
fmt.Printf("Delete failed: %s\n", responseBody)
|
|
os.Exit(1)
|
|
}
|
|
|
|
fmt.Printf("Successfully deleted %s\n", projectName)
|
|
case "list":
|
|
resp, err := http.Get(config.DeamonURL + "/apps")
|
|
if err != nil {
|
|
fmt.Printf("Failed to get apps: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
var apps []models.App
|
|
if err := json.NewDecoder(resp.Body).Decode(&apps); err != nil {
|
|
fmt.Printf("Failed to decode apps: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if len(apps) == 0 {
|
|
fmt.Println("No apps found")
|
|
os.Exit(0)
|
|
}
|
|
|
|
for _, app := range apps {
|
|
fmt.Printf("%s (%s)\n", app.Name, app.DeploymentStatus)
|
|
}
|
|
case "init":
|
|
var projectConfig models.ProjectConfig
|
|
|
|
var response string
|
|
if len(os.Args) > 2 {
|
|
response = os.Args[2]
|
|
} else {
|
|
fmt.Println("What is the name of your project?")
|
|
fmt.Scanln(&response)
|
|
projectConfig.Name = response
|
|
}
|
|
|
|
fmt.Println("What URL should your project listen to?")
|
|
fmt.Scanln(&response)
|
|
if strings.HasPrefix(response, "http") {
|
|
strings.TrimPrefix(response, "http://")
|
|
strings.TrimPrefix(response, "https://")
|
|
}
|
|
|
|
response = strings.Split(response, "/")[0]
|
|
|
|
projectConfig.Url = response
|
|
|
|
fmt.Println("What port does your project listen to?")
|
|
fmt.Scanln(&response)
|
|
projectConfig.Port, err = strconv.Atoi(response)
|
|
if err != nil || projectConfig.Port < 1 || projectConfig.Port > 65535 {
|
|
fmt.Println("That doesnt look like a valid port", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
configBytes, err := json.MarshalIndent(projectConfig, "", " ")
|
|
if err != nil {
|
|
fmt.Printf("Failed to marshal project config: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
os.WriteFile("flux.json", configBytes, 0644)
|
|
|
|
fmt.Printf("Successfully initialized project %s\n", projectConfig.Name)
|
|
default:
|
|
fmt.Println("Unknown command:", command)
|
|
}
|
|
}
|