def client_task_status(self, client_id, task_id):
""" Retrieve a task status, if valid. """
if not self.clients.has_key(client_id):
raise JSONRPCError(jsonrpc.INVALID_CLIENT_ID)
task = self.tasks.get(task_id)
if not task:
raise JSONRPCError(jsonrpc.INVALID_TASK_ID)
return task["_status"]
def client_task_result(self, client_id, task_id):
""" Retrieve a result and drop it from store """
if not self.clients.has_key(client_id):
raise JSONRPCError(jsonrpc.INVALID_CLIENT_ID)
task = self.tasks.get(task_id)
if not task:
raise JSONRPCError(jsonrpc.INVALID_TASK_ID)
if not task["_status"] in (zerotask.FINISHED, zerotask.FAILED):
raise JSONRPCError(jsonrpc.TASK_NOT_COMPLETE)
result = task["result"]
del self.tasks[task_id]
return result
def _get_client_id(self):
""" Tries to connect to broker and get client id """
method = "zerotask.broker.client_connect"
params = []
request = jsonrpc.request(method, params)
self._req_socket.send_json(request)
response = self._req_socket.recv_json()
if response.has_key("error"):
raise JSONRPCError(response["error"]["code"],
response["error"].get("message"))
client_id = response.get("result")
if not client_id:
raise JSONRPCError(jsonrpc.INVALID_CLIENT_ID)
logging.info("New client id: %s", client_id)
return client_id
def client_disconnect(self, client_id):
""" Deletes client from clients list """
client = self.clients.get(client_id)
if not client:
raise JSONRPCError(jsonrpc.INVALID_CLIENT_ID)
del self.clients[client_id]
return True
def node_task_request(self, node_id, task_id):
""" Receive a task request from a node """
if not self.nodes.has_key(node_id):
raise JSONRPCError(jsonrpc.INVALID_NODE_ID)
task = self.tasks.get(task_id)
if not task:
raise JSONRPCError(jsonrpc.INVALID_TASK_ID)
if task and task["_status"] == zerotask.QUEUED:
result = task
task["_status"] = zerotask.ASSIGNED
task["_node"] = node_id
logging.info("Assigned task %s to node %s", task_id, node_id)
else:
# Task has already been assigned to a node
result = None
return result
def node_task_failed(self, node_id, task_id, error):
""" Saves task error state and announces to client(s) """
if not self.nodes.has_key(node_id):
raise JSONRPCError(jsonrpc.INVALID_NODE_ID)
if not self.tasks.has_key(task_id):
raise JSONRPCError(jsonrpc.INVALID_TASK_ID)
task = self.tasks[task_id]
task["_status"] = zerotask.FAILED
task["error"] = error
announce_method = "zerotask.client.task_result_ready"
announce_params = dict(task_id=task_id)
pub_message = jsonrpc.request(method=announce_method,
params=announce_params,
id=None) # notification
logging.info("Publishing message %s", pub_message)
self.publish_socket.send_json(pub_message)
return True
def node_task_finished(self, node_id, task_id, result):
""" Run task finished process """
if not self.nodes.has_key(node_id):
raise JSONRPCError(jsonrpc.INVALID_NODE_ID)
if not self.tasks.has_key(task_id):
raise JSONRPCError(jsonrpc.INVALID_TASK_ID)
task = self.tasks[task_id]
task["result"] = result
task["_status"] = zerotask.FINISHED
announce_method = "zerotask.client.task_result_ready"
announce_params = dict(task_id=task_id)
pub_message = jsonrpc.request(method=announce_method,
params=announce_params,
id=None) # notification
logging.info("Publishing message %s", pub_message)
self.publish_socket.send_json(pub_message)
return True
def node_connect(self, node_id=None):
""" Adds a node to the node list, and returns node id """
node_id = node_id or jsonrpc.get_random_id()
node = self.nodes.get(node_id)
if node and node['activity'] > time.time() - TIMEOUT:
raise JSONRPCError(jsonrpc.INVALID_NODE_ID)
if not node:
node = {}
self.nodes[node_id] = node
self.nodes[node_id]['activity'] = time.time()
return node_id
def _dispatch(self, method, *args, **kwargs):
""" Turns a request into a JSON-RPC call and calls it """
req_method = "zerotask.broker.client_new_task"
req_params = dict(client_id=self._client_id, method=method)
if args:
req_params["params"] = args
else:
req_params["params"] = kwargs
req_obj = jsonrpc.request(req_method, req_params)
logging.info("Sending message %s", req_obj)
self._req_socket.send_json(req_obj)
result = self._req_socket.recv_json()
logging.info("Recieved response %s", result)
if result.get("error"):
raise JSONRPCError(result["error"]["code"],
result["error"].get("message"))
task_id = result["result"]
logging.info("New task id: %s", task_id)
result_response = None
while True:
sub_result = self._sub_socket.recv_json()
logging.info("Recieved response %s", sub_result)
sub_method = sub_result.get("method")
sub_params = sub_result.get("params")
if sub_method != "zerotask.client.task_result_ready":
logging.info("Method %s not important.", sub_method)
continue
if sub_params.get("task_id") != task_id:
logging.info("%s != %s" % (sub_params.get("task_id"), task_id))
continue
result_method = "zerotask.broker.client_task_result"
result_params = dict(client_id=self._client_id, task_id=task_id)
result_req = jsonrpc.request(result_method, result_params)
self._req_socket.send_json(result_req)
result_response = self._req_socket.recv_json()
break
if result_response.has_key("error"):
raise JSONRPCError(result_response["error"]["code"],
result_response["error"].get("message"))
return result_response.get("result")
def client_new_task(self, client_id, method, params, task_id=None):
""" Stores a CLIENTID-TASKID task structure and returns
the task id to the client.
It will create a task id if one is not provided.
"""
if not self.clients.has_key(client_id):
raise JSONRPCError(jsonrpc.INVALID_CLIENT_ID)
task_id = task_id or jsonrpc.get_random_id()
full_id = "%s-%s" % (client_id, task_id)
if self.tasks.has_key(full_id):
raise JSONRPCError(jsonrpc.INVALID_TASK_ID)
task = self.tasks.get(full_id)
announce_params = dict(method=method, task_id=full_id)
announce_method = "zerotask.node.task_ready"
pub_message = jsonrpc.request(method=announce_method,
params=announce_params,
id=None) # notification
self.publish_socket.send_json(pub_message)
task = dict(method=method,
params=params,
_status=zerotask.QUEUED,
id=task_id)
self.tasks[full_id] = task
return full_id
def node_disconnect(self, node_id):
""" Deletes a node entry from the node list """
if not self.nodes.has_key(node_id):
raise JSONRPCError(jsonrpc.INVALID_NODE_ID)
del self.nodes[node_id]
return True