def getController(self, uri):
"""Find method for a given URI.
@param uri: string with URI
@return: None if no method is found or a tuple containing
the following fields:
- method: name of method mapped to URI
- items: a list of variable intems in the path
- args: a dictionary with additional parameters from URL
"""
if "?" in uri:
(path, query) = uri.split("?", 1)
args = urllib.parse.parse_qs(query)
else:
path = uri
query = None
args = {}
# Try to find handler for request path
result = utils.FindMatch(self._connector, path)
if result is None:
raise http.HttpNotFound()
(handler, groups) = result
return (handler, groups, args)
def HandleItemQueryErrors(fn, *args, **kwargs):
"""Converts errors when querying a single item.
"""
try:
result = fn(*args, **kwargs)
except errors.OpPrereqError as err:
if len(err.args) == 2 and err.args[1] == errors.ECODE_NOENT:
raise http.HttpNotFound()
raise
# In case split query mechanism is used
if not result:
raise http.HttpNotFound()
return result
def HandleItemQueryErrors(fn, *args, **kwargs):
"""Converts errors when querying a single item.
"""
try:
result = fn(*args, **kwargs)
except errors.OpPrereqError, err:
if len(err.args) == 2 and err.args[1] == errors.ECODE_NOENT:
raise http.HttpNotFound()
raise
def GET(self):
"""Returns a job status.
@return: a dictionary with job parameters.
The result includes:
- id: job ID as a number
- status: current job status as a string
- ops: involved OpCodes as a list of dictionaries for each
opcodes in the job
- opstatus: OpCodes status as a list
- opresult: OpCodes results as a list of lists
"""
job_id = self.items[0]
result = self.GetClient().QueryJobs([job_id, ], J_FIELDS)[0]
if result is None:
raise http.HttpNotFound()
return baserlib.MapFields(J_FIELDS, result)
def GET(self):
"""Waits for job changes.
"""
job_id = self.items[0]
fields = self.getBodyParameter("fields")
prev_job_info = self.getBodyParameter("previous_job_info", None)
prev_log_serial = self.getBodyParameter("previous_log_serial", None)
if not isinstance(fields, list):
raise http.HttpBadRequest(
"The 'fields' parameter should be a list")
if not (prev_job_info is None or isinstance(prev_job_info, list)):
raise http.HttpBadRequest(
"The 'previous_job_info' parameter should"
" be a list")
if not (prev_log_serial is None or isinstance(prev_log_serial,
(int, long))):
raise http.HttpBadRequest(
"The 'previous_log_serial' parameter should"
" be a number")
client = self.GetClient()
result = client.WaitForJobChangeOnce(job_id,
fields,
prev_job_info,
prev_log_serial,
timeout=_WFJC_TIMEOUT)
if not result:
raise http.HttpNotFound()
if result == constants.JOB_NOTCHANGED:
# No changes
return None
(job_info, log_entries) = result
return {
"job_info": job_info,
"log_entries": log_entries,
}
def HandleRequest(self, req):
"""Handle a request.
"""
if req.request_method.upper() != http.HTTP_POST:
raise http.HttpBadRequest("Only the POST method is supported")
path = req.request_path
if path.startswith("/"):
path = path[1:]
method = getattr(self, "perspective_%s" % path, None)
if method is None:
raise http.HttpNotFound()
try:
result = (True, method(serializer.LoadJson(req.request_body)))
except backend.RPCFail as err:
# our custom failure exception; str(err) works fine if the
# exception was constructed with a single argument, and in
# this case, err.message == err.args[0] == str(err)
result = (False, str(err))
except errors.QuitGanetiException as err:
# Tell parent to quit
logging.info("Shutting down the node daemon, arguments: %s",
str(err.args))
os.kill(self.noded_pid, signal.SIGTERM)
# And return the error's arguments, which must be already in
# correct tuple format
result = err.args
except Exception as err: # pylint: disable=W0703
logging.exception("Error in RPC call")
result = (False,
"Error while executing backend function: %s" % str(err))
return serializer.DumpJson(result)
def HandleRequest(self, req):
"""Handle a request.
"""
if req.request_method.upper() != http.HTTP_POST:
raise http.HttpBadRequest("Only the POST method is supported")
path = req.request_path
if path.startswith("/"):
path = path[1:]
method = getattr(self, "perspective_%s" % path, None)
if method is None:
raise http.HttpNotFound()
try:
result = (True, method(serializer.LoadJson(req.request_body)))
except backend.RPCFail, err:
# our custom failure exception; str(err) works fine if the
# exception was constructed with a single argument, and in
# this case, err.message == err.args[0] == str(err)
result = (False, str(err))
def HandleItemQueryErrors(fn, *args, **kwargs):
"""Converts errors when querying a single item.
"""
try:
result = fn(*args, **kwargs)
except errors.OpPrereqError, err:
if len(err.args) == 2 and err.args[1] == errors.ECODE_NOENT:
raise http.HttpNotFound()
raise
# In case split query mechanism is used
if not result:
raise http.HttpNotFound()
return result
def FeedbackFn(msg):
"""Feedback logging function for jobs.
We don't have a stdout for printing log messages, so log them to the
http log at least.
@param msg: the message
"""
(_, log_type, log_msg) = msg
logging.info("%s: %s", log_type, log_msg)
