def serialize(cls, instance, fields=None): from nailgun.objects import Node data_dict = super(NodeSerializer, cls).serialize(instance, fields) data_dict['fqdn'] = Node.get_node_fqdn(instance) data_dict['status'] = Node.get_status(instance) data_dict['tags'] = instance.tag_names return data_dict
def generate_network_scheme(cls, node, networks): attrs = super(NeutronNetworkDeploymentSerializer60, cls).generate_network_scheme(node, networks) for item in attrs.get("transformations", ()): if "tags" in item: item["vlan_ids"] = item["tags"] # Include information about all subnets that don't belong to this node. # This is used during deployment to configure routes to all other # networks in the environment. nm = Cluster.get_network_manager(node.cluster) other_nets = nm.get_networks_not_on_node(node, networks) netgroup_mapping = [("storage", "br-storage"), ("management", "br-mgmt"), ("fuelweb_admin", "br-fw-admin")] if Node.should_have_public(node): netgroup_mapping.append(("public", "br-ex")) for ngname, brname in netgroup_mapping: netgroup = nm.get_network_by_netname(ngname, networks) if netgroup.get("gateway"): attrs["endpoints"][brname]["gateway"] = netgroup["gateway"] attrs["endpoints"][brname]["other_nets"] = other_nets.get(ngname, []) if Node.should_have_public(node): attrs["endpoints"]["br-ex"]["default_gateway"] = True else: gw = nm.get_default_gateway(node.id) attrs["endpoints"]["br-fw-admin"]["gateway"] = gw attrs["endpoints"]["br-fw-admin"]["default_gateway"] = True return attrs
def generate_network_metadata(cls, cluster): nodes = dict() nm = Cluster.get_network_manager(cluster) for n in Cluster.get_nodes_not_for_deletion(cluster): name = Node.get_slave_name(n) node_roles = Node.all_roles(n) ip_by_net = {"fuelweb_admin": None, "storage": None, "management": None, "public": None} for net in ip_by_net: netgroup = nm.get_node_network_by_netname(n, net) if netgroup.get("ip"): ip_by_net[net] = netgroup["ip"].split("/")[0] netw_roles = { "admin/pxe": ip_by_net["fuelweb_admin"], "fw-admin": ip_by_net["fuelweb_admin"], "keystone/api": ip_by_net["management"], "swift/api": ip_by_net["management"], "sahara/api": ip_by_net["management"], "ceilometer/api": ip_by_net["management"], "cinder/api": ip_by_net["management"], "glance/api": ip_by_net["management"], "heat/api": ip_by_net["management"], "nova/api": ip_by_net["management"], "murano/api": ip_by_net["management"], "horizon": ip_by_net["management"], "management": ip_by_net["management"], "mgmt/api": ip_by_net["management"], "mgmt/database": ip_by_net["management"], "mgmt/messaging": ip_by_net["management"], "mgmt/corosync": ip_by_net["management"], "mgmt/memcache": ip_by_net["management"], "mgmt/vip": ip_by_net["management"], "mongo/db": ip_by_net["management"], "ceph/public": ip_by_net["management"], "storage": ip_by_net["storage"], "ceph/replication": ip_by_net["storage"], "swift/replication": ip_by_net["storage"], "cinder/iscsi": ip_by_net["storage"], "ex": ip_by_net["public"], "public/vip": ip_by_net["public"], "ceph/radosgw": ip_by_net["public"], } nodes[name] = { "uid": n.uid, "fqdn": n.fqdn, "name": name, "user_node_name": n.name, "swift_zone": n.uid, "node_roles": node_roles, "network_roles": netw_roles, } return dict(nodes=nodes, vips=nm.assign_vips_for_net_groups(cluster))
def create_node(self, api=False, exclude=None, expect_http=201, expected_error=None, **kwargs): # TODO(alekseyk) Simplify 'interfaces' and 'mac' manipulation logic metadata = kwargs.get("meta") default_metadata = self.default_metadata() if metadata: default_metadata.update(metadata) meta_ifaces = "interfaces" in metadata mac = kwargs.get("mac", self.generate_random_mac()) if default_metadata["interfaces"]: default_metadata["interfaces"][0]["mac"] = mac if not metadata or not meta_ifaces: for iface in default_metadata["interfaces"][1:]: if "mac" in iface: iface["mac"] = self.generate_random_mac() node_data = {"mac": mac, "status": "discover", "ip": "10.20.0.130", "meta": default_metadata} if kwargs: meta = kwargs.pop("meta", None) node_data.update(kwargs) if meta: kwargs["meta"] = meta if exclude and isinstance(exclude, list): for ex in exclude: try: del node_data[ex] except KeyError as err: logger.warning(err) if api: resp = self.app.post( reverse("NodeCollectionHandler"), jsonutils.dumps(node_data), headers=self.default_headers, expect_errors=True, ) self.tester.assertEqual(resp.status_code, expect_http, resp.body) if expected_error: self.tester.assertEqual(resp.json_body["message"], expected_error) if str(expect_http)[0] != "2": return None self.tester.assertEqual(resp.status_code, expect_http) node = resp.json_body node_db = Node.get_by_uid(node["id"]) if "interfaces" not in node_data["meta"] or not node_data["meta"]["interfaces"]: self._set_interfaces_if_not_set_in_meta(node_db.id, kwargs.get("meta", None)) self.nodes.append(node_db) else: node = Node.create(node_data) db().commit() self.nodes.append(node) return node
def set_default_node_volumes(cls, node): from .objects.volumes import VolumeObject try: VolumeObject.set_default_node_volumes(node) except Exception as exc: logger.exception(exc) msg = "Failed to generate volumes for node '{0}': '{1}'".format( node.human_readable_name, six.text_type(exc) ) Notification.create({"topic": "error", "message": msg, "node_id": node.id}) if node.cluster_id: Node.add_pending_change(node, "disks")
def mellanox_settings(cls, node_attrs, node): """Serialize mellanox node attrs, then it will be merged with common attributes, if mellanox plugin or iSER storage enabled. """ # Get Mellanox data neutron_mellanox_data = \ Cluster.get_attributes(node.cluster).editable\ .get('neutron_mellanox', {}) # Get storage data storage_data = \ Cluster.get_attributes(node.cluster).editable.get('storage', {}) # Get network manager nm = Node.get_network_manager(node) # Init mellanox dict node_attrs['neutron_mellanox'] = {} # Find Physical port for VFs generation if 'plugin' in neutron_mellanox_data and \ neutron_mellanox_data['plugin']['value'] == 'ethernet': node_attrs = cls.set_mellanox_ml2_config(node_attrs, node, nm) # Fix network scheme to have physical port for RDMA if iSER enabled if 'iser' in storage_data and storage_data['iser']['value']: node_attrs = cls.fix_iser_port(node_attrs, node, nm) return node_attrs
def set_default_node_volumes(cls, node): from .objects.volumes import VolumeObject try: VolumeObject.set_default_node_volumes(node) except Exception as exc: logger.exception(exc) msg = "Failed to generate volumes for node '{0}': '{1}'".format( node.human_readable_name, six.text_type(exc)) Notification.create({ 'topic': 'error', 'message': msg, 'node_id': node.id}) if node.cluster_id: Node.add_pending_change(node, 'disks')
def update_nodes(cls, instance, nodes_ids): """Update Cluster nodes by specified node IDs Nodes with specified IDs will replace existing ones in Cluster :param instance: Cluster instance :param nodes_ids: list of nodes ids :returns: None """ # TODO(NAME): sepatate nodes # for deletion and addition by set(). new_nodes = [] if nodes_ids: new_nodes = db().query(models.Node).filter( models.Node.id.in_(nodes_ids) ) nodes_to_remove = [n for n in instance.nodes if n not in new_nodes] nodes_to_add = [n for n in new_nodes if n not in instance.nodes] for node in nodes_to_add: if not node.online: raise errors.NodeOffline( u"Cannot add offline node " u"'{0}' to environment".format(node.id) ) # we should reset hostname to default value to guarantee # hostnames uniqueness for nodes outside clusters from nailgun.objects import Node for node in nodes_to_remove: node.hostname = Node.default_slave_name(node) map(instance.nodes.remove, nodes_to_remove) map(instance.nodes.append, nodes_to_add) net_manager = cls.get_network_manager(instance) map( net_manager.clear_assigned_networks, nodes_to_remove ) map( net_manager.clear_bond_configuration, nodes_to_remove ) cls.replace_provisioning_info_on_nodes(instance, [], nodes_to_remove) cls.replace_deployment_info_on_nodes(instance, [], nodes_to_remove) from nailgun.objects import NodeCollection NodeCollection.reset_network_template(nodes_to_remove) map( net_manager.assign_networks_by_default, nodes_to_add ) cls.update_nodes_network_template(instance, nodes_to_add) db().flush()
def get_dpdk_driver(cls, instance, dpdk_drivers): from nailgun.objects import Node pci_id = instance.meta.get('pci_id', '').lower() sriov_enabled = Node.sriov_enabled(instance.node) for driver, device_ids in six.iteritems(dpdk_drivers): if pci_id in device_ids: if sriov_enabled: return consts.DPDK_DRIVER_IN_SRIOV_CASE return driver return None
def generate_network_metadata(cls, cluster): nodes = dict() nm = Cluster.get_network_manager(cluster) for node in Cluster.get_nodes_not_for_deletion(cluster): name = Node.get_slave_name(node) node_roles = Node.all_roles(node) network_roles = cls.get_network_role_mapping_to_ip(node) nodes[name] = { "uid": node.uid, "fqdn": Node.get_node_fqdn(node), "name": name, "user_node_name": node.name, "swift_zone": node.uid, "node_roles": node_roles, "network_roles": network_roles, } return dict(nodes=nodes, vips=nm.assign_vips_for_net_groups(cluster))
def generate_network_metadata(cls, cluster): nodes = dict() nm = Cluster.get_network_manager(cluster) for node in Cluster.get_nodes_not_for_deletion(cluster): name = Node.get_slave_name(node) node_roles = Node.all_roles(node) network_roles = cls.get_network_role_mapping_to_ip(node) nodes[name] = { "uid": node.uid, "fqdn": Node.get_node_fqdn(node), "name": name, "user_node_name": node.name, "swift_zone": node.uid, "node_roles": node_roles, "network_roles": network_roles } return dict(nodes=nodes, vips=nm.assign_vips_for_net_groups(cluster))
def generate_network_metadata(cls, cluster): metadata = super(NeutronNetworkTemplateSerializer70, cls).generate_network_metadata(cluster) for node_data in metadata['nodes'].values(): node = Node.get_by_uid(node_data['uid']) network_roles = cls._get_network_roles(node) ip_per_ep = cls._get_endpoint_to_ip_mapping(node) node_data['network_roles'] = {} for role, ep in network_roles.items(): node_data['network_roles'][role] = ip_per_ep.get(ep) return metadata
def add_vlan_interfaces(cls, node): """Assign fixed_interfaces and vlan_interface. They should be equal. """ net_manager = Node.get_network_manager(node) fixed_interface = net_manager._get_interface_by_network_name( node.id, 'fixed') attrs = {'fixed_interface': fixed_interface.name, 'vlan_interface': fixed_interface.name} return attrs
def get_default_network_to_endpoint_mapping(cls, node): mapping = { consts.NETWORKS.fuelweb_admin: 'br-fw-admin', consts.NETWORKS.storage: 'br-storage', consts.NETWORKS.management: 'br-mgmt', consts.NETWORKS.private: 'br-prv'} if Node.should_have_public(node): mapping[consts.NETWORKS.public] = 'br-ex' return mapping
def get_default_network_to_endpoint_mapping(cls, node): mapping = { consts.NETWORKS.fuelweb_admin: 'br-fw-admin', consts.NETWORKS.storage: 'br-storage', consts.NETWORKS.management: 'br-mgmt', consts.NETWORKS.private: 'br-prv'} # roles can be assigned to br-ex only in case it has a public IP if Node.should_have_public_with_ip(node): mapping[consts.NETWORKS.public] = 'br-ex' return mapping
def update_nodes_net_info(cls, cluster, nodes): """Adds information about networks to each node.""" for node in Cluster.get_nodes_not_for_deletion(cluster): netw_data = node.network_data addresses = {} for net in node.cluster.network_groups: if net.name == "public" and not Node.should_have_public(node): continue if net.meta.get("render_addr_mask"): addresses.update(cls.get_addr_mask(netw_data, net.name, net.meta.get("render_addr_mask"))) [n.update(addresses) for n in nodes if n["uid"] == str(node.uid)] return nodes
def get_admin_ip_w_prefix(node): """Getting admin ip and assign prefix from admin network.""" network_manager = Node.get_network_manager(node) admin_ip = network_manager.get_admin_ip_for_node(node.id) admin_ip = IPNetwork(admin_ip) # Assign prefix from admin network admin_net = IPNetwork( network_manager.get_admin_network_group(node.id).cidr ) admin_ip.prefixlen = admin_net.prefixlen return str(admin_ip)
def get_default_network_to_endpoint_mapping(cls, node): mapping = { consts.NETWORKS.fuelweb_admin: 'br-fw-admin', consts.NETWORKS.storage: 'br-storage', consts.NETWORKS.management: 'br-mgmt', consts.NETWORKS.private: 'br-prv' } # roles can be assigned to br-ex only in case it has a public IP if Node.should_have_public_with_ip(node): mapping[consts.NETWORKS.public] = 'br-ex' return mapping
def generate_network_scheme(cls, node, networks): attrs = super(NeutronNetworkDeploymentSerializer60, cls). \ generate_network_scheme(node, networks) for item in attrs.get('transformations', ()): if 'tags' in item: item['vlan_ids'] = item['tags'] # Include information about all subnets that don't belong to this node. # This is used during deployment to configure routes to all other # networks in the environment. nm = Cluster.get_network_manager(node.cluster) other_nets = nm.get_networks_not_on_node(node, networks) netgroup_mapping = [ ('storage', 'br-storage'), ('management', 'br-mgmt'), ('fuelweb_admin', 'br-fw-admin'), ] if Node.should_have_public(node): netgroup_mapping.append(('public', 'br-ex')) for ngname, brname in netgroup_mapping: netgroup = nm.get_network_by_netname(ngname, networks) if netgroup.get('gateway'): attrs['endpoints'][brname]['gateway'] = netgroup['gateway'] attrs['endpoints'][brname]['other_nets'] = \ other_nets.get(ngname, []) if Node.should_have_public(node): attrs['endpoints']['br-ex']['default_gateway'] = True else: gw = nm.get_default_gateway(node.id) attrs['endpoints']['br-fw-admin']['gateway'] = gw attrs['endpoints']['br-fw-admin']['default_gateway'] = True return attrs
def generate_network_scheme(cls, node): attrs = super(NeutronNetworkDeploymentSerializer60, cls). \ generate_network_scheme(node) for item in attrs.get('transformations', ()): if 'tags' in item: item['vlan_ids'] = item['tags'] # Include information about all subnets that don't belong to this node. # This is used during deployment to configure routes to all other # networks in the environment. nm = Cluster.get_network_manager(node.cluster) other_nets = nm.get_networks_not_on_node(node) netgroup_mapping = [ ('storage', 'br-storage'), ('management', 'br-mgmt'), ('fuelweb_admin', 'br-fw-admin'), ] if Node.should_have_public(node): netgroup_mapping.append(('public', 'br-ex')) for ngname, brname in netgroup_mapping: netgroup = nm.get_node_network_by_netname(node, ngname) if netgroup.get('gateway'): attrs['endpoints'][brname]['gateway'] = netgroup['gateway'] attrs['endpoints'][brname]['other_nets'] = \ other_nets.get(ngname, []) if Node.should_have_public(node): attrs['endpoints']['br-ex']['default_gateway'] = True else: gw = nm.get_default_gateway(node.id) attrs['endpoints']['br-fw-admin']['gateway'] = gw attrs['endpoints']['br-fw-admin']['default_gateway'] = True return attrs
def update_nodes_net_info(cls, cluster, nodes): """Adds information about networks to each node.""" for node in Cluster.get_nodes_not_for_deletion(cluster): netw_data = node.network_data addresses = {} for net in node.cluster.network_groups: if net.name == 'public' and \ not Node.should_have_public_with_ip(node): continue if net.meta.get('render_addr_mask'): addresses.update( cls.get_addr_mask(netw_data, net.name, net.meta.get('render_addr_mask'))) [n.update(addresses) for n in nodes if n['uid'] == str(node.uid)] return nodes
def network_provider_cluster_attrs(cls, cluster): """Cluster attributes.""" attrs = {'quantum': True, 'quantum_settings': cls.neutron_attrs(cluster)} if cluster.mode == 'multinode': for node in cluster.nodes: if cls._node_has_role_by_name(node, 'controller'): net_manager = Node.get_network_manager(node) mgmt_cidr = net_manager.get_node_network_by_netname( node, 'management' )['ip'] attrs['management_vip'] = mgmt_cidr.split('/')[0] break return attrs
def get_network_to_endpoint_mapping(cls, node): mapping = { consts.NETWORKS.fuelweb_admin: 'br-fw-admin', consts.NETWORKS.storage: 'br-storage', consts.NETWORKS.management: 'br-mgmt'} # roles can be assigned to br-ex only in case it has a public IP if Node.should_have_public_with_ip(node): mapping[consts.NETWORKS.public] = 'br-ex' if node.cluster.network_config.segmentation_type in \ (consts.NEUTRON_SEGMENT_TYPES.gre, consts.NEUTRON_SEGMENT_TYPES.tun): mapping[consts.NETWORKS.private] = 'br-mesh' mapping.update(cls.get_node_non_default_bridge_mapping(node)) return mapping
def generate_network_scheme(cls, node): attrs = super(NeutronNetworkDeploymentSerializer70, cls).generate_network_scheme(node) attrs['roles']['neutron/api'] = 'br-mgmt' attrs['roles']['neutron/mesh'] = 'br-mgmt' attrs['roles']['neutron/private'] = 'br-prv' attrs['roles']['mgmt/corosync'] = 'br-mgmt' attrs['roles']['mgmt/database'] = 'br-mgmt' attrs['roles']['mgmt/messaging'] = 'br-mgmt' attrs['roles']['mgmt/api'] = 'br-mgmt' attrs['roles']['mgmt/vip'] = 'br-mgmt' attrs['roles']['nova/api'] = 'br-mgmt' attrs['roles']['murano/api'] = 'br-mgmt' attrs['roles']['sahara/api'] = 'br-mgmt' attrs['roles']['ceilometer/api'] = 'br-mgmt' attrs['roles']['heat/api'] = 'br-mgmt' attrs['roles']['keystone/api'] = 'br-mgmt' attrs['roles']['horizon'] = 'br-mgmt' attrs['roles']['glance/api'] = 'br-mgmt' if Node.should_have_public(node): attrs['roles']['neutron/floating'] = 'br-floating' attrs['roles']['public/vip'] = 'br-ex' attrs['roles']['ceph/radosgw'] = 'br-ex' attrs['roles']['swift/public'] = 'br-ex' attrs['roles']['admin/pxe'] = 'br-fw-admin' attrs['roles']['ceph/replication'] = 'br-storage' attrs['roles']['ceph/public'] = 'br-mgmt' attrs['roles']['swift/replication'] = 'br-storage' attrs['roles']['swift/api'] = 'br-mgmt' attrs['roles']['cinder/iscsi'] = 'br-storage' attrs['roles']['cinder/api'] = 'br-mgmt' attrs['roles']['mongo/db'] = 'br-mgmt' return attrs
def _update_public_network(cls, cluster, public_map, roles_metadata): """Applies changes to node's public_network checked using public_map. :param instance: Cluster object :param public_map: dict of Node.id to should_have_public result. :param roles_metadata: dict from objects.Cluster.get_roles """ if cluster.network_config.configuration_template is not None: return from nailgun.objects import Node for node in cluster.nodes: should_have_public = Node.should_have_public(node, roles_metadata) if public_map.get(node.id) == should_have_public: continue if should_have_public: cls.assign_public_network(node) else: cls.unassign_public_network(node)
def _update_public_network(cls, cluster, public_map, roles_metadata): """Applies changes to node's public_network checked using public_map. :param instance: Cluster object :param public_map: dict of Node.id to should_have_public result. :param roles_metadata: dict from objects.Cluster.get_roles """ if cluster.network_config.configuration_template is not None: return from nailgun.objects import Node for node in cluster.nodes: should_have_public = Node.should_have_public( node, roles_metadata) if public_map.get(node.id) == should_have_public: continue if should_have_public: cls.assign_public_network(node) else: cls.unassign_public_network(node)
def update_nodes_net_info(cls, cluster, nodes): """Adds information about networks to each node. This info is deprecated in 7.0 and should be removed in later version. """ nm = Cluster.get_network_manager(cluster) for node in Cluster.get_nodes_not_for_deletion(cluster): netw_data = [] for name, data in six.iteritems(nm.get_node_ips(node)): data['name'] = name netw_data.append(data) addresses = {} for net in node.cluster.network_groups: if net.name == 'public' and \ not Node.should_have_public_with_ip(node): continue if net.meta.get('render_addr_mask'): addresses.update(cls.get_addr_mask( netw_data, net.name, net.meta.get('render_addr_mask'))) [n.update(addresses) for n in nodes if n['uid'] == str(node.uid)] return nodes
def create_node( self, api=False, exclude=None, expect_http=201, expect_message=None, **kwargs): #TODO(alekseyk) Simplify 'interfaces' and 'mac' manipulation logic metadata = kwargs.get('meta') default_metadata = self.default_metadata() if metadata: default_metadata.update(metadata) meta_ifaces = 'interfaces' in metadata mac = kwargs.get('mac', self.generate_random_mac()) if default_metadata['interfaces']: default_metadata['interfaces'][0]['mac'] = mac if not metadata or not meta_ifaces: for iface in default_metadata['interfaces'][1:]: if 'mac' in iface: iface['mac'] = self.generate_random_mac() node_data = { 'mac': mac, 'status': 'discover', 'meta': default_metadata } if kwargs: meta = kwargs.pop('meta', None) node_data.update(kwargs) if meta: kwargs['meta'] = meta if exclude and isinstance(exclude, list): for ex in exclude: try: del node_data[ex] except KeyError as err: logger.warning(err) if api: resp = self.app.post( reverse('NodeCollectionHandler'), jsonutils.dumps(node_data), headers=self.default_headers, expect_errors=True ) self.tester.assertEqual(resp.status_code, expect_http) if expect_message: self.tester.assertEqual(resp.body, expect_message) if str(expect_http)[0] != "2": return None self.tester.assertEqual(resp.status_code, expect_http) node = resp.json_body node_db = Node.get_by_uid(node['id']) if 'interfaces' not in node_data['meta'] \ or not node_data['meta']['interfaces']: self._set_interfaces_if_not_set_in_meta( node_db.id, kwargs.get('meta', None)) self.nodes.append(node_db) else: node = Node.create(node_data) db().commit() self.nodes.append(node) return node
def create_node(self, api=False, exclude=None, expect_http=201, expect_message=None, **kwargs): #TODO(alekseyk) Simplify 'interfaces' and 'mac' manipulation logic metadata = kwargs.get('meta') default_metadata = self.default_metadata() if metadata: default_metadata.update(metadata) meta_ifaces = 'interfaces' in metadata mac = kwargs.get('mac', self.generate_random_mac()) if default_metadata['interfaces']: default_metadata['interfaces'][0]['mac'] = mac if not metadata or not meta_ifaces: for iface in default_metadata['interfaces'][1:]: if 'mac' in iface: iface['mac'] = self.generate_random_mac() node_data = { 'mac': mac, 'status': 'discover', 'meta': default_metadata } if kwargs: meta = kwargs.pop('meta', None) node_data.update(kwargs) if meta: kwargs['meta'] = meta if exclude and isinstance(exclude, list): for ex in exclude: try: del node_data[ex] except KeyError as err: logger.warning(err) if api: resp = self.app.post(reverse('NodeCollectionHandler'), json.dumps(node_data), headers=self.default_headers, expect_errors=True) self.tester.assertEquals(resp.status_code, expect_http) if expect_message: self.tester.assertEquals(resp.body, expect_message) if str(expect_http)[0] != "2": return None self.tester.assertEquals(resp.status_code, expect_http) node = json.loads(resp.body) node_db = Node.get_by_uid(node['id']) if 'interfaces' not in node_data['meta'] \ or not node_data['meta']['interfaces']: self._set_interfaces_if_not_set_in_meta( node_db.id, kwargs.get('meta', None)) self.nodes.append(node_db) else: node = Node.create(node_data) db().commit() self.nodes.append(node) return node
def generate_network_metadata(cls, cluster): nodes = dict() nm = Cluster.get_network_manager(cluster) for n in Cluster.get_nodes_not_for_deletion(cluster): name = Node.get_slave_name(n) node_roles = Node.all_roles(n) # Use permanent identifier as a node key key = Node.permanent_id(n) ip_by_net = { 'fuelweb_admin': None, 'storage': None, 'management': None, 'public': None } networks = nm.get_node_networks(n) for net in ip_by_net: netgroup = nm.get_network_by_netname(net, networks) if netgroup.get('ip'): ip_by_net[net] = netgroup['ip'].split('/')[0] netw_roles = { 'admin/pxe': ip_by_net['fuelweb_admin'], 'fw-admin': ip_by_net['fuelweb_admin'], 'keystone/api': ip_by_net['management'], 'swift/api': ip_by_net['management'], 'sahara/api': ip_by_net['management'], 'ceilometer/api': ip_by_net['management'], 'cinder/api': ip_by_net['management'], 'glance/api': ip_by_net['management'], 'heat/api': ip_by_net['management'], 'nova/api': ip_by_net['management'], 'murano/api': ip_by_net['management'], 'horizon': ip_by_net['management'], 'management': ip_by_net['management'], 'mgmt/database': ip_by_net['management'], 'mgmt/messaging': ip_by_net['management'], 'mgmt/corosync': ip_by_net['management'], 'mgmt/memcache': ip_by_net['management'], 'mgmt/vip': ip_by_net['management'], 'mongo/db': ip_by_net['management'], 'ceph/public': ip_by_net['management'], 'storage': ip_by_net['storage'], 'ceph/replication': ip_by_net['storage'], 'swift/replication': ip_by_net['storage'], 'cinder/iscsi': ip_by_net['storage'], 'ex': ip_by_net['public'], 'public/vip': ip_by_net['public'], 'ceph/radosgw': ip_by_net['public'], } nodes[key] = { "uid": n.uid, "fqdn": Node.get_node_fqdn(n), "name": name, "user_node_name": n.name, "swift_zone": n.uid, "node_roles": node_roles, "network_roles": netw_roles } return dict( nodes=nodes, vips=nm.assign_vips_for_net_groups(cluster) )
def generate_vmware_data(self, node): """Extend serialize data with vmware attributes """ vmware_data = {} allowed_roles = [ 'controller', 'primary-controller', 'compute-vmware', 'cinder-vmware' ] all_roles = Node.all_roles(node) use_vcenter = node.cluster.attributes.editable.get('common', {}) \ .get('use_vcenter', {}).get('value') if (use_vcenter and any(role in allowed_roles for role in all_roles)): compute_instances = [] cinder_instances = [] vmware_attributes = node.cluster.vmware_attributes.editable \ .get('value', {}) availability_zones = vmware_attributes \ .get('availability_zones', {}) glance_instance = vmware_attributes.get('glance', {}) network = vmware_attributes.get('network', {}) for zone in availability_zones: vc_user = self.escape_dollar(zone.get('vcenter_username', '')) vc_password = self.escape_dollar( zone.get('vcenter_password', '')) for compute in zone.get('nova_computes', {}): datastore_regex = \ self.escape_dollar(compute.get('datastore_regex', '')) compute_item = { 'availability_zone_name': zone.get('az_name', ''), 'vc_host': zone.get('vcenter_host', ''), 'vc_user': vc_user, 'vc_password': vc_password, 'service_name': compute.get('service_name', ''), 'vc_cluster': compute.get('vsphere_cluster', ''), 'datastore_regex': datastore_regex, 'target_node': compute.get('target_node', {}).get('current', {}).get('id', 'controllers') } compute_instances.append(compute_item) cinder_item = { 'availability_zone_name': zone.get('az_name', ''), 'vc_host': zone.get('vcenter_host', ''), 'vc_user': vc_user, 'vc_password': vc_password } cinder_instances.append(cinder_item) vmware_data['use_vcenter'] = True if compute_instances: vmware_data['vcenter'] = { 'esxi_vlan_interface': network.get('esxi_vlan_interface', ''), 'computes': compute_instances } if cinder_instances: vmware_data['cinder'] = {'instances': cinder_instances} if glance_instance: glance_username = \ self.escape_dollar(glance_instance .get('vcenter_username', '')) glance_password = \ self.escape_dollar(glance_instance .get('vcenter_password', '')) vmware_data['glance'] = { 'vc_host': glance_instance.get('vcenter_host', ''), 'vc_user': glance_username, 'vc_password': glance_password, 'vc_datacenter': glance_instance.get('datacenter', ''), 'vc_datastore': glance_instance.get('datastore', '') } return vmware_data
def update_nodes_network_template(cls, instance, nodes): from nailgun.objects import Node template = instance.network_config.configuration_template for node in nodes: Node.apply_network_template(node, template)
def generate_network_scheme(cls, node): # Create a data structure and fill it with static values. attrs = { 'version': '1.1', 'provider': 'lnx', 'interfaces': {}, # It's a list of physical interfaces. 'endpoints': {}, 'roles': { 'management': 'br-mgmt', 'storage': 'br-storage', 'fw-admin': 'br-fw-admin', }, } is_public = Node.should_have_public(node) if is_public: attrs['endpoints']['br-ex'] = {'IP': 'none'} attrs['endpoints']['br-floating'] = {'IP': 'none'} attrs['roles']['ex'] = 'br-ex' attrs['roles']['neutron/floating'] = 'br-floating' nm = Cluster.get_network_manager(node.cluster) # Populate IP and GW information to endpoints. netgroup_mapping = [ ('storage', 'br-storage'), ('management', 'br-mgmt'), ('fuelweb_admin', 'br-fw-admin'), ] if is_public: netgroup_mapping.append(('public', 'br-ex')) if node.cluster.network_config.segmentation_type in \ (consts.NEUTRON_SEGMENT_TYPES.gre, consts.NEUTRON_SEGMENT_TYPES.tun): netgroup_mapping.append(('private', 'br-mesh')) attrs['endpoints']['br-mesh'] = {} attrs['roles']['neutron/mesh'] = 'br-mesh' netgroups = {} nets_by_ifaces = defaultdict(list) for ngname, brname in netgroup_mapping: # Here we get a dict with network description for this particular # node with its assigned IPs and device names for each network. netgroup = nm.get_node_network_by_netname(node, ngname) if netgroup.get('ip'): attrs['endpoints'][brname] = {'IP': [netgroup['ip']]} netgroups[ngname] = netgroup nets_by_ifaces[netgroup['dev']].append({ 'br_name': brname, 'vlan_id': netgroup['vlan'] }) # Add gateway. if is_public and netgroups['public'].get('gateway'): attrs['endpoints']['br-ex']['gateway'] = \ netgroups['public']['gateway'] else: gw = nm.get_default_gateway(node.id) attrs['endpoints']['br-fw-admin']['gateway'] = gw # Fill up interfaces. for iface in node.nic_interfaces: if iface.bond: attrs['interfaces'][iface.name] = {} else: attrs['interfaces'][iface.name] = \ nm.get_iface_properties(iface) # Dance around Neutron segmentation type. prv_base_ep = None if node.cluster.network_config.segmentation_type == \ consts.NEUTRON_SEGMENT_TYPES.vlan: attrs['endpoints']['br-prv'] = {'IP': 'none'} attrs['roles']['neutron/private'] = 'br-prv' netgroup = nm.get_node_network_by_netname(node, 'private') # create br-aux if there is no untagged network (endpoint) on the # same interface. if netgroup['dev'] in nets_by_ifaces: for ep in nets_by_ifaces[netgroup['dev']]: if not ep['vlan_id']: prv_base_ep = ep['br_name'] if not prv_base_ep: nets_by_ifaces[netgroup['dev']].append({ 'br_name': 'br-aux', 'vlan_id': None }) attrs['transformations'] = cls.generate_transformations( node, nm, nets_by_ifaces, is_public, prv_base_ep) if NodeGroupCollection.get_by_cluster_id( node.cluster.id).count() > 1: cls.generate_routes(node, attrs, nm, netgroup_mapping, netgroups) attrs = cls.generate_driver_information(node, attrs, nm) return attrs
def generate_network_scheme(cls, node): # Create a data structure and fill it with static values. attrs = { 'version': '1.0', 'provider': 'ovs', 'interfaces': {}, # It's a list of physical interfaces. 'endpoints': { 'br-storage': {}, 'br-mgmt': {}, 'br-fw-admin': {}, }, 'roles': { 'management': 'br-mgmt', 'storage': 'br-storage', 'fw-admin': 'br-fw-admin', }, 'transformations': [] } if Node.should_have_public(node): attrs['endpoints']['br-ex'] = {} attrs['roles']['ex'] = 'br-ex' nm = Cluster.get_network_manager(node.cluster) iface_types = consts.NETWORK_INTERFACE_TYPES # Add a dynamic data to a structure. vlan_splinters_data = \ node.cluster.attributes.editable\ .get('vlan_splinters', {})\ # if vlan_splinters is enabled - use its value use_vlan_splinters = 'disabled' if vlan_splinters_data\ .get('metadata', {})\ .get('enabled'): use_vlan_splinters = \ vlan_splinters_data\ .get('vswitch', {})\ .get('value', 'disabled') # Fill up interfaces and add bridges for them. bonded_ifaces = [x for x in node.nic_interfaces if x.bond] for iface in node.interfaces: # Handle vlan splinters. if iface.type == iface_types.ether: attrs['interfaces'][iface.name] = { 'L2': cls._get_vlan_splinters_desc( use_vlan_splinters, iface, node.cluster ) } if iface in bonded_ifaces: continue attrs['transformations'].append({ 'action': 'add-br', 'name': 'br-%s' % iface.name }) if iface.type == iface_types.ether: attrs['transformations'].append({ 'action': 'add-port', 'bridge': 'br-%s' % iface.name, 'name': iface.name }) elif iface.type == iface_types.bond: attrs['transformations'].append({ 'action': 'add-bond', 'bridge': 'br-%s' % iface.name, 'name': iface.name, 'interfaces': [x['name'] for x in iface.slaves], 'properties': nm.get_ovs_bond_properties(iface) }) # Add bridges for networks. # We have to add them after br-ethXX bridges because it is the way # to provide a right ordering of ifdown/ifup operations with # IP interfaces. brnames = ['br-ex', 'br-mgmt', 'br-storage', 'br-fw-admin'] if not Node.should_have_public(node): brnames.pop(0) for brname in brnames: attrs['transformations'].append({ 'action': 'add-br', 'name': brname }) # Populate IP address information to endpoints. netgroup_mapping = [ ('storage', 'br-storage'), ('management', 'br-mgmt'), ('fuelweb_admin', 'br-fw-admin'), ] if Node.should_have_public(node): netgroup_mapping.append(('public', 'br-ex')) netgroups = {} for ngname, brname in netgroup_mapping: # Here we get a dict with network description for this particular # node with its assigned IPs and device names for each network. netgroup = nm.get_node_network_by_netname(node, ngname) if netgroup.get('ip'): attrs['endpoints'][brname]['IP'] = [netgroup['ip']] netgroups[ngname] = netgroup if Node.should_have_public(node): attrs['endpoints']['br-ex']['gateway'] = \ netgroups['public']['gateway'] else: attrs['endpoints']['br-fw-admin']['gateway'] = settings.MASTER_IP # Connect interface bridges to network bridges. for ngname, brname in netgroup_mapping: netgroup = nm.get_node_network_by_netname(node, ngname) if not netgroup['vlan']: # Untagged network. attrs['transformations'].append({ 'action': 'add-patch', 'bridges': ['br-%s' % netgroup['dev'], brname], 'trunks': [0] }) elif netgroup['vlan'] > 1: # Tagged network. attrs['transformations'].append({ 'action': 'add-patch', 'bridges': ['br-%s' % netgroup['dev'], brname], 'tags': [netgroup['vlan'], 0] }) else: # FIXME! Should raise some exception I think. logger.error('Invalid vlan for network: %s' % str(netgroup)) # Dance around Neutron segmentation type. if node.cluster.network_config.segmentation_type == \ consts.NEUTRON_SEGMENT_TYPES.vlan: attrs['endpoints']['br-prv'] = {'IP': 'none'} attrs['roles']['private'] = 'br-prv' attrs['transformations'].append({ 'action': 'add-br', 'name': 'br-prv', }) attrs['transformations'].append({ 'action': 'add-patch', 'bridges': [ 'br-%s' % nm.get_node_interface_by_netname( node.id, 'private' ).name, 'br-prv' ] }) elif node.cluster.network_config.segmentation_type in \ (consts.NEUTRON_SEGMENT_TYPES.gre, consts.NEUTRON_SEGMENT_TYPES.tun): attrs['roles']['mesh'] = 'br-mgmt' return attrs
def generate_network_scheme(cls, node): # create network scheme structure and fill it with static values attrs = { 'version': '1.1', 'provider': 'lnx', 'interfaces': {}, 'endpoints': {}, 'roles': { 'fw-admin': 'br-fw-admin', 'storage': 'br-storage', 'management': 'br-mgmt', 'ex': 'br-ex', }, } netgroup_mapping = [ ('fuelweb_admin', 'br-fw-admin'), ('storage', 'br-storage'), ('management', 'br-mgmt'), ('public', 'br-ex'), ('fixed', '') # will be determined in code below ] nm = Node.get_network_manager(node) # populate IP address information to endpoints netgroups = {} nets_by_ifaces = defaultdict(list) fixed_sub_iface = None for ngname, brname in netgroup_mapping: # Here we get a dict with network description for this particular # node with its assigned IPs and device names for each network. netgroup = nm.get_node_network_by_netname(node, ngname) if ngname == 'fixed': vlan_id = None if node.cluster.network_config.net_manager == \ consts.NOVA_NET_MANAGERS.FlatDHCPManager: vlan_id = \ node.cluster.network_config.fixed_networks_vlan_start net = {'vlan_id': vlan_id} fixed_sub_iface = cls.subiface_name(netgroup['dev'], net) attrs['endpoints'][fixed_sub_iface] = {'IP': 'none'} else: nets_by_ifaces[netgroup['dev']].append({ 'br_name': brname, 'vlan_id': netgroup['vlan'] }) if netgroup.get('ip'): attrs['endpoints'][brname] = {'IP': [netgroup['ip']]} netgroups[ngname] = netgroup attrs['endpoints']['br-ex']['gateway'] = \ netgroups['public']['gateway'] # add manager-related roles if node.cluster.network_config.net_manager == \ consts.NOVA_NET_MANAGERS.VlanManager: attrs['roles']['novanetwork/vlan'] = fixed_sub_iface else: attrs['roles']['novanetwork/fixed'] = fixed_sub_iface for iface in node.nic_interfaces: if iface.bond: attrs['interfaces'][iface.name] = {} else: attrs['interfaces'][iface.name] = \ nm.get_iface_properties(iface) attrs['transformations'] = \ cls.generate_transformations(node, nm, nets_by_ifaces, fixed_sub_iface) return attrs
def generate_vmware_data(self, node): """Extend serialize data with vmware attributes """ vmware_data = {} allowed_roles = ["controller", "primary-controller", "cinder-vmware"] all_roles = Node.all_roles(node) use_vcenter = node.cluster.attributes.editable.get("common", {}).get("use_vcenter", {}).get("value") if use_vcenter and any(role in allowed_roles for role in all_roles): compute_instances = [] cinder_instances = [] vmware_attributes = node.cluster.vmware_attributes.editable.get("value", {}) availability_zones = vmware_attributes.get("availability_zones", {}) glance_instance = vmware_attributes.get("glance", {}) network = vmware_attributes.get("network", {}) for zone in availability_zones: vc_user = self.escape_dollar(zone.get("vcenter_username", "")) vc_password = self.escape_dollar(zone.get("vcenter_password", "")) for compute in zone.get("nova_computes", {}): datastore_regex = self.escape_dollar(compute.get("datastore_regex", "")) compute_item = { "availability_zone_name": zone.get("az_name", ""), "vc_host": zone.get("vcenter_host", ""), "vc_user": vc_user, "vc_password": vc_password, "service_name": compute.get("service_name", ""), "vc_cluster": compute.get("vsphere_cluster", ""), "datastore_regex": datastore_regex, } compute_instances.append(compute_item) cinder_item = { "availability_zone_name": zone.get("az_name", ""), "vc_host": zone.get("vcenter_host", ""), "vc_user": vc_user, "vc_password": vc_password, } cinder_instances.append(cinder_item) vmware_data["use_vcenter"] = True if compute_instances: vmware_data["vcenter"] = { "esxi_vlan_interface": network.get("esxi_vlan_interface", ""), "computes": compute_instances, } if cinder_instances: vmware_data["cinder"] = {"instances": cinder_instances} if glance_instance: glance_username = self.escape_dollar(glance_instance.get("vcenter_username", "")) glance_password = self.escape_dollar(glance_instance.get("vcenter_password", "")) vmware_data["glance"] = { "vc_host": glance_instance.get("vcenter_host", ""), "vc_user": glance_username, "vc_password": glance_password, "vc_datacenter": glance_instance.get("datacenter", ""), "vc_datastore": glance_instance.get("datastore", ""), } return vmware_data
def generate_network_scheme(cls, node, networks): # Create a data structure and fill it with static values. attrs = { 'version': '1.0', 'provider': 'ovs', 'interfaces': {}, # It's a list of physical interfaces. 'endpoints': { 'br-storage': {}, 'br-mgmt': {}, 'br-fw-admin': {}, }, 'roles': { 'management': 'br-mgmt', 'storage': 'br-storage', 'fw-admin': 'br-fw-admin', }, 'transformations': [] } if Node.should_have_public(node): attrs['endpoints']['br-ex'] = {} attrs['roles']['ex'] = 'br-ex' nm = Cluster.get_network_manager(node.cluster) iface_types = consts.NETWORK_INTERFACE_TYPES # Add a dynamic data to a structure. vlan_splinters_data = \ node.cluster.attributes.editable\ .get('vlan_splinters', {})\ # if vlan_splinters is enabled - use its value use_vlan_splinters = 'disabled' if vlan_splinters_data\ .get('metadata', {})\ .get('enabled'): use_vlan_splinters = \ vlan_splinters_data\ .get('vswitch', {})\ .get('value', 'disabled') # Fill up interfaces and add bridges for them. bonded_ifaces = [x for x in node.nic_interfaces if x.bond] for iface in node.interfaces: # Handle vlan splinters. if iface.type == iface_types.ether: attrs['interfaces'][iface.name] = { 'L2': cls._get_vlan_splinters_desc(use_vlan_splinters, iface, node.cluster) } if iface in bonded_ifaces: continue attrs['transformations'].append({ 'action': 'add-br', 'name': 'br-%s' % iface.name }) if iface.type == iface_types.ether: attrs['transformations'].append({ 'action': 'add-port', 'bridge': 'br-%s' % iface.name, 'name': iface.name }) elif iface.type == iface_types.bond: attrs['transformations'].append({ 'action': 'add-bond', 'bridge': 'br-%s' % iface.name, 'name': iface.name, 'interfaces': [x['name'] for x in iface.slaves], 'properties': nm.get_ovs_bond_properties(iface) }) # Add bridges for networks. # We have to add them after br-ethXX bridges because it is the way # to provide a right ordering of ifdown/ifup operations with # IP interfaces. brnames = ['br-ex', 'br-mgmt', 'br-storage', 'br-fw-admin'] if not Node.should_have_public(node): brnames.pop(0) for brname in brnames: attrs['transformations'].append({ 'action': 'add-br', 'name': brname }) # Populate IP address information to endpoints. netgroup_mapping = [ ('storage', 'br-storage'), ('management', 'br-mgmt'), ('fuelweb_admin', 'br-fw-admin'), ] if Node.should_have_public(node): netgroup_mapping.append(('public', 'br-ex')) netgroups = {} for ngname, brname in netgroup_mapping: # Here we get a dict with network description for this particular # node with its assigned IPs and device names for each network. netgroup = nm.get_network_by_netname(ngname, networks) if netgroup.get('ip'): attrs['endpoints'][brname]['IP'] = [netgroup['ip']] netgroups[ngname] = netgroup if Node.should_have_public(node): attrs['endpoints']['br-ex']['gateway'] = \ netgroups['public']['gateway'] else: attrs['endpoints']['br-fw-admin']['gateway'] = settings.MASTER_IP # Connect interface bridges to network bridges. for ngname, brname in netgroup_mapping: netgroup = nm.get_network_by_netname(ngname, networks) if not netgroup['vlan']: # Untagged network. attrs['transformations'].append({ 'action': 'add-patch', 'bridges': ['br-%s' % netgroup['dev'], brname], 'trunks': [0] }) elif netgroup['vlan'] > 1: # Tagged network. attrs['transformations'].append({ 'action': 'add-patch', 'bridges': ['br-%s' % netgroup['dev'], brname], 'tags': [netgroup['vlan'], 0] }) else: # FIXME! Should raise some exception I think. logger.error('Invalid vlan for network: %s' % str(netgroup)) # Dance around Neutron segmentation type. if node.cluster.network_config.segmentation_type == \ consts.NEUTRON_SEGMENT_TYPES.vlan: attrs['endpoints']['br-prv'] = {'IP': 'none'} attrs['roles']['private'] = 'br-prv' attrs['transformations'].append({ 'action': 'add-br', 'name': 'br-prv', }) attrs['transformations'].append({ 'action': 'add-patch', 'bridges': [ 'br-%s' % nm.get_node_interface_by_netname(node.id, 'private').name, 'br-prv' ] }) elif node.cluster.network_config.segmentation_type in \ (consts.NEUTRON_SEGMENT_TYPES.gre, consts.NEUTRON_SEGMENT_TYPES.tun): attrs['roles']['mesh'] = 'br-mgmt' return attrs
def generate_vmware_data(self, node): """Extend serialize data with vmware attributes """ vmware_data = {} allowed_roles = [ 'controller', 'primary-controller', 'compute-vmware', 'cinder-vmware' ] all_roles = Node.all_roles(node) use_vcenter = node.cluster.attributes.editable.get('common', {}) \ .get('use_vcenter', {}).get('value') if (use_vcenter and any(role in allowed_roles for role in all_roles)): compute_instances = [] cinder_instances = [] vmware_attributes = node.cluster.vmware_attributes.editable \ .get('value', {}) availability_zones = vmware_attributes \ .get('availability_zones', {}) glance_instance = vmware_attributes.get('glance', {}) network = vmware_attributes.get('network', {}) for zone in availability_zones: vc_user = self.escape_dollar(zone.get('vcenter_username', '')) vc_password = self.escape_dollar(zone.get('vcenter_password', '')) for compute in zone.get('nova_computes', {}): datastore_regex = \ self.escape_dollar(compute.get('datastore_regex', '')) compute_item = { 'availability_zone_name': zone.get('az_name', ''), 'vc_host': zone.get('vcenter_host', ''), 'vc_user': vc_user, 'vc_password': vc_password, 'service_name': compute.get('service_name', ''), 'vc_cluster': compute.get('vsphere_cluster', ''), 'datastore_regex': datastore_regex, 'target_node': compute.get('target_node', {}).get( 'current', {}).get('id', 'controllers') } compute_instances.append(compute_item) cinder_item = { 'availability_zone_name': zone.get('az_name', ''), 'vc_host': zone.get('vcenter_host', ''), 'vc_user': vc_user, 'vc_password': vc_password } cinder_instances.append(cinder_item) vmware_data['use_vcenter'] = True if compute_instances: vmware_data['vcenter'] = { 'esxi_vlan_interface': network.get('esxi_vlan_interface', ''), 'computes': compute_instances } if cinder_instances: vmware_data['cinder'] = { 'instances': cinder_instances } if glance_instance: glance_username = \ self.escape_dollar(glance_instance .get('vcenter_username', '')) glance_password = \ self.escape_dollar(glance_instance .get('vcenter_password', '')) vmware_data['glance'] = { 'vc_host': glance_instance.get('vcenter_host', ''), 'vc_user': glance_username, 'vc_password': glance_password, 'vc_datacenter': glance_instance.get('datacenter', ''), 'vc_datastore': glance_instance.get('datastore', '') } return vmware_data
def generate_network_scheme(cls, node, networks): """Create a data structure and fill it with static values. :param node: instance of db.sqlalchemy.models.node.Node :param networks: list of networks data dicts :return: dict of network scheme attributes """ attrs = { 'version': '1.1', 'provider': 'lnx', 'interfaces': {}, 'endpoints': {}, 'roles': cls.get_network_role_mapping_to_interfaces(node), } is_public = Node.should_have_public(node) if is_public: attrs['endpoints']['br-ex'] = {'IP': 'none'} attrs['endpoints']['br-floating'] = {'IP': 'none'} attrs['roles']['ex'] = 'br-ex' attrs['roles']['neutron/floating'] = 'br-floating' nm = Cluster.get_network_manager(node.cluster) # Populate IP and GW information to endpoints. netgroup_mapping = (cls.get_network_to_endpoint_mapping(node) .items()) # get_network_to_endpoint_mapping() adds mapping for 'public' only in # case the node 'should_have_public_with_ip'. Here we need to add it # because proper transformations should be formed no matter if br-ex # has IP or not. public_mapping = (consts.NETWORKS.public, 'br-ex') if is_public and public_mapping not in netgroup_mapping: netgroup_mapping.append(public_mapping) if node.cluster.network_config.segmentation_type in \ (consts.NEUTRON_SEGMENT_TYPES.gre, consts.NEUTRON_SEGMENT_TYPES.tun): attrs['endpoints']['br-mesh'] = {} attrs['roles']['neutron/mesh'] = 'br-mesh' netgroups = {} nets_by_ifaces = defaultdict(list) for ngname, brname in netgroup_mapping: # Here we get a dict with network description for this particular # node with its assigned IPs and device names for each network. netgroup = nm.get_network_by_netname(ngname, networks) if netgroup.get('ip'): attrs['endpoints'][brname] = {'IP': [netgroup['ip']]} netgroups[ngname] = netgroup nets_by_ifaces[netgroup['dev']].append({ 'br_name': brname, 'vlan_id': netgroup['vlan'] }) # Add gateway. if Node.should_have_public_with_ip(node): attrs['endpoints']['br-ex']['gateway'] = \ netgroups['public']['gateway'] else: gw = nm.get_default_gateway(node.id) attrs['endpoints']['br-fw-admin']['gateway'] = gw # Fill up interfaces. for iface in node.nic_interfaces: if iface.bond: attrs['interfaces'][iface.name] = {} else: attrs['interfaces'][iface.name] = \ nm.get_iface_properties(iface) # Dance around Neutron segmentation type. prv_base_ep = None if node.cluster.network_config.segmentation_type == \ consts.NEUTRON_SEGMENT_TYPES.vlan: attrs['endpoints']['br-prv'] = {'IP': 'none'} attrs['roles']['neutron/private'] = 'br-prv' netgroup = nm.get_network_by_netname('private', networks) # create br-aux if there is no untagged network (endpoint) on the # same interface. if netgroup['dev'] in nets_by_ifaces: for ep in nets_by_ifaces[netgroup['dev']]: if not ep['vlan_id']: prv_base_ep = ep['br_name'] if not prv_base_ep: nets_by_ifaces[netgroup['dev']].append({ 'br_name': 'br-aux', 'vlan_id': None }) attrs['transformations'] = cls.generate_transformations( node, nm, nets_by_ifaces, is_public, prv_base_ep) if NodeGroupCollection.get_by_cluster_id( node.cluster.id).count() > 1: cls.generate_routes(node, attrs, nm, netgroup_mapping, netgroups, networks) attrs = cls.generate_driver_information(node, attrs, nm, networks) if node.cluster.network_config.segmentation_type in \ (consts.NEUTRON_SEGMENT_TYPES.gre, consts.NEUTRON_SEGMENT_TYPES.tun): attrs['roles'].pop('neutron/private', None) if node.cluster.network_config.segmentation_type == \ consts.NEUTRON_SEGMENT_TYPES.vlan: attrs['roles'].pop('neutron/mesh', None) return attrs
def generate_network_metadata(cls, cluster): nodes = dict() nm = Cluster.get_network_manager(cluster) for n in Cluster.get_nodes_not_for_deletion(cluster): name = Node.get_slave_name(n) node_roles = Node.all_roles(n) # Use permanent identifier as a node key key = Node.permanent_id(n) ip_by_net = { 'fuelweb_admin': None, 'storage': None, 'management': None, 'public': None } networks = nm.get_node_networks(n) for net in ip_by_net: netgroup = nm.get_network_by_netname(net, networks) if netgroup.get('ip'): ip_by_net[net] = netgroup['ip'].split('/')[0] netw_roles = { 'admin/pxe': ip_by_net['fuelweb_admin'], 'fw-admin': ip_by_net['fuelweb_admin'], 'keystone/api': ip_by_net['management'], 'swift/api': ip_by_net['management'], 'sahara/api': ip_by_net['management'], 'ceilometer/api': ip_by_net['management'], 'cinder/api': ip_by_net['management'], 'glance/api': ip_by_net['management'], 'heat/api': ip_by_net['management'], 'nova/api': ip_by_net['management'], 'murano/api': ip_by_net['management'], 'horizon': ip_by_net['management'], 'management': ip_by_net['management'], 'mgmt/database': ip_by_net['management'], 'mgmt/messaging': ip_by_net['management'], 'mgmt/corosync': ip_by_net['management'], 'mgmt/memcache': ip_by_net['management'], 'mgmt/vip': ip_by_net['management'], 'mongo/db': ip_by_net['management'], 'ceph/public': ip_by_net['management'], 'storage': ip_by_net['storage'], 'ceph/replication': ip_by_net['storage'], 'swift/replication': ip_by_net['storage'], 'cinder/iscsi': ip_by_net['storage'], 'ex': ip_by_net['public'], 'public/vip': ip_by_net['public'], 'ceph/radosgw': ip_by_net['public'], } nodes[key] = { "uid": n.uid, "fqdn": Node.get_node_fqdn(n), "name": name, "user_node_name": n.name, "swift_zone": n.uid, "node_roles": node_roles, "network_roles": netw_roles } return dict(nodes=nodes, vips=nm.assign_vips_for_net_groups(cluster))
def generate_network_scheme(cls, node, networks): # Create a data structure and fill it with static values. attrs = { 'version': '1.1', 'provider': 'lnx', 'interfaces': {}, # It's a list of physical interfaces. 'endpoints': {}, 'roles': { 'management': 'br-mgmt', 'storage': 'br-storage', 'fw-admin': 'br-fw-admin', }, } is_public = Node.should_have_public(node) if is_public: attrs['endpoints']['br-ex'] = {'IP': 'none'} attrs['endpoints']['br-floating'] = {'IP': 'none'} attrs['roles']['ex'] = 'br-ex' attrs['roles']['neutron/floating'] = 'br-floating' nm = Cluster.get_network_manager(node.cluster) # Populate IP and GW information to endpoints. netgroup_mapping = [ ('storage', 'br-storage'), ('management', 'br-mgmt'), ('fuelweb_admin', 'br-fw-admin'), ] if is_public: netgroup_mapping.append(('public', 'br-ex')) if node.cluster.network_config.segmentation_type in \ (consts.NEUTRON_SEGMENT_TYPES.gre, consts.NEUTRON_SEGMENT_TYPES.tun): netgroup_mapping.append(('private', 'br-mesh')) attrs['endpoints']['br-mesh'] = {} attrs['roles']['neutron/mesh'] = 'br-mesh' netgroups = {} nets_by_ifaces = defaultdict(list) for ngname, brname in netgroup_mapping: # Here we get a dict with network description for this particular # node with its assigned IPs and device names for each network. netgroup = nm.get_network_by_netname(ngname, networks) if netgroup.get('ip'): attrs['endpoints'][brname] = {'IP': [netgroup['ip']]} netgroups[ngname] = netgroup nets_by_ifaces[netgroup['dev']].append({ 'br_name': brname, 'vlan_id': netgroup['vlan'] }) # Add gateway. if is_public and netgroups['public'].get('gateway'): attrs['endpoints']['br-ex']['gateway'] = \ netgroups['public']['gateway'] else: gw = nm.get_default_gateway(node.id) attrs['endpoints']['br-fw-admin']['gateway'] = gw # Fill up interfaces. for iface in node.nic_interfaces: if iface.bond: attrs['interfaces'][iface.name] = {} else: attrs['interfaces'][iface.name] = \ nm.get_iface_properties(iface) # Dance around Neutron segmentation type. prv_base_ep = None if node.cluster.network_config.segmentation_type == \ consts.NEUTRON_SEGMENT_TYPES.vlan: attrs['endpoints']['br-prv'] = {'IP': 'none'} attrs['roles']['neutron/private'] = 'br-prv' netgroup = nm.get_network_by_netname('private', networks) # create br-aux if there is no untagged network (endpoint) on the # same interface. if netgroup['dev'] in nets_by_ifaces: for ep in nets_by_ifaces[netgroup['dev']]: if not ep['vlan_id']: prv_base_ep = ep['br_name'] if not prv_base_ep: nets_by_ifaces[netgroup['dev']].append({ 'br_name': 'br-aux', 'vlan_id': None }) attrs['transformations'] = cls.generate_transformations( node, nm, nets_by_ifaces, is_public, prv_base_ep) if NodeGroupCollection.get_by_cluster_id(node.cluster.id).count() > 1: cls.generate_routes(node, attrs, nm, netgroup_mapping, netgroups, networks) attrs = cls.generate_driver_information(node, attrs, nm, networks) return attrs