def require_representation(self, req): """Require raw representation dictionary from falcon request object. This does not perform any field parsing or validation but only uses allowed content-encoding handler to decode content body. Note: Currently only JSON is allowed as content type. Args: req (falcon.Request): request object Returns: dict: raw dictionary of representation supplied in request body """ try: type_, subtype, _ = parse_mime_type(req.content_type) content_type = '/'.join((type_, subtype)) except: raise falcon.HTTPUnsupportedMediaType( description="Invalid Content-Type header: {}".format( req.content_type)) if content_type == 'application/json': body = req.stream.read() return json.loads(body.decode('utf-8')) else: raise falcon.HTTPUnsupportedMediaType( description="only JSON supported, got: {}".format( content_type))
def process_request(self, req, resp): if not req.client_accepts_json: raise falcon.HTTPNotAcceptable( 'This API only supports responses encoded as JSON.', href='http://docs.examples.com/api/json') if req.method in ('POST', 'PUT'): if req.content_type is None: raise falcon.HTTPUnsupportedMediaType( 'No encoding given. This API only supports requests encoded as JSON.', href='https://github.com/eoss-cloud/madxxx_catalog_api') if 'application/json' not in req.content_type: raise falcon.HTTPUnsupportedMediaType( 'This API only supports requests encoded as JSON.', href='https://github.com/eoss-cloud/madxxx_catalog_api')
def on_post(self, req, resp): if not req.client_accepts_json: raise falcon.HTTPNotAcceptable( 'This API only supports responses encoded as JSON.') if 'application/json' not in req.content_type: raise falcon.HTTPUnsupportedMediaType( 'This API only supports requests encoded as JSON.') data = json.loads(req.stream.read().decode('utf-8')) print(data) action = data['action'] result = {'action': action, 'result': 0} if action == 'add': add_result = self.contacts.insert_one(data['data']) result['result'] = str(add_result.inserted_id) elif action == 'delete': delete_result = self.contacts.delete_one( {'_id': ObjectId(data['id'])}) if (delete_result.deleted_count): result['result'] = data['id'] elif action == 'update': update_result = self.contacts.replace_one( {'_id': ObjectId(data['id'])}, data['data']) if (update_result.modified_count): result['result'] = data['id'] resp.content_type = 'application/json' resp.body = json_util.dumps(result)
def process_request(self, request, response): if not request.client_accepts_json: raise falcon.HTTPNotAcceptable('Response encoded as JSON') if request.method in ('POST'): if 'application/json' not in request.content_type: raise falcon.HTTPUnsupportedMediaType('Requests encoded as JSON')
def require_representation(self, req): """Require raw representation dictionary from falcon request object. This does not perform any field parsing or validation but only uses allowed content-encoding handler to decode content body. Note: By default, only JSON is allowed as content type. Args: req (falcon.Request): request object Returns: dict: raw dictionary of representation supplied in request body """ try: type_, subtype, _ = parse_mime_type(req.content_type) content_type = '/'.join((type_, subtype)) except: raise falcon.HTTPUnsupportedMediaType( description="Invalid Content-Type header: {}".format( req.content_type)) return self.media_handler.handle_request(req, content_type=content_type)
def process_request(self, req, resp): """ # req.stream corresponds to the WSGI wsgi.input environ variable, # and allows you to read bytes from the request body. # # See also: PEP 3333 :param req: :param resp: :return: """ if req.content_length in (None, 0): # Nothing to do return try: if 'application/json' in req.content_type: body = req.stream.read() if not body: raise falcon.HTTPBadRequest('Empty request body', 'A valid JSON document is required.') req.context['doc'] = json.loads(body.decode('utf-8')) elif 'multipart/form-data' in (req.content_type or ''): parse(req) else: raise falcon.HTTPUnsupportedMediaType( 'This API only supports requests encoded as JSON or multipart/form-data.') except (ValueError, UnicodeDecodeError): raise falcon.HTTPError(falcon.HTTP_753, 'Malformed JSON', 'Could not decode the request body. The ' 'JSON was incorrect or not encoded as ' 'UTF-8.')
def process_request(self, req, resp): logger.info('Incoming request ' + req.path) enforce = False if self.paths is None: enforce = True else: for path in self.paths: if req.path.startswith(path): enforce = True if enforce: if not req.client_accepts_json: logger.info( 'Client does not accept an JSON answer for {path}'.format( path=req.path)) raise falcon.HTTPNotAcceptable( 'This API only supports responses encoded as JSON.', href='http://docs.examples.com/api/json') if req.method in ('POST', 'PUT'): logger.info( 'For path {method}: {path} only JSON requests are accepted' .format(method=req.method, path=req.path)) if 'application/json' not in req.content_type: raise falcon.HTTPUnsupportedMediaType( 'This API only supports requests encoded as JSON.', href='http://docs.examples.com/api/json')
def on_get(self, req, resp): # Primarily offer DER encoded CRL as per RFC5280 # This is also what StrongSwan expects if req.client_accepts("application/x-pkcs7-crl"): resp.set_header("Content-Type", "application/x-pkcs7-crl") resp.append_header( "Content-Disposition", ("attachment; filename=%s.crl" % const.HOSTNAME)) # Convert PEM to DER logger.debug("Serving revocation list (DER) to %s", req.context.get("remote_addr")) resp.body = self.authority.export_crl(pem=False) elif req.client_accepts("application/x-pem-file"): resp.set_header("Content-Type", "application/x-pem-file") resp.append_header( "Content-Disposition", ("attachment; filename=%s-crl.pem" % const.HOSTNAME)) logger.debug("Serving revocation list (PEM) to %s", req.context.get("remote_addr")) resp.body = self.authority.export_crl() else: logger.debug( "Client %s asked revocation list in unsupported format" % req.context.get("remote_addr")) raise falcon.HTTPUnsupportedMediaType( "Client did not accept application/x-pkcs7-crl or application/x-pem-file" )
def check_media_type(req, resp, params): if req.client_accepts_json: return raise falcon.HTTPUnsupportedMediaType( 'Media Type not Supported', 'This API only supports the JSON media type.', 'http://docs.examples.com/api/json')
def process_request(self, req, resp): if not req.client_accepts_json: raise falcon.HTTPNotAcceptable('This API only supports responses encoded as JSON.') if req.method in ('POST', 'PUT', 'PATCH', 'DELETE'): if not req.content_type or 'application/json' not in req.content_type: raise falcon.HTTPUnsupportedMediaType('This API only supports requests encoded as JSON.')
def _validate_content_type(req): """Validate content type. Function validates request against correct content type. If Content-Type cannot be established (i.e. header is missing), :py:class:`falcon.HTTPMissingHeader` is thrown. If Content-Type is not **application/json**(supported contents types are define in SUPPORTED_CONTENT_TYPES variable), :py:class:`falcon.HTTPUnsupportedMediaType` is thrown. :param falcon.Request req: current request :exception: :py:class:`falcon.HTTPMissingHeader` :exception: :py:class:`falcon.HTTPUnsupportedMediaType` """ content_type = req.content_type LOG.debug('Content-type is {0}'.format(content_type)) if content_type is None or len(content_type) == 0: raise falcon.HTTPMissingHeader('Content-Type') if content_type not in SUPPORTED_CONTENT_TYPES: types = ','.join(SUPPORTED_CONTENT_TYPES) details = ( 'Only [{0}] are accepted as events representation'.format(types)) raise falcon.HTTPUnsupportedMediaType(description=details)
def on_get(self, req, resp): if not req.client_accepts_json: raise falcon.HTTPNotAcceptable( 'This API only supports responses encoded as JSON.', href='http://docs.examples.com/api/json') if req.method in ('POST', 'PUT'): if 'application/json' not in req.content_type: raise falcon.HTTPUnsupportedMediaType( 'This API only supports requests encoded as JSON.', href='http://docs.examples.com/api/json') #id = req.get_param('id') #profiles = RetrieveProfile().ExtractUsersData() #for profile in profiles: # profile.addTag() #recommendations = Recommendation.RetrieveProfileAndCalculate(profiles) #resp.content_type = falcon.MEDIA_JSON #simples = [] #for recommendation in recommendations: # simple = Simple(recommendation.profile.id, recommendation.recommendations) # simples.append(simple) url = "https://8yibsgfqyb.execute-api.us-east-1.amazonaws.com/default/testConnectionMongoDB" payload = {} headers = {} response = requests.request("GET", url, headers=headers, data=payload) print(response.text.encode('utf8')) resp.body = response.text.encode('utf8') resp.status = falcon.HTTP_200
def wrapped(self, req, resp, *args, **kwargs): for content_type in content_types: if req.get_header("Content-Type") == content_type: return func(self, req, resp, *args, **kwargs) raise falcon.HTTPUnsupportedMediaType( "This API call accepts only %s content type" % ", ".join(content_types))
def before_resource(self, req, resp, resource, params): # RequestHeader check if not req.client_accepts_json: raise falcon.HTTPNotAcceptable( 'This API only supports responses encoded as JSON.') if req.method in ('POST', 'PUT'): if 'application/json' not in req.content_type: raise falcon.HTTPUnsupportedMediaType( 'This API only supports requests encoded as JSON.') if req.content_length in (None, 0): # Nothing to do return # convert to json body = req.stream.read() if not body: raise falcon.HTTPBadRequest('Empty request body') try: req.context['data'] = json.loads(body.decode('utf-8')) except (ValueError, UnicodeDecodeError): raise falcon.HTTPError(falcon.HTTP_753, 'Malformed JSON')
def test_http_unsupported_media_type_no_title_and_desc_and_challenges( self): try: raise falcon.HTTPUnsupportedMediaType() except falcon.HTTPUnsupportedMediaType as e: self.assertEqual(None, e.description, 'The description should be None')
def process_request(self, req, resp): """Performs content type enforcement on behalf of REST verbs.""" valid_content_types = ['application/x-yaml'] # GET and DELETE should never carry a message body, and have # no content type. Check for content-length or # transfer-encoding to determine if a content-type header # is required. requires_content_type = (req.method not in ['GET', 'DELETE'] and ( (req.content_length is not None and req.content_length > 0) or req.get_header('transfer-encoding') is not None)) if requires_content_type: content_type = (req.content_type.split(';', 1)[0].strip() if req.content_type else '') if not content_type: raise falcon.HTTPMissingHeader('Content-Type') elif content_type not in valid_content_types: message = ( "Unexpected content type: {type}. Expected content types " "are: {expected}.").format(type=six.b( req.content_type).decode('utf-8'), expected=valid_content_types) raise falcon.HTTPUnsupportedMediaType(description=message)
def lookup_handler(self, media_type, default_media_type=None): """Lookup media handler by media type. Args: media_type (str): A media type of the registered media handler default_media_type (str): The default media type to use when `media_type` is not specified Returns: BaseMediaHandler: A media handler. Raises: falcon.HTTPUnsupportedMediaType: If `content_type` is not supported """ if media_type == '*/*' or not media_type: media_type = default_media_type or self.media_type handler = self.handlers.get(media_type, None) if handler is None: try: resolved = mimeparse.best_match(self.handlers, media_type) assert not resolved handler = self.handlers[resolved] except (AssertionError, KeyError, ValueError): allowed = ', '.join("'{}'".format(media_type) for media_type in self.allowed_media_types) raise falcon.HTTPUnsupportedMediaType( description="'{}' is an unsupported media type, supported " "media types: {}".format(media_type, allowed)) else: self.handlers[media_type] = handler return handler
def on_post(self, req, resp, service): try: svc = self.service_instances[service] except KeyError: self.log.error("Unknown service '%s'", service) raise falcon.HTTPNotFound() if req.content_type and "application/json" not in req.content_type: self.log.error("Unsupported request content type '%s'", req.content_type) raise falcon.HTTPUnsupportedMediaType() try: body = req.bounded_stream.read() headers = req.headers svc_req = Request.from_http(body, headers) except Exception as exc: self.log.error( "Bad request (body: %s, headers: %s): %s", body, headers, exc ) exc = errors.BadRequest(str(exc)) resp.status = exc.http_response_code resp.data = json.dumps(exc.as_dict()).encode("utf-8") self.log.debug("Response body: %s", resp.data) else: svc_resp = svc._execute(svc_req) resp.status = svc_resp.http_status resp.data = svc_resp.http_body for k, v in svc_resp.http_headers.items(): resp.append_header(k, v)
def validate_content_type(req, allowed): """Validates content type. Method validates request against correct content type. If content-type cannot be established (i.e. header is missing), :py:class:`falcon.HTTPMissingHeader` is thrown. If content-type is not **application/json** or **text/plain**, :py:class:`falcon.HTTPUnsupportedMediaType` is thrown. :param falcon.Request req: current request :param iterable allowed: allowed content type :exception: :py:class:`falcon.HTTPMissingHeader` :exception: :py:class:`falcon.HTTPUnsupportedMediaType` """ content_type = req.content_type LOG.debug('Content-Type is %s', content_type) if content_type is None or len(content_type) == 0: raise falcon.HTTPMissingHeader('Content-Type') if content_type not in allowed: sup_types = ', '.join(allowed) details = ('Only [%s] are accepted as logs representations' % str(sup_types)) raise falcon.HTTPUnsupportedMediaType(description=details)
def on_get(self, req, resp): # Primarily offer DER encoded CRL as per RFC5280 # This is also what StrongSwan expects if req.client_accepts("application/x-pkcs7-crl"): resp.set_header("Content-Type", "application/x-pkcs7-crl") resp.append_header("Content-Disposition", ("attachment; filename=%s.crl" % const.HOSTNAME).encode("ascii")) # Convert PEM to DER logger.debug(u"Serving revocation list (DER) to %s", req.context.get("remote_addr")) resp.body = export_crl(pem=False) elif req.client_accepts("application/x-pem-file"): if req.get_param_as_bool("wait"): url = config.LONG_POLL_SUBSCRIBE % "crl" resp.status = falcon.HTTP_SEE_OTHER resp.set_header("Location", url.encode("ascii")) logger.debug(u"Redirecting to CRL request to %s", url) resp.body = "Redirecting to %s" % url else: resp.set_header("Content-Type", "application/x-pem-file") resp.append_header("Content-Disposition", ("attachment; filename=%s-crl.pem" % const.HOSTNAME).encode("ascii")) logger.debug(u"Serving revocation list (PEM) to %s", req.context.get("remote_addr")) resp.body = export_crl() else: logger.debug( u"Client %s asked revocation list in unsupported format" % req.context.get("remote_addr")) raise falcon.HTTPUnsupportedMediaType( "Client did not accept application/x-pkcs7-crl or application/x-pem-file" )
def test_http_unsupported_media_type_with_title_and_desc_and_challenges( self): try: raise falcon.HTTPUnsupportedMediaType( description='Testdescription') except falcon.HTTPUnsupportedMediaType as e: self.assertEqual('Testdescription', e.description, 'Description should be "Testdescription"')
def on_get(self, req, resp,type,id): if type not in ('study','viewer'): raise falcon.HTTPNotFound() file = '%s/%s.hdf5' % (self.viewer_path if type == 'viewer' else self.study_path,id) format = req.params.get('format','png') if format not in ('png','pdf'): raise falcon.HTTPUnsupportedMediaType('Only png and pdf formats are supported') _qq_plot(file,resp,req)
def process_request(self, req, resp): if not req.client_accepts_json: raise falcon.HTTPNotAcceptable('Require Json') if req.method in ('POST', 'PUT'): if 'application/json' not in req.content_type: raise falcon.HTTPUnsupportedMediaType( 'Invalid Content-Type(Require Json)')
def process_request(self, req, resp): if not req.client_accepts_json: raise falcon.HTTPNotAcceptable( description='JSON is the only supported response format') if req.method in ('POST', 'PUT'): if req.content_type and 'application/json' not in req.content_type: raise falcon.HTTPUnsupportedMediaType( description='JSON is the only supported request format')
def require_json(req, resp, resource, params): if not req.client_accepts_json: raise falcon.HTTPNotAcceptable( 'This API only supports responses encoded as JSON.') if req.method in ('POST', 'PUT'): if 'application/json' not in req.content_type: raise falcon.HTTPUnsupportedMediaType( 'This API only supports requests encoded as JSON.')
def process_request(self, req, resp): if not req.client_accepts('application/python-pickle'): raise falcon.HTTPNotAcceptable( 'This API only supports responses encoded as pickle.') if req.method in ('POST', 'PUT'): if 'application/python-pickle' not in req.content_type: raise falcon.HTTPUnsupportedMediaType( 'This API only supports requests encoded as pickle.')
def process_request(self, req, resp): if not req.client_accepts_json: raise falcon.HTTPNotAcceptable( 'This API only supports JSON-encoded responses') if req.method in ['POST']: if 'application/json' not in req.content_type: raise falcon.HTTPUnsupportedMediaType( 'This API only supports JSON-encoded requests')
def RequireJson(**request_handler_args): req = request_handler_args['req'] if not req.client_accepts_json: raise falcon.HTTPNotAcceptable( 'This API only supports responses encoded as JSON.') if req.method in ('POST', 'PUT', 'GET'): if 'application/json' not in req.content_type: raise falcon.HTTPUnsupportedMediaType( 'This API only supports requests encoded as JSON.')
def process_resource(self, req: falcon.Request, _resp: falcon.Response, resource, _params): if req.method in HTTP_WRITE_METHODS: content_type = getattr(resource, 'content_type', 'application/x-www-form-urlencoded') if content_type and content_type not in req.content_type: raise falcon.HTTPUnsupportedMediaType( description="This API only supports requests encoded as '" + content_type + "'")
def process_resource(self, req, resp, resource, params): if _get_response_schema(resource, req) and not req.client_accepts_json: raise falcon.HTTPNotAcceptable( 'This API supports only JSON-encoded responses') if req.method in ('POST', 'PUT', 'PATCH'): if _get_request_schema(req, resource) is not None: if req.content_type is None or 'application/json' not in req.content_type: raise falcon.HTTPUnsupportedMediaType( 'This API supports only JSON-encoded requests')