def _create_ip_ranges_on_notation(cls, instance):
"""Create IP-address ranges basing on 'notation' field of 'meta' field
:param instance: NetworkGroup instance
:type instance: models.NetworkGroup
:return: None
"""
notation = instance.meta.get("notation")
if notation:
try:
if notation == 'cidr':
cls._update_range_from_cidr(
instance, IPNetwork(instance.cidr).cidr,
instance.meta.get('use_gateway'))
elif notation == 'ip_ranges' and instance.meta.get("ip_range"):
cls._set_ip_ranges(instance, [instance.meta["ip_range"]])
else:
raise errors.CannotCreate()
except (
errors.CannotCreate,
IndexError,
TypeError
):
raise errors.CannotCreate(
"IPAddrRange object cannot be created for network '{0}' "
"with notation='{1}', ip_range='{2}'".format(
instance.name,
instance.meta.get('notation'),
instance.meta.get('ip_range'))
)
def create(cls, data):
"""Create Cluster instance with specified parameters in DB.
This includes:
* creating Cluster attributes and generating default values \
(see :func:`create_attributes`)
* creating NetworkGroups for Cluster
* adding default pending changes (see :func:`add_pending_changes`)
* if "nodes" are specified in data then they are added to Cluster \
(see :func:`update_nodes`)
:param data: dictionary of key-value pairs as object fields
:returns: Cluster instance
"""
# TODO(enchantner): fix this temporary hack in clients
if "release_id" not in data:
release_id = data.pop("release", None)
data["release_id"] = release_id
# remove read-only attribute
data.pop("is_locked", None)
assign_nodes = data.pop("nodes", [])
enabled_editable_attributes = None
if 'components' in data:
enabled_core_attributes = cls.get_cluster_attributes_by_components(
data['components'], data["release_id"])
data = dict_merge(data, enabled_core_attributes['cluster'])
enabled_editable_attributes = enabled_core_attributes['editable']
data["fuel_version"] = settings.VERSION["release"]
cluster = super(Cluster, cls).create(data)
cls.create_default_group(cluster)
cls.create_attributes(cluster, enabled_editable_attributes)
cls.create_vmware_attributes(cluster)
cls.create_default_extensions(cluster)
try:
cls.get_network_manager(cluster).\
create_network_groups_and_config(cluster, data)
cls.add_pending_changes(cluster, consts.CLUSTER_CHANGES.attributes)
cls.add_pending_changes(cluster, consts.CLUSTER_CHANGES.networks)
cls.add_pending_changes(cluster,
consts.CLUSTER_CHANGES.vmware_attributes)
if assign_nodes:
cls.update_nodes(cluster, assign_nodes)
except (errors.OutOfVLANs, errors.OutOfIPs,
errors.NoSuitableCIDR) as exc:
raise errors.CannotCreate(exc.message)
db().flush()
ClusterPlugins.add_compatible_plugins(cluster)
PluginManager.enable_plugins_by_components(cluster)
return cluster
def create(cls, data):
"""Create Cluster instance with specified parameters in DB.
This includes:
* creating Cluster attributes and generating default values \
(see :func:`create_attributes`)
* creating NetworkGroups for Cluster
* adding default pending changes (see :func:`add_pending_changes`)
* if "nodes" are specified in data then they are added to Cluster \
(see :func:`update_nodes`)
:param data: dictionary of key-value pairs as object fields
:returns: Cluster instance
"""
# TODO(enchantner): fix this temporary hack in clients
if "release_id" not in data:
release_id = data.pop("release", None)
data["release_id"] = release_id
assign_nodes = data.pop("nodes", [])
data["fuel_version"] = settings.VERSION["release"]
new_cluster = super(Cluster, cls).create(data)
cls.create_default_group(new_cluster)
cls.create_attributes(new_cluster)
cls.create_vmware_attributes(new_cluster)
try:
cls.get_network_manager(new_cluster).\
create_network_groups_and_config(new_cluster, data)
cls.add_pending_changes(new_cluster, "attributes")
cls.add_pending_changes(new_cluster, "networks")
cls.add_pending_changes(new_cluster, "vmware_attributes")
if assign_nodes:
cls.update_nodes(new_cluster, assign_nodes)
except (
errors.OutOfVLANs,
errors.OutOfIPs,
errors.NoSuitableCIDR,
errors.InvalidNetworkPool
) as exc:
db().delete(new_cluster)
raise errors.CannotCreate(exc.message)
db().flush()
return new_cluster
def create(cls, data):
"""Create NetworkGroup instance with specified parameters in DB.
Create corresponding IPAddrRange instance with IP range specified in
data or calculated from CIDR if not specified.
:param data: dictionary of key-value pairs as NetworkGroup fields
:returns: instance of new NetworkGroup
"""
instance = super(NetworkGroup, cls).create(data)
notation = instance.meta.get('notation')
if notation:
ip_range = models.IPAddrRange(network_group_id=instance.id)
try:
if notation == 'cidr':
cidr = IPNetwork(instance.cidr).cidr
ip_range.first = str(cidr[2])
ip_range.last = str(cidr[-2])
elif notation == 'ip_ranges' and instance.meta.get('ip_range'):
ip_range.first = instance.meta['ip_range'][0]
ip_range.last = instance.meta['ip_range'][1]
else:
raise errors.CannotCreate()
except (
errors.CannotCreate,
IndexError,
TypeError
):
raise errors.CannotCreate(
"IPAddrRange object cannot be created for network '{0}' "
"with notation='{1}', ip_range='{2}'".format(
instance.name,
instance.meta.get('notation'),
instance.meta.get('ip_range'))
)
db().add(ip_range)
db().flush()
return instance
def create(cls, data):
new_group = super(NodeGroup, cls).create(data)
try:
cluster = Cluster.get_by_uid(new_group.cluster_id)
nm = Cluster.get_network_manager(cluster)
nst = cluster.network_config.segmentation_type
nm.create_network_groups(cluster, nst, gid=new_group.id)
nm.create_admin_network_group(new_group.cluster_id, new_group.id)
except (errors.OutOfVLANs, errors.OutOfIPs, errors.NoSuitableCIDR,
errors.InvalidNetworkPool) as exc:
db().delete(new_group)
raise errors.CannotCreate(exc.message)
db().flush()
return new_group
def create(cls, data):
new_group = super(NodeGroup, cls).create(data)
try:
cluster = Cluster.get_by_uid(new_group.cluster_id)
nm = Cluster.get_network_manager(cluster)
nst = cluster.network_config.segmentation_type
# We have two node groups here when user adds the first custom
# node group.
if NodeGroupCollection.get_by_cluster_id(cluster.id).count() == 2:
nm.ensure_gateways_present_in_default_node_group(cluster)
nm.create_network_groups(
cluster, neutron_segment_type=nst, node_group_id=new_group.id,
set_all_gateways=True)
nm.create_admin_network_group(new_group.cluster_id, new_group.id)
except (
errors.OutOfVLANs,
errors.OutOfIPs,
errors.NoSuitableCIDR
) as exc:
db().delete(new_group)
raise errors.CannotCreate(exc.message)
db().flush()
return new_group
