def list(self, instanceid=None, days=None):
repositories.setup_database_engine_and_factory()
repo = repositories.get_vmexpire_repository()
res = repo.get_all_by(instance_id=instanceid, project_id=None)
headers = [
'id', 'expire', 'instance.name', 'instance.id', 'project.id',
'user.id', 'notif', 'notif.last'
]
limit = None
if days:
try:
dt = datetime.datetime.now() + datetime.timedelta(
days=int(days))
limit = time.mktime(dt.timetuple())
except Exception as e:
print(str(e))
return
pt = prettytable.PrettyTable(headers)
for instance in res:
if limit and instance.expire > limit:
continue
pt.add_row([
instance.id,
datetime.datetime.fromtimestamp(instance.expire),
instance.instance_name, instance.instance_id,
instance.project_id, instance.user_id, instance.notified,
instance.notified_last
])
if six.PY3:
print(encodeutils.safe_encode(pt.get_string()).decode())
else:
print(encodeutils.safe_encode(pt.get_string()))
def tearDown(self):
super(WhenTestingVmExpiresResource, self).tearDown()
repo = repositories.get_vmexpire_repository()
repo.delete_all_entities()
repositories.commit()
exclude_repo = repositories.get_vmexclude_repository()
exclude_repo.delete_all_entities()
repositories.commit()
def remove(self, expirationid):
if not expirationid:
print("Missing id paramerer")
return
repositories.setup_database_engine_and_factory()
repo = repositories.get_vmexpire_repository()
repo.delete_entity_by_id(entity_id=expirationid)
repositories.commit()
print("VM expiration successfully removed!")
def extend(self, expirationid):
if not expirationid:
print("Missing id parameter")
return
repositories.setup_database_engine_and_factory()
repo = repositories.get_vmexpire_repository()
repo.extend_vm(entity_id=expirationid)
repositories.commit()
print("VM expiration successfully extended!")
def add(self, instanceid):
if not instanceid:
print("Missing id parameter")
return
repositories.setup_database_engine_and_factory()
repo = repositories.get_vmexpire_repository()
instance = repo.add_vm(instanceid)
if not instance:
print("Failure to add VM expiration, check logs")
return
repositories.commit()
print("VM expiration successfully generated!")
def create_vmexpire(instance=None, session=None):
expire = models.VmExpire()
expire.project_id = instance.project_id
expire.instance_id = instance.instance_id
expire.instance_name = instance.instance_name
expire.user_id = instance.user_id
expire.expire = time.mktime(
datetime.datetime.now().timetuple()) + 2 * 3600 * 24
expire.notified = False
expire.notified_last = False
container_repo = repositories.get_vmexpire_repository()
container_repo.create_from(expire, session=session)
return expire
def test_vm_create(self, mock_get, mock_post, mock_get_project_domain):
create_msg = {
'nova_object.data': {
'uuid': '1-2-3-4-5',
'display_name': '12345',
'tenant_id': '12345project',
'user_id': '12345user'
}
}
self.task.info(None, 'mock', 'instance.create.end', create_msg, None)
repo = repositories.get_vmexpire_repository()
expire = repo.get_by_instance(create_msg['nova_object.data']['uuid'])
self.assertEqual(expire.instance_id,
create_msg['nova_object.data']['uuid'])
self.assertTrue(expire.expire > 0)
def check(started_at):
token = get_identity_token()
conf_cleaner = config.CONF.cleaner
LOG.debug("check instances")
repo = repositories.get_vmexpire_repository()
now = int(time.mktime(datetime.datetime.now().timetuple()))
check_time = now + (conf_cleaner.notify_before_days * 3600 * 24)
last_check_time = now + (conf_cleaner.notify_before_days_last * 3600 * 24)
entities = repo.get_entities(expiration_filter=check_time)
for entity in entities:
if entity.expire < check_time and not entity.notified:
# notify
LOG.debug("First expiration notification %s" % (entity.id))
res = send_email(entity, token, delete=False)
if res:
entity.notified = True
try:
entity.save()
repositories.commit()
except Exception as e:
LOG.exception("expiration save error: " + str(e))
repositories.rollback()
elif entity.expire < last_check_time and not entity.notified_last:
# notify_last
LOG.debug("Last expiration notification %s" % (entity.id))
res = send_email(entity, token, delete=False)
if res:
entity.notified_last = True
try:
entity.save()
repositories.commit()
except Exception as e:
LOG.exception("expiration save error: " + str(e))
repositories.rollback()
elif entity.expire < now:
# delete
LOG.debug("Delete VM %s" % (entity.id))
res = delete_vm(entity.instance_id, entity.project_id, token)
if res:
try:
repo.delete_entity_by_id(entity_id=entity.id)
repositories.commit()
except Exception as e:
LOG.exception("expiration deletion error: " + str(e))
repositories.rollback()
send_email(entity, token, delete=True)
def test_vm_exclude_user(self, mock_get, mock_post,
mock_get_project_domain):
create_msg = {
'nova_object.data': {
'uuid': '1-2-3-4-5',
'display_name': '12345',
'tenant_id': '12345project',
'user_id': '12345user'
}
}
entity = create_vmexclude_model('12345user', 2)
create_vmexclude(entity)
self.task.info(None, 'mock', 'instance.create.end', create_msg, None)
repo = repositories.get_vmexpire_repository()
try:
repo.get_by_instance(create_msg['nova_object.data']['uuid'])
except Exception as e:
logging.info('instance not found: ' + str(e))
else:
self.self.fail('domain is excluded, should not have been created')
def test_vm_delete(self):
self.test_vm_create()
delete_msg = {
'nova_object.data': {
'uuid': '1-2-3-4-5',
'display_name': '12345',
'tenant_id': '12345project',
'user_id': '12345user'
}
}
self.task.info(None, 'mock', 'instance.delete.end', delete_msg, None)
repo = repositories.get_vmexpire_repository()
found = False
try:
expire = repo.get_by_instance(
delete_msg['nova_object.data']['uuid'])
if expire:
found = True
except Exception as e:
logging.exception(e)
found = False
self.assertFalse(found)
def info(self, ctxt, publisher_id, event_type, payload, metadata):
if event_type == 'instance.create.end':
LOG.debug(event_type + ':' + payload['nova_object.data']['uuid'])
repo = repositories.get_vmexpire_repository()
instance = None
instance_uuid = str(payload['nova_object.data']['uuid'])
try:
instance = repo.get_by_instance(instance_uuid)
except Exception:
LOG.debug("Fine, instance does not already exists")
if instance:
LOG.warn("InstanceAlreadyExists:" + instance_uuid +
", deleting first")
repo.delete_entity_by_id(entity_id=instance.id)
entity = models.VmExpire()
entity.instance_id = instance_uuid
if payload['nova_object.data']['display_name']:
display_name = payload['nova_object.data']['display_name']
entity.instance_name = display_name
else:
entity.instance_name = instance_uuid
entity.project_id = payload['nova_object.data']['tenant_id']
entity.user_id = payload['nova_object.data']['user_id']
entity.expire = int(
time.mktime(datetime.datetime.now().timetuple()) +
(CONF.max_vm_duration * 3600 * 24))
entity.notified = False
entity.notified_last = False
project_domain = None
try:
project_domain = get_project_domain(entity.project_id)
except Exception:
LOG.exception('Failed to get domain for project')
exclude_repo = repositories.get_vmexclude_repository()
if project_domain:
exclude_id = exclude_repo.get_exclude_by_id(project_domain)
if exclude_id:
LOG.debug('domain %s is excluded, skipping' %
(project_domain))
return
exclude_id = exclude_repo.get_exclude_by_id(entity.project_id)
if exclude_id:
LOG.debug('project %s is excluded, skipping' %
(entity.project_id))
return
exclude_id = exclude_repo.get_exclude_by_id(entity.user_id)
if exclude_id:
LOG.debug('user %s is excluded, skipping' % (entity.user_id))
return
instance = repo.create_from(entity)
LOG.debug("NewInstanceExpiration:" + instance_uuid)
elif event_type == 'instance.delete.end':
instance_uuid = str(payload['nova_object.data']['uuid'])
LOG.debug(event_type + ':' + instance_uuid)
repo = repositories.get_vmexpire_repository()
try:
instance = repo.get_by_instance(instance_uuid)
repo.delete_entity_by_id(entity_id=instance.id)
LOG.debug("Delete id:" + instance.id)
except Exception:
LOG.warn('Failed to delete: ' + instance_uuid)
LOG.debug(publisher_id)
LOG.debug(event_type)
LOG.debug(str(metadata))
LOG.debug(json.dumps(payload, indent=4))
def create_vmexpire(entity):
repo = repositories.get_vmexpire_repository()
instance = repo.create_from(entity)
repositories.commit()
return instance
def tearDown(self):
super(WhenTestingVmExpiresResource, self).tearDown()
repo = repositories.get_vmexpire_repository()
repo.delete_all_entities()
repositories.commit()
repositories.CONF.max_vm_total_duration = self.max_vm_total_duration
def __init__(self, project_id):
self.project_id = str(project_id)
self.vmexpire_repo = repo.get_vmexpire_repository()
def get_vmexpire(entity_id):
repo = repositories.get_vmexpire_repository()
instance = repo.get(entity_id=entity_id)
return instance
