def to_json(self, include_body=False):
"""Exports the object to a JSON friendly dict
Args:
include_body (bool): Include the body of the message in the output
Returns:
Dict representation of object type
"""
message = {
'emailId': self.email_id,
'timestamp': isoformat(self.timestamp),
'subsystem': self.subsystem,
'subject': self.subject,
'sender': self.sender,
'recipients': self.recipients,
'uuid': self.uuid,
'messageHtml': None,
'messageText': None
}
if include_body:
message['messageHtml'] = self.message_html
message['messageText'] = self.message_text
return message
def to_json(self):
"""Exports the object to a JSON friendly dict
Returns:
Dict representation of object type
"""
output = {'__type': self.__class__.__name__}
cls_attribs = self.__class__.__dict__
for attrName in cls_attribs:
attr = getattr(self.__class__, attrName)
value = getattr(self, attrName)
value_class = type(value)
if issubclass(type(attr), QueryableAttribute):
# List of Model, BaseModelMixin objects (one-to-many relationship)
if issubclass(value_class, InstrumentedList):
output[to_camelcase(attrName)] = [
x.to_json() for x in value
]
# Model, BaseModelMixin object (one-to-one relationship)
elif issubclass(value_class, Model):
output[to_camelcase(attrName)] = value.to_json()
# Datetime object
elif isinstance(value, datetime):
output[to_camelcase(attrName)] = isoformat(value)
elif isinstance(value, enum.Enum):
output[to_camelcase(attrName)] = value.name
# Any primitive type
else:
output[to_camelcase(attrName)] = value
return output
def update_instances(self):
"""Update list of EC2 Instances for the account / region
Returns:
`None`
"""
self.log.debug('Updating EC2Instances for {}/{}'.format(
self.account.account_name, self.region))
ec2 = self.session.resource('ec2', region_name=self.region)
try:
existing_instances = EC2Instance.get_all(self.account, self.region)
instances = {}
api_instances = {x.id: x for x in ec2.instances.all()}
try:
for instance_id, data in api_instances.items():
if data.instance_id in existing_instances:
instance = existing_instances[instance_id]
if data.state['Name'] not in ('terminated',
'shutting-down'):
instances[instance_id] = instance
# Add object to transaction if it changed
if instance.update(data):
self.log.debug(
'Updating info for instance {} in {}/{}'.
format(instance.resource.resource_id,
self.account.account_name,
self.region))
db.session.add(instance.resource)
else:
# New instance, if its not in state=terminated
if data.state['Name'] in ('terminated',
'shutting-down'):
continue
tags = {
tag['Key']: tag['Value']
for tag in data.tags or {}
}
properties = {
'launch_date':
to_utc_date(data.launch_time).isoformat(),
'state':
data.state['Name'],
'instance_type':
data.instance_type,
'public_ip':
getattr(data, 'public_ip_address', None),
'public_dns':
getattr(data, 'public_dns_address', None),
'created':
isoformat(datetime.now())
}
instance = EC2Instance.create(
data.instance_id,
account_id=self.account.account_id,
location=self.region,
properties=properties,
tags=tags)
instances[instance.resource.resource_id] = instance
self.log.debug('Added new EC2Instance {}/{}/{}'.format(
self.account.account_name, self.region,
instance.resource.resource_id))
# Check for deleted instances
ik = set(list(instances.keys()))
eik = set(list(existing_instances.keys()))
for instanceID in eik - ik:
db.session.delete(existing_instances[instanceID].resource)
self.log.debug('Deleted EC2Instance {}/{}/{}'.format(
self.account.account_name, self.region, instanceID))
db.session.commit()
except:
db.session.rollback()
raise
finally:
del ec2