def create(self, req, body=None): """Create a network instance in the cloud :param req: request object :param body: body request (not used) """ scheme = { "category": network.NetworkResource.kind, "mixins": [ network.ip_network, ], "optional_mixins": [os_network.os_network] } required = [ "occi.core.title", "occi.network.address", ] attributes = process_parameters(req, scheme, required) name = attributes.get('occi.core.title') cidr = attributes.get('occi.network.address') gateway = attributes.get('occi.network.gateway', None) ip_version = attributes.get('org.openstack.network.ip_version', None) net = self.os_helper.create_network(req, name=name, cidr=cidr, gateway=gateway, ip_version=ip_version) occi_network_resources = self._get_network_resources([net]) return collection.Collection(resources=occi_network_resources)
def create(self, req, body): parser = req.get_parser()(req.headers, req.body) scheme = { "category": compute.ComputeResource.kind, "mixins": [ templates.OpenStackOSTemplate, templates.OpenStackResourceTemplate, ], "optional_mixins": [ contextualization.user_data, contextualization.public_key, ] } obj = parser.parse() validator = occi_validator.Validator(obj) validator.validate(scheme) attrs = obj.get("attributes", {}) name = attrs.get("occi.core.title", "OCCI_VM") image = obj["schemes"][templates.OpenStackOSTemplate.scheme][0] flavor = obj["schemes"][templates.OpenStackResourceTemplate.scheme][0] user_data, key_name, key_data = None, None, None create_key, create_key_tmp = False, False if contextualization.user_data.scheme in obj["schemes"]: user_data = attrs.get("org.openstack.compute.user_data") if contextualization.public_key.scheme in obj["schemes"]: key_name = attrs.get("org.openstack.credentials.publickey.name") key_data = attrs.get("org.openstack.credentials.publickey.data") if key_name and key_data: create_key = True elif not key_name and key_data: # NOTE(orviz) To be occi-os compliant, not # raise exception.MissingKeypairName key_name = uuid.uuid4().hex create_key = True create_key_tmp = True if create_key: # add keypair: if key_name already exists, a 409 HTTP code # will be returned by OpenStack self.os_helper.keypair_create(req, key_name, public_key=key_data) server = self.os_helper.create_server(req, name, image, flavor, user_data=user_data, key_name=key_name) # The returned JSON does not contain the server name server["name"] = name occi_compute_resources = self._get_compute_resources([server]) if create_key_tmp: self.os_helper.keypair_delete(req, key_name) return collection.Collection(resources=occi_compute_resources)
def test_mixed_collection(self): res = resource.Resource("foo", [], uuid.uuid4().hex) knd = kind.Kind("scheme", "term", "title") c = collection.Collection(kinds=[knd], resources=[res]) r = self.renderer.get_renderer(c) observed = r.render() self.assertMixedCollection(knd, res, observed)
def create(self, req, body=None): """Create a security group link Creates a link between a server and a securitygroup. :param req: request object :param body: body request (not used) """ parser = req.get_parser()(req.headers, req.body) scheme = { "category": securitygroup_link.SecurityGroupLink.kind, } obj = parser.parse() validator = occi_validator.Validator(obj) validator.validate(scheme) attrs = obj.get("attributes", {}) _, securitygroup_id = ooi.api.helpers.get_id_with_kind( req, attrs.get("occi.core.target"), securitygroup.SecurityGroupResource.kind) _, server_id = ooi.api.helpers.get_id_with_kind( req, attrs.get("occi.core.source"), compute.ComputeResource.kind) self.os_helper.create_server_security_link(req, server_id, securitygroup_id) link = { "compute_id": server_id, "securitygroup": { "id": securitygroup_id } } occi_instance = _get_security_link_resources([link]) return collection.Collection(resources=occi_instance)
def create(self, req, body): parser = req.get_parser()(req.headers, req.body) scheme = {"category": network_link.NetworkInterface.kind} obj = parser.parse() validator = occi_validator.Validator(obj) validator.validate(scheme) attrs = obj.get("attributes", {}) server_id = attrs.get("occi.core.source") net_id = attrs.get("occi.core.target") # net_id is something like "fixed" or "floating/<pool_name>" if net_id == "fixed": raise exception.Invalid() try: _, pool_name = net_id.split("/", 1) except ValueError: raise exception.NetworkPoolFound(pool=net_id) # Allocate IP ip = self.os_helper.allocate_floating_ip(req, pool_name) # Add it to server self.os_helper.associate_floating_ip(req, server_id, ip["id"]) n = network.NetworkResource(title="network", id=net_id) c = compute.ComputeResource(title="Compute", id=server_id) l = os_network.OSNetworkInterface(c, n, "mac", ip["ip"]) return collection.Collection(resources=[l])
def test_list_ifaces(self, mock_index): tenant = fakes.tenants["foo"] mock_index.return_value = collection.Collection( fakes.fake_network_link_occi( fakes.network_links[tenant['id']] ) ) for url in ("/networklink/", "/networklink"): req = self._build_req(url, tenant["id"], method="GET") resp = req.get_response(self.app) self.assertEqual(200, resp.status_code) expected = [] for ip in fakes.network_links[tenant["id"]]: if ip["instance_id"]: # fixme(jorgesece): test in case of instance None link_id = '_'.join([ip["instance_id"], ip["network_id"], ip["ip"]]) expected.append( ("X-OCCI-Location", utils.join_url(self.application_url + "/", "networklink/%s" % link_id)) ) self.assertExpectedResult(expected, resp)
def index(self, req): """List NetworkLinks :param req: request object """ link_list = self.os_helper.list_compute_net_links(req) occi_link_resources = _get_network_link_resources(link_list) return collection.Collection(resources=occi_link_resources)
def index(self, req): """List security group links :param req: request object """ link_list = self.os_helper.list_server_security_links(req) occi_link_resources = _get_security_link_resources(link_list) return collection.Collection(resources=occi_link_resources)
def index(self, req): """List networks :param req: request object """ occi_networks = self.os_helper.list_networks(req) occi_network_resources = self._get_network_resources(occi_networks) return collection.Collection(resources=occi_network_resources)
def index(self, req): """List security groups :param req: request object """ occi_sc = self.os_helper.list_security_groups(req) occi_sc_resources = self._get_security_group_resources(occi_sc) return collection.Collection(resources=occi_sc_resources)
def index(self, req): volumes = self.os_helper.get_volumes(req) occi_storage_resources = [] if volumes: for v in volumes: s = storage.StorageResource(title=v["displayName"], id=v["id"]) occi_storage_resources.append(s) return collection.Collection(resources=occi_storage_resources)
def index(self, req): """List ip reservations :param req: request object """ occi_ipreservation = self.os_helper.get_floating_ips(req) occi_ipreservation_resources = self._get_ipreservation_resources( occi_ipreservation) return collection.Collection(resources=occi_ipreservation_resources)
def index(self, req): floating_ips = self.os_helper.get_floating_ips(req) occi_link_resources = [] for ip in floating_ips: if ip["instance_id"]: net_id = "%s/%s" % (network_api.FLOATING_PREFIX, ip["pool"]) n = network.NetworkResource(title="network", id=net_id) c = compute.ComputeResource(title="Compute", id=ip["instance_id"]) # TODO(enolfc): get the MAC? iface = os_network.OSNetworkInterface(c, n, "mac", ip["ip"]) occi_link_resources.append(iface) return collection.Collection(resources=occi_link_resources)
def index(self, req): # OCCI Core Kinds: kinds = [] actions = [] mixins = [] kinds.append(entity.Entity.kind) kinds.append(resource.Resource.kind) kinds.append(link.Link.kind) # OCCI infra Compute: kinds.append(compute.ComputeResource.kind) actions.extend(compute.ComputeResource.actions) # OCCI infra Storage kinds.append(storage.StorageResource.kind) kinds.append(storage_link.StorageLink.kind) actions.extend(storage.StorageResource.actions) # OCCI infra network kinds.append(network.NetworkResource.kind) actions.extend(network.NetworkResource.actions) if self.neutron_ooi_endpoint: mixins.append(os_network.neutron_network) mixins.append(network.ip_network) kinds.append(network_link.NetworkInterface.kind) mixins.append(network_link.ip_network_interface) kinds.append(ip_reservation.IPReservation.kind) # OCCI infra compute mixins mixins.append(infra_templates.os_tpl) mixins.append(infra_templates.resource_tpl) # OpenStack flavors & images mixins.extend(self._resource_tpls(req)) mixins.extend(self._os_tpls(req)) # OpenStack Contextualization mixins.append(os_contextualization.user_data) mixins.append(os_contextualization.public_key) # OCCI Contextualization mixins.append(contextualization.user_data) mixins.append(contextualization.ssh_key) # OpenStack Floating IP Pools mixins.extend(self._ip_pools(req)) return collection.Collection(kinds=kinds, mixins=mixins, actions=actions)
def index(self, req): volumes = self.os_helper.get_volumes(req) occi_link_resources = [] for v in volumes: for attach in v["attachments"]: if attach: c = compute.ComputeResource(title="Compute", id=attach["serverId"]) s = storage.StorageResource(title="Storage", id=v["id"]) l = storage_link.StorageLink(c, s, deviceid=attach["device"]) occi_link_resources.append(l) return collection.Collection(resources=occi_link_resources)
def test_list_networks_empty(self, m): tenant = fakes.tenants["bar"] headers = { 'Category': 'network; scheme="http://schema#";class="kind";', 'X_OCCI_Attribute': 'project=%s' % tenant["id"], } url = "/network" req = self._build_req(path=url, tenant_id='X', method="GET", headers=headers, content_type="text/occi") m.return_value = collection.Collection( create_occi_results(fakes.networks[tenant['id']])) resp = req.get_response(self.app) self.assertEqual(204, resp.status_code) expected_result = "" self.assertExpectedResult(expected_result, resp) self.assertDefaults(resp)
def create(self, req, body): parser = req.get_parser()(req.headers, req.body) scheme = {"category": storage_link.StorageLink.kind} obj = parser.parse() validator = occi_validator.Validator(obj) validator.validate(scheme) attrs = obj.get("attributes", {}) vol_id = attrs.get("occi.core.target") server_id = attrs.get("occi.core.source") device = attrs.get("occi.storagelink.deviceid", None) attachment = self.os_helper.create_server_volumes_link(req, server_id, vol_id, dev=device) c = compute.ComputeResource(title="Compute", id=server_id) s = storage.StorageResource(title="Storage", id=vol_id) l = storage_link.StorageLink(c, s, deviceid=attachment["device"]) return collection.Collection(resources=[l])
def test_list_networks(self, m): tenant = fakes.tenants["foo"] ooi_net = helpers_neutron.OpenStackNeutron._build_networks( fakes.networks[tenant['id']] ) m.return_value = collection.Collection( create_occi_results(ooi_net)) req = self._build_req(path="/network", tenant_id='X', method="GET") resp = req.get_response(self.app) self.assertEqual(200, resp.status_code) expected = [] for s in fakes.networks[tenant["id"]]: expected.append( ("X-OCCI-Location", utils.join_url(self.application_url + "/", "network/%s" % s["id"])) ) self.assertDefaults(resp) self.assertExpectedResult(expected, resp)
def create(self, req, body): parser = req.get_parser()(req.headers, req.body) scheme = { "category": network_link.NetworkInterface.kind, "optional_mixins": [ os_network.OSFloatingIPPool, ] } obj = parser.parse() validator = occi_validator.Validator(obj) validator.validate(scheme) attrs = obj.get("attributes", {}) _, net_id = helpers.get_id_with_kind( req, attrs.get("occi.core.target"), network.NetworkResource.kind) _, server_id = helpers.get_id_with_kind( req, attrs.get("occi.core.source"), compute.ComputeResource.kind) # net_id is something like "fixed" or "floating" if net_id == network_api.FIXED_PREFIX: raise exception.Invalid() elif net_id != network_api.FLOATING_PREFIX: raise exception.NetworkNotFound(resource_id=net_id) pool_name = None if os_network.OSFloatingIPPool.scheme in obj["schemes"]: pool_name = obj["schemes"][os_network.OSFloatingIPPool.scheme][0] # Allocate IP ip = self.os_helper.allocate_floating_ip(req, pool_name) # Add it to server self.os_helper.associate_floating_ip(req, server_id, ip["ip"]) n = network.NetworkResource(title="network", id=net_id) c = compute.ComputeResource(title="Compute", id=server_id) l = os_network.OSNetworkInterface(c, n, "mac", ip["ip"]) return collection.Collection(resources=[l])
def create(self, req, body): parser = req.get_parser()(req.headers, req.body) scheme = {"category": storage.StorageResource.kind} obj = parser.parse() validator = occi_validator.Validator(obj) validator.validate(scheme) attrs = obj.get("attributes", {}) name = attrs.get("occi.core.title", "OCCI Volume") # TODO(enolfc): this should be handled by the validator try: size = attrs["occi.storage.size"] except KeyError: raise exception.Invalid() volume = self.os_helper.volume_create(req, name, size) st = storage.StorageResource(title=volume["displayName"], id=volume["id"], size=volume["size"], state=helpers.vol_state(volume["status"])) return collection.Collection(resources=[st])
def create(self, req, body=None): """Create a networkLink Creates a link between a server and a network. It could be fixed or floating IP. :param req: request object :param body: body request (not used) """ parser = req.get_parser()(req.headers, req.body) scheme = { "category": network_link.NetworkInterface.kind, "optional_mixins": [ os_network.OSFloatingIPPool, ] } obj = parser.parse() validator = occi_validator.Validator(obj) validator.validate(scheme) attrs = obj.get("attributes", {}) _, net_id = helpers.get_id_with_kind(req, attrs.get("occi.core.target"), network.NetworkResource.kind) _, server_id = helpers.get_id_with_kind(req, attrs.get("occi.core.source"), compute.ComputeResource.kind) pool = None if os_network.OSFloatingIPPool.scheme in obj["schemes"]: pool = (obj["schemes"][os_network.OSFloatingIPPool.scheme][0]) # Allocate public IP and associate it ot the server if net_id == os_helpers.PUBLIC_NETWORK: os_link = self.os_helper.assign_floating_ip( req, net_id, server_id, pool) else: # Allocate private network os_link = self.os_helper.create_port(req, net_id, server_id) occi_link = _get_network_link_resources([os_link]) return collection.Collection(resources=occi_link)
def create(self, req, body=None): """Create an ip reservation instance in the cloud :param req: request object :param body: body request (not used) """ parser = req.get_parser()(req.headers, req.body) scheme = { "category": ip_reservation.IPReservation.kind, "optional_mixins": [ os_network.OSFloatingIPPool, ] } obj = parser.parse() validator = occi_validator.Validator(obj) validator.validate(scheme) pool = None if os_network.OSFloatingIPPool.scheme in obj["schemes"]: pool = (obj["schemes"][os_network.OSFloatingIPPool.scheme][0]) resp = self.os_helper.allocate_floating_ip(req, pool) occi_network_resources = self._get_ipreservation_resources([resp]) return collection.Collection(resources=occi_network_resources)
def test_create_link_with_pool(self, m_create): tenant = fakes.tenants["foo"] m_create.return_value = collection.Collection( [fakes.fake_network_link_occi( fakes.network_links[tenant['id']] )[0]]) link_info = fakes.network_links[tenant['id']][0] server_url = utils.join_url(self.application_url + "/", "compute/%s" % link_info['instance_id']) net_url = utils.join_url(self.application_url + "/", "network/%s" % link_info['network_id']) pool_name = 'pool' headers = { 'Category': ( 'networkinterface;' 'scheme="http://schemas.ogf.org/occi/infrastructure#";' 'class="kind",' '%s;' 'scheme="http://schemas.openstack.org/network/' 'floatingippool#"; class="mixin"') % pool_name, 'X-OCCI-Attribute': ( 'occi.core.source="%s", ' 'occi.core.target="%s"' ) % (server_url, net_url) } req = self._build_req("/networklink", tenant["id"], method="POST", headers=headers) resp = req.get_response(self.app) link_id = '_'.join([link_info['instance_id'], link_info['network_id'], link_info['ip']]) expected = [("X-OCCI-Location", utils.join_url(self.application_url + "/", "networklink/%s" % link_id))] self.assertEqual(200, resp.status_code) self.assertExpectedResult(expected, resp) self.assertDefaults(resp)
def create(self, req, body=None): """Create a network instance in the cloud :param req: request object :param body: body request (not used) """ scheme = { "category": securitygroup.SecurityGroupResource.kind, } required = ["occi.core.title", "occi.securitygroup.rules"] attributes = process_parameters(req, scheme, required) name = attributes.get('occi.core.title') description = attributes.get("occi.core.summary", "") try: rules = attributes.get('occi.securitygroup.rules') except Exception: raise exception.Invalid( "Bad JSON format for occi.securitygroup.rules: %s" % attributes.get('occi.securitygroup.rules')) sec = self.os_helper.create_security_group(req, name, description, rules) occi_sec_resources = self._get_security_group_resources([sec]) return collection.Collection(resources=occi_sec_resources)
def test_create(self, m): tenant = fakes.tenants["foo"] headers = { 'Category': 'network; scheme="http://schema#";class="kind",' + 'mixinID;' 'scheme="http://schemas.openstack.org/template/os#";' ' class=mixin', 'X_Occi_Attribute': 'project=%s' % tenant["id"], } req = self._build_req(path="/network", tenant_id='X', method="POST", headers=headers) fake_net = fakes.fake_network_occi( fakes.networks[tenant['id']] )[0] m.return_value = collection.Collection([fake_net]) resp = req.get_response(self.app) self.assertEqual(200, resp.status_code) expected = [("X-OCCI-Location", utils.join_url(self.application_url + "/", "network/%s" % fake_net.id))] self.assertExpectedResult(expected, resp)
def index(self, req): occi_network_resources = self._floating_index(req) occi_network_resources.append(_build_network(FIXED_PREFIX)) return collection.Collection(resources=occi_network_resources)
def test_collection_resources(self): r1 = resource.Resource("foo", [], uuid.uuid4().hex) r2 = resource.Resource("bar", [], uuid.uuid4().hex) c = collection.Collection(resources=[r1, r2]) self.get_render_and_assert(c)
def create(self, req, body): parser = req.get_parser()(req.headers, req.body) scheme = { "category": compute.ComputeResource.kind, "mixins": [ templates.OpenStackOSTemplate, templates.OpenStackResourceTemplate, ], "optional_mixins": [ contextualization.user_data, contextualization.ssh_key, os_contextualization.user_data, os_contextualization.public_key, ], "optional_links": [ storage.StorageResource.kind, network.NetworkResource.kind, ] } obj = parser.parse() validator = occi_validator.Validator(obj) validator.validate(scheme) attrs = obj.get("attributes", {}) name = attrs.get("occi.core.title", "OCCI_VM") image = obj["schemes"][templates.OpenStackOSTemplate.scheme][0] flavor = obj["schemes"][templates.OpenStackResourceTemplate.scheme][0] user_data, key_name, key_data = None, None, None create_key, create_key_tmp = False, False # TODO(enolfc): deprecate OS Contextualization in the future # meanwhile, raise 409 conflict if both contextualizations types appear if (os_contextualization.user_data.scheme in obj["schemes"] and contextualization.user_data.scheme in obj["schemes"]): raise exception.OCCIMixinConflict() if os_contextualization.user_data.scheme in obj["schemes"]: user_data = attrs.get("org.openstack.compute.user_data") if contextualization.user_data.scheme in obj["schemes"]: user_data = attrs.get("occi.compute.user_data") if (os_contextualization.public_key.scheme in obj["schemes"] and contextualization.ssh_key.scheme in obj["schemes"]): raise exception.OCCIMixinConflict() key_name = key_data = None if os_contextualization.public_key.scheme in obj["schemes"]: key_name = attrs.get("org.openstack.credentials.publickey.name") key_data = attrs.get("org.openstack.credentials.publickey.data") if contextualization.ssh_key.scheme in obj["schemes"]: if key_data or key_name: raise exception.OCCIMixinConflict() key_data = attrs.get("occi.credentials.ssh_key") if key_name and key_data: create_key = True elif not key_name and key_data: # NOTE(orviz) To be occi-os compliant, not # raise exception.MissingKeypairName key_name = uuid.uuid4().hex create_key = True create_key_tmp = True if create_key: # add keypair: if key_name already exists, a 409 HTTP code # will be returned by OpenStack self.os_helper.keypair_create(req, key_name, public_key=key_data) block_device_mapping_v2 = self._build_block_mapping(req, obj) networks = self._get_network_from_req(req, obj) server = self.os_helper.create_server( req, name, image, flavor, user_data=user_data, key_name=key_name, block_device_mapping_v2=block_device_mapping_v2, networks=networks) # The returned JSON does not contain the server name server["name"] = name occi_compute_resources = self._get_compute_resources([server]) if create_key_tmp: self.os_helper.keypair_delete(req, key_name) return collection.Collection(resources=occi_compute_resources)
def index(self, req): servers = self.os_helper.index(req) occi_compute_resources = self._get_compute_resources(servers) return collection.Collection(resources=occi_compute_resources)