463 lines
12 KiB
Go
463 lines
12 KiB
Go
package server
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"io/fs"
|
|
"net/http"
|
|
"os"
|
|
"path"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"repositories.action2quare.com/ayo/gocommon/logger"
|
|
"repositories.action2quare.com/ayo/houston/shared"
|
|
)
|
|
|
|
/*
|
|
*
|
|
현재 접속 중인 Agent 목록을 보여줍니다.
|
|
- http method : GET
|
|
*/
|
|
const (
|
|
sub_folder_name_deploys = string("_deploys")
|
|
sub_folder_name_downloads = string("_downloads")
|
|
)
|
|
|
|
func (h *houstonHandler) GetAgents(w http.ResponseWriter, r *http.Request) {
|
|
enc := json.NewEncoder(w)
|
|
allHosts := h.Operation().Hosts()
|
|
enc.Encode(allHosts)
|
|
}
|
|
|
|
func (h *houstonHandler) GetDeploySources(w http.ResponseWriter, r *http.Request) {
|
|
files, err := os.ReadDir(h.deployPath)
|
|
if err != nil {
|
|
logger.Println(err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
getVersions := func(name string) []string {
|
|
var out []string
|
|
vers, _ := os.ReadDir(path.Join(h.deployPath, name))
|
|
for _, fd := range vers {
|
|
if fd.IsDir() {
|
|
ver := fd.Name()
|
|
files, _ := os.ReadDir(path.Join(h.deployPath, name, ver))
|
|
if len(files) > 0 {
|
|
downloadpath := path.Join(sub_folder_name_deploys, name, ver, files[0].Name())
|
|
ver = fmt.Sprintf("%s:%s", ver, downloadpath)
|
|
}
|
|
out = append(out, ver)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
out := make(map[string][]string)
|
|
for _, fd := range files {
|
|
if fd.IsDir() {
|
|
out[fd.Name()] = getVersions(fd.Name())
|
|
}
|
|
}
|
|
|
|
enc := json.NewEncoder(w)
|
|
enc.Encode(out)
|
|
}
|
|
|
|
func (h *houstonHandler) UploadDeploySource(w http.ResponseWriter, r *http.Request) {
|
|
// <form action="/houston" method="post" enctype="multipart/form-data">
|
|
// <input type="file" name="file">
|
|
// <input type="text" name="name">
|
|
// <input type="text" name="version">
|
|
// <input type="submit" value="업로드">
|
|
// </form>
|
|
file, header, err := r.FormFile("file")
|
|
if err != nil {
|
|
logger.Println(err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
defer file.Close()
|
|
|
|
contents, err := io.ReadAll(file)
|
|
if err != nil {
|
|
logger.Println(err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
version := r.FormValue("version")
|
|
name := r.FormValue("name")
|
|
ext := path.Ext(header.Filename)
|
|
|
|
var filename string
|
|
|
|
if version == "config" {
|
|
filename = path.Join(h.deployPath, name, version, "config"+ext)
|
|
} else {
|
|
// deploys 폴더는 파일시스템 서비스이므로 다운로드 가능
|
|
filename = path.Join(h.deployPath, name, version, name+ext)
|
|
}
|
|
|
|
if err = os.MkdirAll(path.Dir(filename), 0775); err != nil {
|
|
logger.Println(err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// 파일 저장
|
|
err = os.WriteFile(filename, contents, 0644)
|
|
if err != nil {
|
|
logger.Println(err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
return
|
|
}
|
|
}
|
|
|
|
func (h *houstonHandler) DeleteDeploySource(w http.ResponseWriter, r *http.Request) {
|
|
// <form action="/houston" method="post" enctype="multipart/form-data">
|
|
// <input type="text" name="name">
|
|
// <input type="text" name="version">
|
|
// </form>
|
|
version := r.FormValue("version")
|
|
name := r.FormValue("name")
|
|
|
|
if len(version) == 0 || len(name) == 0 {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// deploys 폴더는 파일시스템 서비스이므로 다운로드 가능
|
|
targetpath := path.Join(h.deployPath, name, version)
|
|
if err := os.RemoveAll(targetpath); err != nil {
|
|
logger.Println("deleteDeploySource failed :", err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
return
|
|
}
|
|
}
|
|
|
|
func (h *houstonHandler) findLastestConfigFile(name string) (string, error) {
|
|
logger.Println("findLastestConfigFile :", name)
|
|
configFiles, err := os.ReadDir(path.Join(h.deployPath, name, "config"))
|
|
if err != nil {
|
|
logger.Println("findLastestConfigFile failed :", err)
|
|
return "", err
|
|
}
|
|
|
|
var cf fs.FileInfo
|
|
for _, file := range configFiles {
|
|
if file.IsDir() {
|
|
continue
|
|
}
|
|
if strings.HasPrefix(file.Name(), "config.") {
|
|
test, err := file.Info()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
if cf == nil {
|
|
cf = test
|
|
} else if test.ModTime().After(cf.ModTime()) {
|
|
cf = test
|
|
}
|
|
}
|
|
}
|
|
|
|
if cf != nil {
|
|
logger.Println("findLastestConfigFile cf found :", cf.Name())
|
|
return path.Join(sub_folder_name_deploys, name, "config", cf.Name()), nil
|
|
}
|
|
|
|
logger.Println("findLastestConfigFile cf NOT found")
|
|
|
|
return "", nil
|
|
}
|
|
|
|
func (h *houstonHandler) Deploy(w http.ResponseWriter, r *http.Request) {
|
|
// <form action="/houston" method="post" enctype="multipart/form-data">
|
|
// <input type="text" name="name">
|
|
// <input type="text" name="version">
|
|
// <input type="text" name="targets">
|
|
// <input type="submit" value="업로드">
|
|
// </form>
|
|
name := r.FormValue("name")
|
|
version := r.FormValue("version")
|
|
traws := r.FormValue("targets")
|
|
|
|
var targets []string
|
|
if len(traws) > 0 {
|
|
if err := json.Unmarshal([]byte(traws), &targets); err != nil {
|
|
logger.Println(err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
if len(name) == 0 || len(version) == 0 || len(targets) == 0 {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
relPath := path.Join(h.deployPath, name, version)
|
|
files, err := os.ReadDir(relPath)
|
|
if err != nil {
|
|
logger.Println(err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
latestTime := time.Time{}
|
|
var latestFilename string
|
|
for _, fd := range files {
|
|
if fd.IsDir() {
|
|
continue
|
|
}
|
|
|
|
fi, _ := fd.Info()
|
|
if fi.ModTime().After(latestTime) {
|
|
latestFilename = fi.Name()
|
|
latestTime = fi.ModTime()
|
|
}
|
|
}
|
|
if len(latestFilename) == 0 {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
configPath, err := h.findLastestConfigFile(name)
|
|
if err != nil {
|
|
logger.Println(err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
h.Operation().Deploy(MakeDeployRequest(
|
|
shared.DeployRequest{
|
|
Name: name,
|
|
Version: version,
|
|
Url: path.Join(sub_folder_name_deploys, name, version, latestFilename),
|
|
Config: configPath,
|
|
},
|
|
targets,
|
|
))
|
|
}
|
|
|
|
func (h *houstonHandler) Undeploy(w http.ResponseWriter, r *http.Request) {
|
|
// <form action="/houston" method="post" enctype="multipart/form-data">
|
|
// <input type="text" name="name">
|
|
// <input type="text" name="version">
|
|
// <input type="text" name="targets">
|
|
// </form>
|
|
name := r.FormValue("name")
|
|
version := r.FormValue("version")
|
|
traws := r.FormValue("targets")
|
|
|
|
var targets []string
|
|
if len(traws) > 0 {
|
|
if err := json.Unmarshal([]byte(traws), &targets); err != nil {
|
|
logger.Println(err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
if len(name) == 0 || len(version) == 0 || len(targets) == 0 {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
h.Operation().Withdraw(MakeWithdrawRequest(
|
|
shared.WithdrawRequest{
|
|
Name: name,
|
|
Version: version,
|
|
},
|
|
targets,
|
|
))
|
|
}
|
|
|
|
func (h *houstonHandler) StartProcess(w http.ResponseWriter, r *http.Request) {
|
|
// <form action="/houston" method="post" enctype="multipart/form-data">
|
|
// <input type="text" name="name">
|
|
// <input type="text" name="version">
|
|
// <input type="text" name="args">
|
|
// <input type="text" name="targets">
|
|
// <input type="submit" value="업로드">
|
|
// </form>
|
|
name := r.FormValue("name")
|
|
version := r.FormValue("version")
|
|
args := r.FormValue("args")
|
|
traws := r.FormValue("targets")
|
|
|
|
var targets []string
|
|
if len(traws) > 0 {
|
|
if err := json.Unmarshal([]byte(traws), &targets); err != nil {
|
|
logger.Println(err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
if len(name) == 0 || len(version) == 0 || len(targets) == 0 {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
h.Operation().StartProcess(MakeStartProcessRequest(shared.StartProcessRequest{
|
|
Name: name,
|
|
Version: version,
|
|
Args: args, // 실행 파일 포함 e.g. "biglocal.exe -port=8090 -dev",
|
|
}, targets))
|
|
}
|
|
|
|
func (h *houstonHandler) StopProcess(w http.ResponseWriter, r *http.Request) {
|
|
// <form action="/houston" method="post" enctype="multipart/form-data">
|
|
// <input type="text" name="name">
|
|
// <input type="text" name="version">
|
|
// <input type="text" name="args">
|
|
// <input type="text" name="targets">
|
|
// <input type="submit" value="업로드">
|
|
// </form>
|
|
name := r.FormValue("name")
|
|
if len(name) == 0 {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
version := r.FormValue("version") // option
|
|
pidstr := r.FormValue("pid") // option
|
|
traws := r.FormValue("targets")
|
|
|
|
var targets []string
|
|
if len(traws) > 0 {
|
|
if err := json.Unmarshal([]byte(traws), &targets); err != nil {
|
|
logger.Println(err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
pid, _ := strconv.Atoi(pidstr)
|
|
|
|
h.Operation().StopProcess(MakeStopProcessRequest(shared.StopProcessRequest{
|
|
Name: name,
|
|
Version: version,
|
|
Pid: int32(pid),
|
|
}, targets))
|
|
}
|
|
|
|
func (h *houstonHandler) RestartProcess(w http.ResponseWriter, r *http.Request) {
|
|
// <form action="/houston" method="post" enctype="multipart/form-data">
|
|
// <input type="text" name="name">
|
|
// <input type="text" name="target">
|
|
// <input type="text" name="pid">
|
|
// <input type="text" name="config">
|
|
// </form>
|
|
pidstr := r.FormValue("pid")
|
|
target := r.FormValue("target")
|
|
name := r.FormValue("name")
|
|
if len(target) == 0 || len(pidstr) == 0 || len(name) == 0 {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
deployConfig := false
|
|
configstr := r.FormValue("config")
|
|
if len(configstr) > 0 {
|
|
deployConfig, _ = strconv.ParseBool(configstr)
|
|
}
|
|
|
|
pid, err := strconv.ParseInt(pidstr, 10, 0)
|
|
if err != nil {
|
|
logger.Println(err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
var configPath string
|
|
if deployConfig {
|
|
configPath, err = h.findLastestConfigFile(name)
|
|
if err != nil {
|
|
logger.Println(err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
h.Operation().RestartProcess(MakeRestartRequest(shared.RestartProcessRequest{
|
|
Name: name,
|
|
Pid: int32(pid),
|
|
Config: configPath,
|
|
}, []string{target}))
|
|
}
|
|
|
|
func (h *houstonHandler) UploadLogs(w http.ResponseWriter, r *http.Request) {
|
|
// <form action="/houston" method="post" enctype="multipart/form-data">
|
|
// <input type="text" name="name">
|
|
// <input type="text" name="version">
|
|
// <input type="text" name="filter">
|
|
// <input type="text" name="targets">
|
|
// <input type="submit" value="업로드">
|
|
// </form>
|
|
name := r.FormValue("name")
|
|
if len(name) == 0 {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
version := r.FormValue("version") // option
|
|
traws := r.FormValue("targets")
|
|
filter := r.FormValue("filter")
|
|
|
|
if len(filter) == 0 {
|
|
filter = "logs/*"
|
|
}
|
|
var targets []string
|
|
if err := json.Unmarshal([]byte(traws), &targets); err != nil {
|
|
logger.Println(err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
h.Operation().Upload(MakeUploadRequest(shared.UploadRequest{
|
|
Name: name,
|
|
Version: version,
|
|
Url: "upload",
|
|
Filter: filter,
|
|
}, targets))
|
|
}
|
|
|
|
func (h *houstonHandler) GetLogFileLinks(w http.ResponseWriter, r *http.Request) {
|
|
// <form action="/houston" method="post" enctype="multipart/form-data">
|
|
// <input type="text" name="name">
|
|
// <input type="text" name="version">
|
|
// </form>
|
|
name := r.FormValue("name")
|
|
version := r.FormValue("version")
|
|
if len(name) == 0 || len(version) == 0 {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
if version == "latest" {
|
|
version, _ = shared.FindLastestVersion(h.downloadPath, name)
|
|
}
|
|
|
|
root := path.Join(h.downloadPath, name, version)
|
|
logfiles, err := os.ReadDir(root)
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
var out []string
|
|
for _, lf := range logfiles {
|
|
out = append(out, path.Join(sub_folder_name_downloads, name, version, lf.Name()))
|
|
}
|
|
|
|
enc := json.NewEncoder(w)
|
|
enc.Encode(out)
|
|
}
|