def process_request(self, req, body, project_id): try: validation.validate_params(self.schema, body) # parse request_items request_items = parser.Parser.parse_request_items( body[parser.Props.REQUEST_ITEMS]) except Exception: raise exception.ValidationException() try: req.context.tenant = project_id request_list = collections.deque() for rq_item in request_items: request_list.append(rq_item) response = {'unprocessed_items': {}} if not storage.execute_write_batch(req.context, request_list): raise exception.AWSErrorResponseException( 'Batch write failed') return response except exception.AWSErrorResponseException as e: raise e except Exception: raise exception.AWSErrorResponseException()
def scan(self, req, body, project_id, table_name): validation.validate_params(self.schema, body) req.context.tenant = project_id try: # TODO ikhudoshyn: table_name may be index name attrs_to_get = body.get(parser.Props.ATTRIBUTES_TO_GET) select = body.get(parser.Props.SELECT) select_type = parser.Parser.parse_select_type(select, attrs_to_get) limit = body.get(parser.Props.LIMIT) exclusive_start_key = body.get(parser.Props.EXCLUSIVE_START_KEY) exclusive_start_key = ( parser.Parser.parse_item_attributes(exclusive_start_key) if exclusive_start_key else None ) scan_filter = body.get(parser.Props.SCAN_FILTER, {}) condition_map = parser.Parser.parse_attribute_conditions(scan_filter) segment = body.get(parser.Props.SEGMENT, 0) total_segments = body.get(parser.Props.TOTAL_SEGMENTS, 1) assert segment < total_segments except Exception: raise exception.AWSErrorResponseException() try: result = storage.scan( req.context, table_name, condition_map, attributes_to_get=attrs_to_get, limit=limit, exclusive_start_key=exclusive_start_key, ) response = {parser.Props.COUNT: result.count, parser.Props.SCANNED_COUNT: result.scanned_count} if not select_type.is_count: response[parser.Props.ITEMS] = [parser.Parser.format_item_attributes(row) for row in result.items] if result.last_evaluated_key: response[parser.Props.LAST_EVALUATED_KEY] = parser.Parser.format_item_attributes( result.last_evaluated_key ) return response except exception.AWSErrorResponseException as e: raise e except Exception: raise exception.AWSErrorResponseException()
def process_request(self, req, body, project_id, table_name): try: validation.validate_params(self.schema, body) req.context.tenant = project_id # get attributes_to_get attributes_to_get = body.get(parser.Props.ATTRIBUTES_TO_GET) select_type = ( models.SelectType.all() if attributes_to_get is None else models.SelectType.specified_attributes(attributes_to_get) ) # parse key_attributes key_attributes = parser.Parser.parse_item_attributes( body[parser.Props.KEY] ) # parse consistent_read consistent_read = body.get( parser.Props.CONSISTENT_READ, False ) # format conditions to get item indexed_condition_map = { name: [models.IndexedCondition.eq(value)] for name, value in key_attributes.iteritems() } except Exception: raise exception.ValidationException() try: # get item result = storage.select_item( req.context, table_name, indexed_condition_map, select_type=select_type, limit=2, consistent=consistent_read) # format response if result.count == 0: return {} response = { parser.Props.ITEM: parser.Parser.format_item_attributes( result.items[0]) } return response except exception.AWSErrorResponseException as e: raise e except Exception: raise exception.AWSErrorResponseException()
def process_request(self, req, body, project_id, table_name): try: validation.validate_params(self.schema, body) # parse expected item conditions expected_item_conditions = ( parser.Parser.parse_expected_attribute_conditions( body.get(parser.Props.EXPECTED, {}) ) ) # parse item item_attributes = parser.Parser.parse_item_attributes( body[parser.Props.ITEM] ) # parse return_values param return_values = body.get( parser.Props.RETURN_VALUES, parser.Values.RETURN_VALUES_NONE ) except Exception: raise exception.ValidationException() try: # put item req.context.tenant = project_id result = storage.put_item( req.context, models.PutItemRequest(table_name, item_attributes), if_not_exist=False, expected_condition_map=expected_item_conditions) if not result: raise exception.AWSErrorResponseException() # format response response = {} if return_values != parser.Values.RETURN_VALUES_NONE: response[parser.Props.ATTRIBUTES] = ( parser.Parser.format_item_attributes(item_attributes) ) return response except exception.AWSErrorResponseException as e: raise e except Exception: raise exception.AWSErrorResponseException()
def create_table(self, req, body, project_id): validation.validate_params(self.schema, body) try: table_name = body.get(parser.Props.TABLE_NAME, None) #parse table attributes attribute_definitions = parser.Parser.parse_attribute_definitions( body.get(parser.Props.ATTRIBUTE_DEFINITIONS, {}) ) #parse table key schema key_attrs = parser.Parser.parse_key_schema( body.get(parser.Props.KEY_SCHEMA, []) ) #parse table indexed field list indexed_attr_names = parser.Parser.parse_local_secondary_indexes( body.get( parser.Props.LOCAL_SECONDARY_INDEXES, []) ) #prepare table_schema structure table_schema = models.TableSchema( table_name, attribute_definitions, key_attrs, indexed_attr_names) except Exception: raise exception.ValidationException() try: # creating table req.context.tenant = project_id storage.create_table(req.context, table_schema) url = req.path_url + "/" + table_name bookmark = req.path_url + "/" + table_name return { parser.Props.TABLE_DESCRIPTION: { parser.Props.ATTRIBUTE_DEFINITIONS: ( parser.Parser.format_attribute_definitions( attribute_definitions ) ), parser.Props.CREATION_DATE_TIME: 0, parser.Props.ITEM_COUNT: 0, parser.Props.KEY_SCHEMA: ( parser.Parser.format_key_schema( key_attrs ) ), parser.Props.LOCAL_SECONDARY_INDEXES: ( parser.Parser.format_local_secondary_indexes( key_attrs[0], indexed_attr_names ) ), parser.Props.TABLE_NAME: table_name, parser.Props.TABLE_STATUS: ( parser.Values.TABLE_STATUS_ACTIVE ), parser.Props.TABLE_SIZE_BYTES: 0, parser.Props.LINKS: [ { parser.Props.HREF: url, parser.Props.REL: parser.Values.SELF }, { parser.Props.HREF: bookmark, parser.Props.REL: parser.Values.BOOKMARK } ] } } except exception.TableAlreadyExistsException: raise exception.ResourceInUseException() except exception.AWSErrorResponseException as e: raise e except Exception: raise exception.AWSErrorResponseException()
def query(self, req, body, project_id, table_name): validation.validate_params(self.schema, body) req.context.tenant = project_id try: # parse select_type attributes_to_get = body.get(parser.Props.ATTRIBUTES_TO_GET) if attributes_to_get is not None: attributes_to_get = frozenset(attributes_to_get) select = body.get(parser.Props.SELECT) index_name = body.get(parser.Props.INDEX_NAME) select_type = parser.Parser.parse_select_type(select, attributes_to_get, index_name) # parse exclusive_start_key_attributes exclusive_start_key_attributes = body.get( parser.Props.EXCLUSIVE_START_KEY) if exclusive_start_key_attributes is not None: exclusive_start_key_attributes = ( parser.Parser.parse_item_attributes( exclusive_start_key_attributes ) ) # parse indexed_condition_map indexed_condition_map = parser.Parser.parse_attribute_conditions( body.get(parser.Props.KEY_CONDITIONS)) # TODO(dukhlov): # it would be nice to validate given table_name, key_attributes and # attributes_to_get to schema expectation consistent_read = body.get( parser.Props.CONSISTENT_READ, False) limit = body.get(parser.Props.LIMIT) order_asc = body.get(parser.Props.SCAN_INDEX_FORWARD) if order_asc is None: order_type = None elif order_asc: order_type = models.ORDER_TYPE_ASC else: order_type = models.ORDER_TYPE_DESC except Exception: raise exception.ValidationException() try: # select item result = storage.select_item( req.context, table_name, indexed_condition_map, select_type=select_type, index_name=index_name, limit=limit, consistent=consistent_read, order_type=order_type, exclusive_start_key=exclusive_start_key_attributes ) # format response if select_type.type == models.SelectType.SELECT_TYPE_COUNT: response = { parser.Props.COUNT: result.items } else: response = { parser.Props.COUNT: len(result.items), parser.Props.ITEMS: [ parser.Parser.format_item_attributes(row) for row in result.items ] } if limit == len(result.items): response[parser.Props.LAST_EVALUATED_KEY] = ( parser.Parser.format_item_attributes( result.last_evaluated_key) ) return response except exception.AWSErrorResponseException as e: raise e except Exception: raise exception.AWSErrorResponseException()