0
0
package devinstance
import (
"cmp"
"errors"
"fmt"
"os"
"path/filepath"
"sort"
"strconv"
"strings"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/fsx"
)
const Marker = ".swc-dev"
const (
EnvFile = "env"
EnvJSONFile = "env.json"
)
func DevRoot(stateRoot string) string { return filepath.Join(stateRoot, "dev") }
func LinkMarker(worktree, state string) error {
p := filepath.Join(worktree, Marker)
if cur, err := os.Readlink(p); err == nil {
if cur == state {
return nil
}
if err := os.Remove(p); err != nil {
return err
}
} else if _, err := os.Lstat(p); err == nil {
return fmt.Errorf("devinstance: %s exists and is not a symlink; refusing to replace it", p)
}
return os.Symlink(state, p)
}
func UnlinkMarker(worktree, state string) bool {
p := filepath.Join(worktree, Marker)
if cur, err := os.Readlink(p); err != nil || cur != state {
return false
}
return os.Remove(p) == nil
}
type Export struct {
Name string `json:"name"`
Value string `json:"value"`
}
func envWord(s string) string {
var b strings.Builder
for _, r := range strings.ToUpper(s) {
if (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') {
b.WriteRune(r)
continue
}
b.WriteByte('_')
}
return b.String()
}
func Exports(rec Record) []Export {
l := rec.Layout
socket := l.Socket
if rec.Parent != nil {
socket = rec.Parent.Socket
}
out := []Export{
{"SOCIALWEB_INSTANCE", l.ID},
{"SOCIALWEB_DEV_STATE_DIR", l.StateDir},
{"SOCIALWEB_DEVSUP_SOCKET", socket},
{"KUBECONFIG", rec.AdminKubeconfig},
{"SOCIALWEB_KCP_KUBECONFIG", rec.AdminKubeconfig},
{"SOCIALWEB_KCP_HOST", rec.KcpURL},
{"SOCIALWEB_KCP_ROOT", l.KcpRoot},
{"SOCIALWEB_KCP_BASE_WORKSPACE", rec.BaseWorkspace},
{"SOCIALWEB_KINE_URL", rec.KineURL},
{"SOCIALWEB_CLUSTERPROVIDER_UNIT_PREFIX", l.Names().HostProcessPrefix()},
{"SOCIALWEB_CLUSTERPROVIDER_HOSTPROCESS_WORKSPACE", rec.BaseWorkspace},
}
for _, u := range rec.Units {
if u.Port > 0 {
out = append(out, Export{"SOCIALWEB_DEV_PORT_" + envWord(u.Role), strconv.Itoa(u.Port)})
}
}
if rec.VM != nil {
ws := rec.BaseWorkspace
ws = cmp.Or(ws, "root")
host, _, _ := strings.Cut(strings.TrimSuffix(rec.KcpURL, "/"), "/clusters/")
out = append(out,
Export{"COMPUTE_PROVIDER_KCP", "true"},
Export{"KCP_SERVER", host},
Export{"KCP_WORKSPACE", ws},
Export{"COMPUTE_PROVIDER_KCP_HANDLE", rec.VM.Handle})
}
return out
}
func ShellExports(ex []Export) string {
var b strings.Builder
for _, e := range ex {
b.WriteString("export " + e.Name + "='" + strings.ReplaceAll(e.Value, "'", `'\''`) + "'\n")
}
return b.String()
}
func List(stateRoot string) ([]Record, error) {
entries, err := os.ReadDir(DevRoot(stateRoot))
if errors.Is(err, os.ErrNotExist) {
return []Record{}, nil
}
if err != nil {
return nil, err
}
out := []Record{}
for _, e := range entries {
if !e.IsDir() {
continue
}
var rec Record
if err := fsx.ReadJSON(filepath.Join(DevRoot(stateRoot), e.Name(), "instance.json"), &rec); err != nil {
continue
}
out = append(out, rec)
}
sort.Slice(out, func(i, j int) bool { return out[i].Layout.ID < out[j].Layout.ID })
return out, nil
}
type logName struct {
role string
unit string
file string
}
func logNames(l Layout) []logName {
return []logName{
{"pg", l.Names().Store(), filepath.Join(l.Logs, "pg.log")},
{"kine-a", l.KineUnit(), filepath.Join(l.Logs, "kine-a.log")},
{"front", l.FrontUnit(), filepath.Join(l.Logs, "front.log")},
{"kcp-a", l.KcpUnit(), filepath.Join(l.Logs, "kcp-a.log")},
{"kcp-b", l.SlotUnit("b"), filepath.Join(l.Logs, "kcp-b.log")},
{"core", l.CoreUnit(), filepath.Join(l.Logs, "core.log")},
{"devsup", "", filepath.Join(l.SupState, "devsup.log")},
}
}
func LogNames(l Layout) []string {
var out []string
for _, n := range logNames(l) {
out = append(out, n.role)
}
return out
}
func LogFile(l Layout, name string) (string, error) {
for _, n := range logNames(l) {
if name == n.role || (n.unit != "" && name == n.unit) {
return n.file, nil
}
}
return "", fmt.Errorf("devinstance: no unit %q in instance %s: want one of %s or its unit name", name, l.ID, strings.Join(LogNames(l), ", "))
}