def delete_document_revision(self,
document_id,
revision_id,
logger=DEFAULT_LOGGER):
"""
Delete the Cloudant document revision
"""
logger.info("Deleting Cloudant document: %s. Revision: %s...",
document_id, revision_id)
if self._database is None:
message = "Failed to delete Cloudant document: {0}. Revision: {1}. " \
"Database connection is closed: {2}.".format(document_id, revision_id, self._database_name)
logger.error(message)
return False
start_time = datetime.datetime.now()
document_url = self._get_document_url(document_id)
if not document_url:
message = "Failed to delete Cloudant document: {0}. Revision: {1}. " \
"Document URL is undefined: {2}.".format(document_id, revision_id, self._database_name)
logger.error(message)
return False
params = {"rev": revision_id}
session = self._database.r_session
response = session.delete(document_url, params=params)
if logger_util.is_enabled_for_trace(logger):
serialized_response = pformat(vars(response))
logger_util.log_trace(logger, serialized_response)
try:
response.raise_for_status()
except HTTPError as err:
logger.error(
"Failed to delete Cloudant document: %s. Revision: %s.",
document_id, revision_id)
error_util.log_http_error(logger, err)
return False
end_time = datetime.datetime.now()
elapsed_time = (end_time - start_time).total_seconds() * 1000 # ms
logger.info(
"Successfully deleted Cloudant document: %s. Revision: %s (%d ms).",
document_id, revision_id, elapsed_time)
return True
def _process_row(self, index, row, logger=DEFAULT_LOGGER):
"""
TODO
"""
# e.g.
# {
# "id":"*****@*****.**",
# "key":"*****@*****.**",
# "value":[
# "263-b01372f0f37ec98867bce7a2a015402a",
# "164-aa6ffd5138393226f3bd65da320fa75a"
# ]
# }
if logger_util.is_enabled_for_trace(logger):
logger_util.log_trace(logger, str(row))
# Print row
display_row = self._get_display_row(index, row)
logger.info(display_row)
# Track total number of conflicted documents
self._total_conflicted_documents += 1
# Track number of conflicted document revisions
field_conflicts = len(row[constants.PROPERTY_VALUE])
# Track total number of conflicted document revisions
self._total_conflicted_revisions += field_conflicts
# Delete conflicted document revisions
deleted_revisions = self._delete_conflicted_revisions(index, row)
# Generate CSV fields
fields = {}
fields[constants.CSV_FIELD_ID] = row[constants.PROPERTY_ID]
fields[constants.CSV_FIELD_NAME] = row[constants.PROPERTY_KEY]
fields[constants.CSV_FIELD_CONFLICTS] = field_conflicts
fields[constants.CSV_FIELD_DELETED] = len(deleted_revisions)
fields[constants.CSV_FIELD_REVISIONS] = deleted_revisions
# Serialize document to CSV file record
self._serialize_csv_fields(fields)
def _process_row(self, index, row, logger=DEFAULT_LOGGER):
"""
TODO
"""
# e.g.
# {
# "id":"*****@*****.**",
# "key":"*****@*****.**",
# "value":[
# "263-b01372f0f37ec98867bce7a2a015402a",
# "164-aa6ffd5138393226f3bd65da320fa75a"
# ]
# }
if logger_util.is_enabled_for_trace(logger):
logger_util.log_trace(logger, str(row))
# Validate row
# TODO: REVISIT: Should we abort the entire scan when an exception is encountered ?
error = self._validate_row(row=row,
index=self._total_conflicted_documents)
if error:
logger.error(error)
return
# Normalize row
normalized_row = self._get_normalized_row(row)
# Print row
display_row = self._get_display_row(index=index, row=normalized_row)
logger.info(display_row)
# Track total number of conflicted documents
self._total_conflicted_documents += 1
# Store conflicted document in memory
self._store_conflicted_document(normalized_row)
# Serialize document to CSV file record
self._serialize_row(normalized_row)
def get_document(self, document_id, logger=DEFAULT_LOGGER):
"""
Retrieve the Cloudant document by ID (latest revision)
"""
logger.debug("Retrieving Cloudant document: %s...", document_id)
if self._database is None:
message = "Failed to retrieve Cloudant document: {0}. " \
"Database connection is closed: {1}.".format(document_id, self._database_name)
logger.error(message)
return None
start_time = datetime.datetime.now()
try:
document = self._database[document_id]
except KeyError as err:
message = "Failed to retrieve Cloudant document: {0}.".format(
document_id)
logger.error(message)
error_util.log_exception(logger, err)
return None
except HTTPError as err:
message = "Failed to retrieve Cloudant document: {0}.".format(
document_id)
logger.error(message)
error_util.log_http_error(logger, err)
return None
if not document:
message = "Failed to retrieve Cloudant document: {0}. " \
"The document is undefined.".format(document_id)
logger.error(message)
return None
end_time = datetime.datetime.now()
elapsed_time = (end_time - start_time).total_seconds() * 1000 # ms
logger.debug("Successfully retrieved Cloudant document: %s (%d ms).",
document_id, elapsed_time)
if logger_util.is_enabled_for_trace(logger):
formatted_document = json.dumps(
document, indent=constants.JSON_FORMAT_INDENT)
logger_util.log_trace(logger, formatted_document)
return document
def validate_version(logger=DEFAULT_LOGGER): # pylint: disable=unused-variable
"""
Validates whether the minimum Python interpreter version is satisfied
"""
if sys.version_info < MIN_VERSION_PYTHON:
logger.error("Python version %s.%s or later is required.", MIN_VERSION_PYTHON[0], MIN_VERSION_PYTHON[1])
return False
logger_util.log_trace(
logger,
"Detected Python version: %s.%s.%s",
sys.version_info.major,
sys.version_info.minor,
sys.version_info.micro)
return True
def get_design_document(self, ddoc_name, logger=DEFAULT_LOGGER):
"""
Retrieve the Cloudant design document
"""
ddoc = None
logger.info("Retrieving Cloudant design document: %s...", ddoc_name)
if self._database is None:
message = "Failed to retrieve Cloudant design document: {0}. " \
"Database connection is closed: {1}.".format(ddoc_name, self._database_name)
logger.error(message)
return None
try:
ddoc = self._database.get_design_document(ddoc_name)
except HTTPError as err:
logger.error("Failed to retrieve Cloudant design document: %s.",
ddoc_name)
error_util.log_http_error(logger, err)
return None
if ddoc and (ddoc_name in ddoc.views):
logger.info("Successfully retrieved Cloudant design document: %s.",
ddoc_name)
if logger_util.is_enabled_for_trace(logger):
logger_util.log_trace(logger, "Design Document:")
formatted_ddoc = json.dumps(
ddoc, indent=constants.JSON_FORMAT_INDENT)
logger_util.log_trace(logger, formatted_ddoc)
return ddoc
logger.error("Failed to retrieve Cloudant design document: %s.",
ddoc_name)
return None