def update_allocation_metrics(self, allocation_time):
allocation_info = self.auctioneer.winning_bid.get_allocation_info()
task = Task.get_task(allocation_info.new_task.task_id)
self.performance_tracker.update_allocation_metrics(task, allocation_time)
if allocation_info.next_task:
task = Task.get_task(allocation_info.next_task.task_id)
self.performance_tracker.update_allocation_metrics(task, only_constraints=True)
def task_status_cb(self, msg):
payload = msg['payload']
timestamp = TimeStamp.from_str(
msg["header"]["timestamp"]).to_datetime()
task_status = TaskStatus.from_payload(payload)
if self.robot_id == task_status.robot_id:
task = Task.get_task(task_status.task_id)
self.logger.debug("Received task status %s for task %s",
task_status.task_status, task.task_id)
self.logger.debug("Sending task status %s for task %s",
task_status.task_status, task.task_id)
self.api.publish(msg, groups=["TASK-ALLOCATION"])
if task_status.task_status == TaskStatusConst.ONGOING:
self.update_timetable(task, task_status.task_progress,
timestamp)
elif task_status.task_status == TaskStatusConst.COMPLETED:
self.logger.debug("Completing execution of task %s",
task.task_id)
self.task = None
task.update_status(task_status.task_status)
def get_earliest_task(self):
task_id = self.stn.get_earliest_task_id()
if task_id:
try:
task = Task.get_task(task_id)
return task
except DoesNotExist:
self.logger.warning("Task %s is not in db or its first node is not the start node", task_id)
def get_r_time_previous_task(self,
insertion_point,
node_type,
earliest=True):
task_id = self.stn.get_task_id(insertion_point - 1)
previous_task = Task.get_task(task_id)
return self.dispatchable_graph.get_time(previous_task.task_id,
node_type, earliest)
def previous_task_is_frozen(self, insertion_point):
task_id = self.stn.get_task_id(insertion_point - 1)
previous_task = Task.get_task(task_id)
if previous_task.status.status in [
TaskStatusConst.DISPATCHED, TaskStatusConst.ONGOING
]:
return True
return False
def get_next_task(self, task):
task_last_node = self.stn.get_task_node_ids(task.task_id)[-1]
if self.stn.has_node(task_last_node + 1):
next_task_id = self.stn.nodes[task_last_node + 1]['data'].task_id
try:
next_task = Task.get_task(next_task_id)
except DoesNotExist:
self.logger.warning("Task %s is not in db", next_task_id)
next_task = Task.create_new(task_id=next_task_id)
return next_task
def get_task(self, position):
""" Returns the task in the given position
:param position: (int) position in the STN
:return: (Task) task
"""
task_id = self.stn.get_task_id(position)
if task_id:
try:
return Task.get_task(task_id)
except DoesNotExist:
self.logger.warning("Task %s is not in db", task_id)
raise DoesNotExist
else:
raise TaskNotFound(position)
def task_status_cb(self, msg):
payload = msg['payload']
timestamp = TimeStamp.from_str(
msg["header"]["timestamp"]).to_datetime()
task_status = TaskStatus.from_payload(payload)
if self.robot_id == task_status.robot_id:
task = Task.get_task(task_status.task_id)
self.logger.debug("Received task status %s for task %s",
task_status.task_status, task.task_id)
if task_status.task_status == TaskStatusConst.ONGOING:
self._update_timetable(task, task_status.task_progress,
timestamp)
task.update_status(task_status.task_status)
def task_status_cb(self, msg):
while self.deleting_task:
time.sleep(0.1)
self.processing_task = True
payload = msg['payload']
timestamp = TimeStamp.from_str(
msg["header"]["timestamp"]).to_datetime()
task_status = TaskStatus.from_payload(payload)
task_progress = task_status.task_progress
task = Task.get_task(task_status.task_id)
self.logger.debug("Received task status %s for task %s by %s",
task_status.task_status, task_status.task_id,
task_status.robot_id)
if task_status.task_status == TaskStatusConst.ONGOING:
self._update_progress(task, task_progress, timestamp)
self.update_timetable(task, task_status.robot_id, task_progress,
timestamp)
self._update_task_schedule(task, task_progress, timestamp)
task.update_status(task_status.task_status)
elif task_status.task_status == TaskStatusConst.COMPLETED:
self.logger.debug("Adding task %s to tasks to remove",
task.task_id)
self.tasks_to_remove.append((task, task_status.task_status))
elif task_status.task_status == TaskStatusConst.UNALLOCATED:
self.re_allocate(task)
elif task_status.task_status == TaskStatusConst.PREEMPTED:
if task.status.status == TaskStatusConst.PREEMPTED:
self.logger.warning("Task %s is already preempted",
task_status.task_id)
return
try:
self._remove_task(task, task_status.task_status)
except TaskNotFound:
return
self.processing_task = False
def allocate_to_robot(self, task_id):
allocation_info = self.bid_placed.get_allocation_info()
self.timetable.add_stn_task(allocation_info.new_task)
if allocation_info.next_task:
self.timetable.add_stn_task(allocation_info.next_task)
self.timetable.stn = allocation_info.stn
self.timetable.dispatchable_graph = allocation_info.dispatchable_graph
self.timetable.store()
self.logger.debug("Robot %s allocated task %s", self.robot_id, task_id)
self.logger.debug("STN: \n %s", self.timetable.stn)
self.logger.debug("Dispatchable graph: \n %s",
self.timetable.dispatchable_graph)
tasks = [task for task in self.timetable.get_tasks()]
self.logger.debug("Tasks allocated to robot %s:%s", self.robot_id,
tasks)
task = Task.get_task(task_id)
task.update_status(TaskStatusConst.ALLOCATED)
task.assign_robots([self.robot_id])
def get_smallest_bid(bids):
""" Get the bid with the smallest cost among all bids.
:param bids: list of bids
:return: the bid with the smallest cost
"""
smallest_bid = None
for bid in bids:
# Do not consider bids for tasks that were dispatched after the bid computation
task = Task.get_task(bid.task_id)
if task.status.status in [
TaskStatusConst.DISPATCHED, TaskStatusConst.ONGOING
]:
continue
if smallest_bid is None or\
bid < smallest_bid or\
(bid == smallest_bid and bid.task_id < smallest_bid.task_id):
smallest_bid = copy.deepcopy(bid)
return smallest_bid
def get_previous_task(self, task):
task_first_node = self.stn.get_task_node_ids(task.task_id)[0]
if task_first_node > 1 and self.stn.has_node(task_first_node - 1):
prev_task_id = self.stn.nodes[task_first_node - 1]['data'].task_id
prev_task = Task.get_task(prev_task_id)
return prev_task
def remove_task_cb(self, msg):
payload = msg['payload']
remove_task = RemoveTaskFromSchedule.from_payload(payload)
task = Task.get_task(remove_task.task_id)
self._remove_task(task, remove_task.status)
