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)
