init

10 files changed, 606 insertions, 0 deletions

diff --git a/auth.sh b/auth.sh
new file mode 100755
index 0000000..aa3dc1f
--- /dev/null
+++ b/auth.sh
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+podman run -it --rm --network host \
+    -e SECRET="12345678912345678911111111111111" \
+    -e APP_URL="http://10.0.0.92:3000" \
+    -e USERS='diogo464:$2a$10$fE78J/Rq7kSik1cmXQ82Be6.zx3P4GEjhlifnI.ACHpHb5sDH/J1W' \
+    ghcr.io/steveiliop56/tinyauth:v3
+
diff --git a/deployment.yaml b/deployment.yaml
new file mode 100644
index 0000000..3bcd9cc
--- /dev/null
+++ b/deployment.yaml
@@ -0,0 +1,28 @@
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: auth
+spec:
+  selector:
+    matchLabels:
+      app: auth
+  template:
+    metadata:
+      labels:
+        app: auth
+        app.kubernetes.io/name: auth
+    spec:
+      containers:
+        - name: auth
+          image: ghcr.io/steveiliop56/tinyauth:v3
+          resources:
+            requests:
+              memory: "64Mi"
+              cpu: "0"
+            limits:
+              memory: "256Mi"
+              cpu: "1"
+          ports:
+            - name: http
+              containerPort: 8000
diff --git a/filesystem.go b/filesystem.go
new file mode 100644
index 0000000..236f704
--- /dev/null
+++ b/filesystem.go
@@ -0,0 +1,244 @@
+package main
+
+import "fmt"
+
+type Filesystem_Ent_Type string
+
+const (
+        Filesystem_Ent_Type_Dir  Filesystem_Ent_Type = "dir"
+        Filesystem_Ent_Type_File Filesystem_Ent_Type = "file"
+)
+
+type Filesystem struct {
+        Root *Filesystem_Ent
+}
+
+func NewFilesystem() *Filesystem {
+        return &Filesystem{
+                Root: &Filesystem_Ent{
+                        Type:     Filesystem_Ent_Type_Dir,
+                        Children: make(map[PathComponent]*Filesystem_Ent),
+                },
+        }
+}
+
+type Filesystem_Ent struct {
+        Type     Filesystem_Ent_Type
+        Children map[PathComponent]*Filesystem_Ent
+        Blob     string
+}
+
+func (fs *Filesystem) GetEntry(path Path) *Filesystem_Ent {
+        current := fs.Root
+        for _, component := range path.Components() {
+                if current == nil || current.Type != Filesystem_Ent_Type_Dir {
+                        return nil
+                }
+                current = current.Children[component]
+        }
+        return current
+}
+
+func (fs *Filesystem) EnsureParentDirs(path Path) error {
+        if path.IsRoot() {
+                return nil
+        }
+
+        parentPath := path.Parent()
+        current := fs.Root
+
+        for _, component := range parentPath.Components() {
+                if current.Children == nil {
+                        current.Children = make(map[PathComponent]*Filesystem_Ent)
+                }
+
+                if next, exists := current.Children[component]; exists {
+                        if next.Type != Filesystem_Ent_Type_Dir {
+                                return fmt.Errorf("path component '%s' is a file, cannot create directory", component)
+                        }
+                        current = next
+                } else {
+                        newDir := &Filesystem_Ent{
+                                Type:     Filesystem_Ent_Type_Dir,
+                                Children: make(map[PathComponent]*Filesystem_Ent),
+                        }
+                        current.Children[component] = newDir
+                        current = newDir
+                }
+        }
+
+        return nil
+}
+
+func (fs *Filesystem) ApplyOperation(op *Operation) error {
+        switch op.Type {
+        case Operation_Type_CreateFile:
+                return fs.ApplyOperation_CreateFile(op)
+        case Operation_Type_CreateDir:
+                return fs.ApplyOperation_CreateDir(op)
+        case Operation_Type_Remove:
+                return fs.ApplyOperation_Remove(op)
+        case Operation_Type_Rename:
+                return fs.ApplyOperation_Rename(op)
+        default:
+                return fmt.Errorf("unhandled operation type: %s", op.Type)
+        }
+}
+
+func (fs *Filesystem) ApplyOperation_CreateFile(op *Operation) error {
+        params := op.GetCreateFileParams()
+
+        path, err := ParsePath(params.Path)
+        if err != nil {
+                return fmt.Errorf("invalid path '%s': %w", params.Path, err)
+        }
+
+        if path.IsRoot() {
+                return fmt.Errorf("cannot create file at root path")
+        }
+
+        if err := fs.EnsureParentDirs(path); err != nil {
+                return fmt.Errorf("failed to create parent directories: %w", err)
+        }
+
+        parentPath := path.Parent()
+        parent := fs.GetEntry(parentPath)
+        if parent == nil || parent.Type != Filesystem_Ent_Type_Dir {
+                return fmt.Errorf("parent is not a directory")
+        }
+
+        if parent.Children == nil {
+                parent.Children = make(map[PathComponent]*Filesystem_Ent)
+        }
+
+        filename := path.Components()[len(path.Components())-1]
+        parent.Children[filename] = &Filesystem_Ent{
+                Type: Filesystem_Ent_Type_File,
+                Blob: params.Blob,
+        }
+
+        return nil
+}
+
+func (fs *Filesystem) ApplyOperation_CreateDir(op *Operation) error {
+        params := op.GetCreateDirParams()
+
+        path, err := ParsePath(params.Path)
+        if err != nil {
+                return fmt.Errorf("invalid path '%s': %w", params.Path, err)
+        }
+
+        if path.IsRoot() {
+                return nil
+        }
+
+        existing := fs.GetEntry(path)
+        if existing != nil {
+                if existing.Type == Filesystem_Ent_Type_Dir {
+                        return nil
+                }
+                return fmt.Errorf("cannot create directory '%s': file already exists", params.Path)
+        }
+
+        if err := fs.EnsureParentDirs(path); err != nil {
+                return fmt.Errorf("failed to create parent directories: %w", err)
+        }
+
+        parentPath := path.Parent()
+        parent := fs.GetEntry(parentPath)
+        if parent == nil || parent.Type != Filesystem_Ent_Type_Dir {
+                return fmt.Errorf("parent is not a directory")
+        }
+
+        if parent.Children == nil {
+                parent.Children = make(map[PathComponent]*Filesystem_Ent)
+        }
+
+        dirname := path.Components()[len(path.Components())-1]
+        parent.Children[dirname] = &Filesystem_Ent{
+                Type:     Filesystem_Ent_Type_Dir,
+                Children: make(map[PathComponent]*Filesystem_Ent),
+        }
+
+        return nil
+}
+
+func (fs *Filesystem) ApplyOperation_Remove(op *Operation) error {
+        params := op.GetRemoveParams()
+
+        path, err := ParsePath(params.Path)
+        if err != nil {
+                return fmt.Errorf("invalid path '%s': %w", params.Path, err)
+        }
+
+        if path.IsRoot() {
+                return fmt.Errorf("cannot remove root directory")
+        }
+
+        existing := fs.GetEntry(path)
+        if existing == nil {
+                return nil
+        }
+
+        parentPath := path.Parent()
+        parent := fs.GetEntry(parentPath)
+        if parent == nil || parent.Type != Filesystem_Ent_Type_Dir {
+                return fmt.Errorf("parent is not a directory")
+        }
+
+        filename := path.Components()[len(path.Components())-1]
+        delete(parent.Children, filename)
+
+        return nil
+}
+
+func (fs *Filesystem) ApplyOperation_Rename(op *Operation) error {
+        params := op.GetRenameParams()
+
+        oldPath, err := ParsePath(params.Old)
+        if err != nil {
+                return fmt.Errorf("invalid old path '%s': %w", params.Old, err)
+        }
+
+        newPath, err := ParsePath(params.New)
+        if err != nil {
+                return fmt.Errorf("invalid new path '%s': %w", params.New, err)
+        }
+
+        if oldPath.IsRoot() || newPath.IsRoot() {
+                return fmt.Errorf("cannot rename root directory")
+        }
+
+        existing := fs.GetEntry(oldPath)
+        if existing == nil {
+                return nil
+        }
+
+        if err := fs.EnsureParentDirs(newPath); err != nil {
+                return fmt.Errorf("failed to create parent directories for new path: %w", err)
+        }
+
+        oldParentPath := oldPath.Parent()
+        oldParent := fs.GetEntry(oldParentPath)
+        if oldParent == nil || oldParent.Type != Filesystem_Ent_Type_Dir {
+                return fmt.Errorf("old parent is not a directory")
+        }
+
+        newParentPath := newPath.Parent()
+        newParent := fs.GetEntry(newParentPath)
+        if newParent == nil || newParent.Type != Filesystem_Ent_Type_Dir {
+                return fmt.Errorf("new parent is not a directory")
+        }
+
+        if newParent.Children == nil {
+                newParent.Children = make(map[PathComponent]*Filesystem_Ent)
+        }
+
+        oldFilename := oldPath.Components()[len(oldPath.Components())-1]
+        newFilename := newPath.Components()[len(newPath.Components())-1]
+
+        newParent.Children[newFilename] = existing
+        delete(oldParent.Children, oldFilename)
+
+        return nil
+}
diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..54ccc54
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,8 @@
+module git.d464.sh/fctdrive
+
+go 1.24.5
+
+require (
+        github.com/go-chi/chi/v5 v5.2.2
+        github.com/pkg/errors v0.9.1
+)
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..4085610
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,4 @@
+github.com/go-chi/chi/v5 v5.2.2 h1:CMwsvRVTbXVytCk1Wd72Zy1LAsAh9GxMmSNWLHCG618=
+github.com/go-chi/chi/v5 v5.2.2/go.mod h1:L2yAIGWB3H+phAw1NxKwWM+7eUH/lU8pOMm5hHcoops=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..169ebc0
--- /dev/null
+++ b/index.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>FCT Drive</title>
+</head>
+
+<body>
+    <form enctype="multipart/form-data" method="post" action="/upload">
+        <input type="file" name="file">
+        <input type="submit" name="submit" value="Upload">
+    </form>
+</body>
+
+</html>
diff --git a/main.go b/main.go
new file mode 100644
index 0000000..1be1067
--- /dev/null
+++ b/main.go
@@ -0,0 +1,75 @@
+package main
+
+import (
+        "encoding/json"
+        "net/http"
+        "os"
+
+        "github.com/go-chi/chi/v5"
+)
+
+type App struct {
+        Operations []*Operation
+        Filesystem *Filesystem
+}
+
+func main() {
+        router := chi.NewRouter()
+
+        app := &App{
+                Operations: []*Operation{},
+                Filesystem: NewFilesystem(),
+        }
+
+        router.Get("/", func(w http.ResponseWriter, r *http.Request) {
+                w.Header().Add("Content-Type", "text/html")
+                file, _ := os.ReadFile("index.html")
+                w.Write(file)
+        })
+        router.Route("/api", func(r chi.Router) {
+                r.Get("/view", view)
+                r.Get("/filesystem/*", h(app, filesystemGet))
+                r.Post("/filesystem/*", h(app, filesystemPost))
+                r.Delete("/filesystem/*", h(app, filesystemDelete))
+        })
+
+        if err := http.ListenAndServe("0.0.0.0:5000", router); err != nil {
+                panic(err)
+        }
+}
+
+func h(app *App, f func(*App, http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
+        return func(w http.ResponseWriter, r *http.Request) {
+                f(app, w, r)
+        }
+}
+
+func view(w http.ResponseWriter, r *http.Request) {
+        w.Write([]byte("Hi"))
+}
+
+func filesystemGet(app *App, w http.ResponseWriter, r *http.Request) {
+        path, err := ParsePath("/" + chi.URLParam(r, "*"))
+        if err != nil {
+                panic(err)
+        }
+
+        // response := map[string]interface{}{
+        //      "path":    path,
+        //      "message": "Filesystem path requested",
+        // }
+
+        entry := app.Filesystem.GetEntry(path)
+
+        w.Header().Set("Content-Type", "application/json")
+        json.NewEncoder(w).Encode(entry)
+}
+
+func filesystemPost(app *App, w http.ResponseWriter, r *http.Request) {
+        if err := r.ParseMultipartForm(1024 * 1024); err != nil {
+                panic(err)
+        }
+
+}
+
+func filesystemDelete(app *App, w http.ResponseWriter, r *http.Request) {}
diff --git a/operation.go b/operation.go
new file mode 100644
index 0000000..80f7c04
--- /dev/null
+++ b/operation.go
@@ -0,0 +1,147 @@
+package main
+
+import (
+        "fmt"
+        "strconv"
+        "strings"
+
+        "github.com/pkg/errors"
+)
+
+const (
+        Operation_Type_CreateFile string = "create_file"
+        Operation_Type_CreateDir  string = "create_dir"
+        Operation_Type_Remove     string = "remove"
+        Operation_Type_Rename     string = "rename"
+)
+
+type Operation struct {
+        Timestamp uint64
+        Revision  uint64
+        Email     string
+        Type      string
+        Params    []string
+}
+
+type CreateFileParams struct {
+        Path string
+        Blob string
+}
+
+type CreateDirParams struct {
+        Path string
+}
+
+type RemoveParams struct {
+        Path string
+}
+
+type RenameParams struct {
+        Old string
+        New string
+}
+
+func (op *Operation) GetCreateFileParams() CreateFileParams {
+        op.assertType(Operation_Type_CreateFile)
+        op.assertParamsLen(2)
+        return CreateFileParams{
+                Path: op.Params[0],
+                Blob: op.Params[1],
+        }
+}
+
+func (op *Operation) GetCreateDirParams() CreateDirParams {
+        op.assertType(Operation_Type_CreateDir)
+        op.assertParamsLen(1)
+        return CreateDirParams{
+                Path: op.Params[0],
+        }
+}
+
+func (op *Operation) GetRemoveParams() RemoveParams {
+        op.assertType(Operation_Type_Remove)
+        op.assertParamsLen(1)
+        return RemoveParams{
+                Path: op.Params[0],
+        }
+}
+
+func (op *Operation) GetRenameParams() RenameParams {
+        op.assertType(Operation_Type_Rename)
+        op.assertParamsLen(2)
+        return RenameParams{
+                Old: op.Params[0],
+                New: op.Params[1],
+        }
+}
+
+func (op *Operation) assertType(t string) {
+        if op.Type != t {
+                panic(fmt.Sprintf("unexpected operation type, got %s but expected %s", op.Type, t))
+        }
+}
+
+func (op *Operation) assertParamsLen(n int) {
+        if len(op.Params) != n {
+                panic(fmt.Sprintf("unexpected operation parameter length, got %d but expected %d", len(op.Params), n))
+        }
+}
+
+func ParseOperation(line string) (*Operation, error) {
+        op := &Operation{}
+        baseErr := fmt.Errorf("invalid operation line: '%s'", line)
+        components := strings.Split(line, " ")
+        if len(components) < 4 {
+                return nil, errors.Wrapf(baseErr, "invalid number of components %d", len(components))
+        }
+
+        if timestamp, err := strconv.ParseUint(components[0], 10, 64); err != nil {
+                return nil, errors.Wrapf(baseErr, "invalid timestamp %v: %v", components[0], err)
+        } else {
+                op.Timestamp = timestamp
+        }
+
+        if revision, err := strconv.ParseUint(components[0], 10, 64); err != nil {
+                return nil, errors.Wrapf(baseErr, "invalid revision %v: %v", components[0], err)
+        } else {
+                op.Revision = revision
+        }
+
+        op.Email = components[2]
+        op.Type = components[3]
+        op.Params = components[4:]
+
+        switch op.Type {
+        case Operation_Type_CreateFile:
+                if len(op.Params) != 2 {
+                        return nil, errors.Wrapf(baseErr, "invalid number of parameters for operation create file")
+                }
+        case Operation_Type_CreateDir:
+                if len(op.Params) != 1 {
+                        return nil, errors.Wrapf(baseErr, "invalid number of parameters for operation create dir")
+                }
+
+        case Operation_Type_Remove:
+                if len(op.Params) != 1 {
+                        return nil, errors.Wrapf(baseErr, "invalid number of parameters for operation remove")
+                }
+
+        case Operation_Type_Rename:
+                if len(op.Params) != 2 {
+                        return nil, errors.Wrapf(baseErr, "invalid number of parameters for operation rename")
+                }
+        default:
+                return nil, errors.Wrapf(baseErr, "invalid operation type '%v'", op.Type)
+        }
+
+        return op, nil
+}
+
+func (op *Operation) String() string {
+        params := strings.Join(op.Params, " ")
+        base := fmt.Sprintf("%d %d %s %s", op.Timestamp, op.Revision, op.Email, op.Type)
+        if len(params) > 0 {
+                base = base + " " + params
+        }
+        return base
+}
diff --git a/path.go b/path.go
new file mode 100644
index 0000000..bb81229
--- /dev/null
+++ b/path.go
@@ -0,0 +1,75 @@
+package main
+
+import (
+        "fmt"
+        "strings"
+)
+
+type PathComponent string
+
+type Path []PathComponent
+
+func NewPathComponent(s string) (PathComponent, error) {
+        if s != strings.TrimSpace(s) {
+                return PathComponent(""), fmt.Errorf("path component cannot contain leading or trailing spaces")
+        }
+        if strings.Contains(s, "/") {
+                return PathComponent(""), fmt.Errorf("path component cannot contain '/'")
+        }
+        if len(s) == 0 {
+                return PathComponent(""), fmt.Errorf("path component cannot be empty")
+        }
+        return PathComponent(s), nil
+}
+
+func (c PathComponent) String() string {
+        return string(c)
+}
+
+func (p Path) Components() []PathComponent {
+        return []PathComponent(p)
+}
+
+func (p Path) Parent() Path {
+        components := []PathComponent(p)
+        if len(components) == 0 {
+                return Path(components)
+        } else {
+                return Path(components[:len(components)-1])
+        }
+}
+
+func (p Path) IsRoot() bool {
+        return len(p.Components()) == 0
+}
+
+func ParsePath(pathStr string) (Path, error) {
+        if pathStr == "" || pathStr == "/" {
+                return Path{}, nil
+        }
+
+        if !strings.HasPrefix(pathStr, "/") {
+                return nil, fmt.Errorf("path must be absolute, got: %s", pathStr)
+        }
+
+        pathStr = strings.TrimPrefix(pathStr, "/")
+        if len(pathStr) == 0 {
+                return Path{}, nil
+        }
+
+        parts := strings.Split(pathStr, "/")
+        components := make([]PathComponent, 0, len(parts))
+
+        for _, part := range parts {
+                if len(part) == 0 {
+                        return nil, fmt.Errorf("empty path component in: %s", pathStr)
+                }
+                component, err := NewPathComponent(part)
+                if err != nil {
+                        return nil, fmt.Errorf("invalid path component '%s': %w", part, err)
+                }
+                components = append(components, component)
+        }
+
+        return Path(components), nil
+}
diff --git a/service.yaml b/service.yaml
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/service.yaml