Class: Shell::ProcessController
- Inherits:
-
Object
- Object
- Shell::ProcessController
- Extended by:
- Forwardable
- Defined in:
- lib/shell/process-controller.rb
Constant Summary collapse
- USING_AT_EXIT_WHEN_PROCESS_EXIT =
for shell-command complete finish at this process exit.
true
Instance Attribute Summary collapse
-
#shell ⇒ Object
readonly
Returns the value of attribute shell.
Class Method Summary collapse
- .activate(pc) ⇒ Object
- .active_process_controllers ⇒ Object
- .block_output_synchronize(&b) ⇒ Object
- .each_active_object ⇒ Object
- .inactivate(pc) ⇒ Object
- .wait_to_finish_all_process_controllers ⇒ Object
Instance Method Summary collapse
- #active_job?(job) ⇒ Boolean
- #active_jobs ⇒ Object
- #active_jobs_exist? ⇒ Boolean
-
#add_schedule(command) ⇒ Object
schedule a command.
-
#initialize(shell) ⇒ ProcessController
constructor
A new instance of ProcessController.
- #jobs ⇒ Object
- #jobs_exist? ⇒ Boolean
-
#kill_job(sig, command) ⇒ Object
kill a job.
-
#sfork(command) ⇒ Object
simple fork.
-
#start_job(command = nil) ⇒ Object
start a job.
-
#terminate_job(command) ⇒ Object
terminate a job.
-
#wait_all_jobs_execution ⇒ Object
wait for all jobs to terminate.
- #waiting_job?(job) ⇒ Boolean
- #waiting_jobs ⇒ Object
- #waiting_jobs_exist? ⇒ Boolean
Constructor Details
#initialize(shell) ⇒ ProcessController
Returns a new instance of ProcessController.
92 93 94 95 96 97 98 99 100 |
# File 'lib/shell/process-controller.rb', line 92 def initialize(shell) @shell = shell @waiting_jobs = [] @active_jobs = [] @jobs_sync = Sync.new @job_monitor = Thread::Mutex.new @job_condition = Thread::ConditionVariable.new end |
Instance Attribute Details
#shell ⇒ Object (readonly)
Returns the value of attribute shell.
102 103 104 |
# File 'lib/shell/process-controller.rb', line 102 def shell @shell end |
Class Method Details
.activate(pc) ⇒ Object
37 38 39 40 41 42 |
# File 'lib/shell/process-controller.rb', line 37 def activate(pc) process_controllers_exclusive do @ProcessControllers[pc] ||= 0 @ProcessControllers[pc] += 1 end end |
.active_process_controllers ⇒ Object
31 32 33 34 35 |
# File 'lib/shell/process-controller.rb', line 31 def active_process_controllers process_controllers_exclusive do @ProcessControllers.dup end end |
.block_output_synchronize(&b) ⇒ Object
63 64 65 |
# File 'lib/shell/process-controller.rb', line 63 def block_output_synchronize(&b) @BlockOutputMonitor.synchronize(&b) end |
.each_active_object ⇒ Object
55 56 57 58 59 60 61 |
# File 'lib/shell/process-controller.rb', line 55 def each_active_object process_controllers_exclusive do for ref in @ProcessControllers.keys yield ref end end end |
.inactivate(pc) ⇒ Object
44 45 46 47 48 49 50 51 52 53 |
# File 'lib/shell/process-controller.rb', line 44 def inactivate(pc) process_controllers_exclusive do if @ProcessControllers[pc] if (@ProcessControllers[pc] -= 1) == 0 @ProcessControllers.delete(pc) @ProcessControllersCV.signal end end end end |
.wait_to_finish_all_process_controllers ⇒ Object
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 |
# File 'lib/shell/process-controller.rb', line 67 def wait_to_finish_all_process_controllers process_controllers_exclusive do while !@ProcessControllers.empty? Shell::notify("Process finishing, but active shell exists", "You can use Shell#transact or Shell#check_point for more safe execution.") if Shell.debug? for pc in @ProcessControllers.keys Shell::notify(" Not finished jobs in "+pc.shell.to_s) for com in pc.jobs com.notify(" Jobs: %id") end end end @ProcessControllersCV.wait(@ProcessControllersMonitor) end end end |
Instance Method Details
#active_job?(job) ⇒ Boolean
178 179 180 181 182 |
# File 'lib/shell/process-controller.rb', line 178 def active_job?(job) @jobs_sync.synchronize(:SH) do @active_jobs.include?(job) end end |
#active_jobs ⇒ Object
113 114 115 |
# File 'lib/shell/process-controller.rb', line 113 def active_jobs @active_jobs end |
#active_jobs_exist? ⇒ Boolean
127 128 129 130 131 |
# File 'lib/shell/process-controller.rb', line 127 def active_jobs_exist? @jobs_sync.synchronize(:SH) do @active_jobs.empty? end end |
#add_schedule(command) ⇒ Object
schedule a command
140 141 142 143 144 145 146 147 148 149 |
# File 'lib/shell/process-controller.rb', line 140 def add_schedule(command) @jobs_sync.synchronize(:EX) do ProcessController.activate(self) if @active_jobs.empty? start_job command else @waiting_jobs.push(command) end end end |
#jobs ⇒ Object
104 105 106 107 108 109 110 111 |
# File 'lib/shell/process-controller.rb', line 104 def jobs jobs = [] @jobs_sync.synchronize(:SH) do jobs.concat @waiting_jobs jobs.concat @active_jobs end jobs end |
#jobs_exist? ⇒ Boolean
121 122 123 124 125 |
# File 'lib/shell/process-controller.rb', line 121 def jobs_exist? @jobs_sync.synchronize(:SH) do @active_jobs.empty? or @waiting_jobs.empty? end end |
#kill_job(sig, command) ⇒ Object
kill a job
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 |
# File 'lib/shell/process-controller.rb', line 197 def kill_job(sig, command) @jobs_sync.synchronize(:EX) do if @waiting_jobs.delete command ProcessController.inactivate(self) return elsif @active_jobs.include?(command) begin r = command.kill(sig) ProcessController.inactivate(self) rescue print "Shell: Warn: $!\n" if @shell.verbose? return nil end @active_jobs.delete command r end end end |
#sfork(command) ⇒ Object
simple fork
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 |
# File 'lib/shell/process-controller.rb', line 233 def sfork(command) pipe_me_in, pipe_peer_out = IO.pipe pipe_peer_in, pipe_me_out = IO.pipe pid = nil pid_mutex = Thread::Mutex.new pid_cv = Thread::ConditionVariable.new Thread.start do ProcessController.block_output_synchronize do STDOUT.flush ProcessController.each_active_object do |pc| for jobs in pc.active_jobs jobs.flush end end pid = fork { Thread.list.each do |th| th.kill unless Thread.current == th end STDIN.reopen(pipe_peer_in) STDOUT.reopen(pipe_peer_out) ObjectSpace.each_object(IO) do |io| if ![STDIN, STDOUT, STDERR].include?(io) io.close end end yield } end pid_cv.signal pipe_peer_in.close pipe_peer_out.close command.notify "job(%name:##{pid}) start", @shell.debug? begin _pid = nil command.notify("job(%id) start to waiting finish.", @shell.debug?) _pid = Process.waitpid(pid, nil) rescue Errno::ECHILD command.notify "warn: job(%id) was done already waitpid." _pid = true ensure command.notify("Job(%id): Wait to finish when Process finished.", @shell.debug?) # when the process ends, wait until the command terminates if USING_AT_EXIT_WHEN_PROCESS_EXIT or _pid else command.notify("notice: Process finishing...", "wait for Job[%id] to finish.", "You can use Shell#transact or Shell#check_point for more safe execution.") redo end @job_monitor.synchronize do terminate_job(command) @job_condition.signal command.notify "job(%id) finish.", @shell.debug? end end end pid_mutex.synchronize do while !pid pid_cv.wait(pid_mutex) end end return pid, pipe_me_in, pipe_me_out end |
#start_job(command = nil) ⇒ Object
start a job
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 |
# File 'lib/shell/process-controller.rb', line 152 def start_job(command = nil) @jobs_sync.synchronize(:EX) do if command return if command.active? @waiting_jobs.delete command else command = @waiting_jobs.shift return unless command end @active_jobs.push command command.start # start all jobs that input from the job for job in @waiting_jobs.dup start_job(job) if job.input == command end end end |
#terminate_job(command) ⇒ Object
terminate a job
185 186 187 188 189 190 191 192 193 194 |
# File 'lib/shell/process-controller.rb', line 185 def terminate_job(command) @jobs_sync.synchronize(:EX) do @active_jobs.delete command ProcessController.inactivate(self) if @active_jobs.empty? command.notify("start_job in terminate_job(%id)", Shell::debug?) start_job end end end |
#wait_all_jobs_execution ⇒ Object
wait for all jobs to terminate
217 218 219 220 221 222 223 224 225 226 227 228 229 230 |
# File 'lib/shell/process-controller.rb', line 217 def wait_all_jobs_execution @job_monitor.synchronize do begin while !jobs.empty? @job_condition.wait(@job_monitor) for job in jobs job.notify("waiting job(%id)", Shell::debug?) end end ensure redo unless jobs.empty? end end end |
#waiting_job?(job) ⇒ Boolean
172 173 174 175 176 |
# File 'lib/shell/process-controller.rb', line 172 def waiting_job?(job) @jobs_sync.synchronize(:SH) do @waiting_jobs.include?(job) end end |
#waiting_jobs ⇒ Object
117 118 119 |
# File 'lib/shell/process-controller.rb', line 117 def waiting_jobs @waiting_jobs end |
#waiting_jobs_exist? ⇒ Boolean
133 134 135 136 137 |
# File 'lib/shell/process-controller.rb', line 133 def waiting_jobs_exist? @jobs_sync.synchronize(:SH) do @waiting_jobs.empty? end end |