makeshift/pkg/service/service.go

package service

import (
	"encoding/json"
	"fmt"
	"io/fs"
	"net/http"
	"os"
	"path/filepath"
	"plugin"
	"slices"
	"time"

	makeshift "git.towk2.me/towk/makeshift/pkg"
	"git.towk2.me/towk/makeshift/pkg/util"
	"github.com/go-chi/chi/v5"
	"github.com/go-chi/chi/v5/middleware"
	"github.com/rs/zerolog/log"
)

type Service struct {
	Addr        string
	RootPath    string `yaml:"root,omitempty"`
	Environment map[string]string

	// max counts
	PluginsMaxCount  int
	ProfilesMaxCount int
	Timeout          time.Duration
}

// New creates a new Service instance with default values
func New() *Service {
	return &Service{
		Addr:     ":5050",
		RootPath: "./",
		Environment: map[string]string{
			"MAKESHIFT_HOST": "",
			"MAKESHIFT_ROOT": "",
			"ACCESS_TOKEN":   "",
		},
		PluginsMaxCount:  DEFAULT_PLUGINS_MAX_COUNT,
		ProfilesMaxCount: DEFAULT_PROFILES_MAX_COUNT,
		Timeout:          DEFAULT_TIMEOUT_IN_SECS,
	}
}

// Init() sets up the default files and directories for the service
func (s *Service) Init() error {
	// create the default directories
	var err error
	err = os.MkdirAll(s.RootPath, 0o777)
	if err != nil {
		return fmt.Errorf("failed to make service root path: %v", err)
	}
	err = os.MkdirAll(s.PathForPlugins(), 0o777)
	if err != nil {
		return fmt.Errorf("failed to make service plugin path: %v", err)
	}
	err = os.MkdirAll(s.PathForProfiles(), 0o777)
	if err != nil {
		return fmt.Errorf("failed to make service profile path: %v", err)
	}
	err = os.MkdirAll(s.PathForData(), 0o777)
	if err != nil {
		return fmt.Errorf("failed to make service data path: %v", err)
	}

	// create the default files
	err = os.WriteFile(s.PathForMetadata(), []byte(FILE_METADATA), 0o777)
	if err != nil {
		return fmt.Errorf("failed to make service metadata file: %v", err)
	}
	err = os.WriteFile(s.PathForHome(), []byte(FILE_HOME_PAGE), 0o777)
	if err != nil {
		return fmt.Errorf("failed to make service home page file: %v", err)
	}
	err = os.WriteFile(s.PathForProfileWithID("default"), []byte(FILE_DEFAULT_PROFILE), 0o777)
	if err != nil {
		return fmt.Errorf("failed to make service default profile file: %v", err)
	}

	return nil
}

// Serve() starts the makeshift service and waits for requests.
func (s *Service) Serve() error {
	router := chi.NewRouter()
	router.Use(middleware.RequestID)
	router.Use(middleware.RealIP)
	router.Use(middleware.Logger)
	router.Use(middleware.Recoverer)
	router.Use(middleware.StripSlashes)
	router.Use(middleware.Timeout(s.Timeout * time.Second))

	if s.requireAuth() {

	} else {
		// general
		// router.Handle("/download/*", http.StripPrefix("/download/", http.FileServer(http.Dir(s.PathForData()))))
		router.Get("/download/*", s.Download())
		router.Post("/upload", s.Upload())
		router.Get("/list/*", s.List())

		// profiles
		router.Get("/profiles", s.ListProfiles())
		// router.Post("/profiles", s.CreateProfiles())
		router.Get("/profile/{id}", s.GetProfile())
		router.Post("/profile/{id}", s.CreateProfile())
		router.Get("/profile/{id}/data", s.GetProfileData())
		router.Post("/profile/{id}/data", s.SetProfileData())
		router.Delete("/profile/{id}/data", s.DeleteProfileData())

		// plugins
		router.Get("/plugins", s.ListPlugins())
		router.Get("/plugin/{name}", s.GetPlugin())
		router.Post("/plugin/{name}", s.CreatePlugin())
		router.Delete("/plugin/{name}", s.DeletePlugin())
	}

	// always available public routes go here
	router.HandleFunc("/status", s.GetStatus)
	return http.ListenAndServe(s.Addr, router)
}

func (s *Service) requireAuth() bool {
	return false
}

func (s *Service) FetchJwks(uri string) {

}

func LoadProfileFromFile(path string) (*makeshift.Profile, error) {
	return loadFromJSONFile[makeshift.Profile](path)
}

// LoadPluginFromFile loads a single plugin given a single file path
func LoadPluginFromFile(path string) (makeshift.Plugin, error) {
	var (
		isDir        bool
		err          error
		loadedPlugin *plugin.Plugin
	)
	// skip loading plugin if path is a directory with no error
	isDir, err = util.IsDirectory(path)
	if err != nil {
		return nil, fmt.Errorf("failed to test if plugin path is directory: %v", err)
	} else if isDir {
		return nil, fmt.Errorf("path is a directory")
	}

	// try and open the plugin
	loadedPlugin, err = plugin.Open(path)
	if err != nil {
		return nil, fmt.Errorf("failed to open plugin at path '%s': %v", path, err)
	}

	// load the "Target" symbol from plugin
	symbol, err := loadedPlugin.Lookup("Makeshift")
	if err != nil {
		return nil, fmt.Errorf("failed to look up symbol at path '%s': %v", path, err)
	}

	// assert that the plugin is a valid makeshift.Plugin
	target, ok := symbol.(makeshift.Plugin)
	if !ok {
		return nil, fmt.Errorf("failed to assert the correct symbol type at path '%s'", path)
	}
	return target, nil
}

// LoadPluginsFromDir loads all plugins in a given directory.
//
// Returns a map of plugins. Each plugin can be accessed by the name
// returned by the plugin.GetName() implemented.
func LoadPluginsFromDir(dirpath string) (map[string]makeshift.Plugin, error) {
	// check if verbose option is supplied
	var (
		cps = make(map[string]makeshift.Plugin)
		err error
	)

	// helper to check for valid extensions
	var hasValidExt = func(path string) bool {
		var validExts = []string{".so", ".dylib", ".dll"}
		return slices.Contains(validExts, filepath.Ext(path))
	}

	// walk all files in directory only loading *valid* plugins
	err = filepath.Walk(dirpath, func(path string, info fs.FileInfo, err error) error {
		// skip trying to load generator plugin if directory or error
		if info.IsDir() || err != nil {
			return nil
		}

		// only try loading if file has .so extension
		if hasValidExt(path) {
			return nil
		}

		// load the plugin from current path
		p, err := LoadPluginFromFile(path)
		if err != nil {
			return fmt.Errorf("failed to load plugin in directory '%s': %v", path, err)
		}

		// map each plugin by name for lookup
		cps[p.Name()] = p
		return nil
	})

	if err != nil {
		return nil, fmt.Errorf("failed to walk directory '%s': %v", dirpath, err)
	}

	return cps, nil
}

func SaveProfileToFile(path string, profile *makeshift.Profile) error {
	return saveToJSONFile(path, profile)
}

func SavePluginToFile(path string, plugin *makeshift.Plugin) error {
	return saveToJSONFile(path, plugin)
}

func loadFromJSONFile[T any](path string) (*T, error) {
	var (
		res      *T
		contents []byte
		err      error
	)

	contents, err = os.ReadFile(path)
	if err != nil {
		return nil, fmt.Errorf("failed to read file: %v", err)
	}

	err = json.Unmarshal(contents, &res)
	if err != nil {
		return nil, fmt.Errorf("failed to unmarshal contents from JSON: %v", err)
	}

	return res, err
}

func saveToJSONFile[T any](path string, data T) error {
	var (
		contents []byte
		err      error
	)
	contents, err = json.Marshal(data)
	if err != nil {
		return fmt.Errorf("failed to marshal data to JSON: %v", err)
	}
	err = os.WriteFile(path, contents, os.ModePerm)
	if err != nil {
		return fmt.Errorf("failed to write JSON to file: %v", err)
	}

	return nil
}

func (s *Service) PathForProfileWithID(id string) string {
	return s.RootPath + RELPATH_PROFILES + "/" + id + ".json"
}

func (s *Service) PathForPluginWithName(name string) string {
	return s.RootPath + RELPATH_PLUGINS + "/" + name + ".so"
}

func (s *Service) PathForProfiles() string {
	return s.RootPath + RELPATH_PROFILES + "/"
}

func (s *Service) PathForPlugins() string {
	return s.RootPath + RELPATH_PLUGINS + "/"
}

func (s *Service) PathForData() string {
	return s.RootPath + RELPATH_DATA
}

func (s *Service) PathForMetadata() string {
	return s.RootPath + RELPATH_METADATA
}

func (s *Service) PathForHome() string {
	return s.RootPath + RELPATH_HELP
}

func (s *Service) writeErrorResponse(w http.ResponseWriter, message string, code int) {
	http.Error(w, message, code)
	log.Error().Msg(message)
}