Synnefo » snf-ganeti

  @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

class _FakeJob:

  def __init__(self, job_id, status):

    self.id = job_id

    self._status = status

    self._log = []

class TestQueuedJob(unittest.TestCase):

  def test(self):

    self.assertRaises(errors.GenericError, jqueue._QueuedJob,

  def testDefaults(self):

    job_id = 4260

      ]

    def _Check(job):

      self.assertEqual(job.id, job_id)

      self.assertEqual(job.log_serial, 0)

      self.assert_(job.received_timestamp)

      self.assertEqual(job.GetInfo(["summary"]),

                       [[op.input.Summary() for op in job.ops]])

    _Check(job1)

    _Check(job2)

    self.assertEqual(job1.Serialize(), job2.Serialize())

  def testPriority(self):

    job_id = 4283

    ops = [

      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_QUEUED)

      self.assert_(repr(job).startswith("<"))

    _Check(job)

    self.assert_(compat.all(op.priority == constants.OP_PRIO_DEFAULT

                            for op in job.ops))

    def _NewJob():

      job = jqueue._QueuedJob(None, 1,

      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_QUEUED)

      self.assert_(compat.all(op.status == constants.OP_STATUS_QUEUED

                              for op in job.ops))

class _JobProcessorTestUtils:

  def _CreateJob(self, queue, job_id, ops):

    self.assertFalse(job.start_timestamp)

    self.assertFalse(job.end_timestamp)

    self.assertEqual(len(ops), len(job.ops))

      self.assert_(job.ops_iter)

      # Serialize and restore (simulates program restart)

      self.assertFalse(newjob.ops_iter)

      self._TestPartial(newjob, successcount)

    self.assertRaises(IndexError, queue.GetNextUpdate)

    # ... also after being restored

    # Calling the processor on a finished job should be a no-op

    self.assertTrue(jqueue._JobProcessor(queue, opexec, job2)())

    self.assertRaises(IndexError, queue.GetNextUpdate)

    self._CheckLogMessages(job, logmsgcount)

    # Serialize and restore (simulates program restart)

    self._CheckLogMessages(newjob, logmsgcount)

    # Check each message