feat: initial commit

internal/agent/controller/gateway/controller.go

@@ -0,0 +1,124 @@
+package gateway
+
+import (
+	"context"
+
+	"forge.cadoles.com/Cadoles/emissary/internal/agent"
+	"forge.cadoles.com/Cadoles/emissary/internal/spec"
+	"github.com/pkg/errors"
+	"gitlab.com/wpetit/goweb/logger"
+)
+
+type Controller struct {
+	proxies             map[spec.GatewayID]*ReverseProxy
+	currentSpecRevision int
+}
+
+// Name implements node.Controller.
+func (c *Controller) Name() string {
+	return "gateway-controller"
+}
+
+// Reconcile implements node.Controller.
+func (c *Controller) Reconcile(ctx context.Context, state *agent.State) error {
+	gatewaySpec := spec.NewGatewaySpec()
+
+	if err := state.GetSpec(spec.NameGateway, gatewaySpec); err != nil {
+		if errors.Is(err, agent.ErrSpecNotFound) {
+			logger.Info(ctx, "could not find gateway spec, stopping all remaining proxies")
+
+			c.stopAllProxies(ctx)
+
+			return nil
+		}
+
+		return errors.WithStack(err)
+	}
+
+	logger.Info(ctx, "retrieved spec", logger.F("spec", gatewaySpec.SpecName()), logger.F("revision", gatewaySpec.SpecRevision()))
+
+	if c.currentSpecRevision == gatewaySpec.SpecRevision() {
+		logger.Info(ctx, "spec revision did not change, doing nothing")
+
+		return nil
+	}
+
+	c.updateProxies(ctx, gatewaySpec)
+
+	c.currentSpecRevision = gatewaySpec.SpecRevision()
+	logger.Info(ctx, "updating current spec revision", logger.F("revision", c.currentSpecRevision))
+
+	return nil
+}
+
+func (c *Controller) stopAllProxies(ctx context.Context) {
+	for gatewayID, proxy := range c.proxies {
+		logger.Info(ctx, "stopping proxy", logger.F("gatewayID", gatewayID))
+
+		if err := proxy.Stop(); err != nil {
+			logger.Error(
+				ctx, "error while stopping proxy",
+				logger.F("gatewayID", gatewayID),
+				logger.E(errors.WithStack(err)),
+			)
+
+			delete(c.proxies, gatewayID)
+		}
+	}
+}
+
+func (c *Controller) updateProxies(ctx context.Context, spec *spec.Gateway) {
+	// Stop and remove obsolete gateways
+	for gatewayID, proxy := range c.proxies {
+		if _, exists := spec.Gateways[gatewayID]; exists {
+			continue
+		}
+
+		logger.Info(ctx, "stopping proxy", logger.F("gatewayID", gatewayID))
+
+		if err := proxy.Stop(); err != nil {
+			logger.Error(
+				ctx, "error while stopping proxy",
+				logger.F("gatewayID", gatewayID),
+				logger.E(errors.WithStack(err)),
+			)
+
+			delete(c.proxies, gatewayID)
+		}
+	}
+
+	// (Re)start gateways
+	for gatewayID, gatewaySpec := range spec.Gateways {
+		proxy, exists := c.proxies[gatewayID]
+		if !exists {
+			proxy = NewReverseProxy()
+			c.proxies[gatewayID] = proxy
+		}
+
+		logger.Info(
+			ctx, "starting proxy",
+			logger.F("gatewayID", gatewayID),
+			logger.F("addr", gatewaySpec.Address),
+			logger.F("target", gatewaySpec.Target),
+		)
+
+		if err := proxy.Start(ctx, gatewaySpec.Address, gatewaySpec.Target); err != nil {
+			logger.Error(
+				ctx, "error while starting proxy",
+				logger.F("gatewayID", gatewayID),
+				logger.E(errors.WithStack(err)),
+			)
+
+			delete(c.proxies, gatewayID)
+		}
+	}
+}
+
+func NewController() *Controller {
+	return &Controller{
+		proxies:             make(map[spec.GatewayID]*ReverseProxy),
+		currentSpecRevision: -1,
+	}
+}
+
+var _ agent.Controller = &Controller{}

internal/agent/controller/gateway/reverse_proxy.go

@@ -0,0 +1,78 @@
+package gateway
+
+import (
+	"context"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+
+	"github.com/pkg/errors"
+	"gitlab.com/wpetit/goweb/logger"
+)
+
+type ReverseProxy struct {
+	addr   string
+	target string
+	server *http.Server
+}
+
+func (p *ReverseProxy) Start(ctx context.Context, addr, target string) error {
+	alreadyRunning := p.server != nil && target == p.target && addr == p.target
+
+	if alreadyRunning {
+		return nil
+	}
+
+	if p.server != nil {
+		if err := p.Stop(); err != nil {
+			return errors.WithStack(err)
+		}
+	}
+
+	server := &http.Server{
+		Addr: addr,
+	}
+
+	url, err := url.Parse(target)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	proxy := httputil.NewSingleHostReverseProxy(url)
+
+	server.Handler = proxy
+
+	p.server = server
+	p.addr = addr
+	p.target = target
+
+	go func() {
+		if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
+			logger.Error(ctx, "error while listening", logger.E(errors.WithStack(err)))
+		}
+
+		if err := p.Stop(); err != nil {
+			logger.Error(ctx, "error while stopping gateway", logger.E(errors.WithStack(err)))
+		}
+	}()
+
+	return nil
+}
+
+func (p *ReverseProxy) Stop() error {
+	if p.server == nil {
+		return nil
+	}
+
+	if err := p.server.Close(); err != nil && !errors.Is(err, http.ErrServerClosed) {
+		return errors.WithStack(err)
+	}
+
+	p.server = nil
+
+	return nil
+}
+
+func NewReverseProxy() *ReverseProxy {
+	return &ReverseProxy{}
+}

internal/agent/controller/openwrt/uci_controller.go

@@ -0,0 +1,116 @@
+package openwrt
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"os/exec"
+
+	"forge.cadoles.com/Cadoles/emissary/internal/agent"
+	"forge.cadoles.com/Cadoles/emissary/internal/openwrt/uci"
+	"forge.cadoles.com/Cadoles/emissary/internal/spec"
+	"github.com/pkg/errors"
+	"gitlab.com/wpetit/goweb/logger"
+)
+
+type UCIController struct {
+	binPath             string
+	currentSpecRevision int
+}
+
+// Name implements node.Controller.
+func (*UCIController) Name() string {
+	return "uci-controller"
+}
+
+// Reconcile implements node.Controller.
+func (c *UCIController) Reconcile(ctx context.Context, state *agent.State) error {
+	uciSpec := spec.NewUCISpec()
+
+	if err := state.GetSpec(spec.NameUCI, uciSpec); err != nil {
+		if errors.Is(err, agent.ErrSpecNotFound) {
+			logger.Info(ctx, "could not find uci spec, doing nothing")
+
+			return nil
+		}
+
+		return errors.WithStack(err)
+	}
+
+	logger.Info(ctx, "retrieved spec", logger.F("spec", uciSpec.SpecName()), logger.F("revision", uciSpec.SpecRevision()))
+
+	if c.currentSpecRevision == uciSpec.SpecRevision() {
+		logger.Info(ctx, "spec revision did not change, doing nothing")
+
+		return nil
+	}
+
+	if err := c.updateConfiguration(ctx, uciSpec); err != nil {
+		logger.Error(ctx, "could not update configuration", logger.E(errors.WithStack(err)))
+
+		return nil
+	}
+
+	c.currentSpecRevision = uciSpec.SpecRevision()
+	logger.Info(ctx, "updating current spec revision", logger.F("revision", c.currentSpecRevision))
+
+	return nil
+}
+
+func (c *UCIController) updateConfiguration(ctx context.Context, spec *spec.UCI) error {
+	logger.Info(ctx, "importing uci config")
+
+	if err := c.importConfig(ctx, spec.Config); err != nil {
+		return errors.WithStack(err)
+	}
+
+	if err := c.execPostImportCommands(ctx, spec.PostImportCommands); err != nil {
+		return errors.WithStack(err)
+	}
+
+	return nil
+}
+
+func (c *UCIController) importConfig(ctx context.Context, uci *uci.UCI) error {
+	cmd := exec.CommandContext(ctx, c.binPath, "import")
+
+	var buf bytes.Buffer
+
+	if _, err := buf.WriteString(uci.Export()); err != nil {
+		return errors.WithStack(err)
+	}
+
+	cmd.Stdin = &buf
+	cmd.Stderr = os.Stderr
+	cmd.Stdout = os.Stdout
+
+	if err := cmd.Run(); err != nil {
+		return errors.WithStack(err)
+	}
+
+	return nil
+}
+
+func (c *UCIController) execPostImportCommands(ctx context.Context, commands []*spec.UCIPostImportCommand) error {
+	for _, postImportCmd := range commands {
+		cmd := exec.CommandContext(ctx, postImportCmd.Command, postImportCmd.Args...)
+
+		cmd.Stderr = os.Stderr
+		cmd.Stdout = os.Stdout
+
+		if err := cmd.Run(); err != nil {
+			return errors.WithStack(err)
+		}
+	}
+
+	return nil
+}
+
+func NewUCIController(binPath string) *UCIController {
+	return &UCIController{
+		binPath:             binPath,
+		currentSpecRevision: -1,
+	}
+}
+
+var _ agent.Controller = &UCIController{}

internal/agent/controller/persistence/controller.go

@@ -0,0 +1,218 @@
+package persistence
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"forge.cadoles.com/Cadoles/emissary/internal/agent"
+	"forge.cadoles.com/Cadoles/emissary/internal/spec"
+	"github.com/pkg/errors"
+	"gitlab.com/wpetit/goweb/logger"
+)
+
+type Controller struct {
+	trackedSpecRevisions map[spec.Name]int
+	filename             string
+	loaded               bool
+}
+
+// Name implements node.Controller.
+func (c *Controller) Name() string {
+	return "persistence-controller"
+}
+
+// Reconcile implements node.Controller.
+func (c *Controller) Reconcile(ctx context.Context, state *agent.State) error {
+	specs := state.Specs()
+	changed := c.specChanged(state.Specs())
+
+	switch {
+	// If first cycle, load state from file system
+	case !c.loaded:
+		logger.Info(ctx, "first cycle, loading state", logger.F("stateFile", c.filename))
+
+		if err := c.loadState(ctx, state); err != nil {
+			if errors.Is(err, os.ErrNotExist) {
+				logger.Info(ctx, "state file not found", logger.F("stateFile", c.filename))
+
+				c.loaded = true
+
+				return nil
+			}
+
+			return errors.WithStack(err)
+		}
+
+		c.trackSpecsRevisions(specs)
+
+		c.loaded = true
+
+		return nil
+
+		// If specs did not change, return
+	case !changed:
+		logger.Info(ctx, "no changes detected, doing nothing")
+
+		return nil
+
+	// If specs has changed, save it
+	case changed:
+		logger.Info(ctx, "saving state", logger.F("stateFile", c.filename))
+
+		if err := c.writeState(ctx, state); err != nil {
+			return errors.WithStack(err)
+		}
+
+		c.trackSpecsRevisions(specs)
+	}
+
+	return nil
+}
+
+func (c *Controller) specChanged(specs agent.Specs) bool {
+	if len(specs) != len(c.trackedSpecRevisions) {
+		return true
+	}
+
+	for name, spec := range specs {
+		trackedRevision, exists := c.trackedSpecRevisions[name]
+		if !exists {
+			return true
+		}
+
+		if trackedRevision != spec.SpecRevision() {
+			return true
+		}
+	}
+
+	for trackedSpecName, trackedRevision := range c.trackedSpecRevisions {
+		spec, exists := specs[trackedSpecName]
+		if !exists {
+			return true
+		}
+
+		if trackedRevision != spec.SpecRevision() {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (c *Controller) trackSpecsRevisions(specs agent.Specs) {
+	c.trackedSpecRevisions = make(map[spec.Name]int)
+
+	for name, spec := range specs {
+		c.trackedSpecRevisions[name] = spec.SpecRevision()
+	}
+}
+
+func (c *Controller) loadState(ctx context.Context, state *agent.State) error {
+	data, err := ioutil.ReadFile(c.filename)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	if err := json.Unmarshal(data, state); err != nil {
+		return errors.WithStack(err)
+	}
+
+	return nil
+}
+
+func (c *Controller) writeState(ctx context.Context, state *agent.State) error {
+	dir, file := filepath.Split(c.filename)
+	if dir == "" {
+		dir = "."
+	}
+
+	f, err := ioutil.TempFile(dir, file)
+	if err != nil {
+		return errors.Errorf("cannot create temp file: %v", err)
+	}
+
+	defer func() {
+		if err == nil {
+			return
+		}
+
+		if err := os.Remove(f.Name()); err != nil {
+			if errors.Is(err, os.ErrNotExist) {
+				return
+			}
+
+			logger.Error(ctx, "could not remove temporary file", logger.E(errors.WithStack(err)))
+		}
+	}()
+
+	defer func() {
+		if err := f.Close(); err != nil {
+			if errors.Is(err, os.ErrClosed) {
+				return
+			}
+
+			logger.Error(ctx, "could not close temporary file", logger.E(errors.WithStack(err)))
+		}
+	}()
+
+	data, err := json.Marshal(state)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	name := f.Name()
+	if err := ioutil.WriteFile(name, data, os.ModePerm); err != nil {
+		return errors.Errorf("cannot write data to temporary file %q: %v", name, err)
+	}
+
+	if err := f.Sync(); err != nil {
+		return errors.Errorf("can't flush temporary file %q: %v", name, err)
+	}
+
+	if err := f.Close(); err != nil {
+		return errors.Errorf("can't close temporary file %q: %v", name, err)
+	}
+
+	// get the file mode from the original file and use that for the replacement
+	// file, too.
+	destInfo, err := os.Stat(c.filename)
+
+	switch {
+	case os.IsNotExist(err):
+		// Do nothing
+
+	case err != nil:
+		return errors.WithStack(err)
+
+	default:
+		sourceInfo, err := os.Stat(name)
+		if err != nil {
+			return errors.WithStack(err)
+		}
+
+		if sourceInfo.Mode() != destInfo.Mode() {
+			if err := os.Chmod(name, destInfo.Mode()); err != nil {
+				return fmt.Errorf("can't set filemode on temporary file %q: %v", name, err)
+			}
+		}
+	}
+
+	if err := os.Rename(name, c.filename); err != nil {
+		return fmt.Errorf("cannot replace %q with temporary file %q: %v", c.filename, name, err)
+	}
+
+	return nil
+}
+
+func NewController(filename string) *Controller {
+	return &Controller{
+		filename:             filename,
+		trackedSpecRevisions: make(map[spec.Name]int),
+	}
+}
+
+var _ agent.Controller = &Controller{}

internal/agent/controller/spec/controller.go

@@ -0,0 +1,116 @@
+package spec
+
+import (
+	"context"
+
+	"forge.cadoles.com/Cadoles/emissary/internal/agent"
+	"forge.cadoles.com/Cadoles/emissary/internal/agent/machineid"
+	"forge.cadoles.com/Cadoles/emissary/internal/client"
+	"forge.cadoles.com/Cadoles/emissary/internal/datastore"
+	"forge.cadoles.com/Cadoles/emissary/internal/server"
+	"github.com/pkg/errors"
+	"gitlab.com/wpetit/goweb/api"
+	"gitlab.com/wpetit/goweb/logger"
+)
+
+type Controller struct {
+	client *client.Client
+}
+
+// Name implements node.Controller.
+func (c *Controller) Name() string {
+	return "spec-controller"
+}
+
+// Reconcile implements node.Controller.
+func (c *Controller) Reconcile(ctx context.Context, state *agent.State) error {
+	machineID, err := machineid.Get()
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	ctx = logger.With(ctx, logger.F("machineID", machineID))
+
+	agent, err := c.client.RegisterAgent(ctx, machineID)
+	isAlreadyRegisteredErr, _ := isAPIError(err, server.ErrCodeAlreadyRegistered)
+
+	switch {
+	case isAlreadyRegisteredErr:
+		agents, _, err := c.client.QueryAgents(
+			ctx,
+			client.WithQueryAgentsLimit(1),
+			client.WithQueryAgentsRemoteID(machineID),
+		)
+		if err != nil {
+			return errors.WithStack(err)
+		}
+
+		if len(agents) == 0 {
+			logger.Error(ctx, "could not find remote matching agent")
+
+			return nil
+		}
+
+		if err := c.reconcileAgent(ctx, state, agents[0]); err != nil {
+			return errors.WithStack(err)
+		}
+
+		return nil
+
+	case agent != nil:
+		if err := c.reconcileAgent(ctx, state, agent); err != nil {
+			return errors.WithStack(err)
+		}
+
+		return nil
+
+	case err != nil:
+		logger.Error(ctx, "could not contact server", logger.E(errors.WithStack(err)))
+
+		return nil
+	}
+
+	return nil
+}
+
+func (c *Controller) reconcileAgent(ctx context.Context, state *agent.State, agent *datastore.Agent) error {
+	ctx = logger.With(ctx, logger.F("agentID", agent.ID))
+
+	if agent.Status != datastore.AgentStatusAccepted {
+		logger.Error(ctx, "unexpected agent status", logger.F("status", agent.Status))
+
+		return nil
+	}
+
+	specs, err := c.client.GetAgentSpecs(ctx, agent.ID)
+	if err != nil {
+		logger.Error(ctx, "could not retrieve agent specs", logger.E(errors.WithStack(err)))
+
+		return nil
+	}
+
+	state.ClearSpecs()
+
+	for _, spec := range specs {
+		state.SetSpec(spec)
+	}
+
+	return nil
+}
+
+func NewController(serverURL string) *Controller {
+	client := client.New(serverURL)
+
+	return &Controller{client}
+}
+
+func isAPIError(err error, code api.ErrorCode) (bool, any) {
+	apiError := &api.Error{}
+	if errors.As(err, &apiError) && apiError.Code == code {
+		return true, apiError.Data
+	}
+
+	return false, nil
+}
+
+var _ agent.Controller = &Controller{}