Shell::ProcessController

 
               # File shell/process-controller.rb, line 34
def activate(pc)
  process_controllers_exclusive do
    @ProcessControllers[pc] ||= 0
    @ProcessControllers[pc] += 1
  end
end
            

 
               # File shell/process-controller.rb, line 51
def each_active_object
  process_controllers_exclusive do
    for ref in @ProcessControllers.keys
      yield ref
    end
  end
end
            

 
               # File shell/process-controller.rb, line 41
def inactivate(pc)
  process_controllers_exclusive do
    if @ProcessControllers[pc]
      if (@ProcessControllers[pc] -= 1) == 0
        @ProcessControllers.delete(pc)
      end
    end
  end
end
            

 
               # File shell/process-controller.rb, line 60
def initialize(shell)
  @shell = shell
  @waiting_jobs = []
  @active_jobs = []
  @jobs_sync = Sync.new

  @job_monitor = Mutex.new
  @job_condition = ConditionVariable.new
end
            

 
               # File shell/process-controller.rb, line 25
def process_controllers_exclusive
  begin
    @ProcessControllers.lock unless Thread.critical 
    yield
  ensure
    @ProcessControllers.unlock unless Thread.critical 
  end
end
            

 
               # File shell/process-controller.rb, line 143
def active_job?(job)
  @jobs_sync.synchronize(:SH) do
    @active_jobs.include?(job)
  end
end
            

 
               # File shell/process-controller.rb, line 79
def active_jobs
  @active_jobs
end
            

 
               # File shell/process-controller.rb, line 93
def active_jobs_exist?
  @jobs_sync.synchronize(:SH) do
    @active_jobs.empty?
  end
end
            

 
               # File shell/process-controller.rb, line 106
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
            

 
               # File shell/process-controller.rb, line 70
def jobs
  jobs = []
  @jobs_sync.synchronize(:SH) do
    jobs.concat @waiting_jobs
    jobs.concat @active_jobs
  end
  jobs
end
            

 
               # File shell/process-controller.rb, line 87
def jobs_exist?
  @jobs_sync.synchronize(:SH) do
    @active_jobs.empty? or @waiting_jobs.empty?
  end
end
            

 
               # File shell/process-controller.rb, line 161
def kill_job(sig, command)
  @jobs_sync.synchronize(:SH) 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
            

 
               # File shell/process-controller.rb, line 194
def sfork(command, &block)
  pipe_me_in, pipe_peer_out = IO.pipe
  pipe_peer_in, pipe_me_out = IO.pipe
  Thread.critical = true

  STDOUT.flush
  ProcessController.each_active_object do |pc|
    for jobs in pc.active_jobs
      jobs.flush
    end
  end
  
  pid = fork {
    Thread.critical = true

    Thread.list.each do |th| 
      th.kill unless [Thread.main, Thread.current].include?(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 unless io.closed?
      end
    end
    yield
  }

  pipe_peer_in.close
  pipe_peer_out.close
  command.notify "job(%name:##{pid}) start", @shell.debug?
  Thread.critical = false

  th = Thread.start {
    Thread.critical = true
    begin
      _pid = nil
      command.notify("job(%id) start to waiting finish.", @shell.debug?)
      Thread.critical = false
      _pid = Process.waitpid(pid, nil)
    rescue Errno::ECHILD
      command.notify "warn: job(%id) was done already waitipd."
      _pid = true
    ensure
      # when the process ends, wait until the command termintes
      if _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
      Thread.exclusive do
        @job_monitor.synchronize do 
          terminate_job(command)
          @job_condition.signal
          command.notify "job(%id) finish.", @shell.debug?
        end
      end
    end
  }
  return pid, pipe_me_in, pipe_me_out
end
            

 
               # File shell/process-controller.rb, line 118
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
      start_job(job) if job.input == command
    end
  end
end
            

 
               # File shell/process-controller.rb, line 150
def terminate_job(command)
  @jobs_sync.synchronize(:EX) do
    @active_jobs.delete command
    ProcessController.inactivate(self)
    if @active_jobs.empty?
      start_job
    end
  end
end
            

 
               # File shell/process-controller.rb, line 181
def wait_all_jobs_execution
  @job_monitor.synchronize do
    begin
      while !jobs.empty?
        @job_condition.wait(@job_monitor)
      end
    ensure
      redo unless jobs.empty?
    end
  end
end
            

 
               # File shell/process-controller.rb, line 137
def waiting_job?(job)
  @jobs_sync.synchronize(:SH) do
    @waiting_jobs.include?(job)
  end
end
            

 
               # File shell/process-controller.rb, line 83
def waiting_jobs
  @waiting_jobs
end
            

 
               # File shell/process-controller.rb, line 99
def waiting_jobs_exist?
  @jobs_sync.synchronize(:SH) do
    @waiting_jobs.empty?
  end
end