def add_item(self, context, name, body, scope=None):
# expected that either network is provided in parameters or
# default network exists (as in Google)
network = self._get_network_by_url(
context, body.get('network', CONF.default_network_name))
self._check_rules(body)
default_description = _("Firewall rules for network {}")
group_description = body.get(
"description", default_description.format(network['name']))
client = clients.nova(context)
operation_util.start_operation(context)
sg = client.security_groups.create(body['name'], group_description)
try:
rules = self._convert_to_secgroup_rules(body)
for rule in rules:
client.security_group_rules.create(
sg.id,
ip_protocol=rule["protocol"],
from_port=rule["from_port"],
to_port=rule["to_port"],
cidr=rule["cidr"],
)
except Exception:
client.security_groups.delete(sg)
raise
new_firewall = utils.to_dict(client.security_groups.get(sg.id))
new_firewall = self._prepare_firewall(new_firewall)
new_firewall["network_name"] = network["name"]
new_firewall = self._add_db_item(context, new_firewall)
self._process_callbacks(context, base_api._callback_reasons.post_add,
new_firewall)
return new_firewall
def delete_item(self, context, name, scope=None):
routes, aliased_routes = self._sync_routes(context)
route = routes[name]
if route.get("nexthop") is None:
raise exception.InvalidInput(
_("The local route cannot be deleted."))
destination = route["destination"]
nexthop = route["nexthop"]
# NOTE(ft): delete OS route only if it doesn't have aliases
# at the moment
client = clients.neutron(context)
operation_util.start_operation(context)
if self._get_route_key(route) not in aliased_routes:
dummy, router = self._get_network_objects(client, route["network"])
if "external_gateway_info" in route:
client.remove_gateway_router(router["id"])
else:
routes = [
r for r in router["routes"]
if (destination != r["destination"]
or nexthop != r["nexthop"])
]
client.update_router(router["id"], {
"router": {
"routes": routes,
},
})
self._delete_db_item(context, route)
def delete_item(self, context, name, scope=None):
routes, aliased_routes = self._sync_routes(context)
route = routes[name]
if route.get("nexthop") is None:
raise exception.InvalidInput(
_("The local route cannot be deleted."))
destination = route["destination"]
nexthop = route["nexthop"]
# NOTE(ft): delete OS route only if it doesn't have aliases
# at the moment
client = clients.neutron(context)
operation_util.start_operation(context)
if self._get_route_key(route) not in aliased_routes:
dummy, router = self._get_network_objects(client,
route["network"])
if "external_gateway_info" in route:
client.remove_gateway_router(router["id"])
else:
routes = [r for r in router["routes"]
if (destination != r["destination"] or
nexthop != r["nexthop"])]
client.update_router(
router["id"],
{"router": {"routes": routes, }, })
self._delete_db_item(context, route)
def add_item(self, context, name, body, scope=None):
routes, dummy = self._sync_routes(context)
if name in routes:
raise exception.InvalidInput(
_("The resource '%s' already exists.") % name)
# NOTE(ft): check network is plugged to router
network_name = utils._extract_name_from_url(body["network"])
network = network_api.API().get_item(context, network_name)
nexthop = body.get("nextHopGateway")
if (nexthop is not None and
(utils._extract_name_from_url(nexthop) ==
"default-internet-gateway") and
# NOTE(ft): OS doesn't support IP mask for external gateway
body.get("destRange") == ALL_IP_CIDR):
operation_util.start_operation(context)
return self._create_internet_route(context, network, body)
nexthop = body.get("nextHopIp")
if nexthop is not None:
operation_util.start_operation(context)
return self._create_custom_route(context, network, body)
raise exception.InvalidInput(_("Unsupported route."))
def delete_item(self, context, name, scope=None):
"""Delete an image, if allowed."""
image = self.get_item(context, name, scope)
image_service = clients.glance(context).images
operation_util.start_operation(context, self._get_delete_item_progress, image["id"])
image_service.delete(image["id"])
self._delete_db_item(context, image)
def add_item(self, context, name, body, scope=None):
network = self._get_network_by_url(context, body['network'])
self._check_rules(body)
group_description = body.get("description", "")
client = clients.nova(context)
operation_util.start_operation(context)
sg = client.security_groups.create(body['name'], group_description)
try:
rules = self._convert_to_secgroup_rules(body)
for rule in rules:
client.security_group_rules.create(
sg.id, ip_protocol=rule["protocol"],
from_port=rule["from_port"], to_port=rule["to_port"],
cidr=rule["cidr"], )
except Exception:
client.security_groups.delete(sg)
raise
new_firewall = utils.to_dict(client.security_groups.get(sg.id))
new_firewall = self._prepare_firewall(new_firewall)
new_firewall["creationTimestamp"] = 1
new_firewall["network_name"] = network["name"]
new_firewall = self._add_db_item(context, new_firewall)
self._process_callbacks(
context, base_api._callback_reasons.post_add, new_firewall)
return new_firewall
def add_item(self, context, name, body, scope=None):
sizeGb = int(body['sizeGb']) if 'sizeGb' in body else None
snapshot_uri = body.get("sourceSnapshot")
image_uri = body.get("sourceImage")
snapshot_id = None
image_id = None
client = clients.cinder(context)
if snapshot_uri:
snapshot_name = utils._extract_name_from_url(snapshot_uri)
snapshots = client.volume_snapshots.list(
search_opts={"display_name": snapshot_name})
if not snapshots or len(snapshots) != 1:
raise exception.NotFound
snapshot_id = snapshots[0].id
elif image_uri:
image_name = utils._extract_name_from_url(image_uri)
image = image_api.API().get_item(context, image_name, scope)
image_id = image['id']
# Cinder API doesn't get size from image, so we do this
image_size_in_gb = (int(image['size']) + GB - 1) / GB
if not sizeGb or sizeGb < image_size_in_gb:
sizeGb = image_size_in_gb
operation_util.start_operation(context, self._get_add_item_progress)
volume = client.volumes.create(
sizeGb, snapshot_id=snapshot_id,
display_name=body.get('name'),
display_description=body.get('description'),
imageRef=image_id,
availability_zone=scope.get_name())
operation_util.set_item_id(context, volume.id)
return self._prepare_item(client, utils.to_dict(volume))
def add_item(self, context, name, body, scope=None):
# expected that either network is provided in parameters or
# default network exists (as in Google)
network = self._get_network_by_url(
context,
body.get('network', CONF.default_network_name)
)
self._check_rules(body)
default_description = _("Firewall rules for network {}")
group_description = body.get(
"description",
default_description.format(network['name'])
)
client = clients.nova(context)
operation_util.start_operation(context)
sg = client.security_groups.create(body['name'], group_description)
try:
rules = self._convert_to_secgroup_rules(body)
for rule in rules:
client.security_group_rules.create(
sg.id, ip_protocol=rule["protocol"],
from_port=rule["from_port"], to_port=rule["to_port"],
cidr=rule["cidr"], )
except Exception:
client.security_groups.delete(sg)
raise
new_firewall = utils.to_dict(client.security_groups.get(sg.id))
new_firewall = self._prepare_firewall(new_firewall)
new_firewall["network_name"] = network["name"]
new_firewall = self._add_db_item(context, new_firewall)
self._process_callbacks(
context, base_api._callback_reasons.post_add, new_firewall)
return new_firewall
def delete_item(self, context, name, scope=None):
client = clients.cinder(context).volume_snapshots
snapshots = client.list(search_opts={"display_name": name})
if not snapshots or len(snapshots) != 1:
raise exception.NotFound
operation_util.start_operation(context, self._get_delete_item_progress,
snapshots[0].id)
client.delete(snapshots[0])
def delete_item(self, context, name, scope=None):
client = clients.cinder(context).volume_snapshots
snapshots = client.list(search_opts={"display_name": name})
if not snapshots or len(snapshots) != 1:
raise exception.NotFound
operation_util.start_operation(context,
self._get_delete_item_progress,
snapshots[0].id)
client.delete(snapshots[0])
def delete_item(self, context, name, scope=None):
"""Delete an image, if allowed."""
image = self.get_item(context, name, scope)
image_service = clients.glance(context).images
operation_util.start_operation(context,
self._get_delete_item_progress,
image["id"])
image_service.delete(image["id"])
self._delete_db_item(context, image)
def set_common_instance_metadata(self, context, metadata_list):
instance_metadata = dict([(x['key'], x['value'])
for x in metadata_list])
operation_util.start_operation(context)
ssh_keys = instance_metadata.pop('sshKeys', None)
if ssh_keys:
nova_client = clients.nova(context)
for key_data in ssh_keys.split('\n'):
user_name, ssh_key = key_data.split(":")
self._update_key(nova_client, user_name, ssh_key)
def set_common_instance_metadata(self, context, metadata_list):
instance_metadata = dict(
[(x['key'], x['value']) for x in metadata_list])
operation_util.start_operation(context)
ssh_keys = instance_metadata.pop('sshKeys', None)
if ssh_keys:
nova_client = clients.nova(context)
for key_data in ssh_keys.split('\n'):
user_name, ssh_key = key_data.split(":")
self._update_key(nova_client, user_name, ssh_key)
def delete_item(self, context, name, scope=None):
network = self.get_item(context, name)
self._process_callbacks(
context, base_api._callback_reasons.check_delete, network)
operation_util.start_operation(context)
self._delete_db_item(context, network)
self._process_callbacks(
context, base_api._callback_reasons.pre_delete, network)
client = clients.nova(context)
client.networks.delete(network["id"])
def reset_instance(self, context, scope, name):
client = clients.nova(context)
instances = client.servers.list(search_opts={"name": name})
if not instances or len(instances) != 1:
raise exception.NotFound
instance = instances[0]
operation_util.start_operation(context,
self._get_reset_instance_progress,
instance.id)
instance.reboot("HARD")
def add_item(self, context, instance_name, params, source, name,
auto_delete, scope):
# NOTE(apavlov): name is a 'device_name' here
if not name:
msg = _("There is no name to assign.")
raise exception.InvalidRequest(msg)
nova_client = clients.nova(context)
instances = nova_client.servers.list(
search_opts={"name": instance_name})
if not instances or len(instances) != 1:
raise exception.NotFound
instance = instances[0]
devices = list()
volumes_client = nova_client.volumes
for server_volume in volumes_client.get_server_volumes(instance.id):
devices.append(server_volume.device)
device_name = None
for letter in string.ascii_lowercase[1:]:
device_name = "vd" + letter
for device in devices:
if device_name in device:
break
else:
break
else:
raise exception.OverQuota
context.operation_data["device_name"] = device_name
if source:
volume_name = utils._extract_name_from_url(source)
if not volume_name:
msg = _("There is no volume to assign.")
raise exception.NotFound(msg)
volume = disk_api.API().get_item(context, volume_name, scope)
context.operation_data["volume_id"] = volume["id"]
elif params:
params.setdefault("diskName", instance_name)
context.operation_data["params"] = params
context.operation_data["scope"] = scope
else:
msg = _('Disk config must contain either "source" or '
'"initializeParams".')
raise exception.InvalidRequest(msg)
context.operation_data["instance_id"] = instance.id
context.operation_data["register_args"] = [
instance_name, name, auto_delete
]
operation_util.start_operation(
context, base_api.API._get_complex_operation_progress)
operation_util.continue_operation(context,
lambda: self._attach_volume(context),
timeout=0)
def delete_item(self, context, name, scope=None):
firewall = self.get_item(context, name)
operation_util.start_operation(context)
self._process_callbacks(
context, base_api._callback_reasons.pre_delete, firewall)
client = clients.nova(context)
try:
client.security_groups.delete(firewall["id"])
self._delete_db_item(context, firewall)
except clients.novaclient.exceptions.ClientException as ex:
raise exception.GceapiException(message=ex.message, code=ex.code)
def delete_item(self, context, name, scope=None):
firewall = self.get_item(context, name)
operation_util.start_operation(context)
self._process_callbacks(context, base_api._callback_reasons.pre_delete,
firewall)
client = clients.nova(context)
try:
client.security_groups.delete(firewall["id"])
self._delete_db_item(context, firewall)
except clients.novaclient.exceptions.ClientException as ex:
raise exception.GceapiException(message=ex.message, code=ex.code)
def delete_item(self, context, name, scope=None):
network = self.get_item(context, name)
self._process_callbacks(context,
base_api._callback_reasons.check_delete,
network)
operation_util.start_operation(context)
self._delete_db_item(context, network)
self._process_callbacks(context, base_api._callback_reasons.pre_delete,
network)
client = clients.nova(context)
client.networks.delete(network["id"])
def add_item(self, context, instance_name, params, source, name,
auto_delete, scope):
# NOTE(apavlov): name is a 'device_name' here
if not name:
msg = _("There is no name to assign.")
raise exception.InvalidRequest(msg)
nova_client = clients.nova(context)
instances = nova_client.servers.list(
search_opts={"name": instance_name})
if not instances or len(instances) != 1:
raise exception.NotFound
instance = instances[0]
devices = list()
volumes_client = nova_client.volumes
for server_volume in volumes_client.get_server_volumes(instance.id):
devices.append(server_volume.device)
device_name = None
for letter in string.ascii_lowercase[1:]:
device_name = "vd" + letter
for device in devices:
if device_name in device:
break
else:
break
else:
raise exception.OverQuota
context.operation_data["device_name"] = device_name
if source:
volume_name = utils._extract_name_from_url(source)
if not volume_name:
msg = _("There is no volume to assign.")
raise exception.NotFound(msg)
volume = disk_api.API().get_item(context, volume_name, scope)
context.operation_data["volume_id"] = volume["id"]
elif params:
params.setdefault("diskName", instance_name)
context.operation_data["params"] = params
context.operation_data["scope"] = scope
else:
msg = _('Disk config must contain either "source" or '
'"initializeParams".')
raise exception.InvalidRequest(msg)
context.operation_data["instance_id"] = instance.id
context.operation_data["register_args"] = [instance_name, name,
auto_delete]
operation_util.start_operation(
context, base_api.API._get_complex_operation_progress)
operation_util.continue_operation(
context, lambda: self._attach_volume(context), timeout=0)
def delete_item(self, context, instance_name, name):
client = clients.nova(context)
instances = client.servers.list(search_opts={"name": instance_name})
if not instances or len(instances) != 1:
raise exception.NotFound
instance = instances[0]
item = self.get_item(context, instance_name, name)
floating_ip = item["addr"]
operation_util.start_operation(context)
instance.remove_floating_ip(floating_ip)
self._delete_db_item(context, item)
def delete_item(self, context, instance_name, name):
client = clients.nova(context)
instances = client.servers.list(search_opts={"name": instance_name})
if not instances or len(instances) != 1:
raise exception.NotFound
instance = instances[0]
item = self.get_item(context, instance_name, name)
floating_ip = item["addr"]
operation_util.start_operation(context)
instance.remove_floating_ip(floating_ip)
self._delete_db_item(context, item)
def add_item(self, context, name, body, scope=None):
client = clients.nova(context)
if any(x["name"] == name
for x in self._get_floating_ips(client, context, scope)):
raise exception.InvalidInput(
_("The resource '%s' already exists.") % name)
operation_util.start_operation(context)
result = client.floating_ips.create()
floating_ip = self._prepare_floating_ip(client, context, result, scope)
floating_ip["name"] = body["name"]
if "description" in body:
floating_ip["description"] = body["description"]
floating_ip = self._add_db_item(context, floating_ip)
return floating_ip
def add_item(self, context, name, body, scope=None):
client = clients.nova(context)
if any(x["name"] == name
for x in self._get_floating_ips(client, context, scope)):
raise exception.InvalidInput(
_("The resource '%s' already exists.") % name)
operation_util.start_operation(context)
result = client.floating_ips.create()
floating_ip = self._prepare_floating_ip(client, context, result, scope)
floating_ip["name"] = body["name"]
if "description" in body:
floating_ip["description"] = body["description"]
floating_ip = self._add_db_item(context, floating_ip)
return floating_ip
def add_item(self, context, body, scope=None):
name = body["name"]
disk_name = body["disk_name"]
client = clients.cinder(context)
volumes = client.volumes.list(search_opts={"display_name": disk_name})
if not volumes or len(volumes) != 1:
raise exception.NotFound
operation_util.start_operation(context, self._get_add_item_progress)
snapshot = client.volume_snapshots.create(volumes[0].id, True, name,
body.get("description"))
operation_util.set_item_id(context, snapshot.id, self.KIND)
return self._prepare_item(client, utils.to_dict(snapshot))
def add_item(self, context, body, scope=None):
name = body["name"]
disk_name = body["disk_name"]
client = clients.cinder(context)
volumes = client.volumes.list(search_opts={"display_name": disk_name})
if not volumes or len(volumes) != 1:
raise exception.NotFound
operation_util.start_operation(context, self._get_add_item_progress)
snapshot = client.volume_snapshots.create(
volumes[0].id, True, name, body["description"])
operation_util.set_item_id(context, snapshot.id)
return self._prepare_item(client, utils.to_dict(snapshot))
def add_item(self, context, name, body, scope=None):
if any(x["name"] == name
for x in self._get_floating_ips(context, scope)):
raise exception.InvalidInput(
_("The resource '%s' already exists.") % name)
public_network_id = network_api.API().get_public_network_id(context)
operation_util.start_operation(context)
floating_ip = clients.neutron(context).create_floatingip(
{"floatingip": {"floating_network_id": public_network_id}})
floating_ip = self._prepare_floating_ip(
clients.nova(context), floating_ip["floatingip"], scope)
floating_ip["name"] = body["name"]
if "description" in body:
floating_ip["description"] = body["description"]
floating_ip = self._add_db_item(context, floating_ip)
return floating_ip
def delete_item(self, context, instance_name, name):
item = self.get_item(context, instance_name, name)
volume_id = item["volume_id"]
nova_client = clients.nova(context)
instances = nova_client.servers.list(
search_opts={"name": instance_name})
if not instances or len(instances) != 1:
raise exception.NotFound
instance = instances[0]
operation_util.start_operation(context, self._get_delete_item_progress,
item["id"])
nova_client.volumes.delete_server_volume(instance.id, volume_id)
self._delete_db_item(context, item)
def delete_item(self, context, instance_name, name):
item = self.get_item(context, instance_name, name)
volume_id = item["volume_id"]
nova_client = clients.nova(context)
instances = nova_client.servers.list(
search_opts={"name": instance_name})
if not instances or len(instances) != 1:
raise exception.NotFound
instance = instances[0]
operation_util.start_operation(context,
self._get_delete_item_progress,
item["id"])
nova_client.volumes.delete_server_volume(instance.id, volume_id)
self._delete_db_item(context, item)
def add_item(self, context, name, body, scope=None):
if any(x["name"] == name
for x in self._get_floating_ips(context, scope)):
raise exception.InvalidInput(
_("The resource '%s' already exists.") % name)
public_network_id = network_api.API().get_public_network_id(context)
operation_util.start_operation(context)
floating_ip = clients.neutron(context).create_floatingip(
{"floatingip": {
"floating_network_id": public_network_id
}})
floating_ip = self._prepare_floating_ip(clients.nova(context),
floating_ip["floatingip"],
scope)
floating_ip["name"] = body["name"]
if "description" in body:
floating_ip["description"] = body["description"]
floating_ip = self._add_db_item(context, floating_ip)
return floating_ip
def delete_item(self, context, name, scope=None):
client = clients.nova(context)
instances = client.servers.list(search_opts={"name": name})
if not instances or len(instances) != 1:
raise exception.NotFound
instance = instances[0]
operation_util.start_operation(
context, base_api.API._get_complex_operation_progress)
ads = instance_disk_api.API().get_items(context, instance.name)
disks_to_delete = []
for ad in ads:
if ad["auto_delete"]:
disks_to_delete.append(ad)
if not disks_to_delete:
operation_util.set_item_id(context, instance.id, self.KIND)
client = clients.nova(context)
instance.delete()
instance = utils.to_dict(instance)
instance = self._prepare_instance(client, context, instance)
self._delete_db_item(context, instance)
ads = instance_disk_api.API().get_items(context, instance["name"])
for ad in ads:
ad = instance_disk_api.API().unregister_item(context,
instance["name"], ad["name"])
acs = instance_address_api.API().get_items(context, instance["name"])
for ac in acs:
ac = instance_address_api.API().unregister_item(context,
instance["name"], ac["name"])
if not disks_to_delete:
return
context.operation_data["scope"] = scope
context.operation_data["count"] = 1 + len(disks_to_delete)
context.operation_data["instance"] = instance
context.operation_data["disks"] = disks_to_delete
operation_util.continue_operation(
context, lambda: self._delete_instance(context))
def add_item(self, context, name, body, scope=None):
ip_range = body.get('IPv4Range', CONF.default_network_ip_range)
gateway = body.get('gatewayIPv4')
if gateway is None:
network_cidr = netaddr.IPNetwork(ip_range)
gateway_ip = netaddr.IPAddress(network_cidr.first + 1)
gateway = str(gateway_ip)
client = clients.neutron(context)
network = None
try:
network = self.get_item(context, name)
except exception.NotFound:
pass
if network is not None:
raise exception.DuplicateVlan
network_body = {}
network_body["network"] = {"name": name}
operation_util.start_operation(context)
network = client.create_network(network_body)
network = network["network"]
if ip_range:
subnet_body = {}
subnet_body["subnet"] = {
# NOTE(Alex) "name": name + ".default_subnet",
# Won't give it a name for now
"network_id": network["id"],
"ip_version": "4",
"cidr": ip_range,
"gateway_ip": gateway
}
result_data = client.create_subnet(subnet_body)
subnet_id = result_data["subnet"]["id"]
network = self._prepare_network(client, network)
if 'description' in body:
network["description"] = body["description"]
network = self._add_db_item(context, network)
self._process_callbacks(context,
base_api._callback_reasons.post_add,
network,
subnet_id=subnet_id)
return network
def add_item(self, context, name, body, scope=None):
name = body["name"]
image_ref = body["rawDisk"]["source"]
meta = {
"name": name,
"disk_format": "raw",
"container_format": "bare",
"min_disk": 0,
"min_ram": 0,
"copy_from": image_ref,
}
image_service = clients.glance(context).images
operation_util.start_operation(context, self._get_add_item_progress)
image = image_service.create(**meta)
operation_util.set_item_id(context, image.id, self.KIND)
new_image = self._prepare_image(utils.to_dict(image))
new_image["description"] = body.get("description", "")
new_image["image_ref"] = image_ref
new_image = self._add_db_item(context, new_image)
return new_image
def add_item(self, context, name, body, scope=None):
name = body['name']
image_ref = body['rawDisk']['source']
meta = {
'name': name,
'disk_format': 'raw',
'container_format': 'bare',
'min_disk': 0,
'min_ram': 0,
'copy_from': image_ref,
}
image_service = clients.glance(context).images
operation_util.start_operation(context, self._get_add_item_progress)
image = image_service.create(**meta)
operation_util.set_item_id(context, image.id)
new_image = self._prepare_image(utils.to_dict(image))
new_image["description"] = body.get("description", "")
new_image["image_ref"] = image_ref
new_image = self._add_db_item(context, new_image)
return new_image
def add_item(self, context, name, body, scope=None):
name = body['name']
image_ref = body['rawDisk']['source']
meta = {
'name': name,
'disk_format': 'raw',
'container_format': 'bare',
'min_disk': 0,
'min_ram': 0,
'copy_from': image_ref,
}
image_service = clients.glance(context).images
operation_util.start_operation(context, self._get_add_item_progress)
image = image_service.create(**meta)
operation_util.set_item_id(context, image.id, self.KIND)
new_image = self._prepare_image(utils.to_dict(image))
new_image["description"] = body.get("description", "")
new_image["image_ref"] = image_ref
new_image = self._add_db_item(context, new_image)
return new_image
def add_item(self, context, name, body, scope=None):
ip_range = body.get('IPv4Range', CONF.default_network_ip_range)
gateway = body.get('gatewayIPv4')
if gateway is None:
network_cidr = netaddr.IPNetwork(ip_range)
gateway_ip = netaddr.IPAddress(network_cidr.first + 1)
gateway = str(gateway_ip)
client = clients.neutron(context)
network = None
try:
network = self.get_item(context, name)
except exception.NotFound:
pass
if network is not None:
raise exception.DuplicateVlan
network_body = {}
network_body["network"] = {"name": name}
operation_util.start_operation(context)
network = client.create_network(network_body)
network = network["network"]
if ip_range:
subnet_body = {}
subnet_body["subnet"] = {
# NOTE(Alex) "name": name + ".default_subnet",
# Won't give it a name for now
"network_id": network["id"],
"ip_version": "4",
"cidr": ip_range,
"gateway_ip": gateway}
result_data = client.create_subnet(subnet_body)
subnet_id = result_data["subnet"]["id"]
network = self._prepare_network(client, network)
if 'description' in body:
network["description"] = body["description"]
network = self._add_db_item(context, network)
self._process_callbacks(
context, base_api._callback_reasons.post_add,
network, subnet_id=subnet_id)
return network
def add_item(self, context, name, body, scope=None):
sizeGb = body.get("sizeGb")
sizeGb = int(sizeGb) if sizeGb else None
snapshot_uri = body.get("sourceSnapshot")
image_uri = body.get("sourceImage")
snapshot_id = None
image_id = None
client = clients.cinder(context)
if snapshot_uri:
snapshot_name = utils._extract_name_from_url(snapshot_uri)
snapshots = client.volume_snapshots.list(
search_opts={"display_name": snapshot_name})
if not snapshots or len(snapshots) != 1:
raise exception.NotFound
snapshot_id = snapshots[0].id
elif image_uri:
image_name = utils._extract_name_from_url(image_uri)
image = image_api.API().get_item(context, image_name, scope)
image_id = image['id']
# Cinder API doesn't get size from image, so we do this
image_size_in_gb = (int(image['size']) + GB - 1) / GB
if not sizeGb or sizeGb < image_size_in_gb:
sizeGb = image_size_in_gb
else:
if not sizeGb:
sizeGb = CONF.default_volume_size_gb
operation_util.start_operation(context, self._get_add_item_progress)
volume = client.volumes.create(
sizeGb, snapshot_id=snapshot_id,
display_name=body.get('name', name),
display_description=body.get('description'),
imageRef=image_id,
availability_zone=scope.get_name())
operation_util.set_item_id(context, volume.id, self.KIND)
return self._prepare_item(client, utils.to_dict(volume))
def add_item(self, context, name, body, scope=None):
ip_range = body.get('IPv4Range', CONF.default_network_ip_range)
gateway = body.get('gatewayIPv4')
if gateway is None:
network_cidr = netaddr.IPNetwork(ip_range)
gateway_ip = netaddr.IPAddress(network_cidr.first + 1)
gateway = str(gateway_ip)
network = None
try:
network = self.get_item(context, name)
except exception.NotFound:
pass
if network is not None:
raise exception.DuplicateVlan
kwargs = {'label': name, 'cidr': ip_range, 'gateway': gateway}
client = clients.nova(context)
operation_util.start_operation(context)
network = client.networks.create(**kwargs)
network = self._prepare_network(utils.to_dict(network))
if "description" in body:
network["description"] = body["description"]
return self._add_db_item(context, network)
def add_item(self, context, name, body, scope=None):
ip_range = body.get('IPv4Range', CONF.default_network_ip_range)
gateway = body.get('gatewayIPv4')
if gateway is None:
network_cidr = netaddr.IPNetwork(ip_range)
gateway_ip = netaddr.IPAddress(network_cidr.first + 1)
gateway = str(gateway_ip)
network = None
try:
network = self.get_item(context, name)
except exception.NotFound:
pass
if network is not None:
raise exception.DuplicateVlan
kwargs = {'label': name, 'cidr': ip_range, 'gateway': gateway}
client = clients.nova(context)
operation_util.start_operation(context)
network = client.networks.create(**kwargs)
network = self._prepare_network(utils.to_dict(network))
if "description" in body:
network["description"] = body["description"]
return self._add_db_item(context, network)
def delete_item(self, context, name, scope=None):
client = clients.nova(context)
instances = client.servers.list(search_opts={"name": name})
if not instances or len(instances) != 1:
raise exception.NotFound
instance = instances[0]
operation_util.start_operation(context,
self._get_delete_item_progress,
instance.id)
instance.delete()
instance = utils.to_dict(instance)
instance = self._prepare_instance(client, context, instance)
self._delete_db_item(context, instance)
ads = instance_disk_api.API().get_items(context, instance["name"])
for ad in ads:
ad = instance_disk_api.API().unregister_item(context,
instance["name"], ad["name"])
acs = instance_address_api.API().get_items(context, instance["name"])
for ac in acs:
ac = instance_address_api.API().unregister_item(context,
instance["name"], ac["name"])
def add_item(self, context, name, body, scope=None):
routes, dummy = self._sync_routes(context)
if name in routes:
raise exception.InvalidInput(
_("The resource '%s' already exists.") % name)
# NOTE(ft): check network is plugged to router
network_name = utils._extract_name_from_url(body["network"])
network = network_api.API().get_item(context, network_name)
nexthop = body.get("nextHopGateway")
if (nexthop is not None and (utils._extract_name_from_url(nexthop)
== "default-internet-gateway") and
# NOTE(ft): OS doesn't support IP mask for external gateway
body.get("destRange") == ALL_IP_CIDR):
operation_util.start_operation(context)
return self._create_internet_route(context, network, body)
nexthop = body.get("nextHopIp")
if nexthop is not None:
operation_util.start_operation(context)
return self._create_custom_route(context, network, body)
raise exception.InvalidInput(_("Unsupported route."))
def add_item(self, context, instance_name, nic, addr, addr_type, name):
if not nic:
msg = _("Network interface is invalid or empty")
raise exception.InvalidRequest(msg)
if addr_type is None:
addr_type = self.DEFAULT_ACCESS_CONFIG_TYPE
elif addr_type != self.DEFAULT_ACCESS_CONFIG_TYPE:
msg = _("Only '%s' type of access config currently supported.")\
% self.DEFAULT_ACCESS_CONFIG_TYPE
raise exception.InvalidRequest(msg)
client = clients.nova(context)
instances = client.servers.list(search_opts={"name": instance_name})
if not instances or len(instances) != 1:
raise exception.NotFound
instance = instances[0]
fixed_ip = None
for network in instance.addresses:
if nic != network:
continue
for address in instance.addresses[network]:
atype = address["OS-EXT-IPS:type"]
if atype == "floating":
msg = _('At most one access config currently supported.')
raise exception.InvalidRequest(msg)
if atype == "fixed":
fixed_ip = address["addr"]
if not fixed_ip:
msg = _('Network interface not found')
raise exception.InvalidRequest(msg)
floating_ips = client.floating_ips.list()
if addr is None:
# NOTE(apavlov): try to find unused
for floating_ip in floating_ips:
if floating_ip.instance_id is None:
addr = floating_ip.ip
break
else:
msg = _('There is no unused floating ips.')
raise exception.InvalidRequest(msg)
else:
for floating_ip in floating_ips:
if floating_ip.ip != addr:
continue
if floating_ip.instance_id is None:
break
msg = _("Floating ip '%s' is already associated") % floating_ip
raise exception.InvalidRequest(msg)
else:
msg = _("There is no such floating ip '%s'.") % addr
raise exception.InvalidRequest(msg)
operation_util.start_operation(context)
instance.add_floating_ip(addr, fixed_ip)
return self.register_item(context, instance_name, nic, addr, addr_type,
name)
def add_item(self, context, name, body, scope=None):
name = body['name']
client = clients.nova(context)
flavor_name = utils._extract_name_from_url(body['machineType'])
flavor_id = machine_type_api.API().get_item(
context, flavor_name, scope)["id"]
nics = []
#NOTE(ft) 'default' security group contains output rules
#but output rules doesn't configurable by GCE API
#all outgoing traffic permitted
#so we support this behaviour
groups_names = set(['default'])
acs = dict()
for net_iface in body['networkInterfaces']:
net_name = utils._extract_name_from_url(net_iface["network"])
ac = net_iface.get("accessConfigs")
if ac:
if len(ac) > 1:
msg = _('At most one access config currently supported.')
raise exception.InvalidRequest(msg)
else:
acs[net_name] = ac[0]
network = network_api.API().get_item(context, net_name, None)
nics.append({"net-id": network["id"]})
for sg in firewall_api.API().get_network_firewalls(
context, net_name):
groups_names.add(sg["name"])
groups_names = list(groups_names)
try:
metadatas = body['metadata']['items']
except KeyError:
metadatas = []
instance_metadata = dict([(x['key'], x['value']) for x in metadatas])
disks = body.get('disks', [])
for disk in disks:
disk["boot"] = True if "initializeParams" in disk else False
if "source" in disk:
volume_name = utils._extract_name_from_url(disk["source"])
volume = disk_api.API().get_item(context, volume_name, scope)
disk["id"] = volume["id"]
elif "initializeParams" not in disk:
msg = _('Disk config must contain either "source" or '
'"initializeParams".')
raise exception.InvalidRequest(msg)
disks.sort(None, lambda x: x.get("boot", False), True)
ssh_keys = instance_metadata.pop('sshKeys', None)
if ssh_keys is not None:
key = ssh_keys.split('\n')[0].split(":")
key_name = key[0] + "-" + str(random.randint(10000, 99999))
key_data = key[1]
client.keypairs.create(key_name, key_data)
else:
key_name = project_api.API().get_gce_user_keypair_name(context)
operation_util.start_operation(
context, base_api.API._get_complex_operation_progress)
context.operation_data["acs"] = acs
context.operation_data["ssh_keys"] = ssh_keys
context.operation_data["bdm"] = dict()
context.operation_data["disk_device"] = 0
context.operation_data["disks"] = disks
context.operation_data["scope"] = scope
context.operation_data["args"] = [name, None, flavor_id]
context.operation_data["kwargs"] = {"meta": instance_metadata,
"min_count": 1, "max_count": 1, "nics": nics,
"security_groups": groups_names, "key_name": key_name}
context.operation_data["description"] = body.get("description")
operation_util.continue_operation(
context, lambda: self._create_instance(context))
def add_item(self, context, name, body, scope=None):
name = body['name']
client = clients.nova(context)
flavor_name = utils._extract_name_from_url(body['machineType'])
flavor_id = machine_type_api.API().get_item(
context, flavor_name, scope)["id"]
try:
metadatas = body['metadata']['items']
except KeyError:
metadatas = []
instance_metadata = dict([(x['key'], x['value']) for x in metadatas])
ssh_keys = instance_metadata.pop('sshKeys', None)
if ssh_keys is not None:
key_name = ssh_keys.split('\n')[0].split(":")[0]
else:
key_name = project_api.API().get_gce_user_keypair_name(context)
disks = body.get('disks', [])
disks.sort(None, lambda x: x.get("boot", False), True)
bdm = dict()
diskDevice = 0
for disk in disks:
device_name = "vd" + string.ascii_lowercase[diskDevice]
volume_name = utils._extract_name_from_url(disk["source"])
volume = disk_api.API().get_item(context, volume_name, scope)
disk["id"] = volume["id"]
bdm[device_name] = volume["id"]
diskDevice += 1
nics = []
#NOTE(ft) 'default' security group contains output rules
#but output rules doesn't configurable by GCE API
#all outgoing traffic permitted
#so we support this behaviour
groups_names = set(['default'])
acs = dict()
for net_iface in body['networkInterfaces']:
net_name = utils._extract_name_from_url(net_iface["network"])
ac = net_iface.get("accessConfigs")
if ac:
if len(ac) > 1:
msg = _('At most one access config currently supported.')
raise exception.InvalidRequest(msg)
else:
acs[net_name] = ac[0]
network = network_api.API().get_item(context, net_name, None)
nics.append({"net-id": network["id"]})
for sg in firewall_api.API().get_network_firewalls(
context, net_name):
groups_names.add(sg["name"])
groups_names = list(groups_names)
operation_util.start_operation(context, self._get_add_item_progress)
instance = client.servers.create(name, None, flavor_id,
meta=instance_metadata, min_count=1, max_count=1,
security_groups=groups_names, key_name=key_name,
availability_zone=scope.get_name(), block_device_mapping=bdm,
nics=nics)
if not acs:
operation_util.set_item_id(context, instance.id)
for disk in disks:
instance_disk_api.API().register_item(context, name,
disk["id"], disk["deviceName"])
instance = utils.to_dict(client.servers.get(instance.id))
instance = self._prepare_instance(client, context, instance)
if "descripton" in body:
instance["description"] = body["description"]
instance = self._add_db_item(context, instance)
if acs:
operation_util.continue_operation(
context,
lambda: self._add_access_config(context, instance,
scope, acs))
return instance
def delete_item(self, context, name, scope=None):
floating_ip = self._get_floating_ips(context, scope, name)[0]
operation_util.start_operation(context)
self._delete_db_item(context, floating_ip)
clients.neutron(context).delete_floatingip(floating_ip["id"])
def delete_item(self, context, name, scope=None):
client = clients.nova(context)
floating_ip = self._get_floating_ips(client, context, scope, name)[0]
operation_util.start_operation(context)
self._delete_db_item(context, floating_ip)
client.floating_ips.delete(floating_ip["id"])
def delete_item(self, context, name, scope=None):
client = clients.nova(context)
floating_ip = self._get_floating_ips(client, context, scope, name)[0]
operation_util.start_operation(context)
self._delete_db_item(context, floating_ip)
client.floating_ips.delete(floating_ip["id"])
def delete_item(self, context, name, scope=None):
floating_ip = self._get_floating_ips(context, scope, name)[0]
operation_util.start_operation(context)
self._delete_db_item(context, floating_ip)
clients.neutron(context).delete_floatingip(floating_ip["id"])
def add_item(self, context, instance_name, nic, addr, addr_type, name):
if not nic:
msg = _("Network interface is invalid or empty")
raise exception.InvalidRequest(msg)
if addr_type is None:
addr_type = self.DEFAULT_ACCESS_CONFIG_TYPE
elif addr_type != self.DEFAULT_ACCESS_CONFIG_TYPE:
msg = _("Only '%s' type of access config currently supported.")\
% self.DEFAULT_ACCESS_CONFIG_TYPE
raise exception.InvalidRequest(msg)
client = clients.nova(context)
instances = client.servers.list(search_opts={"name": instance_name})
if not instances or len(instances) != 1:
raise exception.NotFound
instance = instances[0]
fixed_ip = None
for network in instance.addresses:
if nic != network:
continue
for address in instance.addresses[network]:
atype = address["OS-EXT-IPS:type"]
if atype == "floating":
msg = _('At most one access config currently supported.')
raise exception.InvalidRequest(msg)
if atype == "fixed":
fixed_ip = address["addr"]
if not fixed_ip:
msg = _('Network interface not found')
raise exception.InvalidRequest(msg)
floating_ips = client.floating_ips.list()
if addr is None:
# NOTE(apavlov): try to find unused
for floating_ip in floating_ips:
if floating_ip.instance_id is None:
addr = floating_ip.ip
break
else:
msg = _('There is no unused floating ips.')
raise exception.InvalidRequest(msg)
else:
for floating_ip in floating_ips:
if floating_ip.ip != addr:
continue
if floating_ip.instance_id is None:
break
msg = _("Floating ip '%s' is already associated") % floating_ip
raise exception.InvalidRequest(msg)
else:
msg = _("There is no such floating ip '%s'.") % addr
raise exception.InvalidRequest(msg)
operation_util.start_operation(context)
instance.add_floating_ip(addr, fixed_ip)
return self.register_item(context, instance_name,
nic, addr, addr_type, name)