Synnefo » snf-ganeti

  def GetLockInfo(self, requested): # pylint: disable-msg=W0613

    """Retrieves information about waiting jobs.

    @type requested: set

    @param requested: Requested information, see C{query.LQ_*}

    """

    # No need to sort here, that's being done by the lock manager and query

    # library. There are no priorities for notifying jobs, hence all show up as

    # one item under "pending".

    return [("job/%s" % job_id, None, None,

             [("job", [job.id for job in waiters])])

            for job_id, waiters in self._waiters.items()

            if waiters]

  @locking.ssynchronized(_LOCK, shared=1)

    self.context.glm.AddToLockMonitor(self.depmgr)

import random

from ganeti import query

    self.assertEqual(self.jdm.GetLockInfo([query.LQ_PENDING]), [

      ("job/28625", None, None, [("job", [job.id])])

      ])

    self.assertFalse(self.jdm.GetLockInfo([query.LQ_PENDING]))

    self.assertEqual(self.jdm.GetLockInfo([query.LQ_PENDING]), [

      ("job/9610", None, None, [("job", [job.id])])

      ])

    self.assertFalse(self.jdm.GetLockInfo([query.LQ_PENDING]))

    self.assertFalse(self.jdm.GetLockInfo([query.LQ_PENDING]))

      self.assertEqual(self.jdm.GetLockInfo([query.LQ_PENDING]), [

        ("job/14609", None, None, [("job", [job.id])])

        ])

      self.assertFalse(self.jdm.GetLockInfo([query.LQ_PENDING]))

  def testMultipleWaiting(self):

    # Use a deterministic random generator

    rnd = random.Random(21402)

    job_ids = map(str, rnd.sample(range(1, 10000), 150))

    waiters = dict((job_ids.pop(),

                    set(map(self._FakeJob,

                            [job_ids.pop()

                             for _ in range(rnd.randint(1, 20))])))

                   for _ in range(10))

    # Ensure there are no duplicate job IDs

    assert not utils.FindDuplicates(waiters.keys() +

                                    [job.id

                                     for jobs in waiters.values()

                                     for job in jobs])

    # Register all jobs as waiters

    for job_id, job in [(job_id, job)

                        for (job_id, jobs) in waiters.items()

                        for job in jobs]:

      self._status.append((job_id, constants.JOB_STATUS_QUEUED))

      (result, _) = self.jdm.CheckAndRegister(job, job_id,

                                              [constants.JOB_STATUS_SUCCESS])

      self.assertEqual(result, self.jdm.WAIT)

      self.assertFalse(self._status)

      self.assertFalse(self._queue)

      self.assertTrue(self.jdm.JobWaiting(job))

    self.assertEqual(self.jdm._waiters, waiters)

    def _MakeSet((name, mode, owner_names, pending)):

      return (name, mode, owner_names,

              [(pendmode, set(pend)) for (pendmode, pend) in pending])

    def _CheckLockInfo():

      info = self.jdm.GetLockInfo([query.LQ_PENDING])

      self.assertEqual(sorted(map(_MakeSet, info)), sorted([

        ("job/%s" % job_id, None, None,

         [("job", set([job.id for job in jobs]))])

        for job_id, jobs in waiters.items()

        if jobs

        ]))

    _CheckLockInfo()

    # Notify in random order

    for job_id in rnd.sample(waiters, len(waiters)):

      # Remove from pending waiter list

      jobs = waiters.pop(job_id)

      for job in jobs:

        self._status.append((job_id, constants.JOB_STATUS_SUCCESS))

        (result, _) = self.jdm.CheckAndRegister(job, job_id,

                                                [constants.JOB_STATUS_SUCCESS])

        self.assertEqual(result, self.jdm.CONTINUE)

        self.assertFalse(self._status)

        self.assertFalse(self._queue)

        self.assertFalse(self.jdm.JobWaiting(job))

      _CheckLockInfo()

    self.assertFalse(self.jdm.GetLockInfo([query.LQ_PENDING]))

    assert not waiters

    self.assertFalse(jdm.GetLockInfo([query.LQ_PENDING]))