コード例 #1
0
// ****************************************************************************
// ***  ~khTask
// ****************************************************************************
khTask::~khTask(void) throw()
{
  assert(taskid_);

  if (jobHandler) {
    // stops the job
    // removes me from his list
    // takes ownership of my reservations (until job finished)
    jobHandler->StopTask(this);
  } else {
    theResourceManager.EraseWaitingTask(this);

    // Reservation destructors will release reservation and
    // remove the files they represent. This would happen
    // automatically at the end of this destructor. But I just felt like
    // being explicit
    reservations_.clear();
  }

  taskVerrefMap.erase(verref_);

  // remove my persistence
  if (!khUnlink(TaskFilename())) {
    notify(NFY_WARN, "Unable to unlink %s", TaskFilename().c_str());
  }

  // help to see if we're deleting the task twice
  taskid_ = 0;
}
コード例 #2
0
/*
 * worker_fetch_query_results_file fetches a query results file from the remote
 * node. The function assumes an upstream compute task depends on this query
 * results file, and therefore directly fetches the file into the upstream
 * task's directory.
 */
Datum
worker_fetch_query_results_file(PG_FUNCTION_ARGS)
{
	uint64 jobId = PG_GETARG_INT64(0);
	uint32 queryTaskId = PG_GETARG_UINT32(1);
	uint32 upstreamTaskId = PG_GETARG_UINT32(2);
	text *nodeNameText = PG_GETARG_TEXT_P(3);
	uint32 nodePort = PG_GETARG_UINT32(4);
	char *nodeName = NULL;

	/* remote filename is <jobId>/<queryTaskId> */
	StringInfo remoteDirectoryName = JobDirectoryName(jobId);
	StringInfo remoteFilename = TaskFilename(remoteDirectoryName, queryTaskId);

	/* local filename is <jobId>/<upstreamTaskId>/<queryTaskId> */
	StringInfo taskDirectoryName = TaskDirectoryName(jobId, upstreamTaskId);
	StringInfo taskFilename = TaskFilename(taskDirectoryName, queryTaskId);

	/*
	 * If we are the first function to fetch a file for the upstream task, the
	 * task directory does not exist. We then lock and create the directory.
	 */
	bool taskDirectoryExists = DirectoryExists(taskDirectoryName);
	if (!taskDirectoryExists)
	{
		InitTaskDirectory(jobId, upstreamTaskId);
	}

	nodeName = text_to_cstring(nodeNameText);
	FetchRegularFile(nodeName, nodePort, remoteFilename, taskFilename);

	PG_RETURN_VOID();
}
コード例 #3
0
// ****************************************************************************
// ***  khTask
// ****************************************************************************
khTask::khTask(const SubmitTaskMsg &msg)
    : verref_(msg.verref), taskid_(msg.taskid),
      priority_(msg.priority), taskdef_(msg.taskdef),
      requirements(taskdef_, taskid_, verref_), // <-- can throw exception
      submitTime_(time(0)),
      beginTime_(0),
      progressTime_(0),
      progress_(0),
      jobHandler(0)
{
  // It's assumed that the caller already removed any existing
  // task for this verref

  // make our persistent copy (it's just a symlink)
  if (!khSymlink(verref_, TaskFilename())) {
    throw khErrnoException(kh::tr("Unable to write ") + TaskFilename());
  }

  // now that we're persistent, add myself to the lists
  taskVerrefMap.insert(std::make_pair(verref_, this));
  theResourceManager.InsertWaitingTask(this);
}