class TaskJuggler::ProjectServer

# File lib/taskjuggler/daemon/ProjectServer.rb, line 40
def initialize(daemonAuthKey, projectData = nil, logConsole = false)
  @daemonAuthKey = daemonAuthKey
  @projectData = projectData
  # Since we are still in the ProjectBroker process, the current DRb
  # server is still the ProjectBroker DRb server.
  @daemonURI = DRb.current_server.uri
  # Used later to store the DRbObject of the ProjectBroker.
  @daemon = nil
  initIntercom

  @logConsole = logConsole
  @pid = nil
  @uri = nil

  # A reference to the TaskJuggler object that holds the project data.
  @tj = nil
  # The current state of the project.
  @state = :new
  # A time stamp when the last @state update happened.
  @stateUpdated = TjTime.new
  # A lock to protect access to @state
  @stateLock = Monitor.new

  # A Queue to asynchronously generate new ReportServer objects.
  @reportServerRequests = Queue.new

  # A list of active ReportServer objects
  @reportServers = []
  @reportServers.extend(MonitorMixin)

  @lastPing = TjTime.new

  # We've started a DRb server before. This will continue to live somewhat
  # in the child. All attempts to create a DRb connection from the child
  # to the parent will end up in the child again. So we use a Pipe to
  # communicate the URI of the child DRb server to the parent. The
  # communication from the parent to the child is not affected by the
  # zombie DRb server in the child process.
  rd, wr = IO.pipe

  if (@pid = fork) == -1
    fatal('ps_fork_failed', 'ProjectServer fork failed')
  elsif @pid.nil?
    # This is the child
    if @logConsole
      # If the Broker wasn't daemonized, log stdout and stderr to PID
      # specific files.
      $stderr.reopen("tj3d.ps.#{$$}.stderr", 'w')
      $stdout.reopen("tj3d.ps.#{$$}.stdout", 'w')
    end
    begin
      $SAFE = 1
      DRb.install_acl(ACL.new(%w[ deny all allow 127.0.0.1 ]))
      iFace = ProjectServerIface.new(self)
      begin
        @uri = DRb.start_service('druby://127.0.0.1:0', iFace).uri
        debug('', "Project server is listening on #{@uri}")
      rescue
        error('ps_cannot_start_drb', "ProjectServer can't start DRb: #{$!}")
      end

      # Send the URI of the newly started DRb server to the parent process.
      rd.close
      wr.write @uri
      wr.close

      # Start a Thread that waits for the @terminate flag to be set and does
      # other background tasks.
      startTerminator
      # Start another Thread that will be used to fork-off ReportServer
      # processes.
      startHousekeeping

      # Cleanup the DRb threads
      DRb.thread.join
      debug('', 'Project server terminated')
      exit 0
    rescue => exception
      # TjRuntimeError exceptions are simply passed through.
      if exception.is_a?(TjRuntimeError)
        raise TjRuntimeError, $!
      end

      error('ps_cannot_start_drb', "ProjectServer can't start DRb: #{$!}")
    end
  else
    # This is the parent
    Process.detach(@pid)
    wr.close
    @uri = rd.read
    rd.close
  end
end

# File lib/taskjuggler/daemon/ProjectServer.rb, line 184
def getProjectName
  return nil unless @tj
  restartTimer
  @tj.projectName
end

# File lib/taskjuggler/daemon/ProjectServer.rb, line 191
def getReportList
  return [] unless @tj && (project = @tj.project)
  list = []
  project.reports.each do |report|
    unless report.get('formats').empty?
      list << [ report.fullId, report.name ]
    end
  end
  restartTimer
  list
end

# File lib/taskjuggler/daemon/ProjectServer.rb, line 205
def getReportServer
  # ReportServer objects only make sense for successfully scheduled
  # projects.
  return [ nil, nil ] unless @state == :ready

  # The ReportServer will be created asynchronously in another Thread. To
  # find it in the @reportServers list, we create a unique tag to identify
  # it.
  tag = rand(99999999999999)
  debug('', "Pushing #{tag} onto report server request queue")
  @reportServerRequests.push(tag)

  # Now wait until the new ReportServer shows up in the list.
  reportServer = nil
  while reportServer.nil?
    @reportServers.synchronize do
      @reportServers.each do |rs|
        reportServer = rs if rs.tag == tag
      end
    end
    # It should not take that long, so we use a short idle time here.
    sleep 0.1 if reportServer.nil?
  end

  debug('', "Got report server with URI #{reportServer.uri} for " +
        "tag #{tag}")
  restartTimer
  [ reportServer.uri, reportServer.authKey ]
end

# File lib/taskjuggler/daemon/ProjectServer.rb, line 139
def loadProject(args)
  dirAndFiles = args.dup
  # The first argument is the working directory
  Dir.chdir(args.shift)

  # Save a time stamp of when the project file loading started.
  @modifiedCheck = TjTime.new

  updateState(:loading, dirAndFiles, false)
  begin
    @tj = TaskJuggler.new
    # Make sure that trace reports get CSV formats included so there
    # reports can be generated on request.
    @tj.generateTraces = true

    # Parse all project files
    unless @tj.parse(args, true)
      warning('parse_failed', "Parsing of #{args.join(' ')} failed")
      updateState(:failed, nil, false)
      @terminate = true
      return false
    end

    # Then schedule the project
    unless @tj.schedule
      warning('schedule_failed',
              "Scheduling of project #{@tj.projectId} failed")
      updateState(:failed, @tj.projectId, false)
      @terminate = true
      return false
    end
  rescue TjRuntimeError
    updateState(:failed, nil, false)
    @terminate = true
    return false
  end

  # Great, everything went fine. We've got a project to work with.
  updateState(:ready, @tj.projectId, false)
  debug('', "Project #{@tj.projectId} loaded")
  restartTimer
  true
end

# File lib/taskjuggler/daemon/ProjectServer.rb, line 237
def ping
  # Store the time stamp. If we don't get the ping for some time, we
  # assume the ProjectBroker has died.
  @lastPing = TjTime.new

  # Now also check our ReportServers if they are still there. If not, we
  # can remove them from the @reportServers list.
  @reportServers.synchronize do
    deadServers = []
    @reportServers.each do |rs|
      unless rs.ping
        deadServers << rs
      end
    end
    @reportServers.delete_if { |rs| deadServers.include?(rs) }
  end
end