zoeissleeping/flux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

scaffold CLI and fix logging

Browse Source
This commit is contained in:
Zoe
2024-12-03 03:21:12 -06:00
parent 8a55c1593b
commit 9d97e11fc6
9 changed files with 329 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
server/deploy.go
View File

@@ -31,6 +31,7 @@ type ProjectConfig struct {
func (s *FluxServer) DeployHandler(w http.ResponseWriter, r *http.Request) {
err := r.ParseMultipartForm(10 << 30) // 10 GiB
if err != nil {
log.Printf("Failed to parse multipart form: %v\n", err)
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
@@ -53,7 +54,7 @@ func (s *FluxServer) DeployHandler(w http.ResponseWriter, r *http.Request) {
var projectConfig ProjectConfig
if err := json.NewDecoder(deployRequest.Config).Decode(&projectConfig); err != nil {
log.Printf("Failed to decode config: %v", err)
log.Printf("Failed to decode config: %v\n", err)
http.Error(w, "Invalid flux.json", http.StatusBadRequest)
return
}
@@ -73,58 +74,60 @@ func (s *FluxServer) DeployHandler(w http.ResponseWriter, r *http.Request) {
return
}
log.Printf("Deploying project %s to %s", projectConfig.Name, projectConfig.Urls)
log.Printf("Deploying project %s to %s\n", projectConfig.Name, projectConfig.Urls)
projectPath, err := s.UploadAppCode(deployRequest.Code, projectConfig)
if err != nil {
log.Printf("Failed to upload code: %v", err)
log.Printf("Failed to upload code: %v\n", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
log.Printf("Preparing project %s...\n", projectConfig.Name)
prepareCmd := exec.Command("go", "generate")
prepareCmd.Dir = projectPath
err = prepareCmd.Run()
if err != nil {
log.Printf("Failed to prepare project: %s", err)
log.Printf("Failed to prepare project: %s\n", err)
http.Error(w, fmt.Sprintf("Failed to prepare project: %s", err), http.StatusInternalServerError)
return
}
log.Printf("Building image for project %s...\n", projectConfig.Name)
imageName := fmt.Sprintf("%s-image", projectConfig.Name)
buildCmd := exec.Command("pack", "build", imageName, "--builder", s.config.Builder)
buildCmd.Dir = projectPath
err = buildCmd.Run()
if err != nil {
log.Printf("Failed to build image: %s", err)
log.Printf("Failed to build image: %s\n", err)
http.Error(w, fmt.Sprintf("Failed to build image: %s", err), http.StatusInternalServerError)
return
}
containerID, err := s.containerManager.DeployContainer(r.Context(), imageName, projectConfig.Name, projectPath, projectConfig)
if err != nil {
log.Printf("Failed to deploy container: %v", err)
log.Printf("Failed to deploy container: %v\n", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
deploymentResult, err := s.db.Exec("INSERT INTO deployments (urls) VALUES (?)", strings.Join(projectConfig.Urls, ","))
if err != nil {
log.Printf("Failed to insert deployment: %v", err)
log.Printf("Failed to insert deployment: %v\n", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
deploymentID, err := deploymentResult.LastInsertId()
if err != nil {
log.Printf("Failed to get deployment id: %v", err)
log.Printf("Failed to get deployment id: %v\n", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
_, err = s.db.Exec("INSERT INTO containers (container_id, deployment_id, status) VALUES (?, ?, ?)", containerID, deploymentID, "pending")
if err != nil {
log.Printf("Failed to get container id: %v", err)
log.Printf("Failed to get container id: %v\n", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
@@ -132,7 +135,7 @@ func (s *FluxServer) DeployHandler(w http.ResponseWriter, r *http.Request) {
appExists := s.db.QueryRow("SELECT * FROM apps WHERE name = ?", projectConfig.Name)
configBytes, err := json.Marshal(projectConfig)
if err != nil {
log.Printf("Failed to marshal project config: %v", err)
log.Printf("Failed to marshal project config: %v\n", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
@@ -142,7 +145,7 @@ func (s *FluxServer) DeployHandler(w http.ResponseWriter, r *http.Request) {
// create app in the database
appResult, err = s.db.Exec("INSERT INTO apps (name, image, project_path, project_config, deployment_id) VALUES (?, ?, ?, ?, ?)", projectConfig.Name, imageName, projectPath, configBytes, deploymentID)
if err != nil {
log.Printf("Failed to insert app: %v", err)
log.Printf("Failed to insert app: %v\n", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
@@ -150,7 +153,7 @@ func (s *FluxServer) DeployHandler(w http.ResponseWriter, r *http.Request) {
// update app in the database
appResult, err = s.db.Exec("UPDATE apps SET project_config = ?, deployment_id = ? WHERE name = ?", configBytes, deploymentID, projectConfig.Name)
if err != nil {
log.Printf("Failed to update app: %v", err)
log.Printf("Failed to update app: %v\n", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
@@ -158,7 +161,7 @@ func (s *FluxServer) DeployHandler(w http.ResponseWriter, r *http.Request) {
appId, err := appResult.LastInsertId()
if err != nil {
log.Printf("Failed to get app id: %v", err)
log.Printf("Failed to get app id: %v\n", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}

7
server/docker.go
View File

@@ -32,6 +32,8 @@ func NewContainerManager() *ContainerManager {
}
func (cm *ContainerManager) DeployContainer(ctx context.Context, imageName, containerPrefix, projectPath string, projectConfig ProjectConfig) (string, error) {
log.Printf("Deploying container with image %s\n", imageName)
containerName := fmt.Sprintf("%s-%s", containerPrefix, time.Now().Format("20060102-150405"))
existingContainers, err := cm.findExistingContainers(ctx, containerPrefix)
@@ -41,7 +43,7 @@ func (cm *ContainerManager) DeployContainer(ctx context.Context, imageName, cont
// TODO: swap containers if they are running and have the same image so that we can have a constant uptime
for _, existingContainer := range existingContainers {
log.Printf("Stopping existing container: %s", existingContainer)
log.Printf("Stopping existing container: %s\n", existingContainer)
if err := cm.dockerClient.ContainerStop(ctx, existingContainer, container.StopOptions{}); err != nil {
return "", fmt.Errorf("Failed to stop existing container: %v", err)
@@ -69,6 +71,7 @@ func (cm *ContainerManager) DeployContainer(ctx context.Context, imageName, cont
}
}
log.Printf("Creating and starting container %s...\n", containerName)
resp, err := cm.dockerClient.ContainerCreate(ctx, &container.Config{
Image: imageName,
Env: projectConfig.Environment,
@@ -98,7 +101,7 @@ func (cm *ContainerManager) DeployContainer(ctx context.Context, imageName, cont
return "", fmt.Errorf("Failed to start container: %v", err)
}
log.Printf("Deployed new container: %s", containerName)
log.Printf("Deployed new container: %s\n", containerName)
return resp.ID, nil
}

36
server/server.go
View File

@@ -49,47 +49,47 @@ func NewServer() *FluxServer {
configPath := filepath.Join(rootDir, "config.json")
if _, err := os.Stat(configPath); err != nil {
if err := os.MkdirAll(rootDir, 0755); err != nil {
log.Fatalf("Failed to create fluxd directory: %v", err)
log.Fatalf("Failed to create fluxd directory: %v\n", err)
}
configBytes, err := json.Marshal(DefaultConfig)
if err != nil {
log.Fatalf("Failed to marshal default config: %v", err)
log.Fatalf("Failed to marshal default config: %v\n", err)
}
log.Printf("Config file not found, creating default config file at %s", configPath)
log.Printf("Config file not found, creating default config file at %s\n", configPath)
if err := os.WriteFile(configPath, configBytes, 0644); err != nil {
log.Fatalf("Failed to write config file: %v", err)
log.Fatalf("Failed to write config file: %v\n", err)
}
}
configFile, err := os.ReadFile(configPath)
if err != nil {
log.Fatalf("Failed to read config file: %v", err)
log.Fatalf("Failed to read config file: %v\n", err)
}
if err := json.Unmarshal(configFile, &serverConfig); err != nil {
log.Fatalf("Failed to parse config file: %v", err)
log.Fatalf("Failed to parse config file: %v\n", err)
}
if err := os.MkdirAll(filepath.Join(rootDir, "apps"), 0755); err != nil {
log.Fatalf("Failed to create apps directory: %v", err)
log.Fatalf("Failed to create apps directory: %v\n", err)
}
db, err := sql.Open("sqlite3", filepath.Join(rootDir, "fluxd.db"))
if err != nil {
log.Fatalf("Failed to open database: %v", err)
log.Fatalf("Failed to open database: %v\n", err)
}
// create database schema
schemaBytes, err := schema.ReadFile("schema.sql")
if err != nil {
log.Fatalf("Failed to read schema file: %v", err)
log.Fatalf("Failed to read schema file: %v\n", err)
}
_, err = db.Exec(string(schemaBytes))
if err != nil {
log.Fatalf("Failed to create database schema: %v", err)
log.Fatalf("Failed to create database schema: %v\n", err)
}
return &FluxServer{
@@ -102,27 +102,27 @@ func NewServer() *FluxServer {
func (s *FluxServer) UploadAppCode(code io.Reader, projectConfig ProjectConfig) (string, error) {
projectPath := filepath.Join(rootDir, "apps", projectConfig.Name)
if err := os.MkdirAll(projectPath, 0755); err != nil {
log.Printf("Failed to create project directory: %v", err)
log.Printf("Failed to create project directory: %v\n", err)
return "", err
}
gzReader, err := gzip.NewReader(code)
if err != nil {
log.Printf("Failed to create gzip reader: %v", err)
log.Printf("Failed to create gzip reader: %v\n", err)
return "", err
}
defer gzReader.Close()
tarReader := tar.NewReader(gzReader)
// Extract files
log.Printf("Extracting files for %s...\n", projectPath)
for {
header, err := tarReader.Next()
if err == io.EOF {
break
}
if err != nil {
log.Printf("Failed to read tar header: %v", err)
log.Printf("Failed to read tar header: %v\n", err)
return "", err
}
@@ -133,24 +133,24 @@ func (s *FluxServer) UploadAppCode(code io.Reader, projectConfig ProjectConfig)
switch header.Typeflag {
case tar.TypeDir:
if err := os.MkdirAll(path, 0755); err != nil {
log.Printf("Failed to extract directory: %v", err)
log.Printf("Failed to extract directory: %v\n", err)
return "", err
}
case tar.TypeReg:
if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
log.Printf("Failed to extract directory: %v", err)
log.Printf("Failed to extract directory: %v\n", err)
return "", err
}
outFile, err := os.Create(path)
if err != nil {
log.Printf("Failed to extract file: %v", err)
log.Printf("Failed to extract file: %v\n", err)
return "", err
}
defer outFile.Close()
if _, err := io.Copy(outFile, tarReader); err != nil {
log.Printf("Failed to copy file during extraction: %v", err)
log.Printf("Failed to copy file during extraction: %v\n", err)
return "", err
}
}