def test_lookup_job(self):
client = molequeue.Client()
client.connect_to_server('MoleQueue')
expected_job_request = molequeue.JobRequest()
expected_job_request.queue = 'salix'
expected_job_request.program = 'sleep (testing)'
expected_job_request.description = 'This is a test job'
expected_job_request.hide_from_gui = True
expected_job_request.popup_on_state_change = False
molequeue_id = client.submit_job_request(expected_job_request)
jobrequest = client.lookup_job(molequeue_id)
self.assertEqual(molequeue_id, jobrequest.molequeue_id())
self.assertEqual(jobrequest.job_state(), molequeue.JobState.ACCEPTED)
self.assertTrue(isinstance(jobrequest.queue_id(), int))
self.assertEqual(jobrequest.queue, expected_job_request.queue)
self.assertEqual(jobrequest.program, expected_job_request.program)
self.assertEqual(jobrequest.description,
expected_job_request.description)
self.assertEqual(jobrequest.hide_from_gui,
expected_job_request.hide_from_gui)
self.assertEqual(jobrequest.popup_on_state_change,
expected_job_request.popup_on_state_change)
client.disconnect()
def test_notification_callback(self):
client = molequeue.Client()
client.connect_to_server('MoleQueue')
self.callback_count = 0
def callback_counter(testcase, msg):
testcase.callback_count += 1
callback = partial(callback_counter, self)
client.register_notification_callback(callback)
client.register_notification_callback(callback)
job_request = molequeue.JobRequest()
job_request.queue = 'salix'
job_request.program = 'sleep (testing)'
molequeue_id = client.submit_job_request(job_request)
# wait for notification
time.sleep(1)
self.assertIs(self.callback_count, 2)
client.disconnect()
def test_lookup_job(self):
client = molequeue.Client()
client.connect_to_server('MoleQueue')
expected_job = molequeue.Job()
expected_job.queue = 'salix'
expected_job.program = 'sleep (testing)'
expected_job.description = 'This is a test job'
expected_job.hide_from_gui = True
expected_job.popup_on_state_change = False
file_contents = molequeue.FileContents()
file_contents.filename = 'test.in'
file_contents.contents = 'Hello'
expected_job.input_file = file_contents
molequeue_id = client.submit_job(expected_job)
job = client.lookup_job(molequeue_id)
self.assertEqual(molequeue_id, job.molequeue_id())
self.assertEqual(job.job_state(), molequeue.JobState.ACCEPTED)
self.assertEqual(job.queue_id(), None)
self.assertEqual(job.queue, expected_job.queue)
self.assertEqual(job.program, expected_job.program)
self.assertEqual(job.description, expected_job.description)
self.assertEqual(job.hide_from_gui, expected_job.hide_from_gui)
self.assertEqual(job.popup_on_state_change,
expected_job.popup_on_state_change)
client.disconnect()
def run_test():
global socketname, molequeue_ids_done, clientId, mq_id_lock, num_jobs
if debug:
print "Client %s connecting to socket: %s" % (clientId, socketname)
client = mq.Client()
client.connect_to_server(socketname)
def notification_callback(msg):
global molequeue_ids_done, mq_id_lock
try:
if msg['method'] == 'jobStateChanged':
if msg['params']['newState'] == 'Finished':
moleQueueId = msg['params']['moleQueueId']
with mq_id_lock:
molequeue_ids_done.append(moleQueueId)
if debug:
print "Job %d finished! (Client %s)" % (moleQueueId,
clientId)
except Exception as ex:
print "Unexpected notification:", msg, ex
sys.stdout.flush()
client.register_notification_callback(notification_callback)
molequeue_ids = []
for i in range(num_jobs):
job = mq.Job()
job.queue = "TestQueue"
job.program = "TestProgram"
job.description = "Test job %d from python client %s" % (i + 1,
clientId)
job.popup_on_state_change = False
molequeue_id = client.submit_job(job, 30)
molequeue_ids.append(molequeue_id)
if molequeue_id == None:
# Timeout
client.disconnect()
raise Exception("Connection timed out!")
if debug:
print "Submitted job %d (Client %s)" % (molequeue_id, clientId)
sys.stdout.flush()
timeout = 30
mq_id_lock.acquire()
while len(molequeue_ids) != len(molequeue_ids_done) and timeout > 0:
if debug:
print "Client %s waiting to finish (timeout=%d unmatchedIDs=%d)"%\
(clientId, timeout, len(molequeue_ids) - len(molequeue_ids_done))
sys.stdout.flush()
timeout -= 1
mq_id_lock.release()
time.sleep(1)
mq_id_lock.acquire()
mq_id_lock.release()
client.disconnect()
if timeout > 0:
return 0
return 1
def test_wait_for_response_timeout(self):
client = molequeue.Client()
# Fake up the request
client._request_response_map[1] = None
start = time.time()
response = client._wait_for_response(1, 3)
end = time.time()
self.assertEqual(response, None)
self.assertEqual(int(end - start), 3)
def test_request_queue_list_update(self):
client = molequeue.Client()
client.connect_to_server('MoleQueue')
queues = client.request_queue_list_update()
for q in queues:
print q.name, ", ", q.programs
client.disconnect()
def run_test():
global socketname
if debug:
print "Connecting to socket: %s" % socketname
client = mq.Client()
client.connect_to_server(socketname)
res = client._send_rpc_kill_request(5)
client.disconnect()
if res == None:
raise Exception("Connection timed out!")
if res != True:
return 1
return 0
def test_submit_job_request(self):
client = molequeue.Client()
client.connect_to_server('MoleQueue')
job_request = molequeue.JobRequest()
job_request.queue = 'salix'
job_request.program = 'sleep (testing)'
molequeue_id = client.submit_job_request(job_request)
print "MoleQueue ID: ", molequeue_id
self.assertTrue(isinstance(molequeue_id, int))
client.disconnect()
def test_submit_job(self):
client = molequeue.Client()
client.connect_to_server('MoleQueue')
job = molequeue.Job()
job.queue = 'salix'
job.program = 'sleep (testing)'
file_path = molequeue.FilePath()
file_path.path = "/tmp/test"
job.input_file = file_path
molequeue_id = client.submit_job(job)
print "MoleQueue ID: ", molequeue_id
self.assertTrue(isinstance(molequeue_id, int))
client.disconnect()
