def testGetOrderProgressFromId(self):
self.testInstall()
order = Order('fooservice')
self.db.save_order(order)
id = order.get_id()
self.assertEqual(self.db.get_order_progress_from_id(id), .0)
order.close()
self.db.save_order(order)
self.assertEqual(self.db.get_order_progress_from_id(id), 1.0)
task1 = Task(order.id, 'my test task')
self.db.save_task(task1)
self.assertEqual(self.db.get_order_progress_from_id(id), .0)
task2 = Task(order.id, 'another test task')
self.db.save_task(task2)
self.assertEqual(self.db.get_order_progress_from_id(id), .0)
task1.set_progress(.5)
self.db.save_task(task1)
self.assertEqual(self.db.get_order_progress_from_id(id), .25)
task2.set_progress(.5)
self.db.save_task(task2)
self.assertEqual(self.db.get_order_progress_from_id(id), .5)
task1.set_progress(1.0)
self.db.save_task(task1)
self.assertEqual(self.db.get_order_progress_from_id(id), .75)
task2.set_progress(1.0)
self.db.save_task(task2)
self.assertEqual(self.db.get_order_progress_from_id(id), 1.0)
def testGetOrderProgressFromId(self):
self.testInstall()
order = Order('fooservice')
self.db.save_order(order)
id = order.get_id()
self.assertEqual(self.db.get_order_progress_from_id(id), .0)
order.close()
self.db.save_order(order)
self.assertEqual(self.db.get_order_progress_from_id(id), 1.0)
task1 = Task(order.id, 'my test task')
self.db.save_task(task1)
self.assertEqual(self.db.get_order_progress_from_id(id), .0)
task2 = Task(order.id, 'another test task')
self.db.save_task(task2)
self.assertEqual(self.db.get_order_progress_from_id(id), .0)
task1.set_progress(.5)
self.db.save_task(task1)
self.assertEqual(self.db.get_order_progress_from_id(id), .25)
task2.set_progress(.5)
self.db.save_task(task2)
self.assertEqual(self.db.get_order_progress_from_id(id), .5)
task1.set_progress(1.0)
self.db.save_task(task1)
self.assertEqual(self.db.get_order_progress_from_id(id), .75)
task2.set_progress(1.0)
self.db.save_task(task2)
self.assertEqual(self.db.get_order_progress_from_id(id), 1.0)
def testSaveOrder(self):
self.testInstall()
order1 = Order('fooservice')
self.assert_(order1.get_id() is None)
self.db.save_order(order1)
# Check that the order is stored.
order2 = self.db.get_order(id=order1.get_id())
self.assertEqual(order1.get_id(), order2.get_id())
def testCloseOpenOrders(self):
self.testInstall()
order = Order('fooservice')
self.db.add_order(order)
order = self.db.get_orders()[0]
self.assertEqual(order.closed, None)
self.db.close_open_orders()
order = self.db.get_orders()[0]
self.failIfEqual(order.get_closed_timestamp(), None)
def testCloseOpenOrders(self):
self.testInstall()
order = Order('fooservice')
self.db.add_order(order)
order = self.db.get_orders()[0]
self.assertEqual(order.closed, None)
self.db.close_open_orders()
order = self.db.get_orders()[0]
self.assertNotEqual(order.get_closed_timestamp(), None)
def testSaveOrder(self):
self.testInstall()
order1 = Order('fooservice')
self.assertTrue(order1.get_id() is None)
self.db.save_order(order1)
# Check that the order is stored.
order2 = self.db.get_order(id = order1.get_id())
self.assertEqual(order1.get_id(), order2.get_id())
def testSaveTask(self):
self.testInstall()
order = Order('fooservice')
self.db.save_order(order)
task = Task(order.id, 'my test task')
self.assert_(task.id is None)
self.db.save_task(task)
self.assert_(task.id is not None)
def testGetTask(self):
self.testInstall()
order = Order('fooservice')
self.db.save_order(order)
task1 = Task(order.id, 'my test task')
self.db.save_task(task1)
loaded_task = self.db.get_task()
self.assertEqual(task1.id, loaded_task.id)
task2 = Task(order.id, 'another test task')
self.db.save_task(task2)
self.assertRaises(IndexError, self.db.get_task)
def get_order_from_id(self, id):
"""
Returns the order with the given id.
@type id: str
@param id: The id of the order.
@rtype: Order
@return: The order if it exists, None otherwise.
"""
args = 'id=%d' % id
url = self.address + '/order/get/?' + args
result = self.opener.open(url)
if result.getcode() != 200:
raise Exception(response)
return Order.from_xml(result.read())
def get_order_from_id(self, id):
"""
Returns the order with the given id.
@type id: str
@param id: The id of the order.
@rtype: Order
@return: The order if it exists, None otherwise.
"""
args = 'id=%d' % id
url = self.address + '/order/get/?' + args
result = self.opener.open(url)
if result.getcode() != 200:
raise Exception(response)
return Order.from_xml(result.read())
def get_order_list(self, offset = 0, limit = 0):
"""
Returns a list of currently running orders.
@type offset: int
@param offset: The number of orders to skip.
@type limit: int
@param limit: The maximum number of orders to return.
@rtype: list[Order]
@return: A list of orders.
"""
args = 'offset=%d&limit=%d' % (offset, limit)
url = self.address + '/order/list/?' + args
result = self.opener.open(url)
if result.getcode() != 200:
raise Exception(response)
xml = etree.parse(result)
return [Order.from_etree(n) for n in xml.iterfind('order')]
def get_order_list(self,
order_id = None,
service = None,
description = None,
status = None,
created_by = None,
offset = 0,
limit = 0):
"""
Returns a list of currently running orders.
@type offset: int
@param offset: The number of orders to skip.
@type limit: int
@param limit: The maximum number of orders to return.
@type kwargs: dict
@param kwargs: The following keys may be used:
- order_id - the order id (str)
- service - the service name (str)
- description - the order description (str)
- status - the status (str)
- created_by - the user name (str)
@rtype: list[Order]
@return: A list of orders.
"""
args = {'offset': offset, 'limit': limit}
if order_id:
args['order_id'] = order_id
if service:
args['service'] = service
if description:
args['description'] = description
if status:
args['status'] = status
if created_by:
args['created_by'] = created_by
url = self.address + '/order/list/?' + urlencode(args)
with self.opener.open(url) as result:
if result.getcode() != 200:
raise Exception(response)
xml = etree.parse(result)
return [Order.from_etree(n) for n in xml.iterfind('order')]
def get_order_list(self,
order_id=None,
service=None,
description=None,
status=None,
created_by=None,
offset=0,
limit=0):
"""
Returns a list of currently running orders.
@type offset: int
@param offset: The number of orders to skip.
@type limit: int
@param limit: The maximum number of orders to return.
@type kwargs: dict
@param kwargs: The following keys may be used:
- order_id - the order id (str)
- service - the service name (str)
- description - the order description (str)
- status - the status (str)
- created_by - the user name (str)
@rtype: list[Order]
@return: A list of orders.
"""
args = {'offset': offset, 'limit': limit}
if order_id:
args['order_id'] = order_id
if service:
args['service'] = service
if description:
args['description'] = description
if status:
args['status'] = status
if created_by:
args['created_by'] = created_by
url = self.address + '/order/list/?' + urlencode(args)
result = self.opener.open(url)
if result.getcode() != 200:
raise Exception(response)
xml = etree.parse(result)
return [Order.from_etree(n) for n in xml.iterfind('order')]
def testGetTasks(self):
self.testInstall()
order = Order('fooservice')
self.db.save_order(order)
task1 = Task(order.id, 'my test task')
task2 = Task(order.id, 'another test task')
self.db.save_task(task1)
self.db.save_task(task2)
id_list1 = sorted([task1.id, task2.id])
id_list2 = sorted([task.id for task in self.db.get_tasks()])
self.assertEqual(id_list1, id_list2)
tasks = self.db.get_tasks(order_id=order.id)
id_list2 = sorted([task.id for task in tasks])
self.assertEqual(id_list1, id_list2)
id_list2 = [task.id for task in self.db.get_tasks(order_id=2)]
self.assertEqual([], id_list2)
def testAddOrder(self):
self.testInstall()
order1 = Order('fooservice')
self.assertEqual(order1.get_created_by(), getuser())
self.assertEqual(order1.get_description(), '')
self.assertEqual(order1.get_progress(), .0)
order1.created_by = 'this test'
order1.set_description('my description')
self.assertEqual(order1.get_created_by(), 'this test')
self.assertEqual(order1.get_description(), 'my description')
# Save the order.
self.assertTrue(order1.get_id() is None)
self.db.add_order(order1)
order_id = order1.get_id()
self.assertTrue(order_id is not None)
def assert_progress(value):
progress = self.db.get_order_progress_from_id(order_id)
theorder = self.db.get_order(id = order_id)
self.assertEqual(progress, value)
self.assertEqual(theorder.get_progress(), value)
# Check that the order is stored.
order = self.db.get_order(id = order_id)
self.assertEqual(order.get_id(), order_id)
self.assertEqual(order.get_created_by(), 'this test')
self.assertEqual(order.get_closed_timestamp(), None)
self.assertEqual(order.get_description(), 'my description')
assert_progress(.0)
# Check that an order that has no tasks show progress 100% when
# it is closed.
order.close()
self.db.save_order(order)
assert_progress(1.0)
# Add some sub-tasks.
task1 = Task(order.id, 'my test task')
self.db.save_task(task1)
assert_progress(.0)
task2 = Task(order.id, 'another test task')
self.db.save_task(task2)
assert_progress(.0)
# Change the progress, re-check.
task1.set_progress(.5)
self.db.save_task(task1)
assert_progress(.25)
task2.set_progress(.5)
self.db.save_task(task2)
assert_progress(.5)
task1.set_progress(1.0)
self.db.save_task(task1)
assert_progress(.75)
task2.set_progress(1.0)
self.db.save_task(task2)
assert_progress(1.0)
def testAddOrder(self):
self.testInstall()
order1 = Order('fooservice')
self.assertEqual(order1.get_created_by(), getuser())
self.assertEqual(order1.get_description(), '')
self.assertEqual(order1.get_progress(), .0)
order1.created_by = 'this test'
order1.set_description('my description')
self.assertEqual(order1.get_created_by(), 'this test')
self.assertEqual(order1.get_description(), 'my description')
# Save the order.
self.assert_(order1.get_id() is None)
self.db.add_order(order1)
order_id = order1.get_id()
self.assert_(order_id is not None)
def assert_progress(value):
progress = self.db.get_order_progress_from_id(order_id)
theorder = self.db.get_order(id=order_id)
self.assertEqual(progress, value)
self.assertEqual(theorder.get_progress(), value)
# Check that the order is stored.
order = self.db.get_order(id=order_id)
self.assertEqual(order.get_id(), order_id)
self.assertEqual(order.get_created_by(), 'this test')
self.assertEqual(order.get_closed_timestamp(), None)
self.assertEqual(order.get_description(), 'my description')
assert_progress(.0)
# Check that an order that has no tasks show progress 100% when
# it is closed.
order.close()
self.db.save_order(order)
assert_progress(1.0)
# Add some sub-tasks.
task1 = Task(order.id, 'my test task')
self.db.save_task(task1)
assert_progress(.0)
task2 = Task(order.id, 'another test task')
self.db.save_task(task2)
assert_progress(.0)
# Change the progress, re-check.
task1.set_progress(.5)
self.db.save_task(task1)
assert_progress(.25)
task2.set_progress(.5)
self.db.save_task(task2)
assert_progress(.5)
task1.set_progress(1.0)
self.db.save_task(task1)
assert_progress(.75)
task2.set_progress(1.0)
self.db.save_task(task2)
assert_progress(1.0)
def __get_order_from_row(self, row):
assert row is not None
tbl_a = self._table_map['order']
order = Order(row[tbl_a.c.service])
order.id = row[tbl_a.c.id]
order.status = row[tbl_a.c.status]
order.created = row[tbl_a.c.created]
order.closed = row[tbl_a.c.closed]
order.created_by = row[tbl_a.c.created_by]
order.set_description(row[tbl_a.c.description])
try:
order.progress = float(row.avg_progress)
except TypeError: # Order has no tasks
if order.closed:
order.progress = 1.0
else:
order.progress = .0
return order
def __get_order_from_row(self, row):
assert row is not None
tbl_a = self._table_map['order']
order = Order(row[tbl_a.c.service])
order.id = row[tbl_a.c.id]
order.status = row[tbl_a.c.status]
order.created = row[tbl_a.c.created]
order.closed = row[tbl_a.c.closed]
order.created_by = row[tbl_a.c.created_by]
order.set_description(row[tbl_a.c.description])
try:
order.progress = float(row.avg_progress)
except TypeError: # Order has no tasks
if order.closed:
order.progress = 1.0
else:
order.progress = .0
return order
def get_response(self):
data = parse_qs(self.data)
logger = self.daemon.logger
order_db = self.daemon.parent.get_order_db()
if self.path == '/order/':
logger.debug('Parsing order from HTTP request.')
order = Order.from_xml(data['xml'][0])
logger.debug('XML order parsed complete.')
self.daemon.order_incoming_event(order)
return 'application/json', json.dumps(order.get_id())
elif self.path == '/order/get/':
id = int(self.args.get('id'))
order = order_db.get_order(id = id)
return order.toxml()
elif self.path == '/order/count/':
return str(order_db.count_orders())
elif self.path == '/order/status/':
order_id = int(self.args['id'])
order = order_db.get_order(id = order_id)
progress = order_db.get_order_progress_from_id(order_id)
if not order:
raise Exception('no such order id')
closed = order.get_closed_timestamp()
if closed is not None:
closed = str(closed)
response = {'status': order.get_status(),
'progress': progress,
'closed': closed}
return 'application/json', json.dumps(response)
elif self.path == '/order/list/':
# Fetch the orders.
offset = int(self.args.get('offset', 0))
limit = min(100, int(self.args.get('limit', 100)))
orders = order_db.get_orders(offset = offset, limit = limit)
# Assemble an XML document containing the orders.
xml = etree.Element('xml')
for order in orders:
xml.append(order.toetree())
return etree.tostring(xml, pretty_print = True)
elif self.path == '/task/get/':
id = int(self.args.get('id'))
task = order_db.get_task(id = id)
return task.toxml()
elif self.path == '/task/count/':
order_id = self.args.get('order_id')
if order_id:
n_tasks = order_db.count_tasks(order_id = int(order_id))
else:
n_tasks = order_db.count_tasks()
return 'application/json', json.dumps(n_tasks)
elif self.path == '/task/list/':
# Fetch the tasks.
order_id = int(self.args.get('order_id'))
offset = int(self.args.get('offset', 0))
limit = min(100, int(self.args.get('limit', 100)))
tasks = order_db.get_tasks(order_id = order_id,
offset = offset,
limit = limit)
# Assemble an XML document containing the orders.
xml = etree.Element('xml')
for task in tasks:
xml.append(task.toetree())
return etree.tostring(xml, pretty_print = True)
elif self.path == '/log/':
task_id = int(self.args.get('task_id'))
task = order_db.get_task(id = task_id)
filename = task.get_logfile()
if filename and os.path.isfile(filename):
with open(filename) as file:
return file.read()
else:
return ''
elif self.path == '/trace/':
task_id = int(self.args.get('task_id'))
task = order_db.get_task(id = task_id)
filename = task.get_tracefile()
if filename and os.path.isfile(filename):
with open(filename) as file:
return file.read()
else:
return ''
else:
raise Exception('no such API call')
def get_response(self):
data = parse_qs(self.data)
logger = self.daemon.logger
order_db = self.daemon.parent.get_order_db()
if self.path == '/order/':
logger.debug('Parsing order from HTTP request.')
order = Order.from_xml(data['xml'][0])
logger.debug('XML order parsed complete.')
self.daemon.order_incoming_event(order)
return 'application/json', json.dumps(order.get_id())
elif self.path == '/order/get/':
id = int(self.args.get('id'))
order = order_db.get_order(id = id)
return order.toxml()
elif self.path == '/order/count/':
order_id = self.args.get('order_id')
service = self.args.get('service')
descr = self.args.get('description')
status = self.args.get('status')
created_by = self.args.get('created_by')
return str(order_db.count_orders(id = order_id,
service = service,
description = descr,
status = status,
created_by = created_by))
elif self.path == '/order/status/':
order_id = int(self.args['id'])
order = order_db.get_order(id = order_id)
progress = order_db.get_order_progress_from_id(order_id)
if not order:
raise Exception('no such order id')
closed = order.get_closed_timestamp()
if closed is not None:
closed = str(closed)
response = {'status': order.get_status(),
'progress': progress,
'closed': closed}
return 'application/json', json.dumps(response)
elif self.path == '/order/list/':
# Fetch the orders.
offset = int(self.args.get('offset', 0))
limit = min(100, int(self.args.get('limit', 100)))
order_id = self.args.get('order_id')
service = self.args.get('service')
descr = self.args.get('description')
status = self.args.get('status')
created_by = self.args.get('created_by')
orders = order_db.get_orders(id = order_id,
service = service,
description = descr,
status = status,
created_by = created_by,
offset = offset,
limit = limit)
# Assemble an XML document containing the orders.
xml = etree.Element('xml')
for order in orders:
xml.append(order.toetree())
return etree.tostring(xml, pretty_print = True)
elif self.path == '/task/get/':
id = int(self.args.get('id'))
task = order_db.get_task(id = id)
return task.toxml()
elif self.path == '/task/count/':
order_id = self.args.get('order_id')
if order_id:
n_tasks = order_db.count_tasks(order_id = int(order_id))
else:
n_tasks = order_db.count_tasks()
return 'application/json', json.dumps(n_tasks)
elif self.path == '/task/list/':
# Fetch the tasks.
order_id = int(self.args.get('order_id'))
offset = int(self.args.get('offset', 0))
limit = min(100, int(self.args.get('limit', 100)))
tasks = order_db.get_tasks(order_id = order_id,
offset = offset,
limit = limit)
# Assemble an XML document containing the orders.
xml = etree.Element('xml')
for task in tasks:
xml.append(task.toetree())
return etree.tostring(xml, pretty_print = True)
elif self.path == '/log/':
task_id = int(self.args.get('task_id'))
task = order_db.get_task(id = task_id)
filename = task.get_logfile()
if filename and os.path.isfile(filename):
with open(filename) as file:
return file.read()
else:
return ''
elif self.path == '/trace/':
task_id = int(self.args.get('task_id'))
task = order_db.get_task(id = task_id)
filename = task.get_tracefile()
if filename and os.path.isfile(filename):
with open(filename) as file:
return file.read()
else:
return ''
else:
raise Exception('no such API call')
