def testZExecuteAsync(self):
     self.bookstore_one.set_property("name", self.bookstore_one_update_name)
     self.bookstore_two.set_property("name", self.bookstore_two_update_name)
     pool = Midgard.ExecutionPool(max_n_threads=2)
     self.job_one.connect("execution-end", self.executionEndCallbackAsync,
                          None)
     self.job_two.connect("execution-end", self.executionEndCallbackAsync,
                          None)
     pool.push(self.job_one)
     pool.push(self.job_two)
     time.sleep(1)
     pool = None
     time.sleep(1)
     self.assertEqual(self.async_callback_msg_end, "DONE END ASYNC")
     bookstores = BookStoreQuery.findByName(self.mgd,
                                            self.bookstore_one_update_name)
     self.assertEqual(len(bookstores), 1)
     bookstores = BookStoreQuery.findByName(self.mgd,
                                            self.bookstore_two_update_name)
     self.assertEqual(len(bookstores), 1)
     self.assertEqual(self.job_one.is_running(), False)
     self.assertEqual(self.job_one.is_failed(), False)
     self.assertEqual(self.job_one.is_executed(), True)
     self.assertEqual(self.job_two.is_running(), False)
     self.assertEqual(self.job_two.is_failed(), False)
     self.assertEqual(self.job_two.is_executed(), True)
  def testZExecuteAsync(self):
    pool = Midgard.ExecutionPool(max_n_threads = 2)
    self.job_one.connect("execution-end", self.executionEndCallbackAsyncOne, None)
    self.job_two.connect("execution-end", self.executionEndCallbackAsyncTwo, None)
    pool.push(self.job_one)
    pool.push(self.job_two)
    time.sleep(1)
    pool = None

    self.assertEqual(self.async_callback_msg_end_one, "DONE END ASYNC ONE")
    self.assertEqual(self.async_callback_msg_end_two, "DONE END ASYNC TWO")

    deleted_one = self.bookstore_one.get_property("metadata").get_property("deleted")
    self.assertTrue(deleted_one)
    deleted_two = self.bookstore_two.get_property("metadata").get_property("deleted")
    self.assertTrue(deleted_two)
    
    bookstores = BookStoreQuery.findByName(self.mgd, self.bookstore_one_name)
    self.assertEqual(len(bookstores), 0)
    bookstores = BookStoreQuery.findByName(self.mgd, self.bookstore_two_name)
    self.assertEqual(len(bookstores), 0)

    self.assertEqual(self.job_one.is_running(), False)
    self.assertEqual(self.job_one.is_failed(), False)
    self.assertEqual(self.job_one.is_executed(), True)
    self.assertEqual(self.job_two.is_running(), False)
    self.assertEqual(self.job_two.is_failed(), False)
    self.assertEqual(self.job_two.is_executed(), True)
 def testSelectAsyncAllPersons(self):
   st = Midgard.QueryStorage(dbclass = "midgard_person")
   self.pool = Midgard.ExecutionPool(max_n_threads = 10)
   l = [] # Hold all executors in array to avoid implicit objects' destruction
   for i in range(0, 30):
     qs = Midgard.QuerySelect(connection = self.mgd, storage = st)
     qs.connect("execution-end", self.ExecutionAsyncEndCallback, i)
     self.pool.push(qs)
     l.append(qs)
   # Emulate main loop - ugly   
   time.sleep(1)
   self.pool = None
   self.assertEqual(self.async_execution_callbacks_count, 30)
 def setUp(self):
     if self.mgd == None:
         self.mgd = TestConnection.openConnection()
     self.mgd.beginTransaction()
     if self.bookstore is None:
         self.bookstore = Midgard.Object.factory(self.mgd,
                                                 "gir_test_book_store",
                                                 None)
         self.bookstore.set_property("name", "BookStore One")
         self.bookstore.create()
     if self.reference is None:
         self.reference = Midgard.ObjectReference(
             id=self.bookstore.get_property("guid"), name="guid")
     if self.job is None:
         self.job = Midgard.SqlContentManagerJobLoad(
             connection=self.mgd,
             contentobject=self.bookstore,
             reference=self.reference)
     if self.pool is None:
         self.pool = Midgard.ExecutionPool(max_n_threads=self.max_threads)
 def testZExecuteAsync(self):
     pool = Midgard.ExecutionPool(max_n_threads=2)
     self.job_one.connect("execution-end", self.executionEndCallbackAsync,
                          None)
     self.job_two.connect("execution-end", self.executionEndCallbackAsync,
                          None)
     pool.push(self.job_one)
     pool.push(self.job_two)
     time.sleep(1)
     pool = None
     self.assertEqual(self.async_callback_msg_end, "DONE END ASYNC")
     self.assertNotEqual(self.bookstore_one.get_property("guid"), None)
     self.assertNotEqual(self.bookstore_two.get_property("guid"), None)
     self.assertNotEqual(self.bookstore_one.get_property("id"), None)
     self.assertNotEqual(self.bookstore_one.get_property("id"), 0)
     self.assertNotEqual(self.bookstore_two.get_property("id"), None)
     self.assertNotEqual(self.bookstore_two.get_property("id"), 0)
     self.assertEqual(self.job_one.is_running(), False)
     self.assertEqual(self.job_one.is_failed(), False)
     self.assertEqual(self.job_one.is_executed(), True)
     self.assertEqual(self.job_two.is_running(), False)
     self.assertEqual(self.job_two.is_failed(), False)
     self.assertEqual(self.job_two.is_executed(), True)