get rid of file management - move over to memory storage

Author: refs

go.mod

@@ -3,9 +3,11 @@ module github.com/refs/pman
 go 1.15
 
 require (
+	github.com/magiconair/properties v1.8.1
 	github.com/olekukonko/tablewriter v0.0.4
 	github.com/rs/zerolog v1.19.0
 	github.com/spf13/cobra v1.0.0
 	github.com/spf13/viper v1.7.0
+	github.com/stretchr/testify v1.7.0
 	golang.org/x/sys v0.0.0-20200523222454-059865788121
 )

go.sum

@@ -189,6 +189,8 @@ github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/subosito/gotenv v1.2.0 h1:Slr1R9HxAlEKefgq5jn9U+DnETlIUa6HfgEzj0g5d7s=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
@@ -323,6 +325,8 @@ gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4 h1:/eiJrUcujPVeJ3xlSWaiNi3uSVmDGBK1pDHUHAnao1I=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

pkg/config/config.go

@@ -1,38 +1,28 @@
 package config
 
-import (
-	"io/ioutil"
-	"log"
-)
-
 // Config determines behavior across the tool.
 type Config struct {
 	// Hostname where the runtime is running. When using PMAN in cli mode, it determines where the host runtime is.
 	// Default is localhost.
 	Hostname string
 
 	// Port configures the port where a runtime is available. It defaults to 10666.
-	Port     string
-
-	// File configures where Pman's database of PID lives.
-	File string
+	Port string
 
 	// KeepAlive configures if restart attempts are made if the process supervised terminates. Default is false.
 	KeepAlive bool
 }
 
+var (
+	defaultHostname = "localhost"
+	defaultPort     = "10666"
+)
+
 // NewConfig returns a new config with a set of defaults.
 func NewConfig() *Config {
-	f, err := ioutil.TempFile("", "*")
-	if err != nil {
-		log.Fatal(err)
-	}
-	mustWrite(f.Name(), []byte("{}"))
-
 	return &Config{
 		Hostname:  defaultHostname,
 		Port:      defaultPort,
-		File:      f.Name(),
 		KeepAlive: false,
 	}
 }

pkg/config/util.go

@@ -3,7 +3,10 @@ package controller
 import (
 	"fmt"
 	"github.com/refs/pman/pkg/config"
-	"io/ioutil"
+	"github.com/refs/pman/pkg/process"
+	"github.com/refs/pman/pkg/storage"
+	"github.com/refs/pman/pkg/watcher"
+	"github.com/rs/zerolog"
 	"os"
 	"os/exec"
 	"sort"
@@ -12,25 +15,25 @@ import (
 	"sync"
 	"time"
 
-	"github.com/refs/pman/pkg/log"
-	"github.com/refs/pman/pkg/process"
-	"github.com/refs/pman/pkg/watcher"
-	"github.com/rs/zerolog"
-
 	"github.com/olekukonko/tablewriter"
 )
 
-// Controller writes the current managed processes onto a file, or any ReadWrite.
+// Controller supervises processes.
 type Controller struct {
 	m       *sync.RWMutex
 	options Options
 	log     zerolog.Logger
 	Config  *config.Config
+
+	Store *storage.Map
+
 	// Bin is the OCIS single binary name.
 	Bin string
+
 	// BinPath is the OCIS single binary path withing the host machine.
 	// The Controller needs to know the binary location in order to spawn new extensions.
 	BinPath string
+
 	// Terminated facilitates communication from Watcher <-> Controller. Writes to this
 	// channel WILL always attempt to restart the crashed process.
 	Terminated chan process.ProcEntry
@@ -49,14 +52,14 @@ func NewController(o ...Option) Controller {
 	}
 
 	c := Controller{
-		m: &sync.RWMutex{},
-		options: *opts,
-		log: log.NewLogger(
-			log.WithPretty(true),
-		),
-		Config:     opts.Config,
+		m:          &sync.RWMutex{},
+		options:    *opts,
+		log:        *opts.Log,
 		Bin:        "ocis",
 		Terminated: make(chan process.ProcEntry),
+		Store:      storage.NewMapStorage(),
+
+		Config: opts.Config,
 	}
 
 	if opts.Bin != "" {
@@ -69,45 +72,33 @@ func NewController(o ...Option) Controller {
 		c.log.Debug().Msg("OCIS binary not present in PATH, using Args[0]")
 		path = os.Args[0]
 	}
-
 	c.BinPath = path
-
-	if _, err := os.Stat(opts.Config.File); err != nil {
-		c.log.Debug().Str("package", "controller").Msgf("setting up db")
-		ioutil.WriteFile(opts.Config.File, []byte("{}"), 0644)
-	}
-
 	return c
 }
 
 // Start and watches a process.
 func (c *Controller) Start(pe process.ProcEntry) error {
-	var err error
-	var pid int
-
-	if pid, err = c.storedPID(pe.Extension); pid != 0 {
+	if pid := c.Store.Load(pe.Extension); pid != 0 {
 		c.log.Debug().Msg(fmt.Sprintf("extension already running: %s", pe.Extension))
 		return nil
 	}
-	if err != nil {
-		return err
-	}
 
 	w := watcher.NewWatcher()
 	if err := pe.Start(c.BinPath); err != nil {
 		return err
 	}
 
-	if err := c.write(pe); err != nil {
+	// store the spawned child process PID.
+	if err := c.Store.Store(pe); err != nil {
 		return err
 	}
+
 	w.Follow(pe, c.Terminated, c.options.Config.KeepAlive)
 
 	once.Do(func() {
 		j := janitor{
-			c.m,
-			c.Config.File,
 			time.Second,
+			c.Store,
 		}
 
 		go j.run()
@@ -117,40 +108,29 @@ func (c *Controller) Start(pe process.ProcEntry) error {
 }
 
 // Kill a managed process.
-// TODO(refs) this interface MUST also work with PIDs.
 // Should a process managed by the runtime be allowed to be killed if the runtime is configured not to?
-func (c *Controller) Kill(ext *string) error {
-	pid, err := c.storedPID(*ext)
-	if err != nil {
-		return err
-	}
+func (c *Controller) Kill(pe process.ProcEntry) error {
+	// load stored PID
+	pid := c.Store.Load(pe.Extension)
+
+	// find process in host by PID
 	p, err := os.FindProcess(pid)
 	if err != nil {
 		return err
 	}
 
-	if err := c.delete(*ext); err != nil {
+	if err := c.Store.Delete(pe); err != nil {
 		return err
 	}
-	c.log.Info().Str("package", "watcher").Msgf("terminating %v", *ext)
+	c.log.Info().Str("package", "watcher").Msgf("terminating %v", pe.Extension)
+
+	// terminate child process
 	return p.Kill()
 }
 
 // Shutdown a running runtime.
 func (c *Controller) Shutdown(ch chan struct{}) error {
-	// We cannot be sure when was the last write before a shutdown routine begins without a plan. "Plan" in the sense of
-	// an argument with every extension that must be started. This way we could block access to the io.Writer the "db"
-	// uses, and either halt and prevent main from forking more children, or let them all run and once the reader gets
-	// freed, start shutting them all down, a.k.a reverse the process. For the time being a simple Sleep would ensure
-	// that all children are spawned and the last writer has been executed. Alternatively proper synchronization can
-	// be ensured with the combination of a set of extensions that must run and a wait group.
-	time.Sleep(1 * time.Second)
-
-	entries, err := loadDB(c.Config.File)
-	if err != nil {
-		return err
-	}
-
+	entries := c.Store.LoadAll()
 	for cmd, pid := range entries {
 		c.log.Info().Str("package", "watcher").Msgf("gracefully terminating %v", cmd)
 		p, _ := os.FindProcess(pid)
@@ -159,10 +139,6 @@ func (c *Controller) Shutdown(ch chan struct{}) error {
 		}
 	}
 
-	if err := c.Reset(); err != nil {
-		return err
-	}
-
 	ch <- struct{}{}
 	return nil
 }
@@ -173,12 +149,7 @@ func (c *Controller) List() string {
 	table := tablewriter.NewWriter(tableString)
 	table.SetHeader([]string{"Extension", "PID"})
 
-	c.m.Lock()
-	entries, err := loadDB(c.Config.File)
-	if err != nil {
-		c.log.Err(err).Msg(fmt.Sprintf("error loading file: %s", c.Config.File))
-	}
-	c.m.Unlock()
+	entries := c.Store.LoadAll()
 
 	keys := make([]string, 0, len(entries))
 	for k := range entries {
@@ -194,10 +165,3 @@ func (c *Controller) List() string {
 	table.Render()
 	return tableString.String()
 }
-
-// Reset clears the db file.
-func (c *Controller) Reset() error {
-	c.m.RLock()
-	defer c.m.RUnlock()
-	return os.Remove(c.Config.File)
-}

pkg/controller/controller.go

@@ -1,22 +1,19 @@
 package controller
 
 import (
-	"encoding/json"
-	"io/ioutil"
+	"github.com/refs/pman/pkg/process"
+	"github.com/refs/pman/pkg/storage"
 	"os"
 	"os/signal"
-	"sync"
 	"syscall"
 	"time"
 )
 
 type janitor struct {
-	// shared mutex with the Controller instance.
-	m *sync.RWMutex
-	// file containing the location of the runtime service | process registry.
-	db string
 	// interval at which db is cleared.
 	interval time.Duration
+
+	store *storage.Map
 }
 
 func (j *janitor) run() {
@@ -29,31 +26,23 @@ func (j *janitor) run() {
 		case <-work:
 			return
 		case <-ticker.C:
-			cleanup(j.db, j.m)
+			j.cleanup()
 		}
 	}
 }
 
 // cleanup removes orphaned extension + pid that were killed via SIGKILL given the nature of is being un-catchable,
 // the only way to update pman's database is by polling.
-func cleanup(f string, m *sync.RWMutex) {
-	m.Lock()
-	entries, _ := loadDB(f)
-	m.Unlock()
-
-	m.RLock()
-	for name, pid := range entries {
+func (j *janitor) cleanup() {
+	for name, pid := range j.store.LoadAll() {
 		// On unix like systems (linux, freebsd, etc) os.FindProcess will never return an error
 		if p, err := os.FindProcess(pid); err == nil {
 			if err := p.Signal(syscall.Signal(0)); err != nil {
-				// TODO(refs) use configured logger and log cleaning info
-				delete(entries, name)
+				j.store.Delete(process.ProcEntry{
+					Pid:       pid,
+					Extension: name,
+				})
 			}
 		}
 	}
-
-	bytes, _ := json.Marshal(entries)
-
-	_ = ioutil.WriteFile(f, bytes, 0644)
-	m.RUnlock()
-}
+}

pkg/controller/janitor.go

@@ -1,12 +1,16 @@
 package controller
 
-import "github.com/refs/pman/pkg/config"
+import (
+	"github.com/refs/pman/pkg/config"
+	"github.com/rs/zerolog"
+)
 
 // Options are the configurable options for a Controller.
 type Options struct {
-	Bin  string
+	Bin     string
 	Restart bool
-	Config *config.Config
+	Config  *config.Config
+	Log     *zerolog.Logger
 }
 
 // Option represents an option.
@@ -23,3 +27,10 @@ func WithConfig(cfg *config.Config) Option {
 		o.Config = cfg
 	}
 }
+
+// WithLog sets Controller config.
+func WithLog(l *zerolog.Logger) Option {
+	return func(o *Options) {
+		o.Log = l
+	}
+}