0
0
package bootstrap
import (
"errors"
"fmt"
"os"
"path/filepath"
"syscall"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/bootstrap/table"
"github.com/johnandersen777/socialweb-computer-kcp/internal/devinstance"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostsvc"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kcpdatastore"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kcpserver"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/opt"
"github.com/johnandersen777/socialweb-computer-kcp/internal/pgunit"
)
const (
ProfileQuick = "quick"
ProfileProdlike = "prodlike"
ProfileMarketNetwork = "market-network"
CoreStopTimeout = 10 * time.Second
CoreName = "socialweb-computer"
DropInName = "socialweb-bootstrap.conf"
InstallFrontAddr = "127.0.0.1:0"
PendingFrontURL = "https://front.pending.invalid"
RequestersDir = "requesters"
RequesterInstanceSub = "dev"
RequesterReadyFile = "ready.json"
RequesterRecordFile = "requester.json"
)
type Params struct {
App table.App
Dir string
Run string
Logs string
Exe string
KcpPath string
KinePath string
PostgresRoot string
FrontAddress string
FDStore bool
Owner string
InstanceDir string
ReadyTimeout time.Duration
}
type InstalledUnit struct {
Entry table.Entry
Unit string
Path string
Exec string
File hostsvc.InstalledFile
}
func DevApps(profile string, l devinstance.Layout) ([]table.App, error) {
switch profile {
case ProfileQuick, ProfileMarketNetwork:
return []table.App{table.Dev(l.Short, table.StoreSqlite)}, nil
case ProfileProdlike:
return []table.App{table.Dev(l.Short, table.StorePostgres)}, nil
}
return nil, fmt.Errorf("bootstrap: unknown profile %q: want quick, prodlike or market-network", profile)
}
func (c Config) Params(a table.App) Params {
l := c.Layout
p := Params{App: a, Exe: c.Exe, KcpPath: c.KcpPath, KinePath: c.KinePath, PostgresRoot: c.PostgresRoot,
FrontAddress: c.frontAddress(), FDStore: c.fdStore, Owner: l.ID, InstanceDir: l.StateDir, ReadyTimeout: c.ReadyTimeout,
Dir: l.KcpDir(), Run: l.RuntimeDir, Logs: l.Logs}
if a.Key != l.Short {
p.Dir = filepath.Join(l.StateDir, "apps", a.Key, "kcp")
p.Run = filepath.Join(l.RuntimeDir, a.Key)
p.Logs = filepath.Join(l.StateDir, "apps", a.Key, "logs")
p.Owner = l.ID + "/" + a.Key
p.InstanceDir = filepath.Join(l.StateDir, "apps", a.Key)
}
return p
}
func RequesterInstanceDir(state, name string) string {
return filepath.Join(state, RequestersDir, name, RequesterInstanceSub, name)
}
func AppDir(a table.App, state string) string {
switch a.Role {
case table.RoleBidder:
return filepath.Join(state, "handles", a.Key, "kcp")
case table.RoleRequester:
return filepath.Join(RequesterInstanceDir(state, a.Name), "kcp")
}
return filepath.Join(state, "kcp")
}
func InstallParams(a table.App, state string) Params {
dir := AppDir(a, state)
bin := filepath.Join(dir, "bin")
return Params{App: a, Dir: dir, Run: filepath.Join(dir, "run"), Exe: filepath.Join(state, "bin", "current", CoreName),
KcpPath: filepath.Join(bin, "kcp"), KinePath: filepath.Join(bin, "kine"), PostgresRoot: filepath.Join(bin, pgunit.Asset),
FrontAddress: InstallFrontAddr, Owner: a.Key, InstanceDir: state}
}
func (p Params) KineSocket(slot string) string { return filepath.Join(p.Run, "kine-"+slot+".sock") }
func (p Params) KineURL(slot string) string { return "unix://" + p.KineSocket(slot) }
func (p Params) KineDir(slot string) string { return filepath.Join(p.Dir, "kine-"+slot) }
func (p Params) PgSocketDir() string { return filepath.Join(p.Run, "pg") }
func (p Params) PgData() string { return filepath.Join(p.Dir, "pg", "data") }
func (p Params) SlotRoot(slot string) string { return filepath.Join(p.Dir, "slot-"+slot) }
func (p Params) FrontControl() string { return filepath.Join(p.Run, "front.sock") }
func (p Params) FrontState() string { return filepath.Join(p.Dir, "front.json") }
func (p Params) EnvFile(unit string) string { return filepath.Join(p.Dir, unit+hostsvc.EnvFileSuffix) }
func (p Params) BackupsDir() string { return filepath.Join(p.Dir, kcpdatastore.BackupsDir) }
func (p Params) SlotsFile() string { return filepath.Join(p.Dir, "kcp-slots.json") }
func (p Params) SharedDir() string { return filepath.Join(p.Dir, "shared") }
func (p Params) RollLock() string { return filepath.Join(p.Dir, "roll.lock") }
func (p Params) storeConfig(unit string, in pgunit.Install) kcpdatastore.PostgresConfig {
return kcpdatastore.PostgresConfig{Unit: unit, Slice: p.App.Names().Slice(), Install: in, Data: p.PgData(), SocketDir: p.PgSocketDir()}
}
func (p Params) Postgres() (pgunit.Install, error) { return pgunit.FromRoot(p.PostgresRoot) }
func (p Params) shape() kcpserver.Shape {
if p.App.SingleSlot() && !p.App.DevCore {
return kcpserver.ShapeSingle
}
return kcpserver.ShapeBlueGreen
}
func (p Params) log(role string) hostsvc.Output {
if p.Logs == "" {
return hostsvc.Output{}
}
f := filepath.Join(p.Logs, role+".log")
return hostsvc.Output{StdoutFile: f, StderrFile: f}
}
func (p Params) Spec(e table.Entry, frontURL string) (hostsvc.UnitSpec, error) {
n := p.App.Names()
var spec hostsvc.UnitSpec
var err error
switch e.Kind {
case table.KindStore:
var in pgunit.Install
if in, err = pgunit.At(p.PostgresRoot); err == nil {
spec, err = kcpdatastore.PostgresSpec(p.storeConfig(e.Unit, in))
}
case table.KindKine:
kc := kcpdatastore.KineConfig{Unit: e.Unit, Slice: n.Slice(), Exec: p.KinePath, Dir: p.KineDir(e.Slot),
Socket: p.KineSocket(e.Slot), PostgresSocketDir: p.PgSocketDir()}
if p.App.Store == table.StorePostgres {
spec, err = kcpdatastore.KinePostgresSpec(kc, n.Store())
} else {
spec, err = kcpdatastore.KineSqliteSpec(kc)
}
case table.KindFront:
spec, err = kcpserver.FrontSpec(kcpserver.FrontConfig{Unit: e.Unit, Slice: n.Slice(), Exe: p.Exe, Owner: p.Owner,
Address: p.FrontAddress, Control: p.FrontControl(), State: p.FrontState(), FDStore: p.FDStore})
case table.KindSlot:
spec, err = kcpserver.SlotSpec(kcpserver.SlotConfig{Unit: e.Unit, Slice: n.Slice(), Exec: p.KcpPath,
Root: p.SlotRoot(e.Slot), EtcdServers: p.KineURL(p.App.KineOf(e.Slot)), FrontURL: frontURL, Shape: p.shape(),
Wants: e.Wants})
spec.After = e.After
case table.KindCore:
if !p.App.DevCore {
return hostsvc.UnitSpec{}, errors.New("bootstrap: a production core is an installed unit of install's table, not a spec")
}
timeout := p.ReadyTimeout
timeout = opt.Positive(timeout, DefaultReadyTimeout)
spec = hostsvc.UnitSpec{Name: e.Unit, Description: "dev core of " + p.Owner,
Exec: []string{p.Exe, "internal", "dev-core", "--instance-dir", p.InstanceDir, "--ready-timeout", timeout.String()},
WorkDir: p.InstanceDir, Slice: n.CoreSlice(), Restart: hostsvc.RestartOnFailure, KillSignal: syscall.SIGTERM,
StopTimeout: CoreStopTimeout, After: e.After, Wants: e.Wants, Delegate: true, OOMPolicy: "continue"}
if password := os.Getenv("ATPROTO_PASSWORD"); password != "" {
spec.Env = append(spec.Env, "ATPROTO_PASSWORD="+password)
}
default:
return hostsvc.UnitSpec{}, fmt.Errorf("bootstrap: unknown kind %q", e.Kind)
}
if err != nil {
return hostsvc.UnitSpec{}, err
}
spec.Output = p.log(e.Role)
return spec, nil
}
func (c Config) CoreSpec(rec *devinstance.Record) (hostsvc.UnitSpec, error) {
if len(rec.StandIns) > 0 {
var units []string
for _, s := range rec.StandIns {
units = append(units, c.Layout.Names().StandIn(s.Role))
}
p := c.Params(table.Dev(c.Layout.Short, table.StoreSqlite))
return p.Spec(table.Entry{Kind: table.KindCore, Role: table.RoleCore, Unit: c.Layout.CoreUnit(), After: units, Wants: units}, "")
}
if rec.SharedKcp != "" {
p := c.Params(table.Dev(c.Layout.Short, table.StoreSqlite))
return p.Spec(table.Entry{Kind: table.KindCore, Role: table.RoleCore, Unit: c.Layout.CoreUnit()}, "")
}
app, err := c.App(rec)
if err != nil {
return hostsvc.UnitSpec{}, err
}
tbl, err := table.Table(app)
if err != nil {
return hostsvc.UnitSpec{}, err
}
return c.Params(app).Spec(tbl[len(tbl)-1], "")
}
func ProcSpecs(p Params, frontURL string) ([]hostsvc.UnitSpec, error) {
tbl, err := table.Table(p.App)
if err != nil {
return nil, err
}
var out []hostsvc.UnitSpec
for _, e := range tbl {
if e.Kind == table.KindCore && !p.App.DevCore {
continue
}
s, err := p.Spec(e, frontURL)
if err != nil {
return nil, err
}
out = append(out, s)
}
return out, nil
}
func Installed(p Params, frontURL string) ([]InstalledUnit, error) {
tbl, err := table.Table(p.App)
if err != nil {
return nil, err
}
var out []InstalledUnit
for _, e := range tbl {
if e.Kind == table.KindCore {
out = append(out, InstalledUnit{Entry: e, Unit: e.Unit, Path: filepath.Join(e.Unit+".d", DropInName),
File: hostsvc.InstalledFile{Unit: hostsvc.RenderDropIn(e.After, nil)}})
continue
}
pending := e.Kind == table.KindSlot && frontURL == ""
url := frontURL
if pending {
url = PendingFrontURL
}
spec, err := p.Spec(e, url)
if err != nil {
return nil, err
}
f, err := hostsvc.RenderInstalled(spec, hostsvc.InstallOptions{EnvFile: p.EnvFile(e.Unit)})
if err != nil {
return nil, err
}
if pending {
f.Env = nil
}
out = append(out, InstalledUnit{Entry: e, Unit: e.Unit, Path: e.Unit, Exec: spec.Exec[0], File: f})
}
return out, nil
}