254 lines
6.9 KiB
Go
254 lines
6.9 KiB
Go
package server
|
|
|
|
import (
|
|
"archive/zip"
|
|
"crypto/md5"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"path"
|
|
"reflect"
|
|
"runtime/debug"
|
|
"strings"
|
|
|
|
"repositories.action2quare.com/ayo/gocommon"
|
|
"repositories.action2quare.com/ayo/gocommon/flagx"
|
|
"repositories.action2quare.com/ayo/gocommon/logger"
|
|
)
|
|
|
|
type HoustonServerWithHandler interface {
|
|
HoustonServer
|
|
RegisterHandlers(serveMux gocommon.ServerMuxInterface, prefix string) error
|
|
}
|
|
|
|
type houstonHandler struct {
|
|
HoustonServer
|
|
methods map[string]reflect.Method
|
|
deployPath string
|
|
downloadPath string
|
|
maingateApiToken string
|
|
}
|
|
|
|
func NewHoustonHandler() HoustonServerWithHandler {
|
|
var tmp *houstonHandler
|
|
|
|
methods := make(map[string]reflect.Method)
|
|
tp := reflect.TypeOf(tmp)
|
|
for i := 0; i < tp.NumMethod(); i++ {
|
|
method := tp.Method(i)
|
|
methods[strings.ToLower(method.Name)] = method
|
|
}
|
|
return &houstonHandler{
|
|
HoustonServer: NewServer(),
|
|
methods: methods,
|
|
maingateApiToken: loadServerConfig().MaingateApiToken,
|
|
}
|
|
}
|
|
|
|
func (h *houstonHandler) RegisterHandlers(serveMux gocommon.ServerMuxInterface, prefix string) error {
|
|
config := loadServerConfig()
|
|
storagePath := config.StorageRoot
|
|
h.deployPath = path.Join(storagePath, sub_folder_name_deploys)
|
|
h.downloadPath = path.Join(storagePath, sub_folder_name_downloads)
|
|
|
|
if err := os.MkdirAll(h.deployPath, 0775); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := os.MkdirAll(h.downloadPath, 0775); err != nil {
|
|
return err
|
|
}
|
|
|
|
if len(prefix) > 0 {
|
|
prefix = "/" + prefix
|
|
}
|
|
serveMux.Handle(prefix, h)
|
|
|
|
fsx := http.FileServer(http.Dir(h.deployPath))
|
|
deployPrefix := fmt.Sprintf("%s/%s/", prefix, sub_folder_name_deploys)
|
|
logger.Printf("houstonHandler registed. deployPath : %s -> %s", fmt.Sprintf("%s/%s/", prefix, sub_folder_name_deploys), h.deployPath)
|
|
serveMux.HandleFunc(fmt.Sprintf("%s/%s/", prefix, sub_folder_name_deploys), func(w http.ResponseWriter, r *http.Request) {
|
|
p := strings.TrimPrefix(r.URL.Path, deployPrefix)
|
|
rp := strings.TrimPrefix(r.URL.RawPath, deployPrefix)
|
|
|
|
h := md5.New()
|
|
src := strings.TrimLeft(r.URL.Path, fmt.Sprintf("/%s/", prefix))
|
|
|
|
h.Write([]byte(src))
|
|
at := hex.EncodeToString(h.Sum(nil))
|
|
|
|
if len(p) < len(r.URL.Path) && (r.URL.RawPath == "" || len(rp) < len(r.URL.RawPath)) && at == r.Header.Get("As-X-UrlHash") {
|
|
r2 := new(http.Request)
|
|
*r2 = *r
|
|
r2.URL = new(url.URL)
|
|
*r2.URL = *r.URL
|
|
r2.URL.Path = p
|
|
r2.URL.RawPath = rp
|
|
fsx.ServeHTTP(w, r2)
|
|
} else {
|
|
http.NotFound(w, r)
|
|
}
|
|
})
|
|
|
|
// config는 접근하기 편하게 단축 경로 제공
|
|
serveMux.HandleFunc("/config/", func(w http.ResponseWriter, r *http.Request) {
|
|
logger.Println("config url.path :", r.URL.Path)
|
|
testhash := md5.New()
|
|
testhash.Write([]byte(r.URL.Path))
|
|
at := hex.EncodeToString(testhash.Sum(nil))
|
|
hash := r.Header.Get("As-X-UrlHash")
|
|
logger.Println("config at = hash :", at, hash)
|
|
if at == hash {
|
|
urlpath := strings.TrimPrefix(r.URL.Path, "/config/")
|
|
dir := path.Dir(urlpath)
|
|
file := path.Base(urlpath)
|
|
sourceFile := path.Join(h.deployPath, dir, "config", file)
|
|
logger.Println("config dest :", sourceFile)
|
|
bt, err := os.ReadFile(sourceFile)
|
|
if err != nil && !os.IsExist(err) {
|
|
logger.Println("config file is missing :", sourceFile)
|
|
w.WriteHeader(http.StatusNotFound)
|
|
} else {
|
|
if _, err = w.Write(bt); err != nil {
|
|
logger.Println("config write failed :", err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
}
|
|
}
|
|
} else {
|
|
http.NotFound(w, r)
|
|
}
|
|
})
|
|
|
|
ufsx := http.FileServer(http.Dir(h.downloadPath))
|
|
serveMux.Handle(fmt.Sprintf("%s/%s/", prefix, sub_folder_name_downloads), http.StripPrefix(fmt.Sprintf("%s/%s/", prefix, sub_folder_name_downloads), ufsx))
|
|
|
|
serveMux.HandleFunc(fmt.Sprintf("%s/upload", prefix), func(w http.ResponseWriter, r *http.Request) {
|
|
defer func() {
|
|
s := recover()
|
|
if s != nil {
|
|
logger.Error(s)
|
|
}
|
|
io.Copy(io.Discard, r.Body)
|
|
r.Body.Close()
|
|
}()
|
|
|
|
name := r.Header.Get("Houston-Service-Name")
|
|
version := r.Header.Get("Houston-Service-Version")
|
|
filename := r.Header.Get("Houston-Service-Filename")
|
|
dir := path.Join(h.downloadPath, name, version)
|
|
if err := os.MkdirAll(dir, 0775); err == nil {
|
|
zipfile, _ := os.Create(path.Join(dir, filename))
|
|
logger.Println("file uploaded :", zipfile)
|
|
if zipfile != nil {
|
|
if _, err = io.Copy(zipfile, r.Body); err != nil {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
} else {
|
|
if strings.HasSuffix(filename, ".zip") {
|
|
stat, _ := zipfile.Stat()
|
|
zipreader, _ := zip.NewReader(zipfile, stat.Size())
|
|
for _, f := range zipreader.File {
|
|
file, _ := os.Create(path.Join(dir, f.Name))
|
|
comp, _ := f.Open()
|
|
io.Copy(file, comp)
|
|
file.Close()
|
|
}
|
|
defer os.Remove(path.Join(dir, filename))
|
|
}
|
|
}
|
|
zipfile.Close()
|
|
} else {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
}
|
|
} else {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
}
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
var noauth = flagx.Bool("noauth", false, "")
|
|
var authtype = flagx.String("auth", "on", "on|off|both")
|
|
|
|
func (h *houstonHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
defer func() {
|
|
s := recover()
|
|
if s != nil {
|
|
logger.Println(s)
|
|
debug.PrintStack()
|
|
}
|
|
}()
|
|
|
|
defer func() {
|
|
io.Copy(io.Discard, r.Body)
|
|
r.Body.Close()
|
|
}()
|
|
|
|
// TODO : 구글 인증까지 붙인 후에 주석 제거
|
|
// var userinfo map[string]any
|
|
// if !*noauth && (*authtype == "on" || *authtype == "both") {
|
|
// authheader := r.Header.Get("Authorization")
|
|
// if len(authheader) == 0 {
|
|
// logger.Println("Authorization header is not valid :", authheader)
|
|
// w.WriteHeader(http.StatusBadRequest)
|
|
// return
|
|
// }
|
|
|
|
// req, _ := http.NewRequest("GET", "https://graph.microsoft.com/oidc/userinfo", nil)
|
|
// req.Header.Add("Authorization", authheader)
|
|
// client := &http.Client{}
|
|
|
|
// resp, err := client.Do(req)
|
|
// if err != nil {
|
|
// logger.Println("graph microsoft api call failed :", err)
|
|
// w.WriteHeader(http.StatusBadRequest)
|
|
// return
|
|
// }
|
|
// defer resp.Body.Close()
|
|
|
|
// raw, _ := io.ReadAll(resp.Body)
|
|
// if err = json.Unmarshal(raw, &userinfo); err != nil {
|
|
// return
|
|
// }
|
|
|
|
// if _, expired := userinfo["error"]; expired {
|
|
// w.WriteHeader(http.StatusUnauthorized)
|
|
// return
|
|
// }
|
|
// }
|
|
|
|
var operation string
|
|
if r.Method == "POST" {
|
|
operation = r.FormValue("operation")
|
|
} else {
|
|
operation = r.URL.Query().Get("operation")
|
|
}
|
|
|
|
if len(operation) == 0 {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
method, ok := h.methods[strings.ToLower(operation)]
|
|
if !ok {
|
|
// 없는 operation
|
|
logger.Println("fail to call api. operation is not valid :", operation)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
args := []reflect.Value{
|
|
reflect.ValueOf(h),
|
|
reflect.ValueOf(w),
|
|
reflect.ValueOf(r),
|
|
}
|
|
|
|
w.Header().Set("Access-Control-Allow-Origin", "*")
|
|
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
|
|
|
|
method.Func.Call(args)
|
|
}
|