Revision 47099cd1 test/ganeti.jqueue_unittest.py

b/test/ganeti.jqueue_unittest.py
201 201
    shutil.rmtree(self.tmpdir)
202 202

  
203 203
  def _LoadWaitingJob(self):
204
    return _FakeJob(2614226563, constants.JOB_STATUS_WAITLOCK)
204
    return _FakeJob(2614226563, constants.JOB_STATUS_WAITING)
205 205

  
206 206
  def _LoadLostJob(self):
207 207
    return None
......
211 211

  
212 212
    # No change
213 213
    self.assertEqual(wfjc(self.filename, self._LoadWaitingJob, ["status"],
214
                          [constants.JOB_STATUS_WAITLOCK], None, 0.1),
214
                          [constants.JOB_STATUS_WAITING], None, 0.1),
215 215
                     constants.JOB_NOTCHANGED)
216 216

  
217 217
    # No previous information
218 218
    self.assertEqual(wfjc(self.filename, self._LoadWaitingJob,
219 219
                          ["status"], None, None, 1.0),
220
                     ([constants.JOB_STATUS_WAITLOCK], []))
220
                     ([constants.JOB_STATUS_WAITING], []))
221 221

  
222 222
  def testLostJob(self):
223 223
    wfjc = jqueue._WaitForJobChangesHelper()
......
364 364
                              for op in ops))
365 365

  
366 366
    def _Waitlock1(ops):
367
      ops[0].status = constants.OP_STATUS_WAITLOCK
367
      ops[0].status = constants.OP_STATUS_WAITING
368 368

  
369 369
    def _Waitlock2(ops):
370 370
      ops[0].status = constants.OP_STATUS_SUCCESS
371 371
      ops[1].status = constants.OP_STATUS_SUCCESS
372
      ops[2].status = constants.OP_STATUS_WAITLOCK
372
      ops[2].status = constants.OP_STATUS_WAITING
373 373

  
374 374
    def _Running(ops):
375 375
      ops[0].status = constants.OP_STATUS_SUCCESS
......
408 408

  
409 409
    tests = {
410 410
      constants.JOB_STATUS_QUEUED: [_Queued],
411
      constants.JOB_STATUS_WAITLOCK: [_Waitlock1, _Waitlock2],
411
      constants.JOB_STATUS_WAITING: [_Waitlock1, _Waitlock2],
412 412
      constants.JOB_STATUS_RUNNING: [_Running],
413 413
      constants.JOB_STATUS_CANCELING: [_Canceling1, _Canceling2],
414 414
      constants.JOB_STATUS_CANCELED: [_Canceled],
......
602 602
        self.assertEqual(queue.GetNextUpdate(), (job, True))
603 603
        self.assertRaises(IndexError, queue.GetNextUpdate)
604 604
        self.assertFalse(queue.IsAcquired())
605
        self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITLOCK)
605
        self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITING)
606 606
        self.assertFalse(job.cur_opctx)
607 607

  
608 608
      def _AfterStart(op, cbs):
......
789 789

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

  
792
    job.ops[0].status = constants.OP_STATUS_WAITLOCK
792
    job.ops[0].status = constants.OP_STATUS_WAITING
793 793

  
794 794
    assert len(job.ops) == 5
795 795

  
796
    self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITLOCK)
796
    self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITING)
797 797

  
798 798
    # Mark as cancelling
799 799
    (success, _) = job.Cancel()
......
835 835
      self.assertEqual(queue.GetNextUpdate(), (job, True))
836 836
      self.assertRaises(IndexError, queue.GetNextUpdate)
837 837
      self.assertFalse(queue.IsAcquired())
838
      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITLOCK)
838
      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITING)
839 839

  
840 840
      # Mark as cancelled
841 841
      (success, _) = job.Cancel()
......
884 884

  
885 885
    def _BeforeStart(timeout, priority):
886 886
      self.assertFalse(queue.IsAcquired())
887
      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITLOCK)
887
      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITING)
888 888

  
889 889
      # Mark as cancelled
890 890
      (success, _) = job.Cancel()
......
1089 1089
      self.assertEqual(queue.GetNextUpdate(), (job, True))
1090 1090
      self.assertRaises(IndexError, queue.GetNextUpdate)
1091 1091
      self.assertFalse(queue.IsAcquired())
1092
      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITLOCK)
1092
      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITING)
1093 1093

  
1094 1094
    def _AfterStart(op, cbs):
1095 1095
      self.assertEqual(queue.GetNextUpdate(), (job, True))
......
1204 1204
      self.assertEqual(queue.GetNextUpdate(), (job, True))
1205 1205
      self.assertRaises(IndexError, queue.GetNextUpdate)
1206 1206
      self.assertFalse(queue.IsAcquired())
1207
      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITLOCK)
1207
      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITING)
1208 1208
      self.assertFalse(job.cur_opctx)
1209 1209

  
1210 1210
    def _AfterStart(op, cbs):
......
1286 1286
        self.assertEqual(queue.GetNextUpdate(), (job, True))
1287 1287
      self.assertRaises(IndexError, queue.GetNextUpdate)
1288 1288
      self.assertFalse(queue.IsAcquired())
1289
      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITLOCK)
1289
      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITING)
1290 1290
      self.assertFalse(job.cur_opctx)
1291 1291

  
1292 1292
    def _AfterStart(op, cbs):
......
1345 1345
        # Simulate waiting for other job
1346 1346
        self.assertEqual(result, jqueue._JobProcessor.WAITDEP)
1347 1347
        self.assertTrue(job.cur_opctx)
1348
        self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITLOCK)
1348
        self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITING)
1349 1349
        self.assertRaises(IndexError, depmgr.GetNextNotification)
1350 1350
        self.assert_(job.start_timestamp)
1351 1351
        self.assertFalse(job.end_timestamp)
......
1410 1410
        self.assertEqual(queue.GetNextUpdate(), (job, True))
1411 1411
      self.assertRaises(IndexError, queue.GetNextUpdate)
1412 1412
      self.assertFalse(queue.IsAcquired())
1413
      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITLOCK)
1413
      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITING)
1414 1414
      self.assertFalse(job.cur_opctx)
1415 1415

  
1416 1416
    def _AfterStart(op, cbs):
......
1463 1463
        # Simulate waiting for other job
1464 1464
        self.assertEqual(result, jqueue._JobProcessor.WAITDEP)
1465 1465
        self.assertTrue(job.cur_opctx)
1466
        self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITLOCK)
1466
        self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITING)
1467 1467
        self.assertRaises(IndexError, depmgr.GetNextNotification)
1468 1468
        self.assert_(job.start_timestamp)
1469 1469
        self.assertFalse(job.end_timestamp)
......
1527 1527
        self.assertEqual(queue.GetNextUpdate(), (job, True))
1528 1528
      self.assertRaises(IndexError, queue.GetNextUpdate)
1529 1529
      self.assertFalse(queue.IsAcquired())
1530
      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITLOCK)
1530
      self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITING)
1531 1531
      self.assertFalse(job.cur_opctx)
1532 1532

  
1533 1533
    def _AfterStart(op, cbs):
......
1580 1580
        # Simulate waiting for other job
1581 1581
        self.assertEqual(result, jqueue._JobProcessor.WAITDEP)
1582 1582
        self.assertTrue(job.cur_opctx)
1583
        self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITLOCK)
1583
        self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITING)
1584 1584
        self.assertRaises(IndexError, depmgr.GetNextNotification)
1585 1585
        self.assert_(job.start_timestamp)
1586 1586
        self.assertFalse(job.end_timestamp)
......
1663 1663
    self.assertRaises(IndexError, self.queue.GetNextUpdate)
1664 1664

  
1665 1665
    self.assertFalse(self.queue.IsAcquired())
1666
    self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITLOCK)
1666
    self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITING)
1667 1667

  
1668 1668
    ts = self.timeout_strategy
1669 1669

  
......
1823 1823
        self.assertEqual(job.cur_opctx._timeout_strategy._fn,
1824 1824
                         self.timeout_strategy.NextAttempt)
1825 1825
        self.assertFalse(job.ops[self.curop].exec_timestamp)
1826
        self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITLOCK)
1826
        self.assertEqual(job.CalcStatus(), constants.JOB_STATUS_WAITING)
1827 1827

  
1828 1828
        # If priority has changed since acquiring locks, the job must've been
1829 1829
        # updated
......
1900 1900
    job_id = str(9610)
1901 1901
    dep_status = [constants.JOB_STATUS_CANCELED]
1902 1902

  
1903
    self._status.append((job_id, constants.JOB_STATUS_WAITLOCK))
1903
    self._status.append((job_id, constants.JOB_STATUS_WAITING))
1904 1904
    (result, _) = self.jdm.CheckAndRegister(job, job_id, dep_status)
1905 1905
    self.assertEqual(result, self.jdm.WAIT)
1906 1906
    self.assertFalse(self._status)
......
1922 1922
    job_id = str(25519)
1923 1923
    dep_status = [constants.JOB_STATUS_ERROR]
1924 1924

  
1925
    self._status.append((job_id, constants.JOB_STATUS_WAITLOCK))
1925
    self._status.append((job_id, constants.JOB_STATUS_WAITING))
1926 1926
    (result, _) = self.jdm.CheckAndRegister(job, job_id, dep_status)
1927 1927
    self.assertEqual(result, self.jdm.WAIT)
1928 1928
    self.assertFalse(self._status)
......
1946 1946
      job = self._FakeJob(21343)
1947 1947
      job_id = str(14609)
1948 1948

  
1949
      self._status.append((job_id, constants.JOB_STATUS_WAITLOCK))
1949
      self._status.append((job_id, constants.JOB_STATUS_WAITING))
1950 1950
      (result, _) = self.jdm.CheckAndRegister(job, job_id, dep_status)
1951 1951
      self.assertEqual(result, self.jdm.WAIT)
1952 1952
      self.assertFalse(self._status)

Also available in: Unified diff