Class: HeadlessBrowserTool::SessionManager

Inherits:
Object
  • Object
show all
Defined in:
lib/headless_browser_tool/session_manager.rb

Constant Summary collapse

SESSION_TIMEOUT =

30 minutes

30 * 60
CLEANUP_INTERVAL =

1 minute

60
MAX_SESSIONS =

Maximum concurrent sessions

10

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(headless: true) ⇒ SessionManager

Returns a new instance of SessionManager.



18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/headless_browser_tool/session_manager.rb', line 18

def initialize(headless: true)
  @sessions = {}
  @session_data = {}
  @mutex = Mutex.new
  @headless = headless

  # Enable Capybara threadsafe mode for per-session configuration
  Capybara.threadsafe = true

  # Use common sessions directory
  @sessions_dir = DirectorySetup::SESSIONS_DIR

  # Load existing session data
  load_persisted_sessions

  # Start cleanup thread
  start_cleanup_thread

  # Register shutdown hook
  at_exit { shutdown_all_sessions }
end

Instance Attribute Details

#sessions_dir ⇒ Object (readonly)

Returns the value of attribute sessions_dir.



16
17
18
 
# File 'lib/headless_browser_tool/session_manager.rb', line 16

def sessions_dir
  @sessions_dir
end

Instance Method Details

#close_session(session_id) ⇒ Object 



60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/headless_browser_tool/session_manager.rb', line 60

def close_session(session_id)
  @mutex.synchronize do
    if (session = @sessions.delete(session_id))
      begin
        save_session_state(session_id, session)
        session.quit
      rescue StandardError => e
        HeadlessBrowserTool::Logger.log.info "Error closing session #{session_id}: #{e.message}"
      end
    end
    @session_data.delete(session_id)
  end
end

#get_or_create_session(session_id) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/headless_browser_tool/session_manager.rb', line 40

def get_or_create_session(session_id)
  @mutex.synchronize do
    # Validate session_id
    raise ArgumentError, "Invalid session ID: #{session_id}" unless valid_session_id?(session_id)

    # Update last activity
    session_data = @session_data[session_id] ||= {
      created_at: Time.now,
      last_activity: Time.now
    }
    session_data[:last_activity] = Time.now

    # Check if we're at capacity
    cleanup_least_recently_used if !@sessions[session_id] && @sessions.size >= MAX_SESSIONS

    # Get or create the Capybara session
    @sessions[session_id] ||= create_session(session_id)
  end
end

#save_all_sessions ⇒ Object 



74
75
76
77
78
79
80
 
# File 'lib/headless_browser_tool/session_manager.rb', line 74

def save_all_sessions
  @mutex.synchronize do
    @sessions.each do |session_id, session|
      save_session_state(session_id, session)
    end
  end
end

#session_info ⇒ Object 



82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/headless_browser_tool/session_manager.rb', line 82

def session_info
  @mutex.synchronize do
    {
      active_sessions: @sessions.keys,
      session_count: @sessions.size,
      session_data: @session_data.transform_values do |data|
        {
          created_at: data[:created_at],
          last_activity: data[:last_activity],
          idle_time: Time.now - data[:last_activity]
        }
      end
    }
  end
end