def test_uuid_to_date():
uuid = "e8820616-1462-49b6-9784-e99a32120201"
date_exp = datetime.date(year=2012, month=2, day=1)
date = datetimeutil.uuid_to_date(uuid)
assert date == date_exp
uuid = "e8820616-1462-49b6-9784-e99a32181223"
date_exp = datetime.date(year=1118, month=12, day=23)
date = datetimeutil.uuid_to_date(uuid, century=11)
assert date == date_exp
def test_uuid_to_date():
uuid = "e8820616-1462-49b6-9784-e99a32120201"
date_exp = datetime.date(year=2012, month=2, day=1)
date = datetimeutil.uuid_to_date(uuid)
eq_(date, date_exp)
uuid = "e8820616-1462-49b6-9784-e99a32181223"
date_exp = datetime.date(year=1118, month=12, day=23)
date = datetimeutil.uuid_to_date(uuid, century=11)
eq_(date, date_exp)
def get(self, **kwargs):
"""Return a single crash report from it's UUID. """
filters = [
("uuid", None, "str"),
]
params = external_common.parse_arguments(filters, kwargs)
if params.uuid is None:
raise MissingOrBadArgumentException(
"Mandatory parameter 'uuid' is missing or empty")
crash_date = datetimeutil.uuid_to_date(params.uuid)
logger.debug("Looking for crash %s during day %s" % (params.uuid,
crash_date))
sql = """/* socorro.external.postgresql.crash.Crash.get */
SELECT reports.email, reports.url, reports.addons_checked,
( SELECT reports_duplicates.duplicate_of
FROM reports_duplicates
WHERE reports_duplicates.uuid = reports.uuid
) as duplicate_of
FROM reports
WHERE reports.uuid=%(uuid)s
AND reports.success IS NOT NULL
AND utc_day_is( reports.date_processed, %(crash_date)s)
"""
sql_params = {
"uuid": params.uuid,
"crash_date": crash_date
}
results = []
# Creating the connection to the DB
self.connection = self.database.connection()
cur = self.connection.cursor()
try:
results = db.execute(cur, sql, sql_params)
except psycopg2.Error:
util.reportExceptionAndContinue(logger)
json_result = {
"total": 0,
"hits": []
}
for crash in results:
row = dict(zip((
"email",
"url",
"addons_checked",
"duplicate_of"), crash))
json_result["hits"].append(row)
json_result["total"] = len(json_result["hits"])
self.connection.close()
return json_result
def get(self, **kwargs):
"""Return a single crash report from it's UUID. """
filters = [
("uuid", None, "str"),
]
params = external_common.parse_arguments(filters, kwargs)
if params.uuid is None:
raise MissingOrBadArgumentException(
"Mandatory parameter 'uuid' is missing or empty")
crash_date = datetimeutil.uuid_to_date(params.uuid)
logger.debug("Looking for crash %s during day %s" % (params.uuid,
crash_date))
sql = """/* socorro.external.postgresql.crash.Crash.get */
SELECT reports.email, reports.url, reports.addons_checked,
( SELECT reports_duplicates.duplicate_of
FROM reports_duplicates
WHERE reports_duplicates.uuid = reports.uuid
) as duplicate_of
FROM reports
WHERE reports.uuid=%(uuid)s
AND reports.success IS NOT NULL
AND utc_day_is( reports.date_processed, %(crash_date)s)
"""
sql_params = {
"uuid": params.uuid,
"crash_date": crash_date
}
results = []
# Creating the connection to the DB
self.connection = self.database.connection()
cur = self.connection.cursor()
try:
results = db.execute(cur, sql, sql_params)
except psycopg2.Error:
util.reportExceptionAndContinue(logger)
json_result = {
"total": 0,
"hits": []
}
for crash in results:
row = dict(zip((
"email",
"url",
"addons_checked",
"duplicate_of"), crash))
json_result["hits"].append(row)
json_result["total"] = len(json_result["hits"])
self.connection.close()
return json_result
def _table_suffix_for_crash_id(crash_id):
"""given an crash_id, return the name of its storage table"""
crash_id_date = uuid_to_date(crash_id)
previous_monday_date = (
crash_id_date + datetime.timedelta(days=-crash_id_date.weekday()))
return '%4d%02d%02d' % (previous_monday_date.year,
previous_monday_date.month,
previous_monday_date.day)
def _table_suffix_for_crash_id(crash_id):
"""given an crash_id, return the name of its storage table"""
crash_id_date = uuid_to_date(crash_id)
previous_monday_date = (
crash_id_date + datetime.timedelta(days=-crash_id_date.weekday())
)
return '%4d%02d%02d' % (previous_monday_date.year,
previous_monday_date.month,
previous_monday_date.day)
def get_paireduuid(self, **kwargs):
"""Return paired uuid given a uuid and an optional hangid.
If a hangid is passed, then return only one result. Otherwise, return
all found paired uuids.
"""
filters = [
("uuid", None, "str"),
("hangid", None, "str"),
]
params = external_common.parse_arguments(filters, kwargs)
if not params.uuid:
raise MissingOrBadArgumentError(
"Mandatory parameter 'uuid' is missing or empty")
crash_date = datetimeutil.uuid_to_date(params.uuid)
sql = """
/* socorro.external.postgresql.crashes.Crashes.get_paireduuid */
SELECT uuid
FROM reports r
WHERE r.uuid != %(uuid)s
AND r.date_processed BETWEEN
TIMESTAMP %(crash_date)s - CAST('1 day' AS INTERVAL) AND
TIMESTAMP %(crash_date)s + CAST('1 day' AS INTERVAL)
"""
sql_params = {"uuid": params.uuid, "crash_date": crash_date}
if params.hangid is not None:
sql = """%s
AND r.hangid = %%(hangid)s
LIMIT 1
""" % sql
sql_params["hangid"] = params.hangid
else:
sql = """%s
AND r.hangid IN (
SELECT hangid
FROM reports r2
WHERE r2.date_processed BETWEEN
TIMESTAMP %%(crash_date)s - CAST('1 day' AS INTERVAL)
AND
TIMESTAMP %%(crash_date)s + CAST('1 day' AS INTERVAL)
AND r2.uuid = %%(uuid)s
)
""" % sql
# Query the database
error_message = "Failed to retrieve paired uuids from PostgreSQL"
results = self.query(sql, sql_params, error_message=error_message)
# Transforming the results into what we want
uuids = [dict(zip(("uuid", ), row)) for row in results]
return {"hits": uuids, "total": len(uuids)}
def get(self, **kwargs):
"""Return a single crash report from its UUID. """
filters = [
("uuid", None, "str"),
]
params = external_common.parse_arguments(filters, kwargs)
if params.uuid is None:
raise MissingOrBadArgumentError(
"Mandatory parameter 'uuid' is missing or empty")
crash_date = datetimeutil.uuid_to_date(params.uuid)
logger.debug("Looking for crash %s during day %s" % (params.uuid,
crash_date))
sql = """/* socorro.external.postgresql.crash.Crash.get */
SELECT
reports.email,
reports.url,
reports.addons_checked,
reports.exploitability,
( SELECT reports_duplicates.duplicate_of
FROM reports_duplicates
WHERE reports_duplicates.uuid = reports.uuid
) as duplicate_of
FROM reports
WHERE reports.uuid=%(uuid)s
AND reports.success IS NOT NULL
AND utc_day_is( reports.date_processed, %(crash_date)s)
"""
sql_params = {
"uuid": params.uuid,
"crash_date": crash_date
}
error_message = "Failed to retrieve crash data from PostgreSQL"
results = self.query(sql, sql_params, error_message=error_message)
crashes = []
for row in results:
crash = dict(zip((
"email",
"url",
"addons_checked",
"exploitability",
"duplicate_of"), row))
crashes.append(crash)
return {
"hits": crashes,
"total": len(crashes)
}
def get(self, **kwargs):
"""Return a single crash report from its UUID. """
filters = [
("uuid", None, "str"),
]
params = external_common.parse_arguments(filters, kwargs)
if params.uuid is None:
raise MissingArgumentError("uuid")
crash_date = datetimeutil.uuid_to_date(params.uuid)
logger.debug("Looking for crash %s during day %s" % (params.uuid,
crash_date))
sql = """/* socorro.external.postgresql.crash.Crash.get */
SELECT
reports.signature,
reports.email,
reports.url,
reports.addons_checked,
reports.exploitability,
( SELECT reports_duplicates.duplicate_of
FROM reports_duplicates
WHERE reports_duplicates.uuid = reports.uuid
) as duplicate_of
FROM reports
WHERE reports.uuid=%(uuid)s
AND reports.success IS NOT NULL
AND utc_day_is( reports.date_processed, %(crash_date)s)
"""
sql_params = {
"uuid": params.uuid,
"crash_date": crash_date
}
error_message = "Failed to retrieve crash data from PostgreSQL"
results = self.query(sql, sql_params, error_message=error_message)
crashes = []
for row in results:
crash = dict(zip((
"signature",
"email",
"url",
"addons_checked",
"exploitability",
"duplicate_of"), row))
crashes.append(crash)
return {
"hits": crashes,
"total": len(crashes)
}
def get(self, **kwargs):
"""Return a single error report from its UUID. """
filters = [
("uuid", None, "str"),
]
params = external_common.parse_arguments(filters, kwargs)
if params.uuid is None:
raise MissingOrBadArgumentError(
"Mandatory parameter 'uuid' is missing or empty"
)
crash_date = datetimeutil.uuid_to_date(params.uuid)
sql = """/* socorro.external.postgresql.error.Error.get */
SELECT
bixie.crashes.signature,
bixie.crashes.product,
bixie.crashes.error
FROM bixie.crashes
WHERE bixie.crashes.crash_id=%(uuid)s
AND bixie.crashes.success IS NOT NULL
AND utc_day_is(
bixie.crashes.processor_completed_datetime,
%(crash_date)s
)
"""
sql_params = {
"uuid": params.uuid,
"crash_date": crash_date
}
error_message = "Failed to retrieve error data from PostgreSQL"
results = self.query(sql, sql_params, error_message=error_message)
errors = []
for row in results:
error = dict(zip((
"product",
"error",
"signature"
), row))
errors.append(error)
return {
"hits": errors,
"total": len(errors)
}
def get(self, **kwargs):
"""Return a single error report from its UUID. """
filters = [
("uuid", None, "str"),
]
params = external_common.parse_arguments(filters, kwargs)
if params.uuid is None:
raise MissingArgumentError('uuid')
crash_date = datetimeutil.uuid_to_date(params.uuid)
sql = """/* socorro.external.postgresql.error.Error.get */
SELECT
bixie.crashes.signature,
bixie.crashes.product,
bixie.crashes.error
FROM bixie.crashes
WHERE bixie.crashes.crash_id=%(uuid)s
AND bixie.crashes.success IS NOT NULL
AND utc_day_is(
bixie.crashes.processor_completed_datetime,
%(crash_date)s
)
"""
sql_params = {"uuid": params.uuid, "crash_date": crash_date}
error_message = "Failed to retrieve error data from PostgreSQL"
results = self.query(sql, sql_params, error_message=error_message)
errors = []
for row in results:
error = dict(zip(("product", "error", "signature"), row))
errors.append(error)
return {"hits": errors, "total": len(errors)}
def get_paireduuid(self, **kwargs):
"""Return paired uuid given a uuid and an optional hangid.
If a hangid is passed, then return only one result. Otherwise, return
all found paired uuids.
"""
filters = [
("uuid", None, "str"),
("hangid", None, "str"),
]
params = external_common.parse_arguments(filters, kwargs)
if not params.uuid:
raise MissingOrBadArgumentError(
"Mandatory parameter 'uuid' is missing or empty")
crash_date = datetimeutil.uuid_to_date(params.uuid)
sql = """
/* socorro.external.postgresql.crashes.Crashes.get_paireduuid */
SELECT uuid
FROM reports r
WHERE r.uuid != %(uuid)s
AND r.date_processed BETWEEN
TIMESTAMP %(crash_date)s - CAST('1 day' AS INTERVAL) AND
TIMESTAMP %(crash_date)s + CAST('1 day' AS INTERVAL)
"""
sql_params = {"uuid": params.uuid, "crash_date": crash_date}
if params.hangid is not None:
sql = """%s
AND r.hangid = %%(hangid)s
LIMIT 1
""" % sql
sql_params["hangid"] = params.hangid
else:
sql = """%s
AND r.hangid IN (
SELECT hangid
FROM reports r2
WHERE r2.date_processed BETWEEN
TIMESTAMP %%(crash_date)s - CAST('1 day' AS INTERVAL)
AND
TIMESTAMP %%(crash_date)s + CAST('1 day' AS INTERVAL)
AND r2.uuid = %%(uuid)s
)
""" % sql
result = {"total": 0, "hits": []}
try:
connection = self.database.connection()
cur = connection.cursor()
results = db.execute(cur, sql, sql_params)
# Transforming the results into what we want
for report in results:
row = dict(zip(("uuid", ), report))
result["hits"].append(row)
result["total"] = len(result["hits"])
except psycopg2.Error:
logger.error("Failed to retrieve paired uuids from database",
exc_info=True)
finally:
connection.close()
return result
def get_paireduuid(self, **kwargs):
"""Return paired uuid given a uuid and an optional hangid.
If a hangid is passed, then return only one result. Otherwise, return
all found paired uuids.
"""
filters = [
("uuid", None, "str"),
("hangid", None, "str"),
]
params = external_common.parse_arguments(filters, kwargs)
if not params.uuid:
raise MissingArgumentError('uuid')
try:
crash_date = datetimeutil.uuid_to_date(params.uuid)
except ValueError:
raise BadArgumentError(
'uuid',
'Date could not be converted extract from %s' % (params.uuid,)
)
sql = """
/* socorro.external.postgresql.crashes.Crashes.get_paireduuid */
SELECT uuid
FROM reports r
WHERE r.uuid != %(uuid)s
AND r.date_processed BETWEEN
TIMESTAMP %(crash_date)s - CAST('1 day' AS INTERVAL) AND
TIMESTAMP %(crash_date)s + CAST('1 day' AS INTERVAL)
"""
sql_params = {
"uuid": params.uuid,
"crash_date": crash_date
}
if params.hangid is not None:
sql = """%s
AND r.hangid = %%(hangid)s
LIMIT 1
""" % sql
sql_params["hangid"] = params.hangid
else:
sql = """%s
AND r.hangid IN (
SELECT hangid
FROM reports r2
WHERE r2.date_processed BETWEEN
TIMESTAMP %%(crash_date)s - CAST('1 day' AS INTERVAL)
AND
TIMESTAMP %%(crash_date)s + CAST('1 day' AS INTERVAL)
AND r2.uuid = %%(uuid)s
)
""" % sql
# Query the database
error_message = "Failed to retrieve paired uuids from PostgreSQL"
results = self.query(sql, sql_params, error_message=error_message)
# Transforming the results into what we want
uuids = [dict(zip(("uuid",), row)) for row in results]
return {
"hits": uuids,
"total": len(uuids)
}
def get_paireduuid(self, **kwargs):
"""Return paired uuid given a uuid and an optional hangid.
If a hangid is passed, then return only one result. Otherwise, return
all found paired uuids.
"""
filters = [
("uuid", None, "str"),
("hangid", None, "str"),
]
params = external_common.parse_arguments(filters, kwargs)
if not params.uuid:
raise MissingOrBadArgumentException(
"Mandatory parameter 'uuid' is missing or empty")
crash_date = datetimeutil.uuid_to_date(params.uuid)
sql = """
/* socorro.external.postgresql.crashes.Crashes.get_paireduuid */
SELECT uuid
FROM reports r
WHERE r.uuid != %(uuid)s
AND r.date_processed BETWEEN
TIMESTAMP %(crash_date)s - CAST('1 day' AS INTERVAL) AND
TIMESTAMP %(crash_date)s + CAST('1 day' AS INTERVAL)
"""
sql_params = {
"uuid": params.uuid,
"crash_date": crash_date
}
if params.hangid is not None:
sql = """%s
AND r.hangid = %%(hangid)s
LIMIT 1
""" % sql
sql_params["hangid"] = params.hangid
else:
sql = """%s
AND r.hangid IN (
SELECT hangid
FROM reports r2
WHERE r2.date_processed BETWEEN
TIMESTAMP %%(crash_date)s - CAST('1 day' AS INTERVAL)
AND
TIMESTAMP %%(crash_date)s + CAST('1 day' AS INTERVAL)
AND r2.uuid = %%(uuid)s
)
""" % sql
result = {
"total": 0,
"hits": []
}
try:
connection = self.database.connection()
cur = connection.cursor()
results = db.execute(cur, sql, sql_params)
# Transforming the results into what we want
for report in results:
row = dict(zip(("uuid",), report))
result["hits"].append(row)
result["total"] = len(result["hits"])
except psycopg2.Error:
logger.error("Failed to retrieve paired uuids from database",
exc_info=True)
finally:
connection.close()
return result
