Merge all the server components

internal/component/dis/dis.go

@@ -4,11 +4,16 @@ import (
 	"embed"
 
 	"github.com/FAU-CDI/wisski-distillery/internal/component"
+	"github.com/FAU-CDI/wisski-distillery/internal/component/instances"
 	"github.com/FAU-CDI/wisski-distillery/internal/core"
 )
 
 type Dis struct {
 	component.ComponentBase
+
+	Instances *instances.Instances
+
+	ResolverFile string
 }
 
 func (dis Dis) Name() string {
@@ -35,7 +40,9 @@ func (dis Dis) Stack() component.Installable {
 			"GLOBAL_AUTHORIZED_KEYS_FILE": dis.Config.GlobalAuthorizedKeysFile,
 			"SELF_OVERRIDES_FILE":         dis.Config.SelfOverridesFile,
 		},
-		CopyContextFiles: []string{dis.Config.CurrentExecutable()},
+
+		TouchFiles:       []string{dis.ResolverFile},
+		CopyContextFiles: []string{core.Executable},
 	})
 }
 

internal/component/dis/info.go

@@ -0,0 +1,26 @@
+package dis
+
+import (
+	"net/http"
+
+	"github.com/tkw1536/goprogram/stream"
+)
+
+func (dis Dis) info(io stream.IOStream) (http.Handler, error) {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		all, err := dis.Instances.All()
+		if err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte("internal server error"))
+			io.EPrintln(err)
+			return
+		}
+
+		for _, wk := range all {
+			w.WriteHeader(http.StatusOK)
+			w.Write([]byte(wk.Slug))
+			w.Write([]byte("\n"))
+		}
+
+	}), nil
+}

internal/component/dis/resolver.go

@@ -0,0 +1,61 @@
+package dis
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+
+	"github.com/FAU-CDI/wdresolve"
+	"github.com/FAU-CDI/wdresolve/resolvers"
+	"github.com/tkw1536/goprogram/stream"
+)
+
+func (dis Dis) ResolverConfigPath() string {
+	return filepath.Join(dis.Dir, dis.ResolverFile)
+}
+
+func (dis Dis) resolver(io stream.IOStream) (p wdresolve.ResolveHandler, err error) {
+	p.TrustXForwardedProto = true
+
+	fallback := &resolvers.Regexp{
+		Data: map[string]string{},
+	}
+
+	// handle the default domain name!
+	domainName := dis.Config.DefaultDomain
+	if domainName != "" {
+		fallback.Data[fmt.Sprintf("^https?://(.*)\\.%s", regexp.QuoteMeta(domainName))] = fmt.Sprintf("https://$1.%s", domainName)
+		io.Printf("registering default domain %s\n", domainName)
+	}
+
+	// handle the extra domains!
+	for _, domain := range dis.Config.SelfExtraDomains {
+		fallback.Data[fmt.Sprintf("^https?://(.*)\\.%s", regexp.QuoteMeta(domain))] = fmt.Sprintf("https://$1.%s", domainName)
+		io.Printf("registering legacy domain %s\n", domain)
+	}
+
+	// open the prefix file
+	prefixFile := dis.ResolverConfigPath()
+	fs, err := os.Open(prefixFile)
+	io.Println("loading prefixes from ", prefixFile)
+	if err != nil {
+		return p, err
+	}
+	defer fs.Close()
+
+	// read the prefixes
+	// TODO: Do we want to load these without a file?
+	prefixes, err := resolvers.ReadPrefixes(fs)
+	if err != nil {
+		return p, err
+	}
+
+	// and use that as the resolver!
+	p.Resolver = resolvers.InOrder{
+		prefixes,
+		fallback,
+	}
+
+	return p, nil
+}

internal/component/dis/self.go

@@ -0,0 +1,137 @@
+package dis
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/tkw1536/goprogram/stream"
+)
+
+// self returns the handler for the self overrides
+func (dis Dis) self(io stream.IOStream) (redirect Redirect, err error) {
+	// open the overrides file
+	overrides, err := os.Open(dis.Config.SelfOverridesFile)
+	io.Printf("loading overrides from %q\n", dis.Config.SelfOverridesFile)
+	if err != nil {
+		return redirect, err
+	}
+	defer overrides.Close()
+
+	// decode the overrides file
+	if err := json.NewDecoder(overrides).Decode(&redirect.Overrides); err != nil {
+		return redirect, err
+	}
+
+	if redirect.Overrides == nil {
+		redirect.Overrides = make(map[string]string)
+	}
+	redirect.Overrides["/"] = dis.Config.SelfRedirect.String()
+
+	// create a redirect server
+	redirect.Fallback, err = dis.selfFallback()
+	if err != nil {
+		return redirect, err
+	}
+	redirect.Absolute = false
+	redirect.Overrides = nil
+	redirect.Permanent = false
+
+	// and return!
+	return redirect, nil
+}
+
+func (dis *Dis) selfFallback() (http.Handler, error) {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		dis.serveFallback(w, r)
+	}), nil
+}
+
+var notFoundText = []byte("not found")
+
+func (dis *Dis) serveFallback(w http.ResponseWriter, r *http.Request) {
+
+	slug := dis.Config.SlugFromHost(r.Host)
+	if slug == "" {
+		w.WriteHeader(http.StatusNotFound)
+		w.Write(notFoundText)
+		return
+	}
+
+	if ok, _ := dis.Instances.Has(slug); !ok {
+		w.WriteHeader(http.StatusNotFound)
+		fmt.Fprintf(w, "WissKI %q not found\n", slug)
+		return
+	}
+
+	w.WriteHeader(http.StatusBadGateway)
+	fmt.Fprintf(w, "WissKI %q is currently offline\n", slug)
+
+}
+
+// Redirect implements a redirect server that redirects all requests.
+// It implements http.Handler.
+type Redirect struct {
+	// Target is the target URL to redirect to.
+	Target string
+
+	// Fallback is used when target is the empty string.
+	Fallback http.Handler
+
+	// Absolute determines if the request path should be appended to the target URL when redirecting.
+	// By default this path is always appended, set Absolute to true to prevent this.
+	Absolute bool
+
+	// Overrides is a map from paths to URLs that should override the default target.
+	Overrides map[string]string
+
+	// Permanent determines if the redirect responses issued should return
+	// Permanent Redirect (Status Code 308) or Temporary Redirect (Status Code 307).
+	Permanent bool
+}
+
+// Redirect determines the redirect URL for a specific incoming request
+// If it returns the empty string, the fallback is used.
+func (redirect Redirect) Redirect(r *http.Request) string {
+	// if we have an override for this URL, use it immediatly
+	url := strings.TrimSuffix(r.URL.Path, "/")
+	if override, ok := redirect.Overrides[url]; ok {
+		return override
+	}
+
+	if redirect.Target == "" {
+		return ""
+	}
+
+	// if we are in absolute redirect mode, always return the absolute URL
+	if redirect.Absolute {
+		return redirect.Target
+	}
+
+	// return the target + the redirected URL
+	dest := strings.TrimSuffix(redirect.Target, "/") + r.URL.Path
+	if len(r.URL.RawQuery) > 0 {
+		dest += "?" + r.URL.RawQuery
+	}
+	return dest
+}
+
+// ServeHTTP implements the http.Handler interface and redirects a single request to redirect.Target.
+func (redirect Redirect) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	dest := redirect.Redirect(r)
+	if dest == "" {
+		redirect.Fallback.ServeHTTP(w, r)
+		return
+	}
+
+	// determine if we are temporary or permanent redirect
+	status := http.StatusTemporaryRedirect
+	if redirect.Permanent {
+		status = http.StatusPermanentRedirect
+	}
+
+	// and do the redirect
+	http.Redirect(w, r, dest, status)
+}

internal/component/dis/server.go

@@ -0,0 +1,39 @@
+package dis
+
+import (
+	"net/http"
+
+	"github.com/tkw1536/goprogram/stream"
+)
+
+// Server returns an http.Mux that implements the main server instance
+func (dis Dis) Server(io stream.IOStream) (http.Handler, error) {
+	// self server
+	self, err := dis.self(io)
+	if err != nil {
+		return nil, err
+	}
+
+	resolver, err := dis.resolver(io)
+	if err != nil {
+		return nil, err
+	}
+
+	info, err := dis.info(io)
+	if err != nil {
+		return nil, err
+	}
+
+	// resolver
+
+	mux := http.NewServeMux()
+	mux.Handle("/", self)
+
+	mux.Handle("/go/", resolver)
+	mux.Handle("/wisski/navigate", resolver)
+
+	// TODO: Fix me!
+	mux.Handle("/dis/", info)
+
+	return mux, nil
+}

internal/component/dis/stack/Dockerfile

@@ -2,4 +2,4 @@ FROM docker.io/library/alpine
 
 COPY wdcli /wdcli
 EXPOSE 8888
-CMD ["/wdcli","--internal-in-docker","--config","${CONFIG_PATH}","dis_server","--bind","0.0.0.0:8888"]
+CMD ["/wdcli","--internal-in-docker","--config","${CONFIG_PATH}","server","--bind","0.0.0.0:8888"]

internal/component/dis/stack/docker-compose.yml

@@ -8,7 +8,6 @@ services:
       # port and hostname for this image to use
       VIRTUAL_HOST: ${VIRTUAL_HOST}
       VIRTUAL_PORT: 8888
-      VIRTUAL_PATH: /dis/
 
       CONFIG_PATH: ${CONFIG_PATH}
       

internal/component/installable.go

@@ -90,7 +90,7 @@ func (is Installable) Install(io stream.IOStream, context InstallationContext) e
 		// find the source!
 		src, ok := context[name]
 		if !ok {
-			return errors.Errorf("Missing file from context: %s", src)
+			return errors.Errorf("Missing file from context: %q", src)
 		}
 
 		// find the destination!

internal/component/instances/wisski_create.go

@@ -18,14 +18,16 @@ var errInvalidSlug = errors.New("not a valid slug")
 //
 // It does not perform any checks if the instance already exists, or does the creation in the database.
 func (instances *Instances) Create(slug string) (wisski WissKI, err error) {
+	wisski.instances = instances
 
 	// make sure that the slug is valid!
-	if _, err := stringparser.ParseSlug(slug); err != nil {
+	slug, err = stringparser.ParseSlug(slug)
+	if err != nil {
 		return wisski, errInvalidSlug
 	}
 
 	wisski.Instance.Slug = slug
-	wisski.Instance.FilesystemBase = filepath.Join(instances.Dir, slug)
+	wisski.Instance.FilesystemBase = filepath.Join(instances.Dir, wisski.Domain())
 
 	wisski.Instance.OwnerEmail = ""
 	wisski.Instance.AutoBlindUpdateEnabled = true
@@ -60,7 +62,6 @@ func (instances *Instances) Create(slug string) (wisski WissKI, err error) {
 	}
 
 	// store the instance in the object and return it!
-	wisski.instances = instances
 	return wisski, nil
 }
 

internal/component/resolver/resolver.env

@@ -1,10 +0,0 @@
-VIRTUAL_HOST=${VIRTUAL_HOST}
-
-LETSENCRYPT_HOST=${LETSENCRYPT_HOST}
-LETSENCRYPT_EMAIL=${LETSENCRYPT_EMAIL}
-
-CONFIG_PATH=${CONFIG_PATH}
-DEPLOY_ROOT=${DEPLOY_ROOT}
-GLOBAL_AUTHORIZED_KEYS_FILE=${GLOBAL_AUTHORIZED_KEYS_FILE}
-SELF_OVERRIDES_FILE=${SELF_OVERRIDES_FILE}
-RESOLVER_CONFIG=${RESOLVER_CONFIG}

internal/component/resolver/resolver.go

@@ -1,109 +0,0 @@
-package resolver
-
-import (
-	"embed"
-	"fmt"
-	"os"
-	"path/filepath"
-	"regexp"
-
-	"github.com/FAU-CDI/wdresolve"
-	"github.com/FAU-CDI/wdresolve/resolvers"
-	"github.com/FAU-CDI/wisski-distillery/internal/component"
-	"github.com/FAU-CDI/wisski-distillery/internal/core"
-	"github.com/tkw1536/goprogram/stream"
-)
-
-// TODO: Add a 'self-server' concept!
-
-type Resolver struct {
-	component.ComponentBase
-
-	ConfigName string // the name to the config file
-	Executable string // path to the current executable
-}
-
-func (Resolver) Name() string {
-	return "resolver"
-}
-
-func (resolver Resolver) ConfigPath() string {
-	return filepath.Join(resolver.Dir, resolver.ConfigName)
-}
-
-//go:embed all:stack resolver.env
-var resources embed.FS
-
-func (resolver Resolver) Stack() component.Installable {
-	return resolver.ComponentBase.MakeStack(component.Installable{
-		Resources:   resources,
-		ContextPath: "stack",
-		EnvPath:     "resolver.env",
-
-		EnvContext: map[string]string{
-			"VIRTUAL_HOST":      resolver.Config.DefaultHost(),
-			"LETSENCRYPT_HOST":  resolver.Config.DefaultSSLHost(),
-			"LETSENCRYPT_EMAIL": resolver.Config.CertbotEmail,
-
-			"CONFIG_PATH": resolver.Config.ConfigPath,
-			"DEPLOY_ROOT": resolver.Config.DeployRoot,
-
-			"GLOBAL_AUTHORIZED_KEYS_FILE": resolver.Config.GlobalAuthorizedKeysFile,
-			"SELF_OVERRIDES_FILE":         resolver.Config.SelfOverridesFile,
-			"RESOLVER_CONFIG":             resolver.ConfigPath(),
-		},
-		TouchFiles:       []string{resolver.ConfigName},
-		CopyContextFiles: []string{core.Executable},
-	})
-}
-
-func (resolver Resolver) Context(parent component.InstallationContext) component.InstallationContext {
-	return component.InstallationContext{
-		core.Executable: resolver.Executable,
-	}
-}
-
-func (resolver Resolver) Server(io stream.IOStream) (p wdresolve.ResolveHandler, err error) {
-	p.TrustXForwardedProto = true
-
-	fallback := &resolvers.Regexp{
-		Data: map[string]string{},
-	}
-
-	// handle the default domain name!
-	domainName := resolver.Config.DefaultDomain
-	if domainName != "" {
-		fallback.Data[fmt.Sprintf("^https?://(.*)\\.%s", regexp.QuoteMeta(domainName))] = fmt.Sprintf("https://$1.%s", domainName)
-		io.Printf("registering default domain %s\n", domainName)
-	}
-
-	// handle the extra domains!
-	for _, domain := range resolver.Config.SelfExtraDomains {
-		fallback.Data[fmt.Sprintf("^https?://(.*)\\.%s", regexp.QuoteMeta(domain))] = fmt.Sprintf("https://$1.%s", domainName)
-		io.Printf("registering legacy domain %s\n", domain)
-	}
-
-	// open the prefix file
-	prefixFile := resolver.ConfigPath()
-	fs, err := os.Open(prefixFile)
-	io.Println("loading prefixes from ", prefixFile)
-	if err != nil {
-		return p, err
-	}
-	defer fs.Close()
-
-	// read the prefixes
-	// TODO: Do we want to load these without a file?
-	prefixes, err := resolvers.ReadPrefixes(fs)
-	if err != nil {
-		return p, err
-	}
-
-	// and use that as the resolver!
-	p.Resolver = resolvers.InOrder{
-		prefixes,
-		fallback,
-	}
-
-	return p, nil
-}

internal/component/resolver/stack/Dockerfile

@@ -1,5 +0,0 @@
-FROM docker.io/library/alpine
-
-COPY wdcli /wdcli
-EXPOSE 8888
-CMD ["/wdcli","--internal-in-docker","--config","${CONFIG_PATH}","resolver_server","--bind","0.0.0.0:8888"]

internal/component/resolver/stack/docker-compose.yml

@@ -1,29 +0,0 @@
-version: "3.7"
-
-services:
-  wdresolve:
-    build: .
-    restart: always
-    environment:
-      # port and hostname for this image to use
-      VIRTUAL_HOST: ${VIRTUAL_HOST}
-      VIRTUAL_PORT: 8888
-      VIRTUAL_PATH: /go/
-
-      CONFIG_PATH: ${CONFIG_PATH}
-      
-      # optional letsencrypt email
-      LETSENCRYPT_HOST: ${LETSENCRYPT_HOST}
-      LETSENCRYPT_EMAIL: ${LETSENCRYPT_EMAIL}
-
-    volumes:
-      - "${CONFIG_PATH}:${CONFIG_PATH}:ro"
-      - "${DEPLOY_ROOT}:${DEPLOY_ROOT}:ro"
-      - "${GLOBAL_AUTHORIZED_KEYS_FILE}:${GLOBAL_AUTHORIZED_KEYS_FILE}:ro"
-      - "${SELF_OVERRIDES_FILE}:${SELF_OVERRIDES_FILE}:ro"
-      - "${RESOLVER_CONFIG}:${RESOLVER_CONFIG}:ro"
-
-networks:
-  default:
-    name: distillery
-    external: true

internal/component/self/self.env

@@ -1,7 +0,0 @@
-VIRTUAL_HOST=${VIRTUAL_HOST}
-
-LETSENCRYPT_HOST=${LETSENCRYPT_HOST}
-LETSENCRYPT_EMAIL=${LETSENCRYPT_EMAIL}
-
-TARGET=${TARGET}
-OVERRIDES_FILE=${OVERRIDES_FILE}

internal/component/self/self.go

@@ -1,42 +0,0 @@
-package self
-
-import (
-	"embed"
-
-	"github.com/FAU-CDI/wisski-distillery/internal/component"
-)
-
-type Self struct {
-	component.ComponentBase
-}
-
-func (Self) Name() string {
-	return "self"
-}
-
-//go:embed all:stack
-//go:embed self.env
-var resources embed.FS
-
-func (self Self) Stack() component.Installable {
-	// TODO: Move me into config!
-	TARGET := "https://github.com/FAU-CDI/wisski-distillery"
-	if self.Config.SelfRedirect != nil { // TODO: move to config!
-		TARGET = self.Config.SelfRedirect.String()
-	}
-
-	return self.ComponentBase.MakeStack(component.Installable{
-		Resources: resources,
-
-		ContextPath: "stack",
-		EnvPath:     "self.env",
-
-		EnvContext: map[string]string{
-			"VIRTUAL_HOST":      self.Config.DefaultHost(),
-			"LETSENCRYPT_HOST":  self.Config.DefaultSSLHost(),
-			"LETSENCRYPT_EMAIL": self.Config.CertbotEmail,
-			"TARGET":            TARGET,
-			"OVERRIDES_FILE":    self.Config.SelfOverridesFile,
-		},
-	})
-}

internal/component/self/stack/docker-compose.yml

@@ -1,28 +0,0 @@
-version: "3.7"
-
-services:
-  tr:
-    image: ghcr.io/tkw1536/tr:latest
-    restart: always
-    volumes:
-      - "${OVERRIDES_FILE}:/overrides.json:ro"
-    environment:
-      # port and hostname for this image to use
-      VIRTUAL_HOST: ${VIRTUAL_HOST}
-      VIRTUAL_PORT: 8080
-      VIRTUAL_PATH: /
-      
-      # optional letsencrypt email
-      LETSENCRYPT_HOST: ${LETSENCRYPT_HOST}
-      LETSENCRYPT_EMAIL: ${LETSENCRYPT_EMAIL}
-
-      # the overrides file
-      OVERRIDES: /overrides.json
-
-      # where to redirect to
-      TARGET: ${TARGET}
-
-networks:
-  default:
-    name: distillery
-    external: true