def process_request(self, req, body, project_id, table_name):
with probe.Probe(__name__ + '.validation'):
validation.validate_object(body, "body")
# parse expected item conditions
expected_item_conditions_json = body.pop(parser.Props.EXPECTED,
None)
if expected_item_conditions_json is not None:
validation.validate_object(expected_item_conditions_json,
parser.Props.EXPECTED)
expected_item_conditions = (
parser.Parser.parse_expected_attribute_conditions(
expected_item_conditions_json))
else:
expected_item_conditions = None
attribute_updates_json = body.pop(parser.Props.ATTRIBUTE_UPDATES,
None)
validation.validate_object(attribute_updates_json,
parser.Props.ATTRIBUTE_UPDATES)
# parse attribute updates
attribute_updates = parser.Parser.parse_attribute_updates(
attribute_updates_json)
# parse key_attributes
key_attributes_json = body.pop(parser.Props.KEY, None)
validation.validate_object(key_attributes_json, parser.Props.KEY)
key_attribute_map = parser.Parser.parse_item_attributes(
key_attributes_json)
# parse return_values param
return_values_json = body.pop(parser.Props.RETURN_VALUES,
parser.Values.RETURN_VALUES_NONE)
validation.validate_string(return_values_json,
parser.Props.RETURN_VALUES)
return_values = UpdateReturnValuesType(return_values_json)
validation.validate_unexpected_props(body, "body")
result, old_item = storage.update_item(
req.context,
table_name,
key_attribute_map=key_attribute_map,
attribute_action_map=attribute_updates,
expected_condition_map=expected_item_conditions)
if not result:
raise exception.BackendInteractionException()
# format response
response = {}
if return_values.type != parser.Values.RETURN_VALUES_NONE:
response[parser.Props.ATTRIBUTES] = (
parser.Parser.format_item_attributes(old_item))
return response
def process_request(self, req, body, project_id):
with probe.Probe(__name__ + '.validation'):
validation.validate_object(body, "body")
request_items_json = body.pop(parser.Props.REQUEST_ITEMS, None)
validation.validate_object(request_items_json,
parser.Props.REQUEST_ITEMS)
validation.validate_unexpected_props(body, "body")
# parse request_items
request_list = parser.Parser.parse_batch_get_request_items(
request_items_json)
result, unprocessed = storage.execute_get_batch(
req.context, request_list)
responses = {}
for tname, res in result:
if not res.items:
continue
table_items = responses.get(tname, None)
if table_items is None:
table_items = []
responses[tname] = table_items
item = parser.Parser.format_item_attributes(res.items[0])
table_items.append(item)
return {
'responses':
responses,
'unprocessed_keys':
parser.Parser.format_batch_get_unprocessed(unprocessed,
request_items_json)
}
def process_request(self, req, body, project_id, table_name):
utils.check_project_id(req.context, project_id)
req.context.tenant = project_id
with probe.Probe(__name__ + '.validate'):
validation.validate_object(body, "body")
# get attributes_to_get
attributes_to_get = body.pop(parser.Props.ATTRIBUTES_TO_GET, None)
if attributes_to_get:
attributes_to_get = validation.validate_set(
attributes_to_get, parser.Props.ATTRIBUTES_TO_GET
)
for attr_name in attributes_to_get:
validation.validate_attr_name(attr_name)
select_type = models.SelectType.specific_attributes(
attributes_to_get
)
else:
select_type = models.SelectType.all()
key = body.pop(parser.Props.KEY, None)
validation.validate_object(key, parser.Props.KEY)
# parse consistent_read
consistent_read = body.pop(parser.Props.CONSISTENT_READ, False)
validation.validate_boolean(consistent_read,
parser.Props.CONSISTENT_READ)
validation.validate_unexpected_props(body, "body")
# parse key_attributes
key_attributes = parser.Parser.parse_item_attributes(key)
# format conditions to get item
indexed_condition_map = {
name: [models.IndexedCondition.eq(value)]
for name, value in key_attributes.iteritems()
}
# 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
def process_request(self, req, body, project_id, table_name):
utils.check_project_id(req.context, project_id)
req.context.tenant = project_id
with probe.Probe(__name__ + '.jsonschema.validate'):
validation.validate_object(body, "body")
# parse expected item conditions
expected_item_conditions_json = body.pop(parser.Props.EXPECTED,
None)
if expected_item_conditions_json:
validation.validate_object(expected_item_conditions_json,
parser.Props.EXPECTED)
expected_item_conditions = (
parser.Parser.parse_expected_attribute_conditions(
expected_item_conditions_json))
else:
expected_item_conditions = None
# parse key_attributes
key_attributes_json = body.pop(parser.Props.KEY, None)
validation.validate_object(key_attributes_json, parser.Props.KEY)
key_attributes = parser.Parser.parse_item_attributes(
key_attributes_json)
# parse return_values param
return_values_json = body.pop(parser.Props.RETURN_VALUES,
parser.Values.RETURN_VALUES_NONE)
validation.validate_string(return_values_json,
parser.Props.RETURN_VALUES)
return_values = DeleteReturnValuesType(return_values_json)
validation.validate_unexpected_props(body, "body")
# delete item
storage.delete_item(req.context,
table_name,
key_attributes,
expected_condition_map=expected_item_conditions)
# format response
response = {}
if return_values.type != parser.Values.RETURN_VALUES_NONE:
# TODO(cwang):
# It is needed to return all deleted item attributes
#
response[parser.Props.ATTRIBUTES] = (
parser.Parser.format_item_attributes(key_attributes))
return response
def process_request(self, req, body, project_id, table_name):
utils.check_project_id(req.context, project_id)
req.context.tenant = project_id
with probe.Probe(__name__ + '.validation'):
validation.validate_object(body, "body")
expected = body.pop(parser.Props.EXPECTED, {})
validation.validate_object(expected, parser.Props.EXPECTED)
# parse expected item conditions
expected_item_conditions = (
parser.Parser.parse_expected_attribute_conditions(expected))
item = body.pop(parser.Props.ITEM, None)
validation.validate_object(item, parser.Props.ITEM)
# parse item
item_attributes = parser.Parser.parse_item_attributes(item)
# parse return_values param
return_values_json = body.pop(parser.Props.RETURN_VALUES,
parser.Values.RETURN_VALUES_NONE)
validation.validate_string(return_values_json,
parser.Props.RETURN_VALUES)
return_values = InsertReturnValuesType(return_values_json)
# parse return_values param
time_to_live = body.pop(parser.Props.TIME_TO_LIVE, None)
if time_to_live is not None:
time_to_live = validation.validate_integer(
time_to_live, parser.Props.TIME_TO_LIVE, min_val=0)
validation.validate_unexpected_props(body, "body")
# put item
result, old_item = storage.put_item(
req.context,
table_name,
item_attributes,
return_values=return_values,
if_not_exist=False,
expected_condition_map=expected_item_conditions,
)
response = {}
if old_item:
response[parser.Props.ATTRIBUTES] = (
parser.Parser.format_item_attributes(old_item))
return response
def process_request(self, req, project_id, table_name, backup_id):
utils.check_project_id(req.context, project_id)
req.context.tenant = project_id
with probe.Probe(__name__ + '.validation'):
validation.validate_table_name(table_name)
backup = storage.describe_backup(req.context, table_name,
uuid.UUID(backup_id))
href_prefix = req.path_url
response = parser.Parser.format_backup(backup, href_prefix)
return response
def process_request(self, req, body, project_id, table_name):
with probe.Probe(__name__ + '.validate'):
validation.validate_object(body, "body")
# get attributes_to_get
attributes_to_get = body.pop(parser.Props.ATTRIBUTES_TO_GET, None)
if attributes_to_get:
attributes_to_get = validation.validate_set(
attributes_to_get, parser.Props.ATTRIBUTES_TO_GET)
for attr_name in attributes_to_get:
validation.validate_attr_name(attr_name)
select_type = models.SelectType.specific_attributes(
attributes_to_get)
else:
select_type = models.SelectType.all()
key = body.pop(parser.Props.KEY, None)
validation.validate_object(key, parser.Props.KEY)
# parse consistent_read
consistent_read = body.pop(parser.Props.CONSISTENT_READ, False)
validation.validate_boolean(consistent_read,
parser.Props.CONSISTENT_READ)
validation.validate_unexpected_props(body, "body")
# parse key_attributes
key_attributes = parser.Parser.parse_item_attributes(key)
# get item
result = storage.get_item(req.context,
table_name,
key_attributes,
select_type=select_type,
consistent=consistent_read)
# format response
if result.count == 0:
return {}
response = {
parser.Props.ITEM:
parser.Parser.format_item_attributes(result.items[0])
}
return response
def process_request(self, req, body, project_id, table_name):
utils.check_project_id(req.context, project_id)
req.context.tenant = project_id
with probe.Probe(__name__ + '.validation'):
validation.validate_object(body, "body")
# backup_id =
body.pop(parser.Props.BACKUP_ID, None)
# source =
body.pop(parser.Props.SOURCE, None)
validation.validate_unexpected_props(body, "body")
restore_job = None
href_prefix = req.path_url
response = parser.Parser.format_restore_job(restore_job, href_prefix)
return response
def process_request(self, req, body, project_id):
with probe.Probe(__name__ + '.validation'):
validation.validate_object(body, "body")
request_items_json = body.pop(parser.Props.REQUEST_ITEMS, None)
validation.validate_object(request_items_json,
parser.Props.REQUEST_ITEMS)
validation.validate_unexpected_props(body, "body")
# parse request_items
request_map = parser.Parser.parse_batch_write_request_items(
request_items_json)
unprocessed_items = storage.execute_write_batch(
req.context, request_map)
return {
'unprocessed_items':
parser.Parser.format_request_items(unprocessed_items)
}
def process_request(self, req, body, project_id, table_name):
utils.check_project_id(req.context, project_id)
req.context.tenant = project_id
with probe.Probe(__name__ + '.validation'):
validation.validate_table_name(table_name)
validation.validate_object(body, "body")
backup_name = body.pop(parser.Props.BACKUP_NAME, None)
strategy = body.pop(parser.Props.STRATEGY, {})
validation.validate_unexpected_props(body, "body")
backup = storage.create_backup(req.context, table_name, backup_name,
strategy)
href_prefix = req.path_url
response = parser.Parser.format_backup(backup, href_prefix)
return response
def process_request(self, req, project_id, table_name):
utils.check_project_id(req.context, project_id)
req.context.tenant = project_id
with probe.Probe(__name__ + '.validation'):
validation.validate_table_name(table_name)
params = req.params.copy()
exclusive_start_backup_id = params.pop(
parser.Props.EXCLUSIVE_START_BACKUP_ID, None)
if exclusive_start_backup_id:
exclusive_start_backup_id = uuid.UUID(
exclusive_start_backup_id)
limit = params.pop(parser.Props.LIMIT, None)
if limit:
limit = validation.validate_integer(limit,
parser.Props.LIMIT,
min_val=0)
backups = storage.list_backups(req.context, table_name,
exclusive_start_backup_id, limit)
response = {}
if backups and limit == len(backups):
response[parser.Props.LAST_EVALUATED_BACKUP_ID] = (
backups[-1].id.hex)
self_link_prefix = req.path_url
response[parser.Props.BACKUPS] = [
parser.Parser.format_backup(backup, self_link_prefix)
for backup in backups
]
return response
def __init__(self, app, options):
self.options = options
self.probe = probe.Probe(app.__class__)
super(ProbeFilter, self).__init__(app)
def scan(self, req, body, project_id, table_name):
utils.check_project_id(req.context, project_id)
req.context.tenant = project_id
with probe.Probe(__name__ + '.validation'):
validation.validate_object(body, "body")
# get attributes_to_get
attributes_to_get = body.pop(parser.Props.ATTRIBUTES_TO_GET, None)
if attributes_to_get:
validation.validate_list(attributes_to_get,
parser.Props.ATTRIBUTES_TO_GET)
for attr_name in attributes_to_get:
validation.validate_attr_name(attr_name)
select = body.pop(parser.Props.SELECT, None)
if select is None:
if attributes_to_get:
select = models.SelectType.SELECT_TYPE_SPECIFIC
else:
select = models.SelectType.SELECT_TYPE_ALL
else:
validation.validate_string(select, parser.Props.SELECT)
select_type = models.SelectType(select, attributes_to_get)
limit = body.pop(parser.Props.LIMIT, None)
if limit is not None:
limit = validation.validate_integer(limit,
parser.Props.LIMIT,
min_val=0)
# parse exclusive_start_key_attributes
exclusive_start_key_attributes_json = body.pop(
parser.Props.EXCLUSIVE_START_KEY, None)
if exclusive_start_key_attributes_json is not None:
validation.validate_object(exclusive_start_key_attributes_json,
parser.Props.EXCLUSIVE_START_KEY)
exclusive_start_key_attributes = (
parser.Parser.parse_item_attributes(
exclusive_start_key_attributes_json))
else:
exclusive_start_key_attributes = None
scan_filter_json = body.pop(parser.Props.SCAN_FILTER, None)
if scan_filter_json:
validation.validate_object(scan_filter_json,
parser.Props.SCAN_FILTER)
condition_map = parser.Parser.parse_attribute_conditions(
scan_filter_json, condition_class=ScanCondition)
else:
condition_map = None
total_segments = body.pop(parser.Props.TOTAL_SEGMENTS, 1)
total_segments = validation.validate_integer(
total_segments,
parser.Props.TOTAL_SEGMENTS,
min_val=1,
max_val=4096)
segment = body.pop(parser.Props.SEGMENT, 0)
segment = validation.validate_integer(segment,
parser.Props.SEGMENT,
min_val=0,
max_val=total_segments)
validation.validate_unexpected_props(body, "body")
result = storage.scan(
req.context,
table_name,
condition_map,
attributes_to_get=attributes_to_get,
limit=limit,
exclusive_start_key=exclusive_start_key_attributes)
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
def query(self, req, body, project_id, table_name):
with probe.Probe(__name__ + '.validation'):
validation.validate_object(body, "body")
# get attributes_to_get
attributes_to_get = body.pop(parser.Props.ATTRIBUTES_TO_GET, None)
if attributes_to_get is not None:
validation.validate_list(attributes_to_get,
parser.Props.ATTRIBUTES_TO_GET)
for attr_name in attributes_to_get:
validation.validate_attr_name(attr_name)
index_name = body.pop(parser.Props.INDEX_NAME, None)
if index_name is not None:
validation.validate_index_name(index_name)
select = body.pop(parser.Props.SELECT, None)
if select is None:
if attributes_to_get:
select = models.SelectType.SELECT_TYPE_SPECIFIC
else:
if index_name is not None:
select = models.SelectType.SELECT_TYPE_ALL_PROJECTED
else:
select = models.SelectType.SELECT_TYPE_ALL
else:
validation.validate_string(select, parser.Props.SELECT)
select_type = models.SelectType(select, attributes_to_get)
# parse exclusive_start_key_attributes
exclusive_start_key_attributes_json = body.pop(
parser.Props.EXCLUSIVE_START_KEY, None)
if exclusive_start_key_attributes_json is not None:
validation.validate_object(exclusive_start_key_attributes_json,
parser.Props.EXCLUSIVE_START_KEY)
exclusive_start_key_attributes = (
parser.Parser.parse_item_attributes(
exclusive_start_key_attributes_json))
else:
exclusive_start_key_attributes = None
# parse indexed_condition_map
key_conditions = body.pop(parser.Props.KEY_CONDITIONS, None)
validation.validate_object(key_conditions,
parser.Props.KEY_CONDITIONS)
indexed_condition_map = parser.Parser.parse_attribute_conditions(
key_conditions, condition_class=IndexedCondition)
# TODO(dukhlov):
# it would be nice to validate given table_name, key_attributes and
# attributes_to_get to schema expectation
consistent_read = body.pop(parser.Props.CONSISTENT_READ, False)
validation.validate_boolean(consistent_read,
parser.Props.CONSISTENT_READ)
limit = body.pop(parser.Props.LIMIT, None)
if limit is not None:
limit = validation.validate_integer(limit,
parser.Props.LIMIT,
min_val=0)
scan_forward = body.pop(parser.Props.SCAN_INDEX_FORWARD, None)
if scan_forward is not None:
validation.validate_boolean(scan_forward,
parser.Props.SCAN_INDEX_FORWARD)
order_type = (models.ORDER_TYPE_ASC
if scan_forward else models.ORDER_TYPE_DESC)
else:
order_type = None
validation.validate_unexpected_props(body, "body")
# select item
result = storage.query(
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.count}
else:
response = {
parser.Props.COUNT:
result.count,
parser.Props.ITEMS: [
parser.Parser.format_item_attributes(row)
for row in result.items
]
}
if limit == result.count:
response[parser.Props.LAST_EVALUATED_KEY] = (
parser.Parser.format_item_attributes(
result.last_evaluated_key))
return response
def create_table(self, req, body, project_id):
with probe.Probe(__name__ + '.validate'):
validation.validate_object(body, "body")
table_name = body.pop(parser.Props.TABLE_NAME, None)
validation.validate_table_name(table_name)
# parse table attributes
attribute_definitions_json = body.pop(
parser.Props.ATTRIBUTE_DEFINITIONS, None)
validation.validate_list_of_objects(
attribute_definitions_json, parser.Props.ATTRIBUTE_DEFINITIONS)
attribute_definitions = parser.Parser.parse_attribute_definitions(
attribute_definitions_json)
# parse table key schema
key_attrs_json = body.pop(parser.Props.KEY_SCHEMA, None)
validation.validate_list(key_attrs_json, parser.Props.KEY_SCHEMA)
key_attrs = parser.Parser.parse_key_schema(key_attrs_json)
# parse table indexed field list
lsi_defs_json = body.pop(parser.Props.LOCAL_SECONDARY_INDEXES,
None)
if lsi_defs_json:
validation.validate_list_of_objects(
lsi_defs_json, parser.Props.LOCAL_SECONDARY_INDEXES)
index_def_map = parser.Parser.parse_local_secondary_indexes(
lsi_defs_json)
else:
index_def_map = {}
validation.validate_unexpected_props(body, "body")
# prepare table_schema structure
table_schema = models.TableSchema(attribute_definitions, key_attrs,
index_def_map)
table_meta = storage.create_table(req.context, table_name,
table_schema)
url = req.path_url + "/" + table_name
bookmark = req.path_url + "/" + table_name
result = {
parser.Props.TABLE_DESCRIPTION: {
parser.Props.ATTRIBUTE_DEFINITIONS:
(parser.Parser.format_attribute_definitions(
table_meta.schema.attribute_type_map)),
parser.Props.CREATION_DATE_TIME:
table_meta.creation_date_time,
parser.Props.ITEM_COUNT:
0,
parser.Props.KEY_SCHEMA: (parser.Parser.format_key_schema(
table_meta.schema.key_attributes)),
parser.Props.TABLE_ID:
str(table_meta.id),
parser.Props.TABLE_NAME:
table_name,
parser.Props.TABLE_STATUS:
(parser.Parser.format_table_status(table_meta.status)),
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
}]
}
}
if table_meta.schema.index_def_map:
table_def = result[parser.Props.TABLE_DESCRIPTION]
table_def[parser.Props.LOCAL_SECONDARY_INDEXES] = (
parser.Parser.format_local_secondary_indexes(
table_meta.schema.key_attributes[0],
table_meta.schema.index_def_map))
return result
def create_table(self, req, body, project_id):
with probe.Probe(__name__ + '.validate'):
validation.validate_object(body, "body")
table_name = body.pop(parser.Props.TABLE_NAME, None)
validation.validate_table_name(table_name)
# parse table attributes
attribute_definitions_json = body.pop(
parser.Props.ATTRIBUTE_DEFINITIONS, None)
validation.validate_list_of_objects(
attribute_definitions_json, parser.Props.ATTRIBUTE_DEFINITIONS)
attribute_definitions = parser.Parser.parse_attribute_definitions(
attribute_definitions_json)
# parse table key schema
key_attrs_json = body.pop(parser.Props.KEY_SCHEMA, None)
validation.validate_list(key_attrs_json, parser.Props.KEY_SCHEMA)
key_attrs = parser.Parser.parse_key_schema(key_attrs_json)
# parse table indexed field list
lsi_defs_json = body.pop(parser.Props.LOCAL_SECONDARY_INDEXES,
None)
if lsi_defs_json:
validation.validate_list_of_objects(
lsi_defs_json, parser.Props.LOCAL_SECONDARY_INDEXES)
index_def_map = parser.Parser.parse_local_secondary_indexes(
lsi_defs_json)
else:
index_def_map = {}
# validate the uniqueness of table and its indices' key schema
range_keys = []
if len(key_attrs) > 1:
range_keys.append(key_attrs[1])
else:
# table has hash type primary key
if len(index_def_map) > 0:
raise exception.ValidationError(
_("Table without range key in primary key schema "
"can not have indices"))
for index in index_def_map.values():
range_keys.append(index.alt_range_key_attr)
try:
validation.validate_set(range_keys, "key_schema")
except exception.ValidationError:
raise exception.ValidationError(
_("Table and its indices must have unique key schema"))
validation.validate_unexpected_props(body, "body")
# prepare table_schema structure
table_schema = models.TableSchema(attribute_definitions, key_attrs,
index_def_map)
table_meta = storage.create_table(req.context, table_name,
table_schema)
url = req.path_url + "/" + table_name
bookmark = req.path_url + "/" + table_name
result = {
parser.Props.TABLE_DESCRIPTION: {
parser.Props.ATTRIBUTE_DEFINITIONS:
(parser.Parser.format_attribute_definitions(
table_meta.schema.attribute_type_map)),
parser.Props.CREATION_DATE_TIME:
table_meta.creation_date_time,
parser.Props.ITEM_COUNT:
0,
parser.Props.KEY_SCHEMA: (parser.Parser.format_key_schema(
table_meta.schema.key_attributes)),
parser.Props.TABLE_ID:
str(table_meta.id),
parser.Props.TABLE_NAME:
table_name,
parser.Props.TABLE_STATUS:
(parser.Parser.format_table_status(table_meta.status)),
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
}]
}
}
if table_meta.schema.index_def_map:
table_def = result[parser.Props.TABLE_DESCRIPTION]
table_def[parser.Props.LOCAL_SECONDARY_INDEXES] = (
parser.Parser.format_local_secondary_indexes(
table_meta.schema.key_attributes[0],
table_meta.schema.index_def_map))
return result
