Merge pull request #58 from pldubouilh/pld/bump-ui

bump ui

.github/workflows/go.yml

@@ -19,4 +19,4 @@ jobs:
         submodules: true
 
     - name: Run
-      run: make ci
+      run: make test

.gitignore

@@ -4,6 +4,7 @@ gossa-linux-arm
 gossa-linux-arm64
 gossa-mac
 gossa-windows.exe
+gossa_test.go
 
 .vscode
 test-fixture/*

Makefile

@@ -3,42 +3,38 @@ build:
 	make -C gossa-ui/
 	go vet && go fmt
 	CGO_ENABLED=0 go build gossa.go
-	sleep 1 && rm gossa.go
+	rm gossa.go
+
+install:
+	sudo cp gossa /usr/local/bin
 
 run:
-	make build
 	./gossa -verb=true test-fixture
 
+run-ro:
+	./gossa -verb=true -ro=true test-fixture
+
 run-extra:
-	make build
 	./gossa -verb=true -prefix="/fancy-path/" -k=false -symlinks=true test-fixture
 
 test:
-	timeout 60 make run &
-	sleep 15 && cp src/gossa_test.go . && go test -run TestNormal
-	rm gossa_test.go
-	-killall gossa
-
-test-extra:
-	timeout 60 make run-extra &
-	sleep 15 && cp src/gossa_test.go . && go test -run TestExtra
-	rm gossa_test.go
-	-killall gossa
-
-ci:
+	make build
+	-rm gossa_test.go
 	-@cd test-fixture && ln -s ../support .
-	make test
-	make test-extra
-
+	cp src/gossa_test.go .
+	go test
 
 watch:
-	ls src/* gossa-ui/* | entr -rc make run
+	ls src/* gossa-ui/* | entr -rc make build run
 
 watch-extra:
-	ls src/* gossa-ui/* | entr -rc make run-extra
+	ls src/* gossa-ui/* | entr -rc make build run-extra
 
-watch-ci:
-	ls src/* gossa-ui/* | entr -rc make ci
+watch-ro:
+	ls src/* gossa-ui/* | entr -rc make build run-ro
+
+watch-test:
+	ls src/* gossa-ui/* | entr -rc make test
 
 build-all:
 	cp src/gossa.go gossa.go

readme.md

@@ -14,13 +14,14 @@ a [simple UI](https://github.com/pldubouilh/gossa-ui) comes as default, featurin
 
   * 🔍 files/directories browser
   * 📩 drag-and-drop file/directory uploader
+  * 🚀 lightweight, default ui weights 110kB and prints in ms
   * 🗺️ files handling - move/rename/delete
   * 📸 picture browser
   * 📽️ video streaming
   * ✍️ simple text editor
   * ⌨️ keyboard shortcuts
-  * 🥂 speed - will easily fill available bandwidth
-  * 🔒 safe - easy/secure multi account setup
+  * 🥂 fast golang static server, easily fills available bandwidth
+  * 🔒 easy/secure multi account setup
 
 ### build
 built blobs are available on the [release page](https://github.com/pldubouilh/gossa/releases) - or simply `make build` this repo.
@@ -40,7 +41,7 @@ release images are pushed to [dockerhub](https://hub.docker.com/r/pldubouilh/gos
 % sudo docker run -v ~/LocalDirToShare:/shared -p 8001:8001 pldubouilh/gossa
 ```
 
-in a do-one-thing-well mindset, HTTPS and authentication has been left to middlewares and proxies. for instance [caddy](https://caddyserver.com/) handles this very well - have a look at this small [caddy config](https://github.com/pldubouilh/gossa/blob/master/support/Caddyfile) with authentication and option for HTTPS that works along with gossa.
+in a do-one-thing-well mindset, HTTPS and authentication has been left to middlewares and proxies. [sample caddy configs](https://github.com/pldubouilh/gossa/blob/master/support/) are available to quickly setup multi users setups along with https.
 
 ### shortcuts
 the default UI is fully usable by through keyboard/UI shortcuts - press `Ctrl/Cmd + h` to see them all.

src/gossa.go

@@ -14,6 +14,7 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
+	"sort"
 	"strconv"
 	"strings"
 )
@@ -24,6 +25,7 @@ var extraPath = flag.String("prefix", "/", "url prefix at which gossa can be rea
 var symlinks = flag.Bool("symlinks", false, "follow symlinks \033[4mWARNING\033[0m: symlinks will by nature allow to escape the defined path (default: false)")
 var verb = flag.Bool("verb", false, "verbosity")
 var skipHidden = flag.Bool("k", true, "\nskip hidden files")
+var ro = flag.Bool("ro", false, "read only mode (no upload, rename, move, etc...)")
 var initPath = "."
 
 var fs http.Handler
@@ -39,6 +41,7 @@ type rowTemplate struct {
 type pageTemplate struct {
 	Title       template.HTML
 	ExtraPath   template.HTML
+	Ro          bool
 	RowsFiles   []rowTemplate
 	RowsFolders []rowTemplate
 }
@@ -79,6 +82,7 @@ func humanize(bytes int64) string {
 func replyList(w http.ResponseWriter, fullPath string, path string) {
 	_files, err := ioutil.ReadDir(fullPath)
 	check(err)
+	sort.Slice(_files, func(i, j int) bool { return strings.ToLower(_files[i].Name()) < strings.ToLower(_files[j].Name()) })
 
 	if !strings.HasSuffix(path, "/") {
 		path += "/"
@@ -90,6 +94,7 @@ func replyList(w http.ResponseWriter, fullPath string, path string) {
 		p.RowsFolders = append(p.RowsFolders, rowTemplate{"../", "../", "", "folder"})
 	}
 	p.ExtraPath = template.HTML(html.EscapeString(*extraPath))
+	p.Ro = *ro
 	p.Title = template.HTML(html.EscapeString(title))
 
 	for _, el := range _files {
@@ -188,8 +193,10 @@ func main() {
 	initPath, err = filepath.Abs(initPath)
 	check(err)
 
-	http.HandleFunc(*extraPath+"rpc", rpc)
-	http.HandleFunc(*extraPath+"post", upload)
+	if !*ro {
+		http.HandleFunc(*extraPath+"rpc", rpc)
+		http.HandleFunc(*extraPath+"post", upload)
+	}
 	http.HandleFunc("/", doContent)
 	fs = http.StripPrefix(*extraPath, http.FileServer(http.Dir(initPath)))
 	fmt.Printf("Gossa startig on directory %s\nListening on http://%s:%s%s\n", initPath, *host, *port, *extraPath)

src/gossa_test.go

@@ -5,9 +5,12 @@ import (
 	"fmt"
 	"io/ioutil"
 	"net/http"
+	"os"
+	"os/exec"
 	"regexp"
 	"strings"
 	"testing"
+	"time"
 )
 
 func dieMaybe(t *testing.T, err error) {
@@ -83,7 +86,7 @@ func fetchAndTestDefault(t *testing.T, url string) string {
 	return body0
 }
 
-func doTest(t *testing.T, url string, testExtra bool) {
+func doTestRegular(t *testing.T, url string, testExtra bool) {
 	var payload, path, body0, body1, body2 string
 
 	// ~~~~~~~~~~~~~~~~~
@@ -228,16 +231,99 @@ func doTest(t *testing.T, url string, testExtra bool) {
 	if body0 != `ok` {
 		t.Fatal("cleanup errored #2")
 	}
+
+	fmt.Printf("\r\n=========\r\n")
 }
 
-func TestNormal(t *testing.T) {
+func doTestReadonly(t *testing.T, url string) {
+	var payload, path, body0, body1 string
+
+	// ~~~~~~~~~~~~~~~~~
+	fmt.Println("\r\n~~~~~~~~~~ test fetching default path")
+	fetchAndTestDefault(t, url)
+
+	// ~~~~~~~~~~~~~~~~~
+	fmt.Println("\r\n~~~~~~~~~~ test fetching an invalid path - redirected to root")
+	fetchAndTestDefault(t, url+"../../")
+	fetchAndTestDefault(t, url+"hols/../../")
+
+	// ~~~~~~~~~~~~~~~~~
+	fmt.Println("\r\n~~~~~~~~~~ test fetching regular files")
+	body0 = get(t, url+"subdir_with%20space/file_with%20space.html")
+	body1 = get(t, url+"fancy-path/a")
+	if body0 != `<b>spacious!!</b> ` || body1 != `fancy! ` {
+		t.Fatal("fetching a regular file errored")
+	}
+
+	// ~~~~~~~~~~~~~~~~~
+	fmt.Println("\r\n~~~~~~~~~~ test fetching a invalid file")
+	path = "../../../../../../../../../../etc/passwd"
+	if get(t, url+path) != `error` {
+		t.Fatal("fetching a invalid file didnt errored")
+	}
+
+	// ~~~~~~~~~~~~~~~~~
+	fmt.Println("\r\n~~~~~~~~~~ test mkdir rpc")
+	body0 = postJSON(t, url+"rpc", `{"call":"mkdirp","args":["/AAA"]}`)
+	if body0 == `ok` {
+		t.Fatal("mkdir rpc passed - should not be allowed")
+	}
+
+	// ~~~~~~~~~~~~~~~~~
+	fmt.Println("\r\n~~~~~~~~~~ test post file")
+	path = "%2F%E1%84%92%E1%85%A1%20%E1%84%92%E1%85%A1" // "하 하" encoded
+	payload = "123 하"
+	body0 = postDummyFile(t, url, path, payload)
+	body1 = get(t, url+path)
+	if body0 == `ok` {
+		t.Fatal("post file passed - should not be allowed")
+	}
+
+	// ~~~~~~~~~~~~~~~~~
+	fmt.Println("\r\n~~~~~~~~~~ test mv rpc")
+	body0 = postJSON(t, url+"rpc", `{"call":"mv","args":["/AAA", "/hols/AAA"]}`)
+	body1 = fetchAndTestDefault(t, url)
+	if body0 == `ok` {
+		t.Fatal("mv rpc passed - should not be allowed")
+	}
+
+	// ~~~~~~~~~~~~~~~~~
+	fmt.Println("\r\n~~~~~~~~~~ test rm rpc & cleanup")
+	body0 = postJSON(t, url+"rpc", `{"call":"rm","args":["/hols/AAA"]}`)
+	if body0 == `ok` {
+		t.Fatal("cleanup passed - should not be allowed")
+	}
+
+	fmt.Printf("\r\n=========\r\n")
+}
+
+func startGossa(what string) int {
+	cmd := exec.Command("/usr/bin/make", what)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stdout
+	cmd.Start()
+	time.Sleep(3 * time.Second)
+	return cmd.Process.Pid
+}
+
+func killallgossa() {
+	cmd := exec.Command("/usr/bin/killall", "gossa")
+	cmd.Start()
+}
+
+func TestGossa(t *testing.T) {
+	startGossa("run")
 	fmt.Println("========== testing normal path ============")
-	doTest(t, "http://127.0.0.1:8001/", false)
-	fmt.Printf("\r\n=========\r\n")
-}
+	doTestRegular(t, "http://127.0.0.1:8001/", false)
+	killallgossa()
 
-func TestExtra(t *testing.T) {
-	fmt.Println("========== testing at fancy path ============")
-	doTest(t, "http://127.0.0.1:8001/fancy-path/", true)
-	fmt.Printf("\r\n=========\r\n")
+	startGossa("run-extra")
+	fmt.Println("========== testing extras options ============")
+	doTestRegular(t, "http://127.0.0.1:8001/fancy-path/", true)
+	killallgossa()
+
+	startGossa("run-ro")
+	fmt.Println("========== testing read only ============")
+	doTestReadonly(t, "http://127.0.0.1:8001/")
+	killallgossa()
 }

support/Caddyfile

@@ -1,8 +0,0 @@
-# Caddy config
-# to enable https just set a valid domain (e.g. mydomain.com) instead of :8080 - how simple !
-# authentication has been setup with 2 users, alice and bob
-
-:8080
-basicauth / alice paul
-basicauth / bob dylan
-proxy / 127.0.0.1:8001

support/build.Dockerfile

@@ -3,9 +3,9 @@ COPY . /gossaSrc
 RUN cd /gossaSrc && make
 
 FROM alpine
-ENV UID="1000" GID="1000" HOST="0.0.0.0" PORT="8001" PREFIX="/" FOLLOW_SYMLINKS="false" SKIP_HIDDEN_FILES="true" DATADIR="/shared"
+ENV UID="1000" GID="1000" HOST="0.0.0.0" PORT="8001" PREFIX="/" FOLLOW_SYMLINKS="false" SKIP_HIDDEN_FILES="true" DATADIR="/shared" READONLY="false"
 EXPOSE 8001
 RUN apk add --no-cache su-exec
 COPY --from=builder /gossaSrc/gossa /gossa
-RUN echo -e 'exec su-exec ${UID}:${GID} /gossa -h ${HOST} -p ${PORT} -k=${SKIP_HIDDEN_FILES} --symlinks=${FOLLOW_SYMLINKS} --prefix=${PREFIX} ${DATADIR}'>> /start.sh
+RUN echo -e 'exec su-exec ${UID}:${GID} /gossa -h ${HOST} -p ${PORT} -k=${SKIP_HIDDEN_FILES} -ro=${READONLY} --symlinks=${FOLLOW_SYMLINKS} --prefix=${PREFIX} ${DATADIR}'>> /start.sh
 ENTRYPOINT [ "sh", "/start.sh" ]

support/caddy.Dockerfile

@@ -1,8 +0,0 @@
-FROM pldubouilh/gossa
-
-RUN apk update && apk add curl ca-certificates caddy
-
-ENV UID="1000" GID="1000" HOST="127.0.0.1" PORT="8001" PREFIX="/" FOLLOW_SYMLINKS="false" SKIP_HIDDEN_FILES="true" DATADIR="/shared"
-EXPOSE 443
-RUN echo -e 'exec su-exec ${UID}:${GID} /gossa -h ${HOST} -p ${PORT} -k=${SKIP_HIDDEN_FILES} --symlinks=${FOLLOW_SYMLINKS} --prefix=${PREFIX} ${DATADIR} & \n caddy' > /start.sh
-ENTRYPOINT [ "sh", "/start.sh" ]

support/readme.md

@@ -1,27 +1,110 @@
+## docker
+
 the master branch is automatically built and pushed to [dockerhub](https://hub.docker.com/r/pldubouilh/gossa) under `pldubouilh/gossa`.
 
 ```sh
 # pull from dockerhub and run
+% mkdir ~/LocalDirToShare
 % sudo docker run -v ~/LocalDirToShare:/shared -p 8001:8001 pldubouilh/gossa
+
+# options are settable through env. variabes. all the options are the build.Dockerfile
+% sudo docker run -e PREFIX="/gossa/" -v ~/LocalDirToShare:/shared -p 8001:8001 pldubouilh/gossa
 ```
 
 if you prefer building the image yourself :
 
 ```sh
 # build gossa within a build container, needs to be ran within the sources, ../ from here, and run
+% mkdir ~/LocalDirToShare
 % docker build -t gossa -f support/build.Dockerfile .
 % sudo docker run -v ~/LocalDirToShare:/shared -p 8001:8001 gossa
 ```
 
-the options are settable through environment variables that can be passed starting off the docker image.
+a docker-compose example image is also provided. running docker compose should be straightforward : `docker-compose up .` have a look in `docker-compose.yml` for further configuration.
 
-a fancy docker image using [Caddy](https://caddyserver.com/) is also provided. have a look at the simple config file `Caddyfile`, it shows how to use http basic authentication, and automatic TLS for hands-free https 🎉
+## multi-account setup
+
+authentication / user routing has been left out of the design of gossa, as simple tools are already available for this purpose. [caddy](https://caddyserver.com/v1/) is used here as an example, but other proxy can be used in a similar fashion.
+
+### example 1 root, multiple read-only users
+
+this sample caddy config will
+ + enable https on the domain myserver.com
+ + password protect the access
+ + route the root user requests to 1 gossa instance
+ + route user1 and user2 requests to a readonly gossa instance
 
 ```sh
-# checkout the caddy config, build, and run docker image
-% vim caddy.Dockerfile
-% docker build -t gossa-caddy -f caddy.Dockerfile .
-% sudo docker run -v ~/LocalDirToShare:/shared -v `pwd`/Caddyfile:/Caddyfile --net=host gossa-caddy
+myserver.com
+
+# proxy regular and read only instance
+proxy /   127.0.0.1:8001
+proxy /ro 127.0.0.1:8002 { without /ro }
+
+# reroute non-root user to read-only
+# cm9... is the output of `printf "root:password" | base64`
+rewrite {
+  if {>Authorization} not "Basic cm9vdDpwYXNzd29yZA=="
+  to /ro/{path}
+}
+
+# gate access
+basicauth / root     password
+basicauth / ro_user1 passworduser1
+basicauth / ro_user2 passworduser2
 ```
 
-a docker-compose example image is also provided. running docker compose should be straightforward : `docker-compose up .` have a look in `docker-compose.yml` for further configuration.
+then simply start the 2 gossa instances, and caddy
+
+```sh
+# start an instance in readonly
+% ./gossa -ro=true -p 8002 ~/folder &
+
+# start an instance with access to hidden files
+% ./gossa -k=false  -p 8001 ~/folder &
+
+# start caddy
+% ./caddy
+```
+
+### example 2 users on 2 different folders
+
+this sample caddy config will
+ + enable https on the domain myserver.com
+ + password protect the access
+ + route user1 to own folder
+ + route user2 to own folder
+ + share a folder between 2 users with a symlink
+
+```sh
+myserver.com
+
+proxy /user1 127.0.0.1:8001 { without /user1 }
+proxy /user2 127.0.0.1:8002 { without /user2 }
+
+basicauth / user1 passworduser1
+basicauth / user2 passworduser2
+
+rewrite {
+  if {>Authorization} is "Basic dXNlcjE6cGFzc3dvcmR1c2VyMQ=="
+  to /user1/{path}
+}
+
+rewrite {
+  if {>Authorization} is "Basic dXNlcjI6cGFzc3dvcmR1c2VyMg=="
+  to /user2/{path}
+}
+```
+
+start 2 gossa instances, and caddy
+
+```sh
+# create symlink to share folder between 2 users
+% ln -s /path/shared test/user1
+% ln -s /path/shared test/user2
+
+# start gossa & caddy
+% ./gossa -p 8001 -symlinks=true test/user1 &
+% ./gossa -p 8002 -symlinks=true test/user2 &
+% ./caddy
+```