snapshots: Prepare for restructuring

This commit renames the 'wisski' package to 'dis' and prepares the
snapshots component for restructuring.

internal/dis/backup_prune.go

@@ -0,0 +1,51 @@
+package dis
+
+import (
+	"path/filepath"
+	"time"
+
+	"github.com/tkw1536/goprogram/stream"
+)
+
+// ShouldPrune determines if a file with the provided modtime
+func (dis *Distillery) ShouldPrune(modtime time.Time) bool {
+	return time.Since(modtime) > time.Duration(dis.Config.MaxBackupAge)*24*time.Hour
+}
+
+// PruneBackups prunes all backups older than the maximum backup age
+func (dis *Distillery) PruneBackups(io stream.IOStream) error {
+	sPath := dis.SnapshotManager().ArchivePath()
+
+	// list all the files
+	entries, err := dis.Core.Environment.ReadDir(sPath)
+	if err != nil {
+		return err
+	}
+
+	for _, entry := range entries {
+		// skip directories
+		if entry.IsDir() {
+			continue
+		}
+
+		// grab info about the file
+		info, err := entry.Info()
+		if err != nil {
+			return err
+		}
+
+		// check if it should be pruned!
+		if !dis.ShouldPrune(info.ModTime()) {
+			continue
+		}
+
+		// assemble path, and then remove the file!
+		path := filepath.Join(sPath, entry.Name())
+		io.Printf("Removing %s cause it is older than %d days", path, dis.Config.MaxBackupAge)
+
+		if err := dis.Core.Environment.Remove(path); err != nil {
+			return err
+		}
+	}
+	return nil
+}

internal/dis/component.go

@@ -0,0 +1,138 @@
+package dis
+
+import (
+	"time"
+
+	"github.com/FAU-CDI/wisski-distillery/internal/component"
+	"github.com/FAU-CDI/wisski-distillery/internal/component/control"
+	"github.com/FAU-CDI/wisski-distillery/internal/component/instances"
+	"github.com/FAU-CDI/wisski-distillery/internal/component/snapshots"
+	"github.com/FAU-CDI/wisski-distillery/internal/component/sql"
+	"github.com/FAU-CDI/wisski-distillery/internal/component/ssh"
+	"github.com/FAU-CDI/wisski-distillery/internal/component/triplestore"
+	"github.com/FAU-CDI/wisski-distillery/internal/component/web"
+	"github.com/FAU-CDI/wisski-distillery/internal/core"
+	"github.com/FAU-CDI/wisski-distillery/pkg/lazy"
+)
+
+// components holds the various components of the distillery
+// It is inlined into the [Distillery] struct, and initialized using [makeComponent].
+//
+// The caller is responsible for syncronizing access across multiple goroutines.
+type components struct {
+
+	// installable components
+	web     lazy.Lazy[*web.Web]
+	control lazy.Lazy[*control.Control]
+	ssh     lazy.Lazy[*ssh.SSH]
+	ts      lazy.Lazy[*triplestore.Triplestore]
+	sql     lazy.Lazy[*sql.SQL]
+
+	// other components
+	instances lazy.Lazy[*instances.Instances]
+	snapshots lazy.Lazy[*snapshots.Manager]
+}
+
+//
+// Individual Components
+//
+
+func (dis *Distillery) Web() *web.Web {
+	return component.Initialize(dis.Core, &dis.components.web, nil)
+}
+
+func (d *Distillery) Control() *control.Control {
+	return component.Initialize(d.Core, &d.components.control, func(control *control.Control) {
+		control.ResolverFile = core.PrefixConfig
+		control.Instances = d.Instances()
+	})
+}
+
+func (dis *Distillery) SSH() *ssh.SSH {
+	return component.Initialize(dis.Core, &dis.components.ssh, nil)
+}
+
+func (dis *Distillery) SQL() *sql.SQL {
+	return component.Initialize(dis.Core, &dis.components.sql, func(sql *sql.SQL) {
+		sql.ServerURL = dis.Upstream.SQL
+		sql.PollContext = dis.Context()
+		sql.PollInterval = time.Second
+	})
+}
+
+func (dis *Distillery) Triplestore() *triplestore.Triplestore {
+	return component.Initialize(dis.Core, &dis.components.ts, func(ts *triplestore.Triplestore) {
+		ts.BaseURL = "http://" + dis.Upstream.Triplestore
+		ts.PollContext = dis.Context()
+		ts.PollInterval = time.Second
+	})
+}
+
+func (dis *Distillery) Instances() *instances.Instances {
+	return component.Initialize(dis.Core, &dis.components.instances, func(instances *instances.Instances) {
+		instances.SQL = dis.SQL()
+		instances.TS = dis.Triplestore()
+	})
+}
+
+func (dis *Distillery) SnapshotManager() *snapshots.Manager {
+	return component.Initialize(dis.Core, &dis.components.snapshots, func(snapshots *snapshots.Manager) {
+		snapshots.SQL = dis.SQL()
+		snapshots.TS = dis.Triplestore()
+	})
+}
+
+//
+// ALL COMPONENTS
+//
+
+func (dis *Distillery) Components() []component.Component {
+	return []component.Component{
+		dis.Web(),
+		dis.Control(),
+		dis.SSH(),
+		dis.Triplestore(),
+		dis.SQL(),
+		dis.Instances(),
+	}
+}
+
+//
+// COMPONENT SUBTYPE GETTERS
+//
+
+// Backupable returns all the components that can be backuped up.
+func (dis *Distillery) Backupable() []component.Backupable {
+	return getComponentSubtype[component.Backupable](dis)
+}
+
+// Installables returns all components that can be installed
+func (dis *Distillery) Installables() []component.Installable {
+	return getComponentSubtype[component.Installable](dis)
+}
+
+// Installables returns all components that can be installed
+func (dis *Distillery) Updateable() []component.Updatable {
+	return getComponentSubtype[component.Updatable](dis)
+}
+
+// Provisionable returns all components which can be provisioned
+func (dis *Distillery) Provisionable() []component.Provisionable {
+	return getComponentSubtype[component.Provisionable](dis)
+}
+
+// getComponentSubtype gets all components of type T
+func getComponentSubtype[T component.Component](dis *Distillery) (components []T) {
+	all := dis.Components()
+
+	components = make([]T, 0, len(all))
+	for _, c := range all {
+		sc, ok := c.(T)
+		if !ok {
+			continue
+		}
+		components = append(components, sc)
+	}
+
+	return
+}

internal/dis/distillery.go

@@ -0,0 +1,36 @@
+package dis
+
+import (
+	"context"
+
+	"github.com/FAU-CDI/wisski-distillery/internal/component"
+)
+
+// Distillery represents a WissKI Distillery
+//
+// It is the main structure used to interact with different components.
+type Distillery struct {
+	// core holds the core of the distillery
+	component.Core
+
+	// Upstream holds information to connect to the various running
+	// distillery components.
+	//
+	// NOTE(twiesing): This is intended to eventually allow full remote management of the distillery.
+	// But for now this will just hold upstream configuration.
+	Upstream Upstream
+
+	// components hold references to the various components of the distillery.
+	components
+}
+
+// Upstream contains the configuration for accessing remote configuration.
+type Upstream struct {
+	SQL         string
+	Triplestore string
+}
+
+// Context returns a new Context belonging to this distillery
+func (dis *Distillery) Context() context.Context {
+	return context.Background()
+}

internal/dis/init.go

@@ -0,0 +1,70 @@
+package dis
+
+import (
+	"github.com/FAU-CDI/wisski-distillery/internal/component"
+	"github.com/FAU-CDI/wisski-distillery/internal/config"
+	"github.com/FAU-CDI/wisski-distillery/internal/core"
+	"github.com/FAU-CDI/wisski-distillery/pkg/environment"
+	"github.com/tkw1536/goprogram/exit"
+)
+
+var errNoConfigFile = exit.Error{
+	ExitCode: exit.ExitGeneralArguments,
+	Message:  "Configuration File does not exist",
+}
+
+var errOpenConfig = exit.Error{
+	ExitCode: exit.ExitGeneralArguments,
+	Message:  "error loading configuration file: %s",
+}
+
+// NewDistillery creates a new distillery from the provided flags
+func NewDistillery(params core.Params, flags core.Flags, req core.Requirements) (dis *Distillery, err error) {
+	dis = &Distillery{
+		Core: component.Core{
+			Environment: environment.Native{},
+		},
+		Upstream: Upstream{
+			SQL:         "127.0.0.1:3306",
+			Triplestore: "127.0.0.1:7200",
+		},
+	}
+
+	// we are within the docker
+	//
+	// so setup the ports to connect everything to peroperly.
+	// also override some of the parameters for the environment.
+	if flags.InternalInDocker {
+		dis.Upstream.SQL = "sql:3306"
+		dis.Upstream.Triplestore = "triplestore:7200"
+		params.ConfigPath = dis.Core.Environment.GetEnv("CONFIG_PATH")
+	}
+
+	// if we don't need to load the config, there is nothing to do
+	if !req.NeedsDistillery {
+		return
+	}
+
+	// try to find the configuration file
+	cfg := flags.ConfigPath // command line flags first
+	if cfg == "" {
+		cfg = params.ConfigPath // then globally provided files
+	}
+	if cfg == "" {
+		return nil, errNoConfigFile
+	}
+
+	// open the config file!
+	f, err := dis.Core.Environment.Open(params.ConfigPath)
+	if err != nil {
+		return nil, errOpenConfig.WithMessageF(err)
+	}
+	defer f.Close()
+
+	// unmarshal the config
+	dis.Config = &config.Config{
+		ConfigPath: cfg,
+	}
+	err = dis.Config.Unmarshal(dis.Core.Environment, f)
+	return
+}