Synnefo » snf-ganeti » ganeti-local

      if op.status == constants.OP_STATUS_QUEUED:

        pass

      elif op.status == constants.OP_STATUS_RUNNING:

        status = constants.JOB_STATUS_RUNNING

      elif op.status == constants.OP_STATUS_CANCELING:

      self.Finalize()

      return (True, "Job %s canceled" % self.id)

      # The worker will notice the new status and cancel the job

      self.MarkUnfinishedOps(constants.OP_STATUS_CANCELING, None)

      return (True, "Job %s will be canceled" % self.id)

    This is called from the mcpu code as a notifier function, when the LU is

    finally about to start the Exec() method. Of course, to have end-user

    visible results, the opcode must be initially (before calling into

    """

    assert self._op in self._job.ops

                               constants.OP_STATUS_CANCELING)

    # Cancel here if we were asked to

    """Check whether job has been cancelled.

    """

                               constants.OP_STATUS_CANCELING)

    # Cancel here if we were asked to

    # no changes.

    if (status not in (constants.JOB_STATUS_QUEUED,

                       constants.JOB_STATUS_RUNNING,

        job_info != self._prev_job_info or

        (log_entries and self._prev_log_serial != log_entries[0][0])):

      logging.debug("Job %s changed", job.id)

    """

    assert op in job.ops

    assert op.status in (constants.OP_STATUS_QUEUED,

    update = False

    op.result = None

    if op.status == constants.OP_STATUS_QUEUED:

      update = True

    if op.start_timestamp is None:

      job.start_timestamp = op.start_timestamp

      update = True

    return update

    """

    op = opctx.op

    timeout = opctx.GetNextLockTimeout()

      assert timeout is not None, "Received timeout for blocking acquire"

      logging.debug("Couldn't acquire locks in %0.6fs", timeout)

                           constants.OP_STATUS_CANCELING)

      # Was job cancelled while we were waiting for the lock?

        return (constants.OP_STATUS_CANCELING, None)

      # Stay in waitlock while trying to re-acquire lock

    except CancelJob:

      logging.exception("%s: Canceling job", opctx.log_prefix)

      assert op.status == constants.OP_STATUS_CANCELING

                        for i in job.ops[opctx.index + 1:])

      assert op.status in (constants.OP_STATUS_QUEUED,

                           constants.OP_STATUS_CANCELING)

      assert (op.priority <= constants.OP_PRIO_LOWEST and

      if op.status != constants.OP_STATUS_CANCELING:

        assert op.status in (constants.OP_STATUS_QUEUED,

        # Prepare to start opcode

        if self._MarkWaitlock(job, op):

          # Write to disk

          queue.UpdateJobUnlocked(job)

        assert job.start_timestamp and op.start_timestamp

        assert waitjob is None

        # Check if waiting for a job is necessary

        waitjob = self._CheckDependencies(queue, job, opctx)

                             constants.OP_STATUS_CANCELING,

                             constants.OP_STATUS_ERROR)

          assert not waitjob

          # Couldn't get locks in time

          assert not op.end_timestamp

        else:

          else:

            assert op.status in constants.OPS_FINALIZED

        finalize = False

        if not waitjob and opctx.CheckPriorityIncrease():

                op.priority >= constants.OP_PRIO_HIGHEST)

        # In no case must the status be finalized here

      else:

        # Ensure all opcodes so far have been successful

        restartjobs.append(job)

      elif status in (constants.JOB_STATUS_RUNNING,

                      constants.JOB_STATUS_CANCELING):

        logging.warning("Unfinished job %s found: %s", job.id, job)

          # Restart job

          job.MarkUnfinishedOps(constants.OP_STATUS_QUEUED, None)

          restartjobs.append(job)