def test_no_spec(self): obj = {u'body': {'event': 'start_backup'}, 'ttl': 300} document = six.text_type(json.dumps(obj, ensure_ascii=False)) doc_stream = io.StringIO(document) filtered = utils.filter_stream(doc_stream, len(document), spec=None) self.assertEqual(filtered[0], obj) # NOTE(kgriffs): Ensure default value for *spec* is None doc_stream.seek(0) filtered2 = utils.filter_stream(doc_stream, len(document)) self.assertEqual(filtered2, filtered)
def on_put(self, req, resp, project_id, queue_name): LOG.debug( u"Queue metadata PUT - queue: %(queue)s, " u"project: %(project)s", {"queue": queue_name, "project": project_id}, ) try: # Place JSON size restriction before parsing self._validate.queue_metadata_length(req.content_length) except validation.ValidationFailed as ex: LOG.debug(ex) raise wsgi_errors.HTTPBadRequestAPI(six.text_type(ex)) # Deserialize queue metadata metadata, = wsgi_utils.filter_stream(req.stream, req.content_length, spec=None) try: self.queue_ctrl.set_metadata(queue_name, metadata=metadata, project=project_id) except validation.ValidationFailed as ex: LOG.debug(ex) raise wsgi_errors.HTTPBadRequestAPI(six.text_type(ex)) except storage_errors.QueueDoesNotExist: raise falcon.HTTPNotFound() except Exception as ex: LOG.exception(ex) description = _(u"Metadata could not be updated.") raise wsgi_errors.HTTPServiceUnavailable(description) resp.status = falcon.HTTP_204 resp.location = req.path
def on_patch(self, req, resp, project_id, queue_name, claim_id): LOG.debug( u'Claim Item PATCH - claim: %(claim_id)s, ' u'queue: %(queue_name)s, project:%(project_id)s' % { 'queue_name': queue_name, 'project_id': project_id, 'claim_id': claim_id }) # Read claim metadata (e.g., TTL) and raise appropriate # HTTP errors as needed. metadata, = wsgi_utils.filter_stream(req.stream, req.content_length, CLAIM_PATCH_SPEC) try: self._validate.claim_updating(metadata) self.claim_controller.update(queue_name, claim_id=claim_id, metadata=metadata, project=project_id) resp.status = falcon.HTTP_204 except validation.ValidationFailed as ex: LOG.debug(ex) raise wsgi_errors.HTTPBadRequestAPI(six.text_type(ex)) except storage_errors.DoesNotExist as ex: LOG.debug(ex) raise falcon.HTTPNotFound() except Exception as ex: LOG.exception(ex) description = _(u'Claim could not be updated.') raise wsgi_errors.HTTPServiceUnavailable(description)
def on_patch(self, req, resp, project_id, queue_name, claim_id): LOG.debug(_(u'Claim Item PATCH - claim: %(claim_id)s, ' u'queue: %(queue_name)s, project:%(project_id)s') % {'queue_name': queue_name, 'project_id': project_id, 'claim_id': claim_id}) # Read claim metadata (e.g., TTL) and raise appropriate # HTTP errors as needed. metadata, = wsgi_utils.filter_stream(req.stream, req.content_length, CLAIM_PATCH_SPEC) try: self._validate.claim_updating(metadata) self.claim_controller.update(queue_name, claim_id=claim_id, metadata=metadata, project=project_id) resp.status = falcon.HTTP_204 except validation.ValidationFailed as ex: LOG.debug(ex) raise wsgi_errors.HTTPBadRequestAPI(six.text_type(ex)) except storage_errors.DoesNotExist as ex: LOG.debug(ex) raise falcon.HTTPNotFound() except Exception as ex: LOG.exception(ex) description = _(u'Claim could not be updated.') raise wsgi_errors.HTTPServiceUnavailable(description)
def test_no_spec_array(self): things = [{u'body': {'event': 'start_backup'}, 'ttl': 300}] document = six.text_type(json.dumps(things, ensure_ascii=False)) doc_stream = io.StringIO(document) filtered = utils.filter_stream(doc_stream, len(document), doctype=utils.JSONArray, spec=None) self.assertEqual(filtered, things)
def on_post(self, req, resp, project_id, queue_name): LOG.debug( _(u'Claims collection POST - queue: %(queue)s, ' u'project: %(project)s'), { 'queue': queue_name, 'project': project_id }) # Check for an explicit limit on the # of messages to claim limit = req.get_param_as_int('limit') claim_options = {} if limit is None else {'limit': limit} # Place JSON size restriction before parsing if req.content_length > self._metadata_max_length: description = _(u'Claim metadata size is too large.') raise wsgi_exceptions.HTTPBadRequestBody(description) # Read claim metadata (e.g., TTL) and raise appropriate # HTTP errors as needed. metadata, = wsgi_utils.filter_stream(req.stream, req.content_length, CLAIM_POST_SPEC) # Claim some messages try: self._validate.claim_creation(metadata, **claim_options) cid, msgs = self.claim_controller.create(queue_name, metadata=metadata, project=project_id, **claim_options) # Buffer claimed messages # TODO(kgriffs): optimize, along with serialization (below) resp_msgs = list(msgs) except validation.ValidationFailed as ex: raise wsgi_exceptions.HTTPBadRequestAPI(six.text_type(ex)) except Exception as ex: LOG.exception(ex) description = _(u'Claim could not be created.') raise wsgi_exceptions.HTTPServiceUnavailable(description) # Serialize claimed messages, if any. This logic assumes # the storage driver returned well-formed messages. if len(resp_msgs) != 0: for msg in resp_msgs: msg['href'] = _msg_uri_from_claim( req.path.rpartition('/')[0], msg['id'], cid) del msg['id'] resp.location = req.path + '/' + cid resp.body = utils.to_json(resp_msgs) resp.status = falcon.HTTP_201 else: resp.status = falcon.HTTP_204
def on_post(self, req, resp, project_id, queue_name): LOG.debug(_(u'Claims collection POST - queue: %(queue)s, ' u'project: %(project)s'), {'queue': queue_name, 'project': project_id}) # Check for an explicit limit on the # of messages to claim limit = req.get_param_as_int('limit') claim_options = {} if limit is None else {'limit': limit} # Place JSON size restriction before parsing if req.content_length > self._metadata_max_length: description = _(u'Claim metadata size is too large.') raise wsgi_errors.HTTPBadRequestBody(description) # Read claim metadata (e.g., TTL) and raise appropriate # HTTP errors as needed. metadata, = wsgi_utils.filter_stream(req.stream, req.content_length, CLAIM_POST_SPEC) # Claim some messages try: self._validate.claim_creation(metadata, **claim_options) cid, msgs = self.claim_controller.create( queue_name, metadata=metadata, project=project_id, **claim_options) # Buffer claimed messages # TODO(kgriffs): optimize, along with serialization (below) resp_msgs = list(msgs) except validation.ValidationFailed as ex: LOG.debug(ex) raise wsgi_errors.HTTPBadRequestAPI(six.text_type(ex)) except Exception as ex: LOG.exception(ex) description = _(u'Claim could not be created.') raise wsgi_errors.HTTPServiceUnavailable(description) # Serialize claimed messages, if any. This logic assumes # the storage driver returned well-formed messages. if len(resp_msgs) != 0: for msg in resp_msgs: msg['href'] = _msg_uri_from_claim( req.path.rpartition('/')[0], msg['id'], cid) del msg['id'] resp.location = req.path + '/' + cid resp.body = utils.to_json(resp_msgs) resp.status = falcon.HTTP_201 else: resp.status = falcon.HTTP_204
def test_filter_stream_expect_obj(self): obj = {u'body': {'event': 'start_backup'}, 'id': 'DEADBEEF'} document = six.text_type(json.dumps(obj, ensure_ascii=False)) stream = io.StringIO(document) spec = [('body', dict), ('id', six.string_types)] filtered_object, = utils.filter_stream(stream, len(document), spec) self.assertEqual(filtered_object, obj) stream.seek(0) self.assertRaises(falcon.HTTPBadRequest, utils.filter_stream, stream, len(document), spec, doctype=utils.JSONArray)
def test_filter_stream_expect_obj(self): obj = {u'body': {'event': 'start_backup'}, 'id': 'DEADBEEF'} document = six.text_type(json.dumps(obj, ensure_ascii=False)) stream = io.StringIO(document) spec = [('body', dict), ('id', basestring)] filtered_object, = utils.filter_stream(stream, len(document), spec) self.assertEqual(filtered_object, obj) stream.seek(0) self.assertRaises(falcon.HTTPBadRequest, utils.filter_stream, stream, len(document), spec, doctype=utils.JSONArray)
def test_filter_stream_expect_array(self): array = [{u'body': {u'x': 1}}, {u'body': {u'x': 2}}] document = six.text_type(json.dumps(array, ensure_ascii=False)) stream = io.StringIO(document) spec = [('body', dict)] filtered_objects = list(utils.filter_stream( stream, len(document), spec, doctype=utils.JSONArray)) self.assertEqual(filtered_objects, array) stream.seek(0) self.assertRaises(falcon.HTTPBadRequest, utils.filter_stream, stream, len(document), spec, doctype=utils.JSONObject)
def on_post(self, req, resp, project_id, queue_name): LOG.debug( u"Claims collection POST - queue: %(queue)s, " u"project: %(project)s", {"queue": queue_name, "project": project_id}, ) # Check for an explicit limit on the # of messages to claim limit = req.get_param_as_int("limit") claim_options = {} if limit is None else {"limit": limit} # Read claim metadata (e.g., TTL) and raise appropriate # HTTP errors as needed. metadata, = wsgi_utils.filter_stream(req.stream, req.content_length, CLAIM_POST_SPEC) # Claim some messages try: self._validate.claim_creation(metadata, limit=limit) cid, msgs = self.claim_controller.create(queue_name, metadata=metadata, project=project_id, **claim_options) # Buffer claimed messages # TODO(kgriffs): optimize, along with serialization (below) resp_msgs = list(msgs) except validation.ValidationFailed as ex: LOG.debug(ex) raise wsgi_errors.HTTPBadRequestAPI(six.text_type(ex)) except Exception as ex: LOG.exception(ex) description = _(u"Claim could not be created.") raise wsgi_errors.HTTPServiceUnavailable(description) # Serialize claimed messages, if any. This logic assumes # the storage driver returned well-formed messages. if len(resp_msgs) != 0: for msg in resp_msgs: msg["href"] = _msg_uri_from_claim(req.path.rpartition("/")[0], msg["id"], cid) del msg["id"] resp.location = req.path + "/" + cid resp.body = utils.to_json(resp_msgs) resp.status = falcon.HTTP_201 else: resp.status = falcon.HTTP_204
def on_put(self, req, resp, project_id, queue_name): LOG.debug( _(u'Queue metadata PUT - queue: %(queue)s, ' u'project: %(project)s'), { 'queue': queue_name, 'project': project_id }) # Place JSON size restriction before parsing if req.content_length > self._wsgi_conf.metadata_max_length: description = _(u'Queue metadata size is too large.') raise wsgi_exceptions.HTTPBadRequestBody(description) # Deserialize queue metadata metadata, = wsgi_utils.filter_stream(req.stream, req.content_length, spec=None) try: self._validate.queue_content( metadata, check_size=(self._validate._limits_conf.metadata_size_uplimit < self._wsgi_conf.metadata_max_length)) self.queue_ctrl.set_metadata(queue_name, metadata=metadata, project=project_id) except validation.ValidationFailed as ex: raise wsgi_exceptions.HTTPBadRequestAPI(six.text_type(ex)) except storage_exceptions.QueueDoesNotExist: raise falcon.HTTPNotFound() except Exception as ex: LOG.exception(ex) description = _(u'Metadata could not be updated.') raise wsgi_exceptions.HTTPServiceUnavailable(description) resp.status = falcon.HTTP_204 resp.location = req.path
def on_put(self, req, resp, project_id, queue_name): LOG.debug(_(u'Queue metadata PUT - queue: %(queue)s, ' u'project: %(project)s'), {'queue': queue_name, 'project': project_id}) # Place JSON size restriction before parsing if req.content_length > self._wsgi_conf.metadata_max_length: description = _(u'Queue metadata size is too large.') raise wsgi_errors.HTTPBadRequestBody(description) # Deserialize queue metadata metadata, = wsgi_utils.filter_stream(req.stream, req.content_length, spec=None) try: self._validate.queue_content( metadata, check_size=( self._validate._limits_conf.metadata_size_uplimit < self._wsgi_conf.metadata_max_length)) self.queue_ctrl.set_metadata(queue_name, metadata=metadata, project=project_id) except validation.ValidationFailed as ex: LOG.debug(ex) raise wsgi_errors.HTTPBadRequestAPI(six.text_type(ex)) except storage_errors.QueueDoesNotExist: raise falcon.HTTPNotFound() except Exception as ex: LOG.exception(ex) description = _(u'Metadata could not be updated.') raise wsgi_errors.HTTPServiceUnavailable(description) resp.status = falcon.HTTP_204 resp.location = req.path
def on_post(self, req, resp, project_id, queue_name): LOG.debug( _(u"Messages collection POST - queue: %(queue)s, " u"project: %(project)s"), {"queue": queue_name, "project": project_id}, ) client_uuid = wsgi_utils.get_client_uuid(req) # Place JSON size restriction before parsing if req.content_length > self._wsgi_conf.content_max_length: description = _(u"Message collection size is too large.") raise wsgi_exceptions.HTTPBadRequestBody(description) # Pull out just the fields we care about messages = wsgi_utils.filter_stream( req.stream, req.content_length, MESSAGE_POST_SPEC, doctype=wsgi_utils.JSONArray ) # Enqueue the messages partial = False try: # No need to check each message's size if it # can not exceed the request size limit self._validate.message_posting( messages, check_size=(self._validate._limits_conf.message_size_uplimit < self._wsgi_conf.content_max_length), ) message_ids = self.message_controller.post( queue_name, messages=messages, project=project_id, client_uuid=client_uuid ) except validation.ValidationFailed as ex: raise wsgi_exceptions.HTTPBadRequestAPI(six.text_type(ex)) except storage_exceptions.DoesNotExist: raise falcon.HTTPNotFound() except storage_exceptions.MessageConflict as ex: LOG.exception(ex) partial = True message_ids = ex.succeeded_ids if not message_ids: # TODO(kgriffs): Include error code that is different # from the code used in the generic case, below. description = _(u"No messages could be enqueued.") raise wsgi_exceptions.HTTPServiceUnavailable(description) except Exception as ex: LOG.exception(ex) description = _(u"Messages could not be enqueued.") raise wsgi_exceptions.HTTPServiceUnavailable(description) # Prepare the response ids_value = ",".join(message_ids) resp.location = req.path + "?ids=" + ids_value hrefs = [req.path + "/" + id for id in message_ids] body = {"resources": hrefs, "partial": partial} resp.body = utils.to_json(body) resp.status = falcon.HTTP_201
def on_post(self, req, resp, project_id, queue_name): LOG.debug(_(u'Messages collection POST - queue: %(queue)s, ' u'project: %(project)s'), {'queue': queue_name, 'project': project_id}) client_uuid = wsgi_utils.get_client_uuid(req) try: # Place JSON size restriction before parsing self._validate.message_length(req.content_length) except validation.ValidationFailed as ex: LOG.debug(ex) raise wsgi_errors.HTTPBadRequestAPI(six.text_type(ex)) # Pull out just the fields we care about messages = wsgi_utils.filter_stream( req.stream, req.content_length, MESSAGE_POST_SPEC, doctype=wsgi_utils.JSONArray) # Enqueue the messages partial = False try: self._validate.message_posting(messages) message_ids = self.message_controller.post( queue_name, messages=messages, project=project_id, client_uuid=client_uuid) except validation.ValidationFailed as ex: LOG.debug(ex) raise wsgi_errors.HTTPBadRequestAPI(six.text_type(ex)) except storage_errors.DoesNotExist as ex: LOG.debug(ex) raise falcon.HTTPNotFound() except storage_errors.MessageConflict as ex: LOG.exception(ex) partial = True message_ids = ex.succeeded_ids if not message_ids: # TODO(kgriffs): Include error code that is different # from the code used in the generic case, below. description = _(u'No messages could be enqueued.') raise wsgi_errors.HTTPServiceUnavailable(description) except Exception as ex: LOG.exception(ex) description = _(u'Messages could not be enqueued.') raise wsgi_errors.HTTPServiceUnavailable(description) # Prepare the response ids_value = ','.join(message_ids) resp.location = req.path + '?ids=' + ids_value hrefs = [req.path + '/' + id for id in message_ids] body = {'resources': hrefs, 'partial': partial} resp.body = utils.to_json(body) resp.status = falcon.HTTP_201
def on_post(self, req, resp, project_id, queue_name): LOG.debug( _(u'Messages collection POST - queue: %(queue)s, ' u'project: %(project)s'), { 'queue': queue_name, 'project': project_id }) client_uuid = wsgi_utils.get_client_uuid(req) try: # Place JSON size restriction before parsing self._validate.message_length(req.content_length) except validation.ValidationFailed as ex: LOG.debug(ex) raise wsgi_errors.HTTPBadRequestAPI(six.text_type(ex)) # Pull out just the fields we care about messages = wsgi_utils.filter_stream(req.stream, req.content_length, MESSAGE_POST_SPEC, doctype=wsgi_utils.JSONArray) # Enqueue the messages partial = False try: self._validate.message_posting(messages) message_ids = self.message_controller.post(queue_name, messages=messages, project=project_id, client_uuid=client_uuid) except validation.ValidationFailed as ex: LOG.debug(ex) raise wsgi_errors.HTTPBadRequestAPI(six.text_type(ex)) except storage_errors.DoesNotExist as ex: LOG.debug(ex) raise falcon.HTTPNotFound() except storage_errors.MessageConflict as ex: LOG.exception(ex) partial = True message_ids = ex.succeeded_ids if not message_ids: # TODO(kgriffs): Include error code that is different # from the code used in the generic case, below. description = _(u'No messages could be enqueued.') raise wsgi_errors.HTTPServiceUnavailable(description) except Exception as ex: LOG.exception(ex) description = _(u'Messages could not be enqueued.') raise wsgi_errors.HTTPServiceUnavailable(description) # Prepare the response ids_value = ','.join(message_ids) resp.location = req.path + '?ids=' + ids_value hrefs = [req.path + '/' + id for id in message_ids] body = {'resources': hrefs, 'partial': partial} resp.body = utils.to_json(body) resp.status = falcon.HTTP_201