142 lines
3.1 KiB
Go
142 lines
3.1 KiB
Go
package fs
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
|
|
"ollie/cmd/olliesrv/internal/bypass"
|
|
"ollie/cmd/olliesrv/internal/session"
|
|
)
|
|
|
|
func readSessionIdx() ([]byte, error) {
|
|
return session.BuildIndex(), nil
|
|
}
|
|
|
|
func readAgentIdx(sess *session.Session) ([]byte, error) {
|
|
return session.BuildAgentIndex(sess), nil
|
|
}
|
|
|
|
func requestSessionNew(data []byte) ([]byte, error) {
|
|
args := strings.Fields(string(data))
|
|
name := ""
|
|
remote := ""
|
|
for _, arg := range args {
|
|
if k, v, ok := strings.Cut(arg, "="); ok {
|
|
switch k {
|
|
case "name":
|
|
name = v
|
|
case "remote":
|
|
remote = v
|
|
}
|
|
}
|
|
}
|
|
sess, err := session.CreateEmpty(name, remote)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return []byte(sess.Name() + "\n"), nil
|
|
}
|
|
|
|
func readSessionEnv(s *SessionNode) ([]byte, error) {
|
|
var sb strings.Builder
|
|
fmt.Fprintf(&sb, "OLLIE_SESSION_ID=%s\n", s.ID)
|
|
for _, e := range os.Environ() {
|
|
if strings.HasPrefix(e, "OLLIE_") && !strings.HasPrefix(e, "OLLIE_SESSION_ID=") {
|
|
sb.WriteString(e)
|
|
sb.WriteByte('\n')
|
|
}
|
|
}
|
|
return []byte(sb.String()), nil
|
|
}
|
|
|
|
func readSessionPaused(s *SessionNode) ([]byte, error) {
|
|
if s.IsPaused() {
|
|
return []byte("true\n"), nil
|
|
}
|
|
return []byte("false\n"), nil
|
|
}
|
|
|
|
func readSessionConnected(s *SessionNode) ([]byte, error) {
|
|
if s.IsConnected() {
|
|
return []byte("true\n"), nil
|
|
}
|
|
return []byte("false\n"), nil
|
|
}
|
|
|
|
func sessionCtlHandler(s *SessionNode, removeFn func(), renameFn func(string) error) func([]byte) ([]byte, error) {
|
|
handlers := map[string]func([]string) ([]byte, error){
|
|
"kill": func(_ []string) ([]byte, error) {
|
|
removeFn()
|
|
return []byte("ok\n"), nil
|
|
},
|
|
".": func(_ []string) ([]byte, error) {
|
|
removeFn()
|
|
return []byte("ok\n"), nil
|
|
},
|
|
"save": func(_ []string) ([]byte, error) {
|
|
s.Save()
|
|
return []byte("ok\n"), nil
|
|
},
|
|
"invalidate": func(_ []string) ([]byte, error) {
|
|
s.InvalidateModelsCache()
|
|
return []byte("ok\n"), nil
|
|
},
|
|
"pause": func(_ []string) ([]byte, error) {
|
|
if err := s.Pause(); err != nil {
|
|
return nil, err
|
|
}
|
|
return []byte("ok\n"), nil
|
|
},
|
|
"resume": func(_ []string) ([]byte, error) {
|
|
if err := s.Resume(); err != nil {
|
|
return nil, err
|
|
}
|
|
return []byte("ok\n"), nil
|
|
},
|
|
}
|
|
return func(data []byte) ([]byte, error) {
|
|
return dispatch(handlers, data)
|
|
}
|
|
}
|
|
|
|
func readSessionName(s *SessionNode) ([]byte, error) {
|
|
return []byte(s.Name() + "\n"), nil
|
|
}
|
|
|
|
func writeSessionName(s *SessionNode, renameFn func(string) error, data []byte) error {
|
|
newName := strings.TrimSpace(string(data))
|
|
if newName == "" {
|
|
return nil
|
|
}
|
|
oldName := s.Name()
|
|
if newName != oldName {
|
|
return renameFn(newName)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func readSessionID(s *SessionNode) ([]byte, error) {
|
|
return []byte(s.ID + "\n"), nil
|
|
}
|
|
|
|
func readSessionBypass(b *bypass.Broker, s *SessionNode) ([]byte, error) {
|
|
if b == nil {
|
|
return nil, fmt.Errorf("bypass broker not available")
|
|
}
|
|
p := b.SessionPolicy(s.ID)
|
|
return p.Marshal()
|
|
}
|
|
|
|
func writeSessionBypass(b *bypass.Broker, s *SessionNode, data []byte) error {
|
|
if b == nil {
|
|
return fmt.Errorf("bypass broker not available")
|
|
}
|
|
var p bypass.Policy
|
|
if err := bypass.ParsePolicy(data, &p); err != nil {
|
|
return err
|
|
}
|
|
b.SetSessionPolicy(s.ID, p)
|
|
return nil
|
|
}
|