def process(self): """ Process the request. Produce the data that needs to be displayed for any request handled by this browser. Currently, there is only one request handled by the meta browser. @return: Http return structure. @rtype: Result """ self.breadcrumbs = [ ("Home","/") ] path = self.request.getRequestPath() if path in [ "/", settings.PREFIX_META ]: data = { "code" : Url(settings.PREFIX_CODE), "resource" : Url(settings.PREFIX_RESOURCE), "static" : Url(settings.PREFIX_STATIC), "name" : "MuleSoft RESTx server", "version" : settings.get_version(), "doc" : Url(settings.PREFIX_META + "/doc") } result = Result.ok(data) elif path == settings.PREFIX_META + "/doc": self.breadcrumbs.append(("Doc", settings.PREFIX_META + "/doc")) result = Result.ok(settings.get_docs()) else: result = Result.notFound("Don't know this meta page") return result
def process(self): """ Process the request. Produce the data that needs to be displayed for any request handled by this browser. Currently, there is only one request handled by the meta browser. @return: Http return structure. @rtype: Result """ self.breadcrumbs = [("Home", "/")] path = self.request.getRequestPath() if path in ["/", settings.PREFIX_META]: data = { "code": Url(settings.PREFIX_CODE), "resource": Url(settings.PREFIX_RESOURCE), "static": Url(settings.PREFIX_STATIC), "name": "MuleSoft RESTx server", "version": settings.get_version(), "doc": Url(settings.PREFIX_META + "/doc") } result = Result.ok(data) elif path == settings.PREFIX_META + "/doc": self.breadcrumbs.append(("Doc", settings.PREFIX_META + "/doc")) result = Result.ok(settings.get_docs()) else: result = Result.notFound("Don't know this meta page") return result
def __process_get(self): """ Respond to GET requests. When someone sends GET requests to the code then they want to browse the available code options. @return: HTTP return structure. @rtype: Result """ # It's the responsibility of the browser class to provide breadcrumbs self.breadcrumbs = [("Home", "/"), ("Code", settings.PREFIX_CODE)] if self.request.getRequestPath() == settings.PREFIX_CODE: # # Just show the home page of the code browser (list of all installed code) # data = dict([ (name, { "uri" : Url(class_name().getCodeUri()), "desc" : class_name().getDesc() } ) \ for (name, class_name) in _CODE_MAP.items() \ if name[0] not in EXCLUDE_PREFIXES ]) else: # Path elements (the known code prefix is stripped off) path_elems = self.request.getRequestPath()[len(settings.PREFIX_CODE ):].split("/")[1:] component_name = path_elems[ 0] # This should be the name of the code element # Instantiate the component component_class = getComponentClass(self.request.getRequestPath()) if not component_class: return Result.notFound("Unknown component") component = component_class() component_home_uri = component.getCodeUri() self.breadcrumbs.append((component_name, component_home_uri)) if len(path_elems) == 1: # # No sub-detail specified: We want meta info about a code segment (component) # data = component.getMetaData() data = languageStructToPython(component, data) self.context_header.append( ("[ Create resource ]", settings.PREFIX_RESOURCE + "/_createResourceForm/form/" + component_name, "target=_blank")) else: # # Some sub-detail of the requested component was requested # sub_name = path_elems[1] if sub_name == "doc": data = component.getDocs() self.breadcrumbs.append( ("Doc", component_home_uri + "/doc")) else: return Result.notFound("Unknown code detail") return Result.ok(data)
def handle(self, request): """ Handle a request by dispatching it off to the correct handler. The handler is a 'browser' class, which can be looked up via the BROWSER_MAP that is defined in the settings file. This also catches any RestxExceptions thrown by lower level code and translates them into log messages. @param request: A properly wrapped request. @type request: RestxHttpRequest @return: Response structure and headers @rtype: Tuple of (Result, dict) """ content_type = None try: if request.getRequestPath() == "/": browser_class = BROWSER_MAP['/meta'] else: method = request.getRequestMethod().upper() prefix = "/" + request.getRequestPath().split("/")[1] browser_class = BROWSER_MAP.get(prefix) if browser_class: browser_instance = browser_class(request) result = browser_instance.process() if result.getStatus() >= 200 and result.getStatus() < 300: headers = result.getHeaders() # Check if the Content-type return header was set by # the component. If so, we assume that the component # has returned data in the appropriate format already # and we will not perform any encoding. # For example, if an image file is returned then the # component may have set the content type to "image/jpg". if headers: content_type = result.getHeaders().get("Content-type") else: content_type = None if content_type is None: # If all was OK with the request then we will # render the output in the format that was # requested by the client. But only if we don't # have a content-type set on this request already. content_type, data = browser_instance.renderOutput( result.getEntity()) result.setEntity(data) else: result = Result.notFound("Not found") except RestxMethodNotAllowedException, e: result = Result(e.code, e.msg)
def __process_get(self): """ Respond to GET requests. When someone sends GET requests to the code then they want to browse the available code options. @return: HTTP return structure. @rtype: Result """ # It's the responsibility of the browser class to provide breadcrumbs self.breadcrumbs = [ ("Home", "/"), ("Code", settings.PREFIX_CODE) ] if self.request.getRequestPath() == settings.PREFIX_CODE: # # Just show the home page of the code browser (list of all installed code) # data = dict([ (name, { "uri" : Url(class_name().getCodeUri()), "desc" : class_name().getDesc() } ) \ for (name, class_name) in _CODE_MAP.items() \ if name[0] not in EXCLUDE_PREFIXES ]) else: # Path elements (the known code prefix is stripped off) path_elems = self.request.getRequestPath()[len(settings.PREFIX_CODE):].split("/")[1:] component_name = path_elems[0] # This should be the name of the code element # Instantiate the component component_class = getComponentClass(self.request.getRequestPath()) if not component_class: return Result.notFound("Unknown component") component = component_class() component_home_uri = component.getCodeUri() self.breadcrumbs.append((component_name, component_home_uri)) if len(path_elems) == 1: # # No sub-detail specified: We want meta info about a code segment (component) # data = component.getMetaData() data = languageStructToPython(component, data) self.context_header.append(("[ Create resource ]", settings.PREFIX_RESOURCE+"/_createResourceForm/form/"+component_name, "target=_blank")) else: # # Some sub-detail of the requested component was requested # sub_name = path_elems[1] if sub_name == "doc": data = component.getDocs() self.breadcrumbs.append(("Doc", component_home_uri + "/doc")) else: return Result.notFound("Unknown code detail") return Result.ok(data)
def __process_post(self, is_code, prefix): """ Process a POST request. The only allowed POST requests to code are requests to the base URI of a component. This creates a new resource. Same with spezialiced code. @param is_code: Indicates whether this is a request for un-specialized code. @type is_code: boolean @param prefix: The prefix for this type of request. @type prefix: string @return: HTTP return structure. @rtype: Result """ if is_code: # If we are dealing with actual components then the path of this request # here is the correct path to find the component class. component_path = self.request.getRequestPath() specialized_code_name = None specialized_code = None else: # But if we are dealing with specialized components then we first need to # retrieve the partial resource definition and extract the component path # from there. path_elems = self.request.getRequestPath()[len(prefix):].split("/")[1:] specialized_code_name = path_elems[0] specialized_code = retrieveResourceFromStorage(getResourceUri(specialized_code_name, is_partial=True), only_public=False, is_partial=True) if not specialized_code: return Result.notFound("Cannot find specialized component resource '%s'" % specialized_code_name) component_path = specialized_code["private"]["code_uri"] # # Start by processing and sanity-checking the request. # component = getComponentObjectFromPath(component_path) if not component: return Result.notFound("Unknown component") #component = component_class() body = self.request.getRequestBody() try: param_dict = json.loads(body) except Exception, e: raise RestxException("Malformed request body: " + str(e))
def process(self): """ Process the request. This needs to be overwritten with a specific implementation. @return: Http return code and data as a tuple. @rtype: tuple """ return Result.ok("Base Browser")
def handle(self, request): """ Handle a request by dispatching it off to the correct handler. The handler is a 'browser' class, which can be looked up via the BROWSER_MAP that is defined in the settings file. This also catches any RestxExceptions thrown by lower level code and translates them into log messages. @param request: A properly wrapped request. @type request: RestxHttpRequest @return: Response structure and headers @rtype: Tuple of (Result, dict) """ content_type = None try: if request.getRequestPath() == "/": browser_class = BROWSER_MAP['/meta'] else: method = request.getRequestMethod().upper() prefix = "/"+request.getRequestPath().split("/")[1] browser_class = BROWSER_MAP.get(prefix) if browser_class: browser_instance = browser_class(request) result = browser_instance.process() if result.getStatus() >= 200 and result.getStatus() < 300: headers = result.getHeaders() # Check if the Content-type return header was set by # the component. If so, we assume that the component # has returned data in the appropriate format already # and we will not perform any encoding. # For example, if an image file is returned then the # component may have set the content type to "image/jpg". if headers: content_type = result.getHeaders().get("Content-type") else: content_type = None if content_type is None: # If all was OK with the request then we will # render the output in the format that was # requested by the client. But only if we don't # have a content-type set on this request already. content_type, data = browser_instance.renderOutput(result.getEntity()) result.setEntity(data) else: result = Result.notFound("Not found" ) except RestxMethodNotAllowedException, e: result = Result(e.code, e.msg)
def process(self): """ Process the request. Produce the data that needs to be displayed for any request handled by this browser. Currently, there is only one request handled by the meta browser. @return: Http return code and data as a tuple. @rtype: tuple """ path = self.request.getRequestPath()[len(settings.PREFIX_STATIC) + 1:] if ".." in path: # Won't allow that return HTTP.BAD_REQUEST, "Invalid path specifier" if path.endswith("/"): path = path[:-1] try: fname = settings.get_root_dir() + settings.STATIC_LOCATION + path rfr = RawFileReader() data = rfr.readFile(fname) res = Result.ok(data) # Examine the extension of the filename to see if we can set the content # type based on any of them. If we set the content type here then the # request dispatcher will not attempt to call a render method on the # data we return. i = path.rfind(".") if i > -1: # Found an extension in the filename ext = path[i + 1:].lower() if ext in ["jpg", "png", "gif", "jpeg"]: res.addHeader("Content-type", "image/%s" % ext) return res except (Exception, JavaException), e: return Result.notFound("Not found")
def process(self): """ Process the request. Produce the data that needs to be displayed for any request handled by this browser. Currently, there is only one request handled by the meta browser. @return: Http return code and data as a tuple. @rtype: tuple """ path = self.request.getRequestPath()[len(settings.PREFIX_STATIC)+1:] if ".." in path: # Won't allow that return HTTP.BAD_REQUEST, "Invalid path specifier" if path.endswith("/"): path = path[:-1] try: fname = settings.get_root_dir()+settings.STATIC_LOCATION + path rfr = RawFileReader() data = rfr.readFile(fname) res = Result.ok(data) # Examine the extension of the filename to see if we can set the content # type based on any of them. If we set the content type here then the # request dispatcher will not attempt to call a render method on the # data we return. i = path.rfind(".") if i > -1: # Found an extension in the filename ext = path[i+1:].lower() if ext in [ "jpg", "png", "gif", "jpeg" ]: res.addHeader("Content-type", "image/%s" % ext) return res except (Exception, JavaException), e: return Result.notFound("Not found")
def __process_delete(self, is_code, prefix): """ Process a DELETE request. The only allowed DELETE here is on specialized component resources. @param is_code: Indicates whether this is a request for un-specialized code. @type is_code: boolean @param prefix: The prefix for this type of request. @type prefix: string @return: HTTP return structure. @rtype: Result """ if not is_code: try: deleteResourceFromStorage(self.request.getRequestPath(), True) return Result.ok("Resource deleted") except RestxException, e: return Result(e.code, str(e))
def __process_post(self): """ Process a POST request. The only allowed POST requests to code are requests to the base URI of a component. This creates a new resource. @return: HTTP return structure. @rtype: Result """ # # Start by processing and sanity-checking the request. # component_class = getComponentClass(self.request.getRequestPath()) if not component_class: return Result.notFound("Unknown component") #component = component_class() body = self.request.getRequestBody() try: param_dict = json.loads(body) except Exception, e: raise RestxException("Malformed request body: " + str(e))
def __process_get(self, is_code, prefix): """ Respond to GET requests. When someone sends GET requests to the code then they want to browse the available code options. Same with spezialiced code. @param is_code: Indicates whether this is a request for un-specialized code. @type is_code: boolean @param prefix: The prefix for this type of request. @type prefix: string @return: HTTP return structure. @rtype: Result """ # It's the responsibility of the browser class to provide breadcrumbs if is_code: dirname = "Code" else: dirname = "Specialized" self.breadcrumbs = [ ("Home", "/"), (dirname, prefix) ] if self.request.getRequestPath() == prefix: # # Just show the home page of the code browser (list of all installed (specialized) code) # if is_code: # Data to be taken from the code data = dict() for name in get_component_names(): if name[0] not in EXCLUDE_PREFIXES: # component_info is a tuple, which contains the component class and its manifest info component = make_component(name) data[name] = { "uri" : Url(component.getCodeUri()), "desc" : component.getDesc() } """ data = dict([ (name, { "uri" : Url(component_class().getCodeUri()), "desc" : component_class().getDesc() } ) \ for (name, (component_class, component_config)) in get_code_map().items() \ if name[0] not in EXCLUDE_PREFIXES ]) """ else: # We are looking for partial resources data = listResources(partials=True) else: # Path elements (the known code prefix is stripped off) path_elems = self.request.getRequestPath()[len(prefix):].split("/")[1:] if is_code: # We are referencing actual components here component_name = path_elems[0] # This should be the name of the code element component_path = self.request.getRequestPath() else: # We are looking at a partial resource. Therefore, we need to load # that resource and then get the code URI from it. specialized_code_name = path_elems[0] specialized_code = retrieveResourceFromStorage(getResourceUri(specialized_code_name, is_partial=True), only_public=False, is_partial=True) if not specialized_code: return Result.notFound("Cannot find specialized component resource '%s'" % specialized_code_name) component_path = specialized_code["private"]["code_uri"] # Instantiate the component component = getComponentObjectFromPath(component_path) if not component: return Result.notFound("Unknown component") component_home_uri = component.getCodeUri() if is_code: self.breadcrumbs.append((component_name, component_home_uri)) else: self.breadcrumbs.append((specialized_code_name, specialized_code["public"]["uri"])) if len(path_elems) == 1: # # No sub-detail specified: We want meta info about a code segment (component) # data = component.getMetaData() # # If this is based on a specialized component then we need to overwrite some # of the component's meta data with the info from the specialized component # definition. # if not is_code: data = specializedOverwrite(data, specialized_code) data = languageStructToPython(component, data) if is_code: qs = "" cname = component_name else: qs = "?specialized=y" cname = specialized_code_name self.context_header.append(("[ Create resource ]", settings.PREFIX_RESOURCE+"/_createResourceForm/form/"+cname+qs, "")) #, "target=_blank")) else: # # Some sub-detail of the requested component was requested # sub_name = path_elems[1] if sub_name == "doc": data = component.getDocs() self.breadcrumbs.append(("Doc", component_home_uri + "/doc")) else: return Result.notFound("Unknown code detail") return Result.ok(data)
def process(self): """ Process the request. @return: HTTP result structure. @rtype: Result """ method = self.request.getRequestMethod() if method == HTTP.GET_METHOD: # It's the responsibility of the browser class to provide breadcrumbs self.breadcrumbs = [ ("Home", "/"), ("Resource", settings.PREFIX_RESOURCE) ] if self.request.getRequestPath() == settings.PREFIX_RESOURCE: # # Request to the base URL of all resources (listing resources) # if method == HTTP.GET_METHOD: # # List all the resources # return Result.ok(listResources()) else: raise RestxMethodNotAllowedException() else: # Path elements (the known resource prefix is stripped off) path = self.request.getRequestPath()[len(settings.PREFIX_RESOURCE):] path_elems = path.split("/")[1:] resource_name = path_elems[0] # This should be the name of the resource base # If the path ends with a '/' then there might be an empty element at the end, # which we can remove. if not path_elems[-1:][0]: path_elems.pop() # Before calling delete on a resource, we have to make sure that this DELETE # is just for the resource itself, not a DELETE to some of the sub-services. # If it's just for the resource then there will be only one path element (the # resource name). if method == HTTP.DELETE_METHOD and len(path_elems) == 1: try: deleteResourceFromStorage(self.request.getRequestPath()) return Result.ok("Resource deleted") except RestxException, e: return Result(e.code, e.msg) # Get the public representation of the resource rinfo = _getResourceDetails(resource_name) if not rinfo: return Result.notFound("Unknown component") complete_resource_def = rinfo['complete_resource_def'] resource_home_uri = rinfo['resource_home_uri'] public_resource_def = rinfo['public_resource_def'] code_uri = rinfo['code_uri'] component = rinfo['component'] services = public_resource_def['services'] public_resource_def['uri'] = Url(public_resource_def['uri']) if method == HTTP.GET_METHOD: self.breadcrumbs.append((resource_name, resource_home_uri)) # Was there more to access? if len(path_elems) > 1: # # Some sub-service of the component was requested. This means # we actually need to pass the parameters to the component # and call this service function. # service_name = path_elems[1] # If the service name contains a "." then we might deal with # a content type ID in the URI (used by clients who don't know how # to deal with the 'Accept' or 'Content-type' headers properly). # In that case, we remove that ID from the service name. content_type_from_id = None if "." in service_name: service_name, content_id = service_name.split(".") content_type_from_id = RENDERER_ID_SHORTCUTS.get(content_id) self.request.setContentType(content_type_from_id) if not content_type_from_id: # Get the supported output content types for this service method requested_content_types = self.request.preferredContentTypes() else: # We have a content type specified in the URI requested_content_types = [ content_type_from_id ] try: service_def = complete_resource_def['public']['services'][service_name] except KeyError, e: raise RestxResourceNotFoundException("Cannot find '%s'." % service_name) # This service has some possible runtime parameters defined. # We pass this service definition's parameter list in, since that # means we are filtering out all those parameters that we are # not expecting. service_params = service_def.get('params') if service_params: # Only_params is the list of defined service parameters. Passing this to # get_request_query_dict() means that all other runtime parameters are # filtered out. only_params = service_params.keys() runtime_param_dict = get_request_query_dict(self.request, only_params) else: only_params = None runtime_param_dict = dict() # No service parameters defined? All runtime parameters are removed (ignored). possible_output_types = service_def.get('output_types') if not possible_output_types: # If the service method didn't define any type(s) then we just # indicate the ability to create any of the default types possible_output_types = DEFAULT_OUTPUT_TYPES if type(possible_output_types) in [ str, unicode, java.lang.String ]: # Always store the output types in a list, even if the service method just # defined a single one possible_output_types = [ possible_output_types ] # See that we can match the accepted to possible types matched_type = content_type_match(possible_output_types, requested_content_types) positional_params = path_elems[2:] input = self.request.getRequestBody() try: http_method = __HTTP_METHOD_LOOKUP.get(self.request.getRequestMethod().upper(), HttpMethod.UNKNOWN) result = _accessComponentService(component, complete_resource_def, resource_name, service_name, positional_params, runtime_param_dict, input, self.request, http_method) if result == None or type(result) is not Result: result = Result.noContent() else: result.setNegotiatedContentType(matched_type) except RestxException, e: result = Result(e.code, e.msg)
# and we will not perform any encoding. # For example, if an image file is returned then the # component may have set the content type to "image/jpg". if headers: content_type = result.getHeaders().get("Content-type") else: content_type = None if content_type is None: # If all was OK with the request then we will # render the output in the format that was # requested by the client. But only if we don't # have a content-type set on this request already. content_type, data = browser_instance.renderOutput( result.getEntity()) result.setEntity(data) else: result = Result.notFound("Not found") except RestxMethodNotAllowedException, e: result = Result(e.code, e.msg) except RestxMandatoryParameterMissingException, e: result = Result(e.code, e.msg) except RestxFileNotFoundException, e: result = Result(e.code, e.msg) except RestxException, e: result = Result.badRequest("Bad request: " + e.msg) if content_type: result.addHeader("Content-type", content_type) return result
# and we will not perform any encoding. # For example, if an image file is returned then the # component may have set the content type to "image/jpg". if headers: content_type = result.getHeaders().get("Content-type") else: content_type = None if content_type is None: # If all was OK with the request then we will # render the output in the format that was # requested by the client. But only if we don't # have a content-type set on this request already. content_type, data = browser_instance.renderOutput(result.getEntity()) result.setEntity(data) else: result = Result.notFound("Not found" ) except RestxMethodNotAllowedException, e: result = Result(e.code, e.msg) except RestxMandatoryParameterMissingException, e: result = Result(e.code, e.msg) except RestxFileNotFoundException, e: result = Result(e.code, e.msg) except RestxException, e: result = Result.badRequest("Bad request: " + e.msg) if content_type: result.addHeader("Content-type", content_type); return result
def handle(self, request): """ Handle a request by dispatching it off to the correct handler. The handler is a 'browser' class, which can be looked up via the BROWSER_MAP that is defined in the settings file. This also catches any RestxExceptions thrown by lower level code and translates them into log messages. @param request: A properly wrapped request. @type request: RestxHttpRequest @return: Response structure and headers @rtype: Tuple of (Result, dict) """ content_type = None try: if request.getRequestPath() == "/": browser_class = BROWSER_MAP['/meta'] else: method = request.getRequestMethod().upper() prefix = "/"+request.getRequestPath().split("/")[1] browser_class = BROWSER_MAP.get(prefix) if browser_class: browser_instance = browser_class(request) result = browser_instance.process() if not result: result = Result.badRequest("Cannot handle this request.") elif result.getStatus() >= 200 and result.getStatus() < 300: headers = result.getHeaders() # Check if the Content-type return header was set by # the component. If so, we assume that the component # has returned data in the appropriate format already # and we will not perform any encoding. # For example, if an image file is returned then the # component may have set the content type to "image/jpg". if headers: content_type = result.getHeaders().get("Content-type") else: content_type = None if content_type is None: # If all was OK with the request then we will # render the output in the format that was # requested by the client. But only if we don't # have a content-type set on this request already. ctype = result.getNegotiatedContentType() if ctype: renderer_class = KNOWN_OUTPUT_RENDERERS.get(ctype) if not renderer_class: raise RestxNotAcceptableException() else: # We don't have a negotiated content type yet? # This happens for non-service accesses. pref_content_types = request.preferredContentTypes() renderer_class = KNOWN_OUTPUT_RENDERERS[content_type_match(DEFAULT_OUTPUT_TYPES, pref_content_types)] content_type, data = browser_instance.renderOutput(result.getEntity(), renderer_class) result.setEntity(data) else: result = Result.notFound("Not found" ) except RestxException, e: if type(e) in ALLOWED_EXCEPTIONS: result = Result(e.code, e.msg) else: log("General RestxException: %s" % e.msg) result = Result.internalServerError("Internal Server Error")
@param prefix: The prefix for this type of request. @type prefix: string @return: HTTP return structure. @rtype: Result """ if not is_code: try: deleteResourceFromStorage(self.request.getRequestPath(), True) return Result.ok("Resource deleted") except RestxException, e: return Result(e.code, str(e)) else: return Result.badRequest("Can only delete specialized component resources") def process(self): """ Process the request. @return: HTTP return structure. @rtype: Result """ method = self.request.getRequestMethod() # We are also handling requests for specialized code. Let's # detect them here and pass our findings to the request handlers. if self.request.getRequestPath().startswith(settings.PREFIX_CODE):
class CodeBrowser(BaseBrowser): """ Handles requests for code info. """ def __init__(self, request): """ Initialize the browser with the render-args we need for meta data browsing. @param request: Handle to the HTTP request that needs to be processed. @type request: RestxHttpRequest """ super(CodeBrowser, self).__init__(request, renderer_args=dict(no_annotations=True, no_table_headers=False, no_list_indices=False, no_borders=False)) def __process_get(self): """ Respond to GET requests. When someone sends GET requests to the code then they want to browse the available code options. @return: HTTP return structure. @rtype: Result """ # It's the responsibility of the browser class to provide breadcrumbs self.breadcrumbs = [("Home", "/"), ("Code", settings.PREFIX_CODE)] if self.request.getRequestPath() == settings.PREFIX_CODE: # # Just show the home page of the code browser (list of all installed code) # data = dict([ (name, { "uri" : Url(class_name().getCodeUri()), "desc" : class_name().getDesc() } ) \ for (name, class_name) in _CODE_MAP.items() \ if name[0] not in EXCLUDE_PREFIXES ]) else: # Path elements (the known code prefix is stripped off) path_elems = self.request.getRequestPath()[len(settings.PREFIX_CODE ):].split("/")[1:] component_name = path_elems[ 0] # This should be the name of the code element # Instantiate the component component_class = getComponentClass(self.request.getRequestPath()) if not component_class: return Result.notFound("Unknown component") component = component_class() component_home_uri = component.getCodeUri() self.breadcrumbs.append((component_name, component_home_uri)) if len(path_elems) == 1: # # No sub-detail specified: We want meta info about a code segment (component) # data = component.getMetaData() data = languageStructToPython(component, data) self.context_header.append( ("[ Create resource ]", settings.PREFIX_RESOURCE + "/_createResourceForm/form/" + component_name, "target=_blank")) else: # # Some sub-detail of the requested component was requested # sub_name = path_elems[1] if sub_name == "doc": data = component.getDocs() self.breadcrumbs.append( ("Doc", component_home_uri + "/doc")) else: return Result.notFound("Unknown code detail") return Result.ok(data) def __process_post(self): """ Process a POST request. The only allowed POST requests to code are requests to the base URI of a component. This creates a new resource. @return: HTTP return structure. @rtype: Result """ # # Start by processing and sanity-checking the request. # component_class = getComponentClass(self.request.getRequestPath()) if not component_class: return Result.notFound("Unknown component") #component = component_class() body = self.request.getRequestBody() try: param_dict = json.loads(body) except Exception, e: raise RestxException("Malformed request body: " + str(e)) ret_msg = makeResourceFromClass(component_class, param_dict) # This is returned back to the client, so we should take the URI # string and cast it to a Url() object. That way, the DOCUMENT_ROOT # can be applied as needed before returning this to the client. location = ret_msg['uri'] ret_msg['uri'] = Url(location) return Result.created(location, ret_msg)
def process(self): """ Process the request. @return: HTTP result structure. @rtype: Result """ method = self.request.getRequestMethod() if method == HTTP.GET_METHOD: # It's the responsibility of the browser class to provide breadcrumbs self.breadcrumbs = [("Home", "/"), ("Resource", settings.PREFIX_RESOURCE)] if self.request.getRequestPath() == settings.PREFIX_RESOURCE: # # Request to the base URL of all resources (listing resources) # if method == HTTP.GET_METHOD: # # List all the resources # return Result.ok(listResources()) else: raise RestxMethodNotAllowedException() else: # Path elements (the known resource prefix is stripped off) path = self.request.getRequestPath()[len(settings.PREFIX_RESOURCE ):] path_elems = path.split("/")[1:] resource_name = path_elems[ 0] # This should be the name of the resource base # If the path ends with a '/' then there might be an empty element at the end, # which we can remove. if not path_elems[-1:][0]: path_elems.pop() # Before calling delete on a resource, we have to make sure that this DELETE # is just for the resource itself, not a DELETE to some of the sub-services. # If it's just for the resource then there will be only one path element (the # resource name). if method == HTTP.DELETE_METHOD and len(path_elems) == 1: try: deleteResourceFromStorage(self.request.getRequestPath()) return Result.ok("Resource deleted") except RestxException, e: return Result(e.code, str(e)) # Get the public representation of the resource rinfo = _getResourceDetails(resource_name) complete_resource_def = rinfo['complete_resource_def'] resource_home_uri = rinfo['resource_home_uri'] public_resource_def = rinfo['public_resource_def'] code_uri = rinfo['code_uri'] component = rinfo['component'] services = public_resource_def['services'] public_resource_def['uri'] = Url(public_resource_def['uri']) if method == HTTP.GET_METHOD: self.breadcrumbs.append((resource_name, resource_home_uri)) # Was there more to access? if len(path_elems) > 1: # # Some sub-service of the component was requested. This means # we actually need to pass the parameters to the component # and call this service function. # # This service has some possible runtime parameters defined. runtime_param_dict = get_request_query_dict(self.request) service_name = path_elems[1] positional_params = path_elems[2:] input = self.request.getRequestBody() try: http_method = __HTTP_METHOD_LOOKUP.get( self.request.getRequestMethod().upper(), HttpMethod.UNKNOWN) result = _accessComponentService( component, services, complete_resource_def, resource_name, service_name, positional_params, runtime_param_dict, input, self.request, http_method) except RestxException, e: result = Result(e.code, e.msg) except Exception, e: # The service code threw an exception. We need to log that and return a # normal error back to the user. print traceback.format_exc() log("Exception in component for service '%s': %s" % (service_name, str(e)), facility=LOGF_COMPONENTS) result = Result.internalServerError( "Internal server error. Details have been logged...")
self.request.getRequestMethod().upper(), HttpMethod.UNKNOWN) result = _accessComponentService( component, services, complete_resource_def, resource_name, service_name, positional_params, runtime_param_dict, input, self.request, http_method) except RestxException, e: result = Result(e.code, e.msg) except Exception, e: # The service code threw an exception. We need to log that and return a # normal error back to the user. print traceback.format_exc() log("Exception in component for service '%s': %s" % (service_name, str(e)), facility=LOGF_COMPONENTS) result = Result.internalServerError( "Internal server error. Details have been logged...") if result.getStatus( ) != HTTP.NOT_FOUND and method == HTTP.GET_METHOD and service_name in services: self.breadcrumbs.append( (service_name, services[service_name]['uri'])) return result else: # No, nothing else. Someone just wanted to know more about the resource. if method == HTTP.POST_METHOD: raise RestxMethodNotAllowedException() return Result.ok(public_resource_def)
def process(self): """ Process the request. @return: HTTP result structure. @rtype: Result """ method = self.request.getRequestMethod() if method == HTTP.GET_METHOD: # It's the responsibility of the browser class to provide breadcrumbs self.breadcrumbs = [ ("Home", "/"), ("Resource", settings.PREFIX_RESOURCE) ] if self.request.getRequestPath() == settings.PREFIX_RESOURCE: # # Request to the base URL of all resources (listing resources) # if method == HTTP.GET_METHOD: # # List all the resources # return Result.ok(listResources()) else: raise RestxMethodNotAllowedException() else: # Path elements (the known resource prefix is stripped off) path = self.request.getRequestPath()[len(settings.PREFIX_RESOURCE):] path_elems = path.split("/")[1:] resource_name = path_elems[0] # This should be the name of the resource base # If the path ends with a '/' then there might be an empty element at the end, # which we can remove. if not path_elems[-1:][0]: path_elems.pop() # Before calling delete on a resource, we have to make sure that this DELETE # is just for the resource itself, not a DELETE to some of the sub-services. # If it's just for the resource then there will be only one path element (the # resource name). if method == HTTP.DELETE_METHOD and len(path_elems) == 1: try: deleteResourceFromStorage(self.request.getRequestPath()) return Result.ok("Resource deleted") except RestxException, e: return Result(e.code, str(e)) # Get the public representation of the resource rinfo = _getResourceDetails(resource_name) complete_resource_def = rinfo['complete_resource_def'] resource_home_uri = rinfo['resource_home_uri'] public_resource_def = rinfo['public_resource_def'] code_uri = rinfo['code_uri'] component = rinfo['component'] services = public_resource_def['services'] public_resource_def['uri'] = Url(public_resource_def['uri']) if method == HTTP.GET_METHOD: self.breadcrumbs.append((resource_name, resource_home_uri)) # Was there more to access? if len(path_elems) > 1: # # Some sub-service of the component was requested. This means # we actually need to pass the parameters to the component # and call this service function. # # This service has some possible runtime parameters defined. runtime_param_dict = get_request_query_dict(self.request) service_name = path_elems[1] positional_params = path_elems[2:] input = self.request.getRequestBody() try: http_method = __HTTP_METHOD_LOOKUP.get(self.request.getRequestMethod().upper(), HttpMethod.UNKNOWN) result = _accessComponentService(component, services, complete_resource_def, resource_name, service_name, positional_params, runtime_param_dict, input, self.request, http_method) except RestxException, e: result = Result(e.code, e.msg) except Exception, e: # The service code threw an exception. We need to log that and return a # normal error back to the user. print traceback.format_exc() log("Exception in component for service '%s': %s" % (service_name, str(e)), facility=LOGF_COMPONENTS) result = Result.internalServerError("Internal server error. Details have been logged...")
runtime_param_dict = get_request_query_dict(self.request) service_name = path_elems[1] positional_params = path_elems[2:] input = self.request.getRequestBody() try: http_method = __HTTP_METHOD_LOOKUP.get(self.request.getRequestMethod().upper(), HttpMethod.UNKNOWN) result = _accessComponentService(component, services, complete_resource_def, resource_name, service_name, positional_params, runtime_param_dict, input, self.request, http_method) except RestxException, e: result = Result(e.code, e.msg) except Exception, e: # The service code threw an exception. We need to log that and return a # normal error back to the user. print traceback.format_exc() log("Exception in component for service '%s': %s" % (service_name, str(e)), facility=LOGF_COMPONENTS) result = Result.internalServerError("Internal server error. Details have been logged...") if result.getStatus() != HTTP.NOT_FOUND and method == HTTP.GET_METHOD and service_name in services: self.breadcrumbs.append((service_name, services[service_name]['uri'])) return result else: # No, nothing else. Someone just wanted to know more about the resource. if method == HTTP.POST_METHOD: raise RestxMethodNotAllowedException() return Result.ok(public_resource_def)