def handle(event, context):
records = event.get('Records', [])
if not records:
return {
"status": 200,
"message": "No records found!"
}
for record in records:
event_name = record["eventName"]
logger.info(f"Event name: {event_name}")
record_to_convert = record["dynamodb"]["NewImage"]
firehose_record = dynamodb_stream_record_to_firehose(record_to_convert)
try:
logger.info(firehose_record)
put_firehose_record(firehose_record)
except BaseException as error:
logger.error(error)
return {
"status": "500",
"message": "Something went wrong!"
}
return {
"status": 200,
"message": "All records are put to firehose"
}
def generate_presigned_url(issue_key, file_name, ttl):
error = None
status = 200
resp = {
"ok": not error,
}
try:
upload_url = s3.generate_presigned_post(
Bucket=S3_BUCKET,
Key=f'{issue_key}/{file_name}',
ExpiresIn=int(ttl)
)
logger.debug('S3 presigned upload URL: {}'.format(upload_url))
resp["upload_url"] = upload_url
resp["issue_key"] = issue_key
except Exception as e:
logger.error('Could not generate S3 presigned upload URL failed: {}'.format(str(e)))
error = str(e)
status = 500
if error:
resp["error"] = error
logger.error(error)
return status, resp
def validate_event(event):
error = None
status = 200
body = None
httpMethod = event.get("httpMethod")
if httpMethod != "POST":
status = 405
error = "Method not allowed: {}".format(httpMethod)
else:
body = event.get("body")
try:
body = json.loads(body)
except (json.decoder.JSONDecodeError, TypeError):
status = 400
error = "`body` is not valid JSON: {}".format(body)
resp = {
"ok": not error,
}
if error:
resp["error"] = error
logger.error(error)
return status, resp, body
def save(self, conditional_operator=None, **expected_values):
try:
self.updatedAt = datetime.now().astimezone()
logger.debug('saving: {}'.format(self))
super(AssetModel, self).save()
except Exception as e:
logger.error('save {} failed: {}'.format(self.asset_id, e), exc_info=True)
raise e
def save(self, conditional_operator=None, **expected_values):
try:
self.updatedAt = datetime.now().astimezone()
logger.debug('saving: {}'.format(self))
super(AssetModel, self).save()
except Exception as e:
logger.error('save {} failed: {}'.format(self.asset_id, e),
exc_info=True)
raise e
def put_firehose_record(firehose_record):
timestamp = round(datetime.datetime.utcnow().timestamp() * 1000)
client = boto3.client("firehose", region_name=region_name)
try:
client.put_record(
DeliveryStreamName=delivery_stream_name,
Record={
"Data": json.dumps(firehose_record, ensure_ascii=False) + "\n"
}
)
logger.info(timestamp)
except BaseException as error:
logger.error(f"An exception occured: {error}")
raise error
def validate_environment():
error = ''
s3_presigned_url_ttl = None
status = 200
error, s3_presigned_url_ttl = get_ssm_value(key=Parameters.S3_PRESIGNED_URL_TTL.value)
resp = {
"ok": not error,
}
if error:
resp["error"] = error
status = 500
logger.error(error)
return status, resp, s3_presigned_url_ttl
def validate_environment():
error = ''
global JIRA_SEVER, JIRA_USER, JIRA_API_KEY
err, JIRA_SEVER = get_ssm_value(key=Parameters.JIRA_HOST.value)
error += err
err, JIRA_USER = get_ssm_value(key=Parameters.JIRA_USER_ID.value)
error += err
err, JIRA_API_KEY = get_ssm_value(key=Parameters.JIRA_APP_PASSWORD.value)
error += err
resp = {
"ok": not error,
}
if error:
resp["error"] = error
logger.error(error)
return 500 if error else 200, resp
def validate_body(body):
error = None
issue_key = None
customer_ref_no = None
if not body:
error = "`body` is absent or empty: {}".format(body)
else:
issue_key = body.get("issueKey")
customer_ref_no = body.get('customerRefNo')
if not issue_key:
error = "`issueKey` is empty"
elif not customer_ref_no:
error = "`customerRefNo` is empty"
resp = {
"ok": not error,
}
if error:
resp["error"] = error
logger.error(error)
return 400 if error else 200, resp, issue_key, customer_ref_no
def handler(event, context):
logger.debug("Event: %s", json.dumps(event))
error = validate_environment()
if error:
logger.error(error)
else:
try:
for record in event['Records']:
bucket = record['s3']['bucket']['name']
key = unquote_plus(record['s3']['object']['key'])
logger.debug(f'bucket key: {key}')
customer_ref_key = key.split('/')[0]
jsd_attachment_id = key.split('/')[1]
logger.debug(f'CustomerRefNo: {customer_ref_key}')
tmpkey = key.replace(
f'{customer_ref_key}/{jsd_attachment_id}/', '')
logger.debug(f'filename: {tmpkey}')
download_path = '/tmp/{}'.format(tmpkey)
s3_client.download_file(bucket, key, download_path)
try:
upload_file_to_snow(download_path, customer_ref_key,
tmpkey)
except Exception as ex:
logger.error(f'Failed: {str(ex)}')
finally:
logger.debug(f'Deleting s3 object: {key}')
s3_client.delete_object(Bucket=bucket, Key=key)
except Exception as exc:
logger.error(f'Failed: {str(exc)}')
def handler(event, context):
logger.debug("Event: %s", json.dumps(event))
error = validate_environment()
if error:
logger.error(error)
else:
logger.debug(f'JIRA_SEVER: {JIRA_SEVER} {JIRA_USER} {JIRA_API_KEY}')
for record in event['Records']:
bucket = record['s3']['bucket']['name']
key = unquote_plus(record['s3']['object']['key'])
logger.debug('bucket key: {}'.format(key))
issue_key = key.split('/')[0]
logger.debug('issue_key: {}'.format(issue_key))
tmpkey = key.replace(f'{issue_key}/', '')
download_path = '/tmp/{}'.format(tmpkey)
s3_client.download_file(bucket, key, download_path)
try:
cr = jsd.get_request(issue_key)
# Upload file as temporary attachment
temp_attachment_id = jsd.attach_temporary_file(
cr['serviceDeskId'], download_path)
logger.debug(
'Temporary Attachment Id: {}'.format(temp_attachment_id))
# Set attachment as public for customer
response = jsd.add_attachment(issue_key,
temp_attachment_id,
public=True,
comment=None)
logger.debug(
'Set attachment to be public for customer: {}'.format(
response))
except Exception as ex:
logger.error('Upload attachments to Jira failed: {}'.format(
str(ex)))
finally:
s3_client.delete_object(Bucket=bucket, Key=key)
def download_comment_attachments_and_upload_to_s3(issue_key, body,
customer_ref_no):
error = None
logger.debug('Handling attachments in comment...')
headers = {"Accept": "application/json"}
resp = {
"ok": not error,
}
try:
auth = HTTPBasicAuth(JIRA_USER, JIRA_API_KEY)
response = requests.request(
method='GET',
url=f'{JIRA_SEVER}/rest/api/3/issue/{issue_key}?fields=attachment',
headers=headers,
auth=auth)
data = json.loads(response.text)
attachments = [
item for item in data['fields']['attachment']
if item['filename'] in body
]
msgs = []
if not attachments:
msgs.append('No attachemnt matched')
else:
for attachment in attachments:
msg = download_file_and_upload_to_s3(attachment['filename'],
attachment['id'],
customer_ref_no)
msgs.append(msg)
resp["info"] = msgs
except Exception as ex:
error = f"An error occurred: {str(ex)}"
if error:
resp["error"] = error
logger.error(error)
return 400 if error else 200, resp
def validate_event(event):
error = None
status = 200
queries = event.get("queryStringParameters", {})
logger.debug("Query Parameters: %s", json.dumps(queries))
httpMethod = event.get("httpMethod")
if queries is None or 'issue_key' not in queries or 'file_name' not in queries:
status = 400
error = "`issue_key` and `file_name` must be defined in querystring"
elif httpMethod != "GET":
status = 405
error = "Method not allowed: {}".format(httpMethod)
resp = {
"ok": not error,
}
if error:
resp["error"] = error
logger.error(error)
return status, resp, queries
