0
0
package kcpserver
import (
"encoding/json"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"syscall"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/hostsvc"
)
type Shape string
const (
ShapeSingle Shape = "single"
ShapeBlueGreen Shape = "blue-green"
SlotA = "a"
SlotB = "b"
)
const FrontStopTimeout = 10 * time.Second
var SharedFiles = []string{"apiserver.crt", "apiserver.key", "sa.key", ".admin-token-store", "admin.kubeconfig"}
func SlotNames(s Shape) []string {
if s == ShapeBlueGreen {
return []string{SlotA, SlotB}
}
return []string{SlotA}
}
func Other(slot string) string {
if slot == SlotA {
return SlotB
}
return SlotA
}
type SlotRecord struct {
Unit string `json:"unit"`
Root string `json:"root"`
Port int `json:"port"`
PID int `json:"pid"`
InvocationID string `json:"invocationID"`
Exec string `json:"exec,omitempty"`
Kine string `json:"kine,omitempty"`
SHA256 string `json:"sha256,omitempty"`
Version string `json:"version,omitempty"`
StartedAt time.Time `json:"startedAt,omitzero"`
ReadyAt time.Time `json:"readyAt,omitzero"`
}
type FrontRecord struct {
Unit string `json:"unit"`
Address string `json:"address"`
Port int `json:"port"`
Control string `json:"control"`
PID int `json:"pid"`
}
func (f FrontRecord) URL() string {
return fmt.Sprintf("https://127.0.0.1:%d", f.Port)
}
type Slots struct {
Shape Shape `json:"shape"`
Active string `json:"active"`
Slots map[string]SlotRecord `json:"slots"`
Front FrontRecord `json:"front"`
KineURL string `json:"kineURL,omitempty"`
Updated time.Time `json:"updated"`
}
func ReadSlots(path string) (Slots, error) {
b, err := os.ReadFile(path)
if err != nil {
return Slots{}, err
}
var s Slots
if err := json.Unmarshal(b, &s); err != nil {
return Slots{}, fmt.Errorf("kcpserver: %s: %w", path, err)
}
if s.Slots == nil {
s.Slots = map[string]SlotRecord{}
}
return s, nil
}
func WriteSlots(path string, s Slots) error {
s.Updated = time.Now().UTC()
b, err := json.MarshalIndent(s, "", " ")
if err != nil {
return err
}
if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
return err
}
tmp := path + ".tmp"
f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o600)
if err != nil {
return err
}
if _, err := f.Write(append(b, '\n')); err != nil {
f.Close()
return err
}
if err := f.Sync(); err != nil {
f.Close()
return err
}
if err := f.Close(); err != nil {
return err
}
return os.Rename(tmp, path)
}
func copyFile(src, dst string) error {
in, err := os.Open(src)
if err != nil {
return err
}
defer in.Close()
tmp := dst + ".tmp"
out, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o600)
if err != nil {
return err
}
if _, err := io.Copy(out, in); err != nil {
out.Close()
return err
}
if err := out.Close(); err != nil {
return err
}
return os.Rename(tmp, dst)
}
func missingShared(dir string) []string {
var missing []string
for _, f := range SharedFiles {
if fi, err := os.Stat(filepath.Join(dir, f)); err != nil || fi.Size() == 0 {
missing = append(missing, f)
}
}
return missing
}
func HasShared(shared string) bool { return len(missingShared(shared)) == 0 }
func SaveShared(root, shared string) error {
if missing := missingShared(root); len(missing) > 0 {
return fmt.Errorf("kcpserver: slot root %s lacks %v; the shared material is all five files or none", root, missing)
}
if err := os.MkdirAll(shared, 0o700); err != nil {
return err
}
if err := os.Chmod(shared, 0o700); err != nil {
return err
}
for _, f := range SharedFiles {
if err := copyFile(filepath.Join(root, f), filepath.Join(shared, f)); err != nil {
return fmt.Errorf("kcpserver: saving %s: %w", f, err)
}
}
return nil
}
func SeedSlot(shared, root string) error {
if missing := missingShared(shared); len(missing) > 0 {
return fmt.Errorf("kcpserver: shared material %s lacks %v: a slot started without admin.kubeconfig next to .admin-token-store refuses to start, and one without the rest serves another CA", shared, missing)
}
if err := os.MkdirAll(root, 0o700); err != nil {
return err
}
for _, f := range SharedFiles {
if err := copyFile(filepath.Join(shared, f), filepath.Join(root, f)); err != nil {
return fmt.Errorf("kcpserver: seeding %s into %s: %w", f, root, err)
}
}
return nil
}
type FrontConfig struct {
Unit string
Slice string
Exe string
Owner string
Address string
Control string
State string
Log string
FDStore bool
}
const FrontMemoryMax = 256 << 20
func FrontSpec(c FrontConfig) (hostsvc.UnitSpec, error) {
if !filepath.IsAbs(c.Exe) {
return hostsvc.UnitSpec{}, fmt.Errorf("kcpserver: the front executable must be an absolute path, got %q", c.Exe)
}
if c.Owner == "" || c.Address == "" || c.Control == "" || c.State == "" {
return hostsvc.UnitSpec{}, errors.New("kcpserver: a front needs its owner, address, control socket and state file")
}
spec := hostsvc.UnitSpec{
Name: c.Unit,
Description: "L4 front of kcp for " + c.Owner,
Exec: []string{c.Exe, "internal", "apiserver-front", "--owner", c.Owner, "--kcp-front-address", c.Address,
"--front-control", c.Control, "--front-state", c.State},
WorkDir: filepath.Dir(c.State),
Slice: c.Slice,
Restart: hostsvc.RestartAlways,
KillSignal: syscall.SIGTERM,
StopTimeout: FrontStopTimeout,
Limits: hostsvc.Limits{MemoryMax: FrontMemoryMax},
}
if c.FDStore {
spec.Exec = append(spec.Exec, "--front-fd-store")
spec.FDStore = 1
}
if c.Log != "" {
spec.Output = hostsvc.Output{StdoutFile: c.Log, StderrFile: c.Log}
}
return spec, nil
}