browser.go 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619
  1. // Package cfbrowser provides scoped browser sessions for trusted agent hosts.
  2. package cfbrowser
  3. import (
  4. "context"
  5. "crypto/rand"
  6. "encoding/hex"
  7. "encoding/json"
  8. "errors"
  9. "os"
  10. "path/filepath"
  11. "sort"
  12. "sync"
  13. "time"
  14. "clusterflow.dev/cfbrowser/api"
  15. "clusterflow.dev/cfbrowser/internal/dom"
  16. "clusterflow.dev/cfbrowser/policy"
  17. )
  18. type Config struct {
  19. DataDir string
  20. Executable string
  21. Headed bool
  22. // NoSandbox is an explicit escape hatch for isolated CI containers only.
  23. NoSandbox bool
  24. MaxSessions int
  25. MaxPages int
  26. MaxResultBytes int
  27. MaxDownloadBytes int64
  28. Timeout time.Duration
  29. Policy policy.URLPolicy
  30. }
  31. func (c Config) normalized() (Config, error) {
  32. if c.MaxSessions == 0 {
  33. c.MaxSessions = 2
  34. }
  35. if c.MaxPages == 0 {
  36. c.MaxPages = 3
  37. }
  38. if c.MaxResultBytes == 0 {
  39. c.MaxResultBytes = 64 * 1024
  40. }
  41. if c.MaxDownloadBytes == 0 {
  42. c.MaxDownloadBytes = 100 * 1024 * 1024
  43. }
  44. if c.Timeout == 0 {
  45. c.Timeout = 30 * time.Second
  46. }
  47. if c.MaxSessions < 1 || c.MaxSessions > 32 || c.MaxPages < 1 || c.MaxPages > 16 || c.MaxResultBytes < 1024 || c.MaxResultBytes > 256*1024 || c.MaxDownloadBytes < 1 || c.MaxDownloadBytes > 2<<30 || c.Timeout < time.Millisecond || c.Timeout > 5*time.Minute {
  48. return c, api.Err("BROWSER_INVALID_CONFIG", "invalid resource limits")
  49. }
  50. return c, nil
  51. }
  52. type Manager struct {
  53. mu sync.Mutex
  54. cfg Config
  55. driver api.Driver
  56. sessions map[string]*session
  57. opening int
  58. closed bool
  59. ctx context.Context
  60. cancel context.CancelFunc
  61. root string
  62. removeRoot bool
  63. }
  64. type session struct {
  65. mu sync.Mutex
  66. info api.SessionInfo
  67. engine api.EngineSession
  68. pages map[string]*page
  69. files map[string]storedFile
  70. imported map[string]bool
  71. downloadDir string
  72. closed bool
  73. }
  74. type page struct {
  75. gate chan struct{}
  76. engine api.EnginePage
  77. id string
  78. snapshot string
  79. refs map[string]bool
  80. closed bool
  81. }
  82. func newID(prefix string) string {
  83. var b [16]byte
  84. if _, e := rand.Read(b[:]); e != nil {
  85. panic(e)
  86. }
  87. return prefix + hex.EncodeToString(b[:])
  88. }
  89. func New(cfg Config, driver api.Driver) (*Manager, error) {
  90. if driver == nil {
  91. return nil, api.Err("BROWSER_INVALID_CONFIG", "driver is required")
  92. }
  93. cfg, err := cfg.normalized()
  94. if err != nil {
  95. return nil, err
  96. }
  97. root := cfg.DataDir
  98. temporary := false
  99. if root == "" {
  100. root, err = os.MkdirTemp("", "cfbrowser-")
  101. temporary = true
  102. } else {
  103. err = os.MkdirAll(root, 0700)
  104. }
  105. if err != nil {
  106. return nil, err
  107. }
  108. root, err = filepath.Abs(root)
  109. if err != nil {
  110. return nil, err
  111. }
  112. // Every manager gets a private instance directory, even with a shared data base.
  113. instance, err := os.MkdirTemp(root, "instance-")
  114. if err != nil {
  115. return nil, err
  116. }
  117. ctx, cancel := context.WithCancel(context.Background())
  118. return &Manager{cfg: cfg, driver: driver, sessions: map[string]*session{}, ctx: ctx, cancel: cancel, root: instance, removeRoot: temporary}, nil
  119. }
  120. func (m *Manager) Capabilities(ctx context.Context) (api.Capabilities, error) {
  121. return m.driver.Probe(ctx)
  122. }
  123. func (m *Manager) operation(ctx context.Context) (context.Context, context.CancelFunc) {
  124. ctx, cancel := context.WithTimeout(ctx, m.cfg.Timeout)
  125. stop := context.AfterFunc(m.ctx, cancel)
  126. return ctx, func() { stop(); cancel() }
  127. }
  128. func (m *Manager) CreateSession(ctx context.Context, owner api.Owner) (api.SessionInfo, error) {
  129. if !owner.Valid() {
  130. return api.SessionInfo{}, api.Err("BROWSER_INVALID_OWNER", "environment, thread and run are required")
  131. }
  132. m.mu.Lock()
  133. if m.closed {
  134. m.mu.Unlock()
  135. return api.SessionInfo{}, api.Err("BROWSER_CLOSED", "manager is closed")
  136. }
  137. if len(m.sessions)+m.opening >= m.cfg.MaxSessions {
  138. m.mu.Unlock()
  139. return api.SessionInfo{}, api.Err("BROWSER_LIMIT", "session quota reached")
  140. }
  141. m.opening++
  142. m.mu.Unlock()
  143. defer func() { m.mu.Lock(); m.opening--; m.mu.Unlock() }()
  144. id := newID("bs-")
  145. dir := filepath.Join(m.root, id)
  146. if err := os.Mkdir(dir, 0700); err != nil {
  147. return api.SessionInfo{}, err
  148. }
  149. ctx, cancel := m.operation(ctx)
  150. defer cancel()
  151. engine, err := m.driver.Open(ctx, api.EngineOptions{Headless: !m.cfg.Headed, Executable: m.cfg.Executable, NoSandbox: m.cfg.NoSandbox, DownloadDir: dir, ViewportWidth: 1280, ViewportHeight: 800, MaxDownloadBytes: m.cfg.MaxDownloadBytes})
  152. if err != nil {
  153. _ = os.RemoveAll(dir)
  154. return api.SessionInfo{}, err
  155. }
  156. caps, err := m.driver.Probe(ctx)
  157. if err != nil {
  158. _ = engine.Close()
  159. _ = os.RemoveAll(dir)
  160. return api.SessionInfo{}, err
  161. }
  162. info := api.SessionInfo{ID: id, Owner: owner, Engine: caps.Engine, Pages: []string{}, Created: time.Now().UTC()}
  163. s := &session{info: info, engine: engine, pages: map[string]*page{}, files: map[string]storedFile{}, imported: map[string]bool{}, downloadDir: dir}
  164. m.mu.Lock()
  165. defer m.mu.Unlock()
  166. if m.closed || ctx.Err() != nil {
  167. _ = engine.Close()
  168. _ = os.RemoveAll(dir)
  169. return api.SessionInfo{}, api.Err("BROWSER_CLOSED", "session creation was canceled")
  170. }
  171. m.sessions[id] = s
  172. return info, nil
  173. }
  174. func (m *Manager) owned(owner api.Owner, id string) (*session, error) {
  175. m.mu.Lock()
  176. defer m.mu.Unlock()
  177. s := m.sessions[id]
  178. if m.closed {
  179. return nil, api.Err("BROWSER_CLOSED", "manager is closed")
  180. }
  181. if s == nil || !owner.Valid() || s.info.Owner != owner {
  182. return nil, api.Err("BROWSER_SCOPE_MISMATCH", "session is not owned by this run")
  183. }
  184. return s, nil
  185. }
  186. func (m *Manager) Sessions(owner api.Owner) []api.SessionInfo {
  187. m.mu.Lock()
  188. defer m.mu.Unlock()
  189. out := []api.SessionInfo{}
  190. for _, s := range m.sessions {
  191. if s.info.Owner == owner {
  192. s.mu.Lock()
  193. v := s.info
  194. v.Pages = make([]string, 0, len(s.pages))
  195. for id := range s.pages {
  196. v.Pages = append(v.Pages, id)
  197. }
  198. sort.Strings(v.Pages)
  199. s.mu.Unlock()
  200. out = append(out, v)
  201. }
  202. }
  203. sort.Slice(out, func(i, j int) bool { return out[i].ID < out[j].ID })
  204. return out
  205. }
  206. func (m *Manager) NewPage(ctx context.Context, owner api.Owner, id string) (api.PageInfo, error) {
  207. s, err := m.owned(owner, id)
  208. if err != nil {
  209. return api.PageInfo{}, err
  210. }
  211. s.mu.Lock()
  212. defer s.mu.Unlock()
  213. if s.closed {
  214. return api.PageInfo{}, api.Err("BROWSER_CLOSED", "session is closed")
  215. }
  216. if len(s.pages) >= m.cfg.MaxPages {
  217. return api.PageInfo{}, api.Err("BROWSER_LIMIT", "page quota reached")
  218. }
  219. ctx, cancel := m.operation(ctx)
  220. defer cancel()
  221. p, err := s.engine.NewPage(ctx)
  222. if err != nil {
  223. return api.PageInfo{}, err
  224. }
  225. pid := newID("pg-")
  226. s.pages[pid] = &page{id: pid, engine: p, gate: make(chan struct{}, 1)}
  227. return api.PageInfo{SessionID: id, PageID: pid}, nil
  228. }
  229. func (m *Manager) lockedPage(ctx context.Context, owner api.Owner, sid, pid string) (*page, func(), error) {
  230. s, err := m.owned(owner, sid)
  231. if err != nil {
  232. return nil, nil, err
  233. }
  234. s.mu.Lock()
  235. p := s.pages[pid]
  236. closed := s.closed
  237. s.mu.Unlock()
  238. if p == nil || closed {
  239. return nil, nil, api.Err("BROWSER_PAGE_NOT_FOUND", "page is unavailable")
  240. }
  241. select {
  242. case p.gate <- struct{}{}:
  243. case <-ctx.Done():
  244. return nil, nil, ctx.Err()
  245. case <-m.ctx.Done():
  246. return nil, nil, api.Err("BROWSER_CLOSED", "manager is closed")
  247. }
  248. unlock := func() { <-p.gate }
  249. if p.closed {
  250. unlock()
  251. return nil, nil, api.Err("BROWSER_CLOSED", "page is closed")
  252. }
  253. return p, unlock, nil
  254. }
  255. func (m *Manager) Navigate(ctx context.Context, o api.Owner, sid, pid, url, op string) (api.PageInfo, error) {
  256. ctx, cancel := m.operation(ctx)
  257. defer cancel()
  258. if op == "" {
  259. op = "goto"
  260. }
  261. if op != "goto" && op != "back" && op != "forward" && op != "reload" {
  262. return api.PageInfo{}, api.Err("BROWSER_INVALID_ARGUMENT", "invalid navigation operation")
  263. }
  264. if op == "goto" {
  265. var err error
  266. url, err = m.cfg.Policy.Validate(ctx, url)
  267. if err != nil {
  268. return api.PageInfo{}, err
  269. }
  270. }
  271. p, unlock, err := m.lockedPage(ctx, o, sid, pid)
  272. if err != nil {
  273. return api.PageInfo{}, err
  274. }
  275. defer unlock()
  276. p.snapshot = ""
  277. p.refs = nil
  278. result, err := p.engine.Navigate(ctx, url, op)
  279. return api.PageInfo{SessionID: sid, PageID: pid, URL: result}, err
  280. }
  281. func decode(raw json.RawMessage, out any) error {
  282. var status struct {
  283. Error string `json:"error"`
  284. }
  285. if err := json.Unmarshal(raw, &status); err == nil && status.Error != "" {
  286. return api.Err(status.Error, "page operation could not be completed")
  287. }
  288. if len(raw) > 512*1024 {
  289. return api.Err("BROWSER_RESULT_LIMIT", "engine result exceeds 512 KiB")
  290. }
  291. return json.Unmarshal(raw, out)
  292. }
  293. func evaluate(ctx context.Context, p *page, op string, args any, out any) error {
  294. raw, err := p.engine.Evaluate(ctx, dom.Script(op, args))
  295. if err != nil {
  296. return err
  297. }
  298. return decode(raw, out)
  299. }
  300. func (m *Manager) Snapshot(ctx context.Context, o api.Owner, sid, pid string, r api.SnapshotRequest) (api.Snapshot, error) {
  301. if r.Mode == "" {
  302. r.Mode = "compact"
  303. }
  304. if r.Mode != "compact" && r.Mode != "interactive" {
  305. return api.Snapshot{}, api.Err("BROWSER_INVALID_ARGUMENT", "mode must be compact or interactive")
  306. }
  307. limit := m.budget(r.MaxBytes)
  308. if limit < 1024 {
  309. return api.Snapshot{}, api.Err("BROWSER_INVALID_ARGUMENT", "snapshot budget must be at least 1024 bytes")
  310. }
  311. if r.MaxElements == 0 {
  312. r.MaxElements = 150
  313. }
  314. if r.MaxElements < 1 || r.MaxElements > 150 {
  315. return api.Snapshot{}, api.Err("BROWSER_INVALID_ARGUMENT", "maxElements must be 1..150")
  316. }
  317. ctx, cancel := m.operation(ctx)
  318. defer cancel()
  319. p, unlock, err := m.lockedPage(ctx, o, sid, pid)
  320. if err != nil {
  321. return api.Snapshot{}, err
  322. }
  323. defer unlock()
  324. id := newID("sn-")
  325. var result api.Snapshot
  326. err = evaluate(ctx, p, "snapshot", map[string]any{"id": id, "mode": r.Mode, "maxElements": r.MaxElements, "textLimit": limit / 4}, &result)
  327. if err != nil {
  328. return result, err
  329. }
  330. result.PageID = pid
  331. if result.SnapshotID != id {
  332. return api.Snapshot{}, api.Err("BROWSER_INVALID_RESULT", "snapshot ID mismatch")
  333. }
  334. if err = fitSnapshot(&result, limit); err != nil {
  335. return result, err
  336. }
  337. p.snapshot = id
  338. p.refs = map[string]bool{}
  339. for _, e := range result.Elements {
  340. p.refs[e.Ref] = true
  341. }
  342. return result, nil
  343. }
  344. func (m *Manager) budget(n int) int {
  345. if n <= 0 || n > m.cfg.MaxResultBytes {
  346. return m.cfg.MaxResultBytes
  347. }
  348. return n
  349. }
  350. func fitSnapshot(s *api.Snapshot, limit int) error {
  351. for {
  352. b, err := json.Marshal(s)
  353. if err != nil {
  354. return err
  355. }
  356. if len(b) <= limit {
  357. return nil
  358. }
  359. s.Truncated = true
  360. if len(s.Text) > 0 {
  361. s.Text = truncate(s.Text, len(s.Text)/2)
  362. continue
  363. }
  364. if len(s.Elements) > 0 {
  365. s.Elements = s.Elements[:len(s.Elements)-1]
  366. continue
  367. }
  368. if len(s.Title) > 64 {
  369. s.Title = truncate(s.Title, 64)
  370. continue
  371. }
  372. if len(s.URL) > 128 {
  373. s.URL = truncate(s.URL, 128)
  374. continue
  375. }
  376. return api.Err("BROWSER_RESULT_LIMIT", "budget cannot hold snapshot metadata")
  377. }
  378. }
  379. func truncate(s string, n int) string {
  380. if n >= len(s) {
  381. return s
  382. }
  383. if n < 0 {
  384. n = 0
  385. }
  386. for n > 0 && n < len(s) && s[n]&0xc0 == 0x80 {
  387. n--
  388. }
  389. return s[:n]
  390. }
  391. func (m *Manager) Act(ctx context.Context, o api.Owner, sid, pid string, r api.ActionRequest) (api.ActionResult, error) {
  392. if err := api.ValidateAction(r); err != nil {
  393. return api.ActionResult{Effect: "not_dispatched"}, err
  394. }
  395. ctx, cancel := m.operation(ctx)
  396. defer cancel()
  397. p, unlock, err := m.lockedPage(ctx, o, sid, pid)
  398. if err != nil {
  399. return api.ActionResult{}, err
  400. }
  401. defer unlock()
  402. if p.snapshot != r.SnapshotID || !p.refs[r.Ref] {
  403. return api.ActionResult{Effect: "not_dispatched"}, api.Err("BROWSER_STALE_REF", "take a new snapshot")
  404. }
  405. var target struct {
  406. X, Y float64
  407. Value, Tag, Type string
  408. Checked bool
  409. ReadOnly bool
  410. }
  411. if err = evaluate(ctx, p, "prepare", r, &target); err != nil {
  412. return api.ActionResult{Effect: "not_dispatched"}, err
  413. }
  414. caps, err := m.driver.Probe(ctx)
  415. if err != nil {
  416. return api.ActionResult{}, err
  417. }
  418. trusted := caps.Supports("trustedInput")
  419. kind := "synthetic"
  420. dispatched := false
  421. if trusted && (r.Action == "click" || r.Action == "hover" || r.Action == "type" || r.Action == "press" || r.Action == "fill") {
  422. kind = "browser"
  423. value := r.Value
  424. action := r.Action
  425. if action == "fill" && (target.Tag != "INPUT" && target.Tag != "TEXTAREA" || target.Type == "file" || target.ReadOnly) {
  426. return api.ActionResult{Effect: "not_dispatched"}, api.Err("BROWSER_TARGET_NOT_ACTIONABLE", "fill requires a text input")
  427. }
  428. dispatched = true
  429. err = p.engine.Input(ctx, action, value, target.X, target.Y)
  430. } else {
  431. var result map[string]any
  432. dispatched = true
  433. err = evaluate(ctx, p, "mutation", r, &result)
  434. }
  435. if err != nil {
  436. var typed *api.Error
  437. if errors.As(err, &typed) && (typed.Code == "BROWSER_STALE_REF" || typed.Code == "BROWSER_TARGET_NOT_ACTIONABLE" || typed.Code == "BROWSER_INVALID_ARGUMENT" || typed.Code == "BROWSER_CAPABILITY_UNSUPPORTED") {
  438. return api.ActionResult{Effect: "not_dispatched", InputKind: kind}, err
  439. }
  440. if dispatched {
  441. return api.ActionResult{Effect: "unknown", InputKind: kind}, &api.Error{Code: "BROWSER_ACTION_OUTCOME_UNKNOWN", Message: "observe the page before retrying", Effect: "unknown"}
  442. }
  443. }
  444. return api.ActionResult{Effect: "dispatched", InputKind: kind}, err
  445. }
  446. func (m *Manager) Read(ctx context.Context, o api.Owner, sid, pid string, r api.ReadRequest) (api.ReadResult, error) {
  447. if r.Mode == "" {
  448. r.Mode = "text"
  449. }
  450. if r.Mode != "text" && r.Mode != "table" {
  451. return api.ReadResult{}, api.Err("BROWSER_INVALID_ARGUMENT", "read mode must be text or table")
  452. }
  453. limit := m.budget(r.MaxBytes)
  454. if limit < 256 {
  455. return api.ReadResult{}, api.Err("BROWSER_INVALID_ARGUMENT", "read budget must be at least 256 bytes")
  456. }
  457. ctx, cancel := m.operation(ctx)
  458. defer cancel()
  459. p, unlock, err := m.lockedPage(ctx, o, sid, pid)
  460. if err != nil {
  461. return api.ReadResult{}, err
  462. }
  463. defer unlock()
  464. if r.Ref != "" && (p.snapshot != r.SnapshotID || !p.refs[r.Ref]) {
  465. return api.ReadResult{}, api.Err("BROWSER_STALE_REF", "take a new snapshot")
  466. }
  467. var result api.ReadResult
  468. err = evaluate(ctx, p, "read", map[string]any{"snapshotId": r.SnapshotID, "ref": r.Ref, "mode": r.Mode, "limit": limit / 4}, &result)
  469. if err != nil {
  470. return result, err
  471. }
  472. for {
  473. b, _ := json.Marshal(result)
  474. if len(b) <= limit {
  475. break
  476. }
  477. result.Truncated = true
  478. if len(result.Text) > 0 {
  479. result.Text = truncate(result.Text, len(result.Text)/2)
  480. } else if len(result.Rows) > 0 {
  481. result.Rows = result.Rows[:len(result.Rows)-1]
  482. } else if len(result.URL) > 64 {
  483. result.URL = truncate(result.URL, 64)
  484. } else {
  485. return result, api.Err("BROWSER_RESULT_LIMIT", "read metadata exceeds budget")
  486. }
  487. }
  488. return result, nil
  489. }
  490. func (m *Manager) Wait(ctx context.Context, o api.Owner, sid, pid string, r api.WaitRequest) error {
  491. if r.Kind != "ready" && r.Kind != "url" && r.Kind != "text" && r.Kind != "textGone" {
  492. return api.Err("BROWSER_INVALID_ARGUMENT", "unsupported wait condition")
  493. }
  494. if len(r.Value) > 8192 || r.TimeoutMS < 0 || r.TimeoutMS > 300000 {
  495. return api.Err("BROWSER_INVALID_ARGUMENT", "invalid wait value or timeout")
  496. }
  497. ctx, cancel := m.operation(ctx)
  498. defer cancel()
  499. if r.TimeoutMS > 0 {
  500. var stop context.CancelFunc
  501. ctx, stop = context.WithTimeout(ctx, time.Duration(r.TimeoutMS)*time.Millisecond)
  502. defer stop()
  503. }
  504. p, unlock, err := m.lockedPage(ctx, o, sid, pid)
  505. if err != nil {
  506. return err
  507. }
  508. defer unlock()
  509. ticker := time.NewTicker(50 * time.Millisecond)
  510. defer ticker.Stop()
  511. for {
  512. var ok bool
  513. raw, e := p.engine.Evaluate(ctx, dom.Script("wait", r))
  514. if e != nil {
  515. return e
  516. }
  517. if e = json.Unmarshal(raw, &ok); e != nil {
  518. return e
  519. }
  520. if ok {
  521. return nil
  522. }
  523. select {
  524. case <-ctx.Done():
  525. return ctx.Err()
  526. case <-ticker.C:
  527. }
  528. }
  529. }
  530. func (m *Manager) CloseSession(o api.Owner, id string) error {
  531. s, err := m.owned(o, id)
  532. if err != nil {
  533. return err
  534. }
  535. m.mu.Lock()
  536. delete(m.sessions, id)
  537. m.mu.Unlock()
  538. return errors.Join(s.close(), os.RemoveAll(s.downloadDir))
  539. }
  540. func (m *Manager) ClosePage(ctx context.Context, o api.Owner, sid, pid string) error {
  541. ctx, cancel := m.operation(ctx)
  542. defer cancel()
  543. p, unlock, err := m.lockedPage(ctx, o, sid, pid)
  544. if err != nil {
  545. return err
  546. }
  547. defer unlock()
  548. s, err := m.owned(o, sid)
  549. if err != nil {
  550. return err
  551. }
  552. s.mu.Lock()
  553. delete(s.pages, pid)
  554. s.mu.Unlock()
  555. p.closed = true
  556. p.refs = nil
  557. p.snapshot = ""
  558. return p.engine.Close()
  559. }
  560. func (s *session) close() error {
  561. s.mu.Lock()
  562. defer s.mu.Unlock()
  563. if s.closed {
  564. return nil
  565. }
  566. s.closed = true
  567. return s.engine.Close()
  568. }
  569. func (m *Manager) Close() error {
  570. m.mu.Lock()
  571. if m.closed {
  572. m.mu.Unlock()
  573. return nil
  574. }
  575. m.closed = true
  576. m.cancel()
  577. sessions := m.sessions
  578. m.sessions = map[string]*session{}
  579. m.mu.Unlock()
  580. var result error
  581. for _, s := range sessions {
  582. result = errors.Join(result, s.close())
  583. }
  584. result = errors.Join(result, os.RemoveAll(m.root))
  585. if m.removeRoot {
  586. result = errors.Join(result, os.Remove(filepath.Dir(m.root)))
  587. }
  588. return result
  589. }