def remind_about_instances():
"""Run periodically to send reminding emails"""
cs = admin_client_set()
server_mgr = cs.compute.servers
user_mgr = cs.identity_admin.users
for instance_data in InstanceDataDAO.remind_list(datetime.utcnow()):
try:
try:
server = server_mgr.get(instance_data.instance_id)
except osc_exc.NotFound:
InstanceDataDAO.delete(instance_data.instance_id)
continue
try:
user = user_mgr.get(server.user_id)
except osc_exc.NotFound:
pass
else:
send_instance_reminder(user.email,
server.name,
server.id,
instance_data.expires_at,
greeting=getattr(user, 'fullname', ''))
InstanceDataDAO.update(instance_data.instance_id, remind_at=None)
except Exception:
current_app.logger.exception(
'Failed to send reminder email about instance %r' %
instance_data.instance_id)
def remind_about_instances():
"""Run periodically to send reminding emails"""
cs = admin_client_set()
server_mgr = cs.compute.servers
user_mgr = cs.identity_admin.users
for instance_data in InstanceDataDAO.remind_list(datetime.utcnow()):
try:
try:
server = server_mgr.get(instance_data.instance_id)
except osc_exc.NotFound:
InstanceDataDAO.delete(instance_data.instance_id)
continue
try:
user = user_mgr.get(server.user_id)
except osc_exc.NotFound:
pass
else:
send_instance_reminder(user.email, server.name,
server.id, instance_data.expires_at,
greeting=getattr(user, 'fullname', ''))
InstanceDataDAO.update(instance_data.instance_id, remind_at=None)
except Exception:
current_app.logger.exception(
'Failed to send reminder email about instance %r'
% instance_data.instance_id)
def setUp(self):
super(InstanceDataDAOTestCase, self).setUp()
self.instance_id = 'VMID'
self.expires_at = datetime(2012, 10, 11, 12, 13, 14)
self.remind_at = datetime(2012, 10, 11, 9, 8, 7)
InstanceDataDAO.create(self.instance_id,
self.expires_at, self.remind_at)
def setUp(self):
super(InstanceDataDAOTestCase, self).setUp()
self.instance_id = 'VMID'
self.expires_at = datetime(2012, 10, 11, 12, 13, 14)
self.remind_at = datetime(2012, 10, 11, 9, 8, 7)
InstanceDataDAO.create(self.instance_id, self.expires_at,
self.remind_at)
def _do_remove_instance(instance_id):
"""The real instance removal implementation"""
try:
fetch_instance(instance_id).delete()
except osc_exc.NotFound:
abort(404)
InstanceDataDAO.delete(instance_id)
try:
return fetch_instance(instance_id)
except HTTPException:
return None
def instance_data_gc():
"""Remove instance data for already deleted servers"""
server_mgr = admin_client_set().compute.servers
for instance_data in InstanceDataDAO.list_all():
try:
server_mgr.get(instance_data.instance_id)
except osc_exc.NotFound:
InstanceDataDAO.delete(instance_data.instance_id)
except Exception:
current_app.logger.exception('Failed to delete data '
'for non-existing instance %r' %
instance_data.instance_id)
def instance_data_gc():
"""Remove instance data for already deleted servers"""
server_mgr = admin_client_set().compute.servers
for instance_data in InstanceDataDAO.list_all():
try:
server_mgr.get(instance_data.instance_id)
except osc_exc.NotFound:
InstanceDataDAO.delete(instance_data.instance_id)
except Exception:
current_app.logger.exception('Failed to delete data '
'for non-existing instance %r'
% instance_data.instance_id)
def rip_expired_instances():
"""Run periodically to remove expired instances"""
server_mgr = admin_client_set().compute.servers
for instance_data in InstanceDataDAO.expired_list(datetime.utcnow()):
try:
server_mgr.delete(instance_data.instance_id)
AuditDAO.create_record(dict(
resource=url_for('instances.delete_instance',
instance_id=instance_data.instance_id),
method='DELETE',
response_status=200,
message='Automatically deleted expired instance',
))
except osc_exc.NotFound:
InstanceDataDAO.delete(instance_data.instance_id)
except Exception:
current_app.logger.exception('Failed to delete expired instance %r'
% instance_data.instance_id)
def update_instance(instance_id):
data = parse_request_data(_SCHEMA.updatable)
if "name" in data:
try:
fetch_instance(instance_id).update(name=data["name"])
except osc_exc.NotFound:
abort(404)
instance = fetch_instance(instance_id)
for_instance_data = {}
if "expires-at" in data:
for_instance_data["expires_at"] = data["expires-at"]
if "remind-at" in data:
for_instance_data["remind_at"] = data["remind-at"]
if for_instance_data:
InstanceDataDAO.update(instance.id, **for_instance_data)
set_audit_resource_id(instance)
return make_json_response(_instance_to_view(instance))
def rip_expired_instances():
"""Run periodically to remove expired instances"""
server_mgr = admin_client_set().compute.servers
for instance_data in InstanceDataDAO.expired_list(datetime.utcnow()):
try:
server_mgr.delete(instance_data.instance_id)
AuditDAO.create_record(
dict(
resource=url_for('instances.delete_instance',
instance_id=instance_data.instance_id),
method='DELETE',
response_status=200,
message='Automatically deleted expired instance',
))
except osc_exc.NotFound:
InstanceDataDAO.delete(instance_data.instance_id)
except Exception:
current_app.logger.exception(
'Failed to delete expired instance %r' %
instance_data.instance_id)
def create_instance():
data = parse_request_data(_SCHEMA.create_allowed, _SCHEMA.create_required)
tcs = client_set_for_tenant(data["project"])
security_groups = _security_group_ids_to_names(data.get("fw-rule-sets"), tcs.compute.security_groups)
try:
server = tcs.compute.servers.create(
name=data["name"],
image=data["image"],
flavor=data["instance-type"],
security_groups=security_groups,
key_name=data.get("ssh-key-pair"),
admin_pass=data.get("admin-pass"),
)
if "expires-at" in data or "remind-at" in data:
InstanceDataDAO.create(server.id, expires_at=data.get("expires-at"), remind_at=data.get("remind-at"))
except osc_exc.OverLimit, e:
return make_json_response(
status_code=403,
data={"path": request.path, "method": request.method, "message": "Limits exceeded (%s)" % str(e)},
)
def _instance_to_view(server):
client = admin_client_set()
project_link = link_for_project(server.tenant_id)
flavor = client.compute.flavors.get(server.flavor["id"])
user_link = link_for_user_id(server.user_id)
image_link = link_for_image(server.image["id"])
instancedata = InstanceDataDAO.get(server.id)
href_for = lambda endpoint: url_for(endpoint, instance_id=server.id)
result = {
u"id": server.id,
u"href": href_for("instances.get_instance"),
u"name": server.name,
u"project": project_link,
u"created-by": user_link,
u"image": image_link,
u"instance-type": {
u"id": flavor.id,
u"name": flavor.name,
u"href": url_for("instance_types.get_instance_type", instance_type_id=flavor.id),
},
u"created": timestamp_from_openstack(server.created),
u"state": server.status,
u"ipv4": [elem["addr"] for val in server.addresses.itervalues() for elem in val if elem["version"] == 4],
u"links": {
u"reboot": href_for("instances.reboot_instance"),
u"reset": href_for("instances.reset_instance"),
u"remove": href_for("instances.remove_instance"),
u"vnc": href_for("instances.instance_vnc_console"),
u"console-output": href_for("instances.instance_console_output"),
u"fw-rules": href_for("instance_fw_rule_sets" ".list_instance_fw_rule_sets"),
},
}
if instancedata:
if instancedata.expires_at is not None:
result[u"expires-at"] = instancedata.expires_at
if instancedata.remind_at is not None:
result[u"remind-at"] = instancedata.remind_at
if g.is_admin and hasattr(server, _HOST_ATTRIBUTE):
result["node"] = link_for_node(getattr(server, _HOST_ATTRIBUTE))
return result
def test_update_expires_at_to_none(self):
InstanceDataDAO.update(self.instance_id, expires_at=None)
self.assertEquals(None,
InstanceDataDAO.get(self.instance_id).expires_at)
def test_delete_deletes(self):
self.assertTrue(InstanceDataDAO.delete(self.instance_id))
self.assertEquals(None, InstanceDataDAO.get(self.instance_id))
def test_remind_list_empty(self):
one_day_before = self.remind_at - timedelta(days=1)
l = list(InstanceDataDAO.remind_list(one_day_before))
self.assertEquals(l, [])
def test_update_remind_at_to_none(self):
InstanceDataDAO.update(self.instance_id, remind_at=None)
self.assertEquals(None,
InstanceDataDAO.get(self.instance_id).remind_at)
def test_expired_list(self):
l = list(InstanceDataDAO.expired_list(self.expires_at))
self.assertEquals(l, [InstanceDataDAO.get(self.instance_id)])
def test_update_expires_at(self):
new_expires_at = self.expires_at + timedelta(days=30)
InstanceDataDAO.update(self.instance_id, expires_at=new_expires_at)
self.assertEquals(new_expires_at,
InstanceDataDAO.get(self.instance_id).expires_at)
def test_update_expires_at_to_none(self):
InstanceDataDAO.update(self.instance_id, expires_at=None)
self.assertEquals(None,
InstanceDataDAO.get(self.instance_id).expires_at)
def test_get(self):
instancedata = InstanceDataDAO.get(self.instance_id)
self.assertEquals(self.instance_id, instancedata.instance_id)
self.assertEquals(self.expires_at, instancedata.expires_at)
self.assertEquals(self.remind_at, instancedata.remind_at)
def test_update_expires_not_found(self):
instance_id = 'OTHER_TEST_VMID'
InstanceDataDAO.update(instance_id, expires_at=self.expires_at)
self.assertEquals(self.expires_at,
InstanceDataDAO.get(instance_id).expires_at)
def test_update_expires_at(self):
new_expires_at = self.expires_at + timedelta(days=30)
InstanceDataDAO.update(self.instance_id, expires_at=new_expires_at)
self.assertEquals(new_expires_at,
InstanceDataDAO.get(self.instance_id).expires_at)
def test_get_none(self):
instancedata = InstanceDataDAO.get('non-existing id')
self.assertEquals(instancedata, None)
def test_get(self):
instancedata = InstanceDataDAO.get(self.instance_id)
self.assertEquals(self.instance_id, instancedata.instance_id)
self.assertEquals(self.expires_at, instancedata.expires_at)
self.assertEquals(self.remind_at, instancedata.remind_at)
def test_get_none(self):
instancedata = InstanceDataDAO.get('non-existing id')
self.assertEquals(instancedata, None)
def test_update_remind_at(self):
new_remind_at = self.remind_at + timedelta(days=30)
InstanceDataDAO.update(self.instance_id, remind_at=new_remind_at)
self.assertEquals(new_remind_at,
InstanceDataDAO.get(self.instance_id).remind_at)
def test_update_expires_not_found(self):
instance_id = 'OTHER_TEST_VMID'
InstanceDataDAO.update(instance_id, expires_at=self.expires_at)
self.assertEquals(self.expires_at,
InstanceDataDAO.get(instance_id).expires_at)
def test_update_remind_at_to_none(self):
InstanceDataDAO.update(self.instance_id, remind_at=None)
self.assertEquals(None,
InstanceDataDAO.get(self.instance_id).remind_at)
def test_update_remind_at(self):
new_remind_at = self.remind_at + timedelta(days=30)
InstanceDataDAO.update(self.instance_id, remind_at=new_remind_at)
self.assertEquals(new_remind_at,
InstanceDataDAO.get(self.instance_id).remind_at)
def test_list_all(self):
l = list(InstanceDataDAO.list_all())
self.assertEquals(l, [InstanceDataDAO.get(self.instance_id)])
def test_list_all(self):
l = list(InstanceDataDAO.list_all())
self.assertEquals(l, [InstanceDataDAO.get(self.instance_id)])
def test_expired_list(self):
l = list(InstanceDataDAO.expired_list(self.expires_at))
self.assertEquals(l, [InstanceDataDAO.get(self.instance_id)])
def test_remind_list(self):
l = list(InstanceDataDAO.remind_list(self.remind_at))
self.assertEquals(l, [InstanceDataDAO.get(self.instance_id)])
def test_remind_list(self):
l = list(InstanceDataDAO.remind_list(self.remind_at))
self.assertEquals(l, [InstanceDataDAO.get(self.instance_id)])
def test_delete_deletes(self):
self.assertTrue(InstanceDataDAO.delete(self.instance_id))
self.assertEquals(None, InstanceDataDAO.get(self.instance_id))
def test_remind_list_empty(self):
one_day_before = self.remind_at - timedelta(days=1)
l = list(InstanceDataDAO.remind_list(one_day_before))
self.assertEquals(l, [])
