Class: Async::Container::Controller
- Inherits:
-
Object
- Object
- Async::Container::Controller
- Defined in:
- lib/async/container/controller.rb
Overview
Manages the life-cycle of a container.
Constant Summary collapse
- SIGHUP =
Signal.list["HUP"]
- SIGINT =
Signal.list["INT"]
- SIGTERM =
Signal.list["TERM"]
- SIGUSR1 =
Signal.list["USR1"]
- SIGUSR2 =
Signal.list["USR2"]
Instance Attribute Summary collapse
-
#container ⇒ Object
readonly
Returns the value of attribute container.
Instance Method Summary collapse
- #create_container ⇒ Object
-
#initialize(notify: Notify.open!) ⇒ Controller
constructor
A new instance of Controller.
- #reload ⇒ Object
- #restart ⇒ Object
- #run ⇒ Object
- #running? ⇒ Boolean
- #setup(container) ⇒ Object
- #start ⇒ Object
- #state_string ⇒ Object
- #stop(graceful = true) ⇒ Object
- #to_s ⇒ Object
- #trap(signal, &block) ⇒ Object
- #wait ⇒ Object
Constructor Details
#initialize(notify: Notify.open!) ⇒ Controller
Returns a new instance of Controller.
46 47 48 49 50 51 52 53 54 55 56 |
# File 'lib/async/container/controller.rb', line 46 def initialize(notify: Notify.open!) @container = nil if @notify = notify @notify.status!("Initializing...") end @signals = {} trap(SIGHUP, &self.method(:restart)) end |
Instance Attribute Details
#container ⇒ Object (readonly)
Returns the value of attribute container.
74 75 76 |
# File 'lib/async/container/controller.rb', line 74 def container @container end |
Instance Method Details
#create_container ⇒ Object
76 77 78 |
# File 'lib/async/container/controller.rb', line 76 def create_container Container.new end |
#reload ⇒ Object
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 |
# File 'lib/async/container/controller.rb', line 145 def reload @notify&.reloading! Async.logger.info(self) {"Reloading container: #{@container}..."} begin self.setup(@container) rescue raise ContainerError, container end # Wait for all child processes to enter the ready state. Async.logger.debug(self, "Waiting for startup...") @container.wait_until_ready Async.logger.debug(self, "Finished startup.") if @container.failed? @notify.error!("Container failed!") raise ContainerError, @container else @notify&.ready! end end |
#restart ⇒ Object
102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 |
# File 'lib/async/container/controller.rb', line 102 def restart if @container @notify&.restarting! Async.logger.debug(self) {"Restarting container..."} else Async.logger.debug(self) {"Starting container..."} end container = self.create_container begin self.setup(container) rescue @notify&.error!($!.to_s) raise ContainerError, container end # Wait for all child processes to enter the ready state. Async.logger.debug(self, "Waiting for startup...") container.wait_until_ready Async.logger.debug(self, "Finished startup.") if container.failed? @notify&.error!($!.to_s) container.stop raise ContainerError, container end # Make this swap as atomic as possible: old_container = @container @container = container old_container&.stop @notify&.ready! rescue # If we are leaving this function with an exception, try to kill the container: container&.stop(false) end |
#run ⇒ Object
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 |
# File 'lib/async/container/controller.rb', line 170 def run # I thought this was the default... but it doesn't always raise an exception unless you do this explicitly. interrupt_action = Signal.trap(:INT) do raise Interrupt end terminate_action = Signal.trap(:TERM) do raise Terminate end self.start while @container&.running? begin @container.wait rescue SignalException => exception if handler = @signals[exception.signo] begin handler.call rescue ContainerError => failure Async.logger.error(self) {failure} end else raise end end end rescue Interrupt self.stop(true) rescue Terminate self.stop(false) else self.stop(true) ensure # Restore the interrupt handler: Signal.trap(:INT, interrupt_action) Signal.trap(:TERM, terminate_action) end |
#running? ⇒ Boolean
80 81 82 |
# File 'lib/async/container/controller.rb', line 80 def running? !!@container end |
#setup(container) ⇒ Object
88 89 90 91 |
# File 'lib/async/container/controller.rb', line 88 def setup(container) # Don't do this, otherwise calling super is risky for sub-classes: # raise NotImplementedError, "Container setup is must be implemented in derived class!" end |
#start ⇒ Object
93 94 95 |
# File 'lib/async/container/controller.rb', line 93 def start self.restart unless @container end |
#state_string ⇒ Object
58 59 60 61 62 63 64 |
# File 'lib/async/container/controller.rb', line 58 def state_string if running? "running" else "stopped" end end |
#stop(graceful = true) ⇒ Object
97 98 99 100 |
# File 'lib/async/container/controller.rb', line 97 def stop(graceful = true) @container&.stop(graceful) @container = nil end |
#to_s ⇒ Object
66 67 68 |
# File 'lib/async/container/controller.rb', line 66 def to_s "#{self.class} #{state_string}" end |
#trap(signal, &block) ⇒ Object
70 71 72 |
# File 'lib/async/container/controller.rb', line 70 def trap(signal, &block) @signals[signal] = block end |
#wait ⇒ Object
84 85 86 |
# File 'lib/async/container/controller.rb', line 84 def wait @container&.wait end |