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 _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 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_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_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_list_all(self): l = list(InstanceDataDAO.list_all()) 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)])