123 lines
3.2 KiB
Go
123 lines
3.2 KiB
Go
package session
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"sync"
|
|
"syscall"
|
|
"time"
|
|
|
|
"ollie/pkg/tools/execute"
|
|
)
|
|
|
|
// mountState holds the per-session mount process state.
|
|
type mountState struct {
|
|
mu sync.RWMutex
|
|
proc *os.Process
|
|
path string
|
|
envExtra map[string]string // reference to Server's envExtra for OLLIE_UNAME lookup
|
|
}
|
|
|
|
// MountPathFor returns the per-session FUSE mount path for a given uname.
|
|
func MountPathFor(uname string) string {
|
|
return filepath.Join(os.TempDir(), "ollie-mount-"+uname)
|
|
}
|
|
|
|
// WithMount9P returns an execute.Option that enables per-session 9P FUSE mounts.
|
|
// It wires up hooks to start, check, and tear down the mount lifecycle.
|
|
func WithMount9P() execute.Option {
|
|
state := &mountState{envExtra: make(map[string]string)}
|
|
|
|
return func(s *execute.Server) {
|
|
// Hook: OnEnvSet - start mount when OLLIE_UNAME is set
|
|
s.OnEnvSet = func(key, value string) {
|
|
state.mu.Lock()
|
|
state.envExtra[key] = value
|
|
if key == "OLLIE_UNAME" && value != "" {
|
|
startMount(state, value)
|
|
}
|
|
state.mu.Unlock()
|
|
}
|
|
|
|
// Hook: OnPreDispatch - check mount health before each dispatch
|
|
s.OnPreDispatch = func() {
|
|
remountIfStale(state)
|
|
}
|
|
|
|
// Hook: OnClose - tear down mount on session end
|
|
s.OnClose = func() {
|
|
teardownMount(state)
|
|
}
|
|
}
|
|
}
|
|
|
|
// startMount launches ollie-9p-mount for this session.
|
|
func startMount(state *mountState, uname string) {
|
|
bin, err := exec.LookPath("ollie-9p-mount")
|
|
if err != nil {
|
|
return
|
|
}
|
|
mnt := MountPathFor(uname)
|
|
os.MkdirAll(mnt, 0755) //nolint:errcheck
|
|
cmd := exec.Command(bin, "-u", uname, mnt)
|
|
cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
|
|
if err := cmd.Start(); err != nil {
|
|
return
|
|
}
|
|
// Reap in background so Wait works later.
|
|
go cmd.Wait() //nolint:errcheck
|
|
// Wait for mount to be ready.
|
|
for i := 0; i < 20; i++ {
|
|
time.Sleep(50 * time.Millisecond)
|
|
if _, err := os.Stat(filepath.Join(mnt, "s")); err == nil {
|
|
break
|
|
}
|
|
}
|
|
state.proc = cmd.Process
|
|
state.path = mnt
|
|
state.envExtra["OLLIE"] = mnt
|
|
}
|
|
|
|
// remountIfStale checks the per-session FUSE mount health and re-establishes it if broken.
|
|
func remountIfStale(state *mountState) {
|
|
state.mu.RLock()
|
|
mnt := state.path
|
|
proc := state.proc
|
|
state.mu.RUnlock()
|
|
if mnt == "" || proc == nil {
|
|
return
|
|
}
|
|
if _, err := os.Stat(filepath.Join(mnt, "s")); err == nil {
|
|
return
|
|
}
|
|
// Mount is stale — tear down and restart.
|
|
state.mu.Lock()
|
|
defer state.mu.Unlock()
|
|
exec.Command("fusermount", "-u", state.path).Run() //nolint:errcheck
|
|
syscall.Kill(state.proc.Pid, syscall.SIGKILL) //nolint:errcheck
|
|
state.proc = nil
|
|
state.path = ""
|
|
if uname := state.envExtra["OLLIE_UNAME"]; uname != "" {
|
|
startMount(state, uname)
|
|
}
|
|
}
|
|
|
|
// teardownMount tears down the per-session FUSE mount.
|
|
func teardownMount(state *mountState) {
|
|
state.mu.Lock()
|
|
proc := state.proc
|
|
mnt := state.path
|
|
state.proc = nil
|
|
state.path = ""
|
|
state.mu.Unlock()
|
|
if proc != nil {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
|
exec.CommandContext(ctx, "fusermount", "-u", mnt).Run() //nolint:errcheck
|
|
cancel()
|
|
syscall.Kill(proc.Pid, syscall.SIGKILL) //nolint:errcheck
|
|
os.Remove(mnt) //nolint:errcheck
|
|
}
|
|
}
|