Synnefo » snf-ganeti » ganeti-local

  @ivar received_timestamp: the timestamp for when the job was received

  @ivar start_timestmap: the timestamp for start of execution

  @ivar end_timestamp: the timestamp for end of execution

  """

  # pylint: disable-msg=W0212

  __slots__ = ["queue", "id", "ops", "log_serial", "ops_iter", "cur_opctx",

               "received_timestamp", "start_timestamp", "end_timestamp",

    """Constructor for the _QueuedJob.

    @type queue: L{JobQueue}

    @type ops: list

    @param ops: the list of opcodes we hold, which will be encapsulated

        in _QueuedOpCodes

    """

    if not ops:

    self.start_timestamp = None

    self.end_timestamp = None

  @staticmethod

    """Initializes in-memory variables.

    """

    obj.ops_iter = None

    obj.cur_opctx = None

    obj.processor_lock = threading.Lock()

    return "<%s at %#x>" % (" ".join(status), id(self))

  @classmethod

    """Restore a _QueuedJob from serialized state:

    @type queue: L{JobQueue}

    @param queue: to which queue the restored job belongs

    @type state: dict

    @param state: the serialized state

    @rtype: _JobQueue

    @return: the restored _JobQueue instance

        obj.log_serial = max(obj.log_serial, log_entry[0])

      obj.ops.append(op)

    return obj

    @param job: Job object

    """

    status = job.CalcStatus()

    job_info = job.GetInfo(self._fields)

    log_entries = job.GetLogEntries(self._prev_log_serial)

    try:

      opcount = len(job.ops)

      # Don't do anything for finalized jobs

      if job.CalcStatus() in constants.JOBS_FINALIZED:

        return True

      return bool(waitjob)

    finally:

      queue.release()

    job = self._memcache.get(job_id, None)

    if job:

      logging.debug("Found job %s in memcache", job_id)

      return job

    try:

        self._RenameFilesUnlocked([(old_path, new_path)])

      return None

    self._memcache[job_id] = job

    logging.debug("Added job %s to the cache", job_id)

    return job

    """Load the given job file from disk.

    Given a job file, read, load and restore it in a _QueuedJob format.

    @return: either None or the job object

    """

    if try_archived:

    raw_data = None

      filepath = fn(job_id)

      logging.debug("Loading job from %s", filepath)

      try:

    if not raw_data:

      return None

    try:

      data = serializer.LoadJson(raw_data)

    except Exception, err: # pylint: disable-msg=W0703

      raise errors.JobFileCorrupted(err)

    return job

    """Load the given job file from disk.

    Given a job file, read, load and restore it in a _QueuedJob format.

    """

    try:

    except (errors.JobFileCorrupted, EnvironmentError):

      logging.exception("Can't load/parse job %s", job_id)

      return None

    if self._queue_size >= constants.JOB_QUEUE_SIZE_HARD_LIMIT:

      raise errors.JobQueueFull()

    # Check priority

    for idx, op in enumerate(job.ops):

    # Not using in-memory cache as doing so would require an exclusive lock

    # Try to load from disk

    if job:

      return job.CalcStatus()

    if __debug__:

      finalized = job.CalcStatus() in constants.JOBS_FINALIZED

      assert (finalized ^ (job.end_timestamp is None))

    filename = self._GetJobPath(job.id)

    data = serializer.DumpJson(job.Serialize(), indent=False)

        as such by the clients

    """

    helper = _WaitForJobChangesHelper()

      logging.debug("Job %s not found", job_id)

      return (False, "Job %s not found" % job_id)

    (success, msg) = job.Cancel()

    if success:

    archive_jobs = []

    rename_files = []

    for job in jobs:

      if job.CalcStatus() not in constants.JOBS_FINALIZED:

        logging.debug("Job %s is not yet done", job.id)

        continue