Updates to server

Author: djthorpe

pkg/httprequest/indent.go

@@ -0,0 +1,17 @@
+package httprequest
+
+import "net/http"
+
+////////////////////////////////////////////////////////////////////////////////
+// GLOBALS
+
+const (
+	defaultIndent = 2
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+func Indent(r *http.Request) int {
+	return defaultIndent
+}

pkg/httprouter/httprouter.go

@@ -65,14 +65,16 @@ func (r *router) HandleFunc(ctx context.Context, prefix string, fn http.HandlerF
 	}
 
 	// Apply middleware, set context
+	provider.Log(ctx).Print(ctx, "Register route: ", types.JoinPath(r.prefix, prefix))
 	r.ServeMux.HandleFunc(types.JoinPath(r.prefix, prefix), func(w http.ResponseWriter, r *http.Request) {
-		fn(w, r.WithContext(
+		fn(w, r)
+		/* TODO fn(w, r.WithContext(
 			provider.WithLog(
 				provider.WithName(
 					r.Context(), provider.Name(ctx),
 				), provider.Log(ctx),
 			),
-		))
+		))*/
 	})
 }
 

pkg/provider/context.go

@@ -0,0 +1,58 @@
+package provider
+
+import (
+	"context"
+
+	// Packages
+	server "github.com/mutablelogic/go-server"
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type ctx int
+
+const (
+	ctxProvider ctx = iota
+	ctxPath
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+func Provider(ctx context.Context) server.Provider {
+	if value := ctx.Value(ctxProvider); value == nil {
+		return nil
+	} else {
+		return value.(server.Provider)
+	}
+}
+
+func Path(ctx context.Context) []string {
+	if value, ok := ctx.Value(ctxPath).([]string); !ok {
+		return nil
+	} else {
+		return value
+	}
+}
+
+func Log(ctx context.Context) server.Logger {
+	if value := ctx.Value(ctxProvider); value == nil {
+		return nil
+	} else {
+		return value.(server.Logger)
+	}
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
+// Set the provider in the context
+func withProvider(parent context.Context, provider server.Provider) context.Context {
+	return context.WithValue(parent, ctxProvider, provider)
+}
+
+// Append a path to the context
+func withPath(parent context.Context, path ...string) context.Context {
+	return context.WithValue(parent, ctxPath, append(Path(parent), path...))
+}

pkg/provider/logger.go

@@ -0,0 +1,14 @@
+package provider
+
+import (
+	"context"
+	"log"
+)
+
+/////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+// Emit an informational message
+func (provider *provider) Print(ctx context.Context, a ...any) {
+	log.Print(a...)
+}

pkg/provider/provider.go

@@ -0,0 +1,159 @@
+package provider
+
+import (
+	"context"
+	"encoding/json"
+	"sync"
+
+	// Packages
+	server "github.com/mutablelogic/go-server"
+	httpresponse "github.com/mutablelogic/go-server/pkg/httpresponse"
+	types "github.com/mutablelogic/go-server/pkg/types"
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+type provider struct {
+	// Map labels to plugins
+	plugin map[string]server.Plugin
+
+	// Map labels to tasks
+	task map[string]*state
+
+	// Order that the tasks were created
+	order []string
+
+	// Function to resolve plugin members
+	resolver ResolverFunc
+}
+
+type state struct {
+	server.Task
+	context.Context
+	context.CancelFunc
+	sync.WaitGroup
+}
+
+// ResolverFunc is a function that resolves a plugin from label and plugin
+type ResolverFunc func(context.Context, string, server.Plugin) (server.Plugin, error)
+
+////////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+func New(resolver ResolverFunc, plugins ...server.Plugin) (*provider, error) {
+	self := new(provider)
+	self.plugin = make(map[string]server.Plugin, len(plugins))
+	self.task = make(map[string]*state, len(plugins))
+	self.order = make([]string, 0, len(plugins))
+	self.resolver = resolver
+
+	// Add the plugins
+	for _, plugin := range plugins {
+		// Check plugin
+		if plugin == nil {
+			return nil, httpresponse.ErrInternalError.With("Plugin is nil")
+		} else if !types.IsIdentifier(plugin.Name()) {
+			return nil, httpresponse.ErrInternalError.Withf("Plugin name %q is not valid", plugin.Name())
+		}
+
+		// TODO: Don't use names, use labels!
+		label := plugin.Name()
+		if _, exists := self.plugin[label]; exists {
+			return nil, httpresponse.ErrInternalError.Withf("Plugin %q already exists", plugin.Name())
+		} else {
+			self.plugin[label] = plugin
+		}
+	}
+
+	// Return success
+	return self, nil
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// STRINGIFY
+
+func (provider *provider) String() string {
+	type jtask struct {
+		Name        string        `json:"name"`
+		Description string        `json:"description,omitempty"`
+		Label       string        `json:"label,omitempty"`
+		Plugin      server.Plugin `json:"plugin,omitempty"`
+		Task        server.Task   `json:"task,omitempty"`
+	}
+	result := make([]jtask, 0, len(provider.task))
+	for _, label := range provider.order {
+		plugin := provider.plugin[label]
+		result = append(result, jtask{
+			Name:        plugin.Name(),
+			Description: plugin.Description(),
+			Label:       label,
+			Plugin:      plugin,
+			Task:        provider.task[label].Task,
+		})
+	}
+	data, err := json.MarshalIndent(result, "", "  ")
+	if err != nil {
+		return err.Error()
+	}
+	return string(data)
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+// Return a task from a label
+func (provider *provider) Task(ctx context.Context, label string) server.Task {
+	provider.Print(ctx, "Called Task for ", label)
+
+	// If the task is already created, then return it
+	if task, exists := provider.task[label]; exists {
+		return task.Task
+	}
+
+	// If the plugin doesn't exist, return nil
+	plugin, exists := provider.plugin[label]
+	if !exists {
+		return nil
+	}
+
+	// Resolve the plugin
+	if provider.resolver != nil {
+		var err error
+		plugin, err = provider.resolver(withProvider(ctx, provider), label, plugin)
+		if err != nil {
+			provider.Print(ctx, "Error: ", label, ": ", err)
+			return nil
+		}
+	}
+
+	// Create the task
+	task, err := plugin.New(withPath(ctx, label))
+	if err != nil {
+		provider.Print(ctx, "Error: ", label, ": ", err)
+		return nil
+	} else if task == nil {
+		provider.Print(ctx, "Error: ", label, ": ", httpresponse.ErrInternalError.With("Task is nil"))
+		return nil
+	}
+
+	// Set the task and order
+	provider.task[label] = &state{Task: task}
+	provider.order = append(provider.order, label)
+
+	// Return the task
+	return task
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
+// Make all tasks
+func (provider *provider) constructor(ctx context.Context) error {
+	for label := range provider.plugin {
+		if task := provider.Task(ctx, label); task == nil {
+			return httpresponse.ErrConflict.Withf("Failed to create task %q", label)
+		}
+	}
+	return nil
+}

pkg/provider/provider_test.go

@@ -0,0 +1,28 @@
+package provider_test
+
+import (
+	"testing"
+
+	// Packages
+	provider "github.com/mutablelogic/go-server/pkg/provider"
+	httpserver "github.com/mutablelogic/go-server/plugin/httpserver"
+	assert "github.com/stretchr/testify/assert"
+)
+
+func Test_Provider_001(t *testing.T) {
+	assert := assert.New(t)
+
+	t.Run("1", func(t *testing.T) {
+		provider, err := provider.New()
+		if assert.NoError(err) {
+			assert.NotNil(provider)
+		}
+	})
+
+	t.Run("2", func(t *testing.T) {
+		provider, err := provider.New(httpserver.Config{})
+		if assert.NoError(err) {
+			assert.NotNil(provider)
+		}
+	})
+}

pkg/provider/run.go

@@ -0,0 +1,80 @@
+package provider
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sort"
+
+	httpresponse "github.com/mutablelogic/go-server/pkg/httpresponse"
+	// Packages
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// GLOBALS
+
+const (
+	providerLabel = "root"
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+// Run a task until context is cancelled and return any errors
+func (provider *provider) Run(parent context.Context) error {
+	var result error
+
+	// Append the provider to the context
+	parent = withProvider(parent, provider)
+
+	// Create a child context which will allow us to cancel all the tasks
+	// prematurely if any of them fail
+	ctx, prematureCancel := context.WithCancel(parent)
+	defer prematureCancel()
+
+	// Put the provider at the top of the path
+	ctx = withPath(ctx, providerLabel)
+
+	// Create all the tasks
+	if err := provider.constructor(parent); err != nil {
+		return err
+	}
+
+	// Run the tasks in parallel
+	for _, label := range provider.order {
+		task, exists := provider.task[label]
+		if !exists {
+			return httpresponse.ErrNotFound.Withf("Task %q not found", label)
+		}
+
+		// Create a context for each task
+		ctx, cancel := context.WithCancel(context.Background())
+		task.Context = withProvider(ctx, provider)
+		task.CancelFunc = cancel
+		task.WaitGroup.Add(1)
+		go func(task *state) {
+			defer task.WaitGroup.Done()
+			defer task.CancelFunc()
+			provider.Print(ctx, "Starting task ", label)
+			if err := task.Run(task.Context); err != nil {
+				result = errors.Join(result, fmt.Errorf("%q: %w", label, err))
+				prematureCancel()
+			}
+		}(task)
+	}
+
+	// Wait for the context to be cancelled
+	<-ctx.Done()
+
+	// Cancel all the tasks in reverse order, waiting for each to complete before cancelling the next
+	// TODO: Make sure we are cancelling in the right order
+	sort.Sort(sort.Reverse(sort.StringSlice(provider.order)))
+	for _, label := range provider.order {
+		provider.Print(ctx, "Stopping task ", label)
+		provider.task[label].CancelFunc()
+		provider.task[label].WaitGroup.Wait()
+	}
+
+	// Return any errors
+	return result
+}