def on_get(self, req, resp, project_id, queue_name): try: resp_dict = self.queue_ctrl.stats(queue_name, project=project_id) message_stats = resp_dict['messages'] if message_stats['total'] != 0: base_path = req.path[:req.path.rindex('/')] + '/messages/' newest = message_stats['newest'] newest['href'] = base_path + newest['id'] del newest['id'] oldest = message_stats['oldest'] oldest['href'] = base_path + oldest['id'] del oldest['id'] resp.content_location = req.path resp.body = utils.to_json(resp_dict) # status defaults to 200 except storage_errors.QueueDoesNotExist as ex: resp_dict = {'messages': {'claimed': 0, 'free': 0, 'total': 0}} resp.content_location = req.path resp.body = utils.to_json(resp_dict) except storage_errors.DoesNotExist as ex: LOG.debug(ex) raise falcon.HTTPNotFound() except Exception as ex: LOG.exception(ex) description = _(u'Queue stats could not be read.') raise wsgi_errors.HTTPServiceUnavailable(description)
def on_get(self, request, response, project_id, pool): """Returns a JSON object for a single pool entry: :: {"weight": 100, "uri": "", options: {...}} :returns: HTTP | [200, 404] """ LOG.debug(u'GET pool - name: %s', pool) data = None detailed = request.get_param_as_bool('detailed') or False try: data = self._ctrl.get(pool, detailed) except errors.PoolDoesNotExist as ex: LOG.debug(ex) raise falcon.HTTPNotFound() data['href'] = request.path # remove the name entry - it isn't needed on GET del data['name'] response.body = transport_utils.to_json(data) response.content_location = request.relative_uri
def on_get(self, req, resp, project_id, queue_name, claim_id): LOG.debug(u'Claim item GET - 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}) try: meta, msgs = self._claim_controller.get( queue_name, claim_id=claim_id, project=project_id) # Buffer claimed messages # TODO(kgriffs): Optimize along with serialization (see below) meta['messages'] = list(msgs) 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 queried.') raise wsgi_errors.HTTPServiceUnavailable(description) # Serialize claimed messages # TODO(kgriffs): Optimize meta['messages'] = [wsgi_utils.format_message_v1( msg, req.path.rsplit('/', 2)[0], meta['id']) for msg in meta['messages']] meta['href'] = req.path del meta['id'] resp.content_location = req.relative_uri resp.body = utils.to_json(meta)
def on_get(self, request, response, project_id, flavor): """Returns a JSON object for a single flavor entry: :: {"pool": "", capabilities: {...}} :returns: HTTP | [200, 404] """ LOG.debug(u'GET flavor - name: %s', flavor) data = None detailed = request.get_param_as_bool('detailed') or False try: data = self._ctrl.get(flavor, project=project_id, detailed=detailed) except errors.FlavorDoesNotExist as ex: LOG.debug(ex) raise falcon.HTTPNotFound() data['href'] = request.path # remove the name entry - it isn't needed on GET del data['name'] response.body = transport_utils.to_json(data)
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} # NOTE(kgriffs): Clients may or may not actually include the # Content-Length header when the body is empty; the following # check works for both 0 and None. if not req.content_length: # No values given, so use defaults metadata = self._default_meta else: # Read claim metadata (e.g., TTL) and raise appropriate # HTTP errors as needed. document = wsgi_utils.deserialize(req.stream, req.content_length) metadata = wsgi_utils.sanitize(document, self._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: base_path = req.path.rpartition('/')[0] resp_msgs = [ wsgi_utils.format_message_v1_1(msg, base_path, cid) for msg in resp_msgs ] resp.location = req.path + '/' + cid resp.body = utils.to_json({'messages': resp_msgs}) resp.status = falcon.HTTP_201 else: resp.status = falcon.HTTP_204
def on_get(self, req, resp, project_id, queue_name): try: resp_dict = self._queue_ctrl.stats(queue_name, project=project_id) message_stats = resp_dict['messages'] if message_stats['total'] != 0: base_path = req.path[:req.path.rindex('/')] + '/messages/' newest = message_stats['newest'] newest['href'] = base_path + newest['id'] del newest['id'] oldest = message_stats['oldest'] oldest['href'] = base_path + oldest['id'] del oldest['id'] resp.content_location = req.path resp.body = utils.to_json(resp_dict) # status defaults to 200 except storage_errors.DoesNotExist as ex: LOG.debug(ex) raise falcon.HTTPNotFound() except Exception as ex: LOG.exception(ex) description = _(u'Queue stats could not be read.') raise wsgi_errors.HTTPServiceUnavailable(description)
def on_get(self, req, resp, project_id, queue_name, claim_id): LOG.debug(u'Claim item GET - 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}) try: meta, msgs = self._claim_controller.get( queue_name, claim_id=claim_id, project=project_id) # Buffer claimed messages # TODO(kgriffs): Optimize along with serialization (see below) meta['messages'] = list(msgs) 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 queried.') raise wsgi_errors.HTTPServiceUnavailable(description) # Serialize claimed messages # TODO(kgriffs): Optimize for msg in meta['messages']: msg['href'] = wsgi_utils.message_url( msg, req.path.rsplit('/', 2)[0], meta['id']) del msg['id'] meta['href'] = req.path del meta['id'] resp.body = utils.to_json(meta)
def on_get(self, request, response, project_id): """Returns a pool listing as objects embedded in an array: [ {"href": "", "weight": 100, "uri": ""}, ... ] :returns: HTTP | [200, 204] """ LOG.debug(u'LIST pools') store = {} request.get_param('marker', store=store) request.get_param_as_int('limit', store=store) request.get_param_as_bool('detailed', store=store) results = {} results['pools'] = list(self._ctrl.list(**store)) for entry in results['pools']: entry['href'] = request.path + '/' + entry.pop('name') if not results['pools']: response.status = falcon.HTTP_204 return response.content_location = request.relative_uri response.body = transport_utils.to_json(results) response.status = falcon.HTTP_200
def on_get(self, request, response, project_id): """Returns a flavor listing as objects embedded in an array: :: [ {"href": "", "capabilities": {}, "pool": ""}, ... ] :returns: HTTP | [200, 204] """ LOG.debug(u'LIST flavors for project_id %s' % project_id) store = {} request.get_param('marker', store=store) request.get_param_as_int('limit', store=store) request.get_param_as_bool('detailed', store=store) results = {} results['flavors'] = list(self._ctrl.list(project=project_id, **store)) for entry in results['flavors']: entry['href'] = request.path + '/' + entry.pop('name') if not results['flavors']: response.status = falcon.HTTP_204 return response.body = transport_utils.to_json(results) response.status = falcon.HTTP_200
def on_get(self, request, response, project_id): """Returns a pool listing as objects embedded in an array: :: [ {"href": "", "weight": 100, "uri": ""}, ... ] :returns: HTTP | [200, 204] """ LOG.debug(u'LIST pools') store = {} request.get_param('marker', store=store) request.get_param_as_int('limit', store=store) request.get_param_as_bool('detailed', store=store) results = {} results['pools'] = list(self._ctrl.list(**store)) for entry in results['pools']: entry['href'] = request.path + '/' + entry.pop('name') if not results['pools']: response.status = falcon.HTTP_204 return response.content_location = request.relative_uri response.body = transport_utils.to_json(results) response.status = falcon.HTTP_200
def on_get(self, req, resp, project_id, queue_name, message_id): LOG.debug(u'Messages item GET - message: %(message)s, ' u'queue: %(queue)s, project: %(project)s', {'message': message_id, 'queue': queue_name, 'project': project_id}) try: message = self._message_controller.get( queue_name, message_id, project=project_id) except storage_errors.DoesNotExist as ex: LOG.debug(ex) raise falcon.HTTPNotFound() except Exception as ex: LOG.exception(ex) description = _(u'Message could not be retrieved.') raise wsgi_errors.HTTPServiceUnavailable(description) resp.content_location = req.relative_uri message = wsgi_utils.format_message_v1( message, req.path.rsplit('/', 2)[0]) resp.body = utils.to_json(message)
def on_get(self, req, resp, project_id, queue_name, message_id): LOG.debug( u'Messages item GET - message: %(message)s, ' u'queue: %(queue)s, project: %(project)s', { 'message': message_id, 'queue': queue_name, 'project': project_id }) try: message = self.message_controller.get(queue_name, message_id, project=project_id) except storage_errors.DoesNotExist as ex: LOG.debug(ex) raise falcon.HTTPNotFound() except Exception as ex: LOG.exception(ex) description = _(u'Message could not be retrieved.') raise wsgi_errors.HTTPServiceUnavailable(description) # Prepare response message['href'] = req.path del message['id'] resp.content_location = req.relative_uri resp.body = utils.to_json(message)
def on_get(self, req, resp, project_id, queue_name, message_id): LOG.debug( u'Messages item GET - message: %(message)s, ' u'queue: %(queue)s, project: %(project)s', { 'message': message_id, 'queue': queue_name, 'project': project_id }) try: message = self._message_controller.get(queue_name, message_id, project=project_id) except storage_errors.DoesNotExist as ex: LOG.debug(ex) raise falcon.HTTPNotFound() except Exception as ex: LOG.exception(ex) description = _(u'Message could not be retrieved.') raise wsgi_errors.HTTPServiceUnavailable(description) # Prepare response message['href'] = req.path message = wsgi_utils.format_message_v1_1(message, req.path.rsplit('/', 2)[0], message['claim_id']) resp.body = utils.to_json(message)
def _pop_messages(self, queue_name, project_id, pop_limit): try: LOG.debug( u'POP messages - queue: %(queue)s, ' u'project: %(project)s', { 'queue': queue_name, 'project': project_id }) messages = self._message_controller.pop(queue_name, project=project_id, limit=pop_limit) except Exception as ex: LOG.exception(ex) description = _(u'Messages could not be popped.') raise wsgi_errors.HTTPServiceUnavailable(description) # Prepare response if not messages: messages = [] body = {'messages': messages} body = utils.to_json(body) return falcon.HTTP_200, body
def on_get(self, req, resp, project_id, queue_name): LOG.debug( u'Messages collection GET - queue: %(queue)s, ' u'project: %(project)s', { 'queue': queue_name, 'project': project_id }) ids = req.get_param_as_list('ids') if ids is None: response = self._get(req, project_id, queue_name) else: response = self._get_by_id( req.path.rsplit('/', 1)[0], project_id, queue_name, ids) if response is None: # NOTE(TheSriram): Trying to get a message by id, should # return the message if its present, otherwise a 404 since # the message might have been deleted. resp.status = falcon.HTTP_404 else: resp.body = utils.to_json(response)
def on_get(self, req, resp, **kwargs): try: resp_dict = self._driver.health() resp.body = utils.to_json(resp_dict) except Exception as ex: LOG.exception(ex) description = _(u'Health status could not be read.') raise wsgi_errors.HTTPServiceUnavailable(description)
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} # NOTE(kgriffs): Clients may or may not actually include the # Content-Length header when the body is empty; the following # check works for both 0 and None. if not req.content_length: # No values given, so use defaults metadata = self._default_meta else: # Read claim metadata (e.g., TTL) and raise appropriate # HTTP errors as needed. document = wsgi_utils.deserialize(req.stream, req.content_length) metadata = wsgi_utils.sanitize(document, self._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_get(self, req, resp, project_id): LOG.debug(u'Queue collection GET - project: %(project)s', {'project': project_id}) kwargs = {} # NOTE(kgriffs): This syntax ensures that # we don't clobber default values with None. req.get_param('marker', store=kwargs) req.get_param_as_int('limit', store=kwargs) req.get_param_as_bool('detailed', store=kwargs) try: self._validate.queue_listing(**kwargs) results = self.queue_controller.list(project=project_id, **kwargs) 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'Queues could not be listed.') raise wsgi_errors.HTTPServiceUnavailable(description) # Buffer list of queues queues = list(next(results)) # Check for an empty list if len(queues) == 0: resp.status = falcon.HTTP_204 return # Got some. Prepare the response. kwargs['marker'] = next(results) for each_queue in queues: each_queue['href'] = req.path + '/' + each_queue['name'] response_body = { 'queues': queues, 'links': [ { 'rel': 'next', 'href': req.path + falcon.to_query_str(kwargs) } ] } resp.content_location = req.relative_uri resp.body = utils.to_json(response_body)
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. document = wsgi_utils.deserialize(req.stream, req.content_length) metadata = wsgi_utils.sanitize(document, 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_get(self, request, response, project_id): """Returns a flavor listing as objects embedded in an object: :: { "flavors": [ {"href": "", "capabilities": {}, "pool": ""}, ... ], "links": [ {"rel": "next", "href": ""}, ... ] } :returns: HTTP | 200 """ LOG.debug(u'LIST flavors for project_id %s' % project_id) store = {} request.get_param('marker', store=store) request.get_param_as_int('limit', store=store) request.get_param_as_bool('detailed', store=store) cursor = self._ctrl.list(project=project_id, **store) flavors = list(next(cursor)) results = {} if flavors: store['marker'] = next(cursor) for entry in flavors: entry['href'] = request.path + '/' + entry.pop('name') results['links'] = [ { 'rel': 'next', 'href': request.path + falcon.to_query_str(store) } ] results['flavors'] = flavors response.body = transport_utils.to_json(results) response.status = falcon.HTTP_200
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. document = wsgi_utils.deserialize(req.stream, req.content_length) metadata = wsgi_utils.sanitize(document, 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: resp_msgs = [wsgi_utils.format_message_v1( msg, req.path.rpartition('/')[0], cid) for msg in resp_msgs] 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_get(self, request, response, project_id): """Returns a pool listing as objects embedded in an object: :: { "pools": [ {"href": "", "weight": 100, "uri": ""}, ... ], "links": [ {"href": "", "rel": "next"} ] } :returns: HTTP | 200 """ LOG.debug(u'LIST pools') store = {} request.get_param('marker', store=store) request.get_param_as_int('limit', store=store) request.get_param_as_bool('detailed', store=store) cursor = self._ctrl.list(**store) pools = list(next(cursor)) results = {} if pools: store['marker'] = next(cursor) for entry in pools: entry['href'] = request.path + '/' + entry.pop('name') results['links'] = [ { 'rel': 'next', 'href': request.path + falcon.to_query_str(store) } ] results['pools'] = pools response.content_location = request.relative_uri response.body = transport_utils.to_json(results) response.status = falcon.HTTP_200
def on_get(self, request, response, project_id): """Returns a flavor listing as objects embedded in an object: :: { "flavors": [ {"href": "", "capabilities": {}, "pool": ""}, ... ], "links": [ {"rel": "next", "href": ""}, ... ] } :returns: HTTP | 200 """ LOG.debug(u'LIST flavors for project_id %s' % project_id) store = {} request.get_param('marker', store=store) request.get_param_as_int('limit', store=store) request.get_param_as_bool('detailed', store=store) cursor = self._ctrl.list(project=project_id, **store) flavors = list(next(cursor)) results = {} if flavors: store['marker'] = next(cursor) for entry in flavors: entry['href'] = request.path + '/' + entry.pop('name') results['links'] = [{ 'rel': 'next', 'href': request.path + falcon.to_query_str(store) }] results['flavors'] = flavors response.body = transport_utils.to_json(results) response.status = falcon.HTTP_200
def on_get(self, req, resp, project_id, queue_name): LOG.debug(u'Messages collection GET - queue: %(queue)s, ' u'project: %(project)s', {'queue': queue_name, 'project': project_id}) resp.content_location = req.relative_uri ids = req.get_param_as_list('ids') if ids is None: response = self._get(req, project_id, queue_name) else: response = self._get_by_id(req.path, project_id, queue_name, ids) if response is None: resp.status = falcon.HTTP_204 return resp.body = utils.to_json(response)
def on_get(self, req, resp, project_id, queue_name): LOG.debug(u'Queue metadata GET - queue: %(queue)s, ' u'project: %(project)s', {'queue': queue_name, 'project': project_id}) try: resp_dict = self._queue_controller.get(queue_name, project=project_id) except storage_errors.DoesNotExist as ex: LOG.debug(ex) raise falcon.HTTPNotFound() except Exception as ex: LOG.exception(ex) description = _(u'Queue metadata could not be retrieved.') raise wsgi_errors.HTTPServiceUnavailable(description) resp.body = utils.to_json(resp_dict)
def on_get(self, req, resp, project_id, queue_name): LOG.debug( u'Messages collection GET - queue: %(queue)s, ' u'project: %(project)s', { 'queue': queue_name, 'project': project_id }) resp.content_location = req.relative_uri ids = req.get_param_as_list('ids') if ids is None: response = self._get(req, project_id, queue_name) else: response = self._get_by_id(req.path, project_id, queue_name, ids) if response is None: resp.status = falcon.HTTP_204 return resp.body = utils.to_json(response)
def on_get(self, req, resp, project_id, queue_name): LOG.debug(u'Messages collection GET - queue: %(queue)s, ' u'project: %(project)s', {'queue': queue_name, 'project': project_id}) ids = req.get_param_as_list('ids') if ids is None: response = self._get(req, project_id, queue_name) else: response = self._get_by_id(req.path.rsplit('/', 1)[0], project_id, queue_name, ids) if response is None: # NOTE(TheSriram): Trying to get a message by id, should # return the message if its present, otherwise a 404 since # the message might have been deleted. resp.status = falcon.HTTP_404 else: resp.body = utils.to_json(response)
def _pop_messages(self, queue_name, project_id, pop_limit): try: LOG.debug(u'POP messages - queue: %(queue)s, ' u'project: %(project)s', {'queue': queue_name, 'project': project_id}) messages = self._message_controller.pop( queue_name, project=project_id, limit=pop_limit) except Exception as ex: LOG.exception(ex) description = _(u'Messages could not be popped.') raise wsgi_errors.HTTPServiceUnavailable(description) # Prepare response if not messages: messages = [] body = {'messages': messages} body = utils.to_json(body) return falcon.HTTP_200, body
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_helpers.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)) # Deserialize and validate the request body document = wsgi_utils.deserialize(req.stream, req.content_length) messages = wsgi_utils.sanitize(document, MESSAGE_POST_SPEC, doctype=wsgi_utils.JSONArray) 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) 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] # NOTE(kgriffs): As of the Icehouse release, drivers are # no longer allowed to enqueue a subset of the messages # submitted by the client; it's all or nothing. Therefore, # 'partial' is now always False in the v1.0 API, and the # field has been removed in v1.1. body = {'resources': hrefs, 'partial': False} 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_helpers.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)) # Deserialize and validate the incoming messages document = wsgi_utils.deserialize(req.stream, req.content_length) if 'messages' not in document: description = _(u'No messages were found in the request body.') raise wsgi_errors.HTTPBadRequestAPI(description) messages = wsgi_utils.sanitize(document['messages'], self._message_post_spec, doctype=wsgi_utils.JSONArray) try: self._validate.message_posting(messages) if not self._queue_controller.exists(queue_name, project_id): self._queue_controller.create(queue_name, project=project_id) 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) 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} 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)) # Deserialize and validate the request body document = wsgi_utils.deserialize(req.stream, req.content_length) messages = wsgi_utils.sanitize(document, MESSAGE_POST_SPEC, doctype=wsgi_utils.JSONArray) 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) 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] # NOTE(kgriffs): As of the Icehouse release, drivers are # no longer allowed to enqueue a subset of the messages # submitted by the client; it's all or nothing. Therefore, # 'partial' is now always False in the v1.0 API, and the # field has been removed in v1.1. body = {'resources': hrefs, 'partial': False} 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_helpers.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)) # Deserialize and validate the incoming messages document = wsgi_utils.deserialize(req.stream, req.content_length) if 'messages' not in document: description = _(u'No messages were found in the request body.') raise wsgi_errors.HTTPBadRequestAPI(description) messages = wsgi_utils.sanitize(document['messages'], self._message_post_spec, doctype=wsgi_utils.JSONArray) try: self._validate.message_posting(messages) if not self._queue_controller.exists(queue_name, project_id): self._queue_controller.create(queue_name, project=project_id) 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) 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} resp.body = utils.to_json(body) resp.status = falcon.HTTP_201