Loader.go

package core

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"path/filepath"
	"regexp"
	"strings"

	"your_project/util"
)

// Config constants
const (
	LOADER = "loader.json"
	SOURCE = "source"
	DS     = string(os.PathSeparator)
)

// Loader 구조체 정의
type Loader struct{}

// Ref 메서드는 loader.json 파일에서 데이터를 읽어와 map[string]interface{} 형태로 반환합니다.
func (l *Loader) Ref() map[string]interface{} {
	ref := make(map[string]interface{})
	data, err := ioutil.ReadFile(LOADER)
	if err != nil {
		return nil
	}
	json.Unmarshal(data, &ref)
	return ref
}

// Build 메서드는 주어진 옵션에 따라 loader.json 파일을 업데이트합니다.
func (l *Loader) Build(options map[string]string) {
	ref := l.Ref()
	apiRoot := options["api_root"]
	scriptRoot := options["script_root"]
	serviceRoot := options["service_root"]

	ref["api"] = l.Items(apiRoot)
	ref["script"] = l.Items(scriptRoot)
	ref["service"] = l.Items(serviceRoot)

	data, _ := json.Marshal(ref)
	ioutil.WriteFile(LOADER, data, 0644)
}

// Items 메서드는 주어진 디렉토리 내의 파일 목록을 읽어와 map[string]string 형태로 반환합니다.
func (l *Loader) Items(directory string) map[string]string {
	items := make(map[string]string)
	if _, err := os.Stat(directory); os.IsNotExist(err) {
		return items
	}

	files, _ := util.ListFiles(directory)
	for _, file := range files {
		class := strings.TrimSuffix(strings.TrimPrefix(file, SOURCE+DS), ".go")
		name := strings.TrimSuffix(strings.TrimPrefix(file, directory+DS), ".go")
		name = util.ToLower(strings.ReplaceAll(name, DS, "/"))
		items[name] = strings.ReplaceAll(class, DS, ".")
	}
	return items
}

// API 메서드는 HTTP 요청을 처리하고 해당하는 API를 실행합니다.
func (l *Loader) API() {
	// 입력 처리
	rawParameters, _ := ioutil.ReadAll(os.Stdin)
	var rawParams map[string]interface{}
	json.Unmarshal(rawParameters, &rawParams)
	for k, v := range rawParams {
		os.Setenv(k, fmt.Sprint(v))
	}

	// 경로 파싱
	uri := os.Getenv("REQUEST_URI")
	apiName := util.ToLower(strings.Trim(uri, "/"))
	if apiName == "" {
		apiName = "main"
	}

	// 실행
	ref := l.Ref()
	class, found := ref["api"].(map[string]interface{})[apiName]
	if !found {
		api := Api{}
		api.Fail(http.StatusNotFound, "Api not found. Please check request uri.")
	} else {
		// class의 main 함수 호출 로직 추가
	}
}

// ExecApi 메서드는 주어진 Api 구조체의 Main 함수를 실행하고 결과를 처리합니다.
func (l *Loader) ExecApi(api Api) {
	// 실행
	r := api.Main()

	// 클래스를 배열로 변환
	if _, ok := r.(map[string]interface{}); !ok {
		r = util.ObjectToMap(r)
	}

	// 결과 생성
	if _, ok := r.(Result); !ok {
		result := Result{}
		result.Data = r
		r = result
	}

	if res, ok := r.(Result); ok {
		res.Code = http.StatusOK
		api.View(res)
	}
}

// Script 메서드는 주어진 인자에 따라 스크립트를 실행하거나 도움말을 출력합니다.
func (l *Loader) Script(argv []string) {
	scriptName := util.ToLower(strings.Trim(argv[1], "/"))

	// 버전 확인
	if scriptName == "--version" || scriptName == "-v" {
		scriptName = "version"
	}

	// 실행
	ref := l.Ref()
	class, found := ref["script"].(map[string]interface{})[scriptName]
	if !found {
		class = ref["script"].(map[string]interface{})["help"]
	}

	if class != nil {
		// script의 main 함수 호출 로직 추가
		inputs := l.ReadArg(argv)
		l.ExecScript(script, inputs)
	} else {
		l.DefaultScript(scriptName)
	}
}

// DefaultScript 메서드는 주어진 스크립트명에 따른 기본 도움말을 출력합니다.
func (l *Loader) DefaultScript(scriptName string) {
	var str strings.Builder
	ref := l.Ref()
	items := ref["script"].(map[string]interface{})
	base := filepath.Base(os.Args[0])
	var outputs []string
	maxlength := 0

	str.WriteString("\nUsage: " + base + " <command> \n\nCommands: \n")

	for key := range items {
		if strings.HasPrefix(key, scriptName) {
			outputs = append(outputs, key)
			if len(key) > maxlength {
				maxlength = len(key)
			}
		}
	}

	if len(outputs) == 0 {
		for key := range items {
			outputs = append(outputs, key)
			if len(key) > maxlength {
				maxlength = len(key)
			}
		}
	}

	for _, key := range outputs {
		class := ref["script"].(map[string]interface{})[key]
		description := "" // class의 설명 추가
		str.WriteString("  " + key + strings.Repeat(" ", maxlength-len(key)+1) + description + "\n")
	}

	fmt.Println(str.String())
}

// ReadArg 메서드는 주어진 인자 배열을 파싱하여 map[string]string으로 반환합니다.
func (l *Loader) ReadArg(argv []string) map[string]string {
	inputs := make(map[string]string)

	for i := 2; i < len(argv); i++ {
		arg := argv[i]

		if match, _ := regexp.MatchString(`^-([a-zA-Z_])$`, arg); match {
			inputs[arg[1:2]] = argv[i+1]
			i++
		} else if match, _ := regexp.MatchString(`^-([a-zA-Z_])(.+)`, arg); match {
			inputs[arg[1:2]] = arg[2:]
		} else if match, _ := regexp.MatchString(`^--([a-zA-Z0-9_]+)$`, arg); match {
			inputs[arg[2:]] = argv[i+1]
			i++
		} else if match, _ := regexp.MatchString(`^--([a-zA-Z0-9_]+)=(.+)`, arg); match {
			inputs[arg[2:strings.Index(arg, "=")]] = arg[strings.Index(arg, "=")+1:]
		} else {
			inputs[arg] = ""
		}
	}

	return inputs
}

// ExecScript 메서드는 주어진 Script 구조체의 Args와 Main 함수를 실행합니다.
func (l *Loader) ExecScript(script Script, inputs map[string]string) {
	// 실행
	script.Args(inputs)
	script.Main()
}

// Service 메서드는 주어진 서비스명에 따라 해당 서비스를 실행하거나 사용 가능한 서비스 목록을 출력합니다.
func (l *Loader) Service(serviceBin string, argv []string) {
	// 초기화
	serviceName := util.ToLower(strings.Trim(argv[1], "/"))
	inputs := argv[2:]

	// 실행
	if serviceName == "run" {
		fmt.Println("runService: ", strings.Join(inputs, " "))
		l.RunService(serviceBin, inputs)
		return
	}

	// 실행
	ref := l.Ref()
	class, found := ref["service"].(map[string]interface{})[serviceName]
	if !found {
		fmt.Println("\nService not found. Please check service name. \n\n[Available services]\n")
		for key := range ref["service"].(map[string]interface{}) {
			fmt.Println(" - " + key)
		}
		fmt.Println()
	} else {
		// class의 main 함수 호출 로직 추가
		l.ExecService(service, inputs)
	}
}

// RunService 메서드는 주어진 서비스명과 입력에 따라 해당 서비스를 실행합니다.
func (l *Loader) RunService(serviceBin string, inputs []string) {
	serviceName := util.ToLower(strings.Trim(inputs[0], "/"))
	inputs = inputs[1:]

	if serviceName == "run" {
		os.Exit(0)
	}

	util.ForkProcess(serviceBin, serviceName, inputs)
}

// ExecService 메서드는 주어진 Service 구조체의 Args, Init, Main 및 Iterate 함수를 반복 실행합니다.
func (l *Loader) ExecService(service Service, inputs []string) {
	// 가비지 컬렉터
	if os.Getenv("ENABLE_GC") == "true" {
		util.EnableGC()
	}

	// 실행
	service.Args(inputs)
	service.Init()

	for {
		service.Main()
		service.Iterate()

		util.ClearStatCache()

		if os.Getenv("ENABLE_GC") == "true" {
			util.CollectCycles()
		}
	}
}

1. Ref 메서드

func (l *Loader) Ref() map[string]interface{} {
    ref := make(map[string]interface{})
    data, err := ioutil.ReadFile(LOADER)
    if err != nil {
        return nil
    }
    json.Unmarshal(data, &ref)
    return ref
}

• 역할: LOADER 파일(보통 loader.json)을 읽어서 JSON 데이터를 맵 형태로 반환합니다.

• 동작 방식:

  • ioutil.ReadFile(LOADER)를 사용하여 파일을 읽습니다. 파일이 없거나 읽기에 실패하면 nil을 반환합니다.

  • 파일의 내용을 json.Unmarshal을 사용하여 ref 맵에 언마샬링(디코딩)합니다.

  • 언마샬링된 ref 맵을 반환합니다.

2. Build 메서드

func (l *Loader) Build(options map[string]string) {
    ref := l.Ref()
    apiRoot := options["api_root"]
    scriptRoot := options["script_root"]
    serviceRoot := options["service_root"]

    ref["api"] = l.Items(apiRoot)
    ref["script"] = l.Items(scriptRoot)
    ref["service"] = l.Items(serviceRoot)

    data, _ := json.Marshal(ref)
    ioutil.WriteFile(LOADER, data, 0644)
}

• 역할: 지정된 디렉토리에서 API, 스크립트, 서비스 항목을 스캔하여 LOADER 파일을 업데이트합니다.

• 동작 방식:

  • Ref 메서드를 호출하여 기존의 loader.json 파일 내용을 읽어옵니다.

  • 옵션으로 받은 api_root, script_root, service_root 디렉토리를 각각 Items 메서드를 사용하여 스캔합니다.

  • 각 디렉토리의 내용을 ref 맵에 추가합니다.

  • json.Marshal을 사용하여 ref 맵을 JSON으로 변환하고, ioutil.WriteFile을 사용하여 LOADER 파일에 씁니다.

3. Items 메서드

func (l *Loader) Items(directory string) map[string]string {
    items := make(map[string]string)
    if _, err := os.Stat(directory); os.IsNotExist(err) {
        return items
    }

    files, _ := util.ListFiles(directory)
    for _, file := range files {
        class := strings.TrimSuffix(strings.TrimPrefix(file, SOURCE+DS), ".go")
        name := strings.TrimSuffix(strings.TrimPrefix(file, directory+DS), ".go")
        name = util.ToLower(strings.ReplaceAll(name, DS, "/"))
        items[name] = strings.ReplaceAll(class, DS, ".")
    }
    return items
}

• 역할: 지정된 디렉토리 내의 파일들을 스캔하여 파일 경로와 클래스 이름을 맵 형태로 반환합니다.

• 동작 방식:

  • os.Stat를 사용하여 디렉토리의 존재 여부를 확인합니다. 디렉토리가 없으면 빈 맵을 반환합니다.

  • util.ListFiles(directory)를 사용하여 디렉토리 내 모든 파일을 리스트로 가져옵니다.

  • 각 파일에 대해:

    • SOURCE+DS 및 .go 확장자를 제거하여 클래스 이름을 추출합니다.

    • 디렉토리 경로와 .go 확장자를 제거하고, 경로 구분자를 /로 바꾸고 소문자로 변환하여 이름을 추출합니다.

    • 클래스 이름을 .으로 구분하여 저장합니다.

  • 완성된 items 맵을 반환합니다.

4. API 메서드

func (l *Loader) API() {
    // Input
    rawParameters, _ := ioutil.ReadAll(os.Stdin)
    var rawParams map[string]interface{}
    json.Unmarshal(rawParameters, &rawParams)
    for k, v := range rawParams {
        os.Setenv(k, fmt.Sprint(v))
    }

    // Path
    uri := os.Getenv("REQUEST_URI")
    apiName := util.ToLower(strings.Trim(uri, "/"))
    if apiName == "" {
        apiName = "main"
    }

    // Execution
    ref := l.Ref()
    class, found := ref["api"].(map[string]interface{})[apiName]
    if !found {
        api := Api{}
        api.Fail(http.StatusNotFound, "Api not found. Please check request uri.")
    } else {
        // class의 main 함수 호출 로직 추가
    }
}

• 역할: API 요청을 처리합니다.

• 동작 방식:

  • os.Stdin에서 입력을 읽어와 rawParams 맵으로 언마샬링합니다.

  • 각 입력 파라미터를 환경 변수로 설정합니다.

  • REQUEST_URI 환경 변수에서 요청된 URI를 가져와 API 이름을 추출합니다. 기본값은 main입니다.

  • Ref 메서드를 호출하여 API 맵을 가져옵니다. 요청된 API가 존재하지 않으면 404 오류를 반환합니다.

  • 존재하면 해당 API 클래스를 찾아서 main 함수를 호출하는 로직을 추가합니다.

5. ExecApi 메서드

func (l *Loader) ExecApi(api Api) {
    // Execution
    r := api.Main()

    // Class to array
    if _, ok := r.(map[string]interface{}); !ok {
        r = util.ObjectToMap(r)
    }

    // Make result
    if _, ok := r.(Result); !ok {
        result := Result{}
        result.Data = r
        r = result
    }

    if res, ok := r.(Result); ok {
        res.Code = http.StatusOK
        api.View(res)
    }
}

• 역할: API를 실행하고 결과를 처리합니다.

• 동작 방식:

  • api.Main()을 호출하여 결과를 받습니다.

  • 결과가 map[string]interface{} 타입이 아니면 util.ObjectToMap을 사용하여 변환합니다.

  • 결과가 Result 타입이 아니면 Result 구조체로 감쌉니다.

  • 결과를 Result 타입으로 변환하여 HTTP 상태 코드를 설정하고 api.View를 호출하여 응답을 처리합니다.

6. Script 메서드

func (l *Loader) Script(argv []string) {
    scriptName := util.ToLower(strings.Trim(argv[1], "/"))

    // Version
    if scriptName == "--version" || scriptName == "-v" {
        scriptName = "version"
    }

    // Execution
    ref := l.Ref()
    class, found := ref["script"].(map[string]interface{})[scriptName]
    if !found {
        class = ref["script"].(map[string]interface{})["help"]
    }

    if class != nil {
        // script의 main 함수 호출 로직 추가
        inputs := l.ReadArg(argv)
        l.ExecScript(script, inputs)
    } else {
        l.DefaultScript(scriptName)
    }
}

• 역할: 주어진 스크립트를 실행합니다.

• 동작 방식:

  • 명령줄 인자를 파싱하여 스크립트 이름을 추출합니다.

  • --version 또는 -v 옵션을 처리합니다.

  • Ref 메서드를 호출하여 스크립트 맵을 가져옵니다. 해당 스크립트가 없으면 도움말 스크립트를 설정합니다.

  • 스크립트가 존재하면 ReadArg를 호출하여 인자를 읽고 ExecScript를 호출하여 스크립트를 실행합니다. 그렇지 않으면 DefaultScript를 호출하여 기본 스크립트를 실행합니다.

7. DefaultScript 메서드

func (l *Loader) DefaultScript(scriptName string) {
    var str strings.Builder
    ref := l.Ref()
    items := ref["script"].(map[string]interface{})
    base := filepath.Base(os.Args[0])
    var outputs []string
    maxlength := 0

    str.WriteString("\nUsage: " + base + " <command> \n\nCommands: \n")

    for key := range items {
        if strings.HasPrefix(key, scriptName) {
            outputs = append(outputs, key)
            if len(key) > maxlength {
                maxlength = len(key)
            }
        }
    }

    if len(outputs) == 0 {
        for key := range items {
            outputs = append(outputs, key)
            if len(key) > maxlength {
                maxlength = len(key)
            }
        }
    }

    for _, key := range outputs {
        class := ref["script"].(map[string]interface{})[key]
        description := "" // class의 설명 추가
        str.WriteString("  " + key + strings.Repeat(" ", maxlength-len(key)+1) + description + "\n")
    }

    fmt.Println(str.String())
}

• 역할: 사용 가능한 스크립트 명령어 목록을 출력합니다.

• 동작 방식:

  • Ref 메서드를 호출하여 스크립트 맵을 가져옵니다.

  • 명령어 목록을 작성하고 최대 길이를 계산하여 출력 포맷을 조정합니다.

  • 각 스크립트 명령어와 설명을 출력합니다.

8. ReadArg 메서드

func (l *Loader) ReadArg(argv []string) map[string]string {
    inputs := make(map[string]string)

    for i := 2; i < len(argv); i++ {
        arg := argv[i]

        if match, _ := regexp.MatchString(`^-([a-zA-Z_])$`, arg); match {
            inputs[arg[1:2]] = argv[i+1]
            i++
        } else if match, _ := regexp.MatchString(`^-([a-zA-Z_])(.+)`, arg); match {
            inputs[arg[1:2]] = arg[2:]
        } else if match, _ := regexp.MatchString(`^--([a-zA-Z0-9_]+)$`, arg); match {
            inputs[arg[2:]] = argv[i+1]
            i++
        } else if match, _ := regexp.MatchString(`^--([a-zA-Z0-9_]+)=(.+)`, arg); match {
            inputs[arg[2:strings.Index(arg, "=")]] = arg[strings.Index(arg, "=")+1:]
        } else {
            inputs[arg] = ""
        }
    }

    return inputs
}

• 역할: 명령줄 인자를 파싱하여 맵 형태로 반환합니다.

• 동작 방식:

  • 명령줄 인자(argv)를 순회하며 정규 표현식을 사용하여 파라미터 형식을 확인합니다.

  • 짝수 인덱스에서 키를, 홀수 인덱스에서 값을 추출하여 맵에 추가합니다.

9. ExecScript 메서드

func (l *Loader) ExecScript(script Script, inputs map[string]string) {
    // Execution
    script.Args(inputs)
    script.Main()
}

• 역할: 주어진 스크립트를 실행합니다.

• 동작 방식:

  • 스크립트의 Args 메서드를 호출하여 인자를 설정합니다.

  • 스크립트의 Main 메서드를 호출하여 스크립트를 실행합니다.

10. Service 메서드

func (l *Loader) Service(serviceBin string, argv []string) {
    // Init
    serviceName := util.ToLower(strings.Trim(argv[1], "/"))
    inputs := argv[2:]

    // Run
    if serviceName == "run" {
        fmt.Println("runService: ", strings.Join(inputs, " "))
        l.RunService(serviceBin, inputs)
        return
    }

    // Execution
    ref := l.Ref()
    class, found := ref["service"].(map[string]interface{})[serviceName]
    if !found {
        fmt.Println("\nService not found. Please check service name. \n\n[Available services]\n")
        for key := range ref["service"].(map[string]interface{}) {
            fmt.Println(" - " + key)
        }
        fmt.Println()
    } else {
        // class의 main 함수 호출 로직 추가
        l.ExecService(service, inputs)
    }
}

• 역할: 주어진 서비스를 실행합니다.

• 동작 방식:

  • 명령줄 인자에서 서비스 이름을 추출합니다.

  • run 명령어를 처리하여 RunService 메서드를 호출합니다.

  • Ref 메서드를 호출하여 서비스 맵을 가져옵니다. 해당 서비스가 없으면 사용 가능한 서비스 목록을 출력합니다.

  • 존재하면 해당 서비스를 실행합니다.

11. RunService 메서드

func (l *Loader) RunService(serviceBin string, inputs []string) {
    serviceName := util.ToLower(strings.Trim(inputs[0], "/"))
    inputs = inputs[1:]

    if serviceName == "run" {
        os.Exit(0)
    }

    util.ForkProcess(serviceBin, serviceName, inputs)
}

• 역할: 주어진 서비스 바이너리를 실행합니다.

• 동작 방식:

  • 명령줄 인자에서 서비스 이름을 추출합니다.

  • run 명령어를 처리하여 프로그램을 종료합니다.

  • util.ForkProcess를 호출하여 서비스 바이너리를 포크 프로세스로 실행합니다.

12. ExecService 메서드

func (l *Loader) ExecService(service Service, inputs []string) {
    // Garbage collector
    if os.Getenv("ENABLE_GC") == "true" {
        util.EnableGC()
    }

    // Execution
    service.Args(inputs)
    service.Init()

    for {
        service.Main()
        service.Iterate()

        util.ClearStatCache()

        if os.Getenv("ENABLE_GC") == "true" {
            util.CollectCycles()
        }
    }
}

• 역할: 주어진 서비스를 반복적으로 실행합니다.

• 동작 방식:

  • 가비지 컬렉터가 활성화되어 있으면 활성화합니다.

  • 서비스의 Args와 Init 메서드를 호출하여 초기화합니다.

  • 무한 루프에서 서비스의 Main과 Iterate 메서드를 호출하여 반복 실행합니다.

  • 필요시 캐시를 지우고 가비지 컬렉터를 실행합니다.

이와 같이 각 함수는 API 호출, 스크립트 실행, 서비스 실행 등의 작업을 처리하기 위한 다양한 기능을 제공하며, 주어진 입력과 설정을 기반으로 필요한 작업을 수행합니다.