def _update_host_oam_address(host, interface): if utils.get_system_mode() == constants.SYSTEM_MODE_SIMPLEX: address_name = cutils.format_address_name( constants.CONTROLLER_HOSTNAME, constants.NETWORK_TYPE_OAM) else: address_name = cutils.format_address_name(host.hostname, constants.NETWORK_TYPE_OAM) address = pecan.request.dbapi.address_get_by_name(address_name) updates = {'interface_id': interface['id']} pecan.request.dbapi.address_update(address.uuid, updates)
def _update_addresses(addresses_table, interface_table, host_table): interfaces = list(interface_table.select().where( (interface_table.c.networktype == constants.NETWORK_TYPE_OAM) | (interface_table.c.networktype == constants.NETWORK_TYPE_PXEBOOT)). execute()) simplex = (system_mode == constants.SYSTEM_MODE_SIMPLEX) for interface in interfaces: host = list(host_table.select().where( host_table.c.id == interface.forihostid).execute()) if not simplex: hostname = host[0].hostname else: hostname = constants.CONTROLLER address_name = cutils.format_address_name(hostname, interface.networktype) address = list(addresses_table.select().where( addresses_table.c.name == address_name).execute()) if len(address) > 0: addresses_table.update().where( addresses_table.c.id == address[0].id).values({ 'interface_id': interface.id }).execute()
def _populate_address_fields(address_pool_table, addresses_table, networks_table): prefix_to_field_name = { constants.CONTROLLER_HOSTNAME: address_pool.ADDRPOOL_FLOATING_ADDRESS_ID, constants.CONTROLLER_0_HOSTNAME: address_pool.ADDRPOOL_CONTROLLER0_ADDRESS_ID, constants.CONTROLLER_1_HOSTNAME: address_pool.ADDRPOOL_CONTROLLER1_ADDRESS_ID, constants.CONTROLLER_GATEWAY: address_pool.ADDRPOOL_GATEWAY_ADDRESS_ID, } networks = list(networks_table.select().execute()) if len(networks) > 0: for net in networks: fields = {} for prefix, field_name in prefix_to_field_name.items(): address_name = cutils.format_address_name(prefix, net.type) addr = list(addresses_table.select().where( addresses_table.c.name == address_name).execute()) if len(addr) > 0: fields.update({field_name: addr[0].id}) if fields: address_pool_table.update().where( address_pool_table.c.id == net.address_pool_id).values( fields).execute()
def _get_address_by_name(self, name, networktype): """ Retrieve an address entry by name and scoped by network type """ addresses = self.context.setdefault('_address_names', {}) address_name = utils.format_address_name(name, networktype) address = addresses.get(address_name) if address is None: address = self.dbapi.address_get_by_name(address_name) addresses[address_name] = address return address
def _create_test_host(self, personality, subfunction=None, numa_nodes=1, unit=0, **kw): subfunctions = [personality] if subfunction: subfunctions.append(subfunction) if personality == constants.CONTROLLER: hostname = '%s-%s' % (personality, unit) name = utils.format_address_name(hostname, constants.NETWORK_TYPE_MGMT) address = self.dbapi.address_get_by_name(name) mgmt_ipaddr = address.address host = dbutils.create_test_ihost( uuid=uuidutils.generate_uuid(), personality=personality, hostname='%s-%s' % (personality, unit), mgmt_mac='03:11:22:33:44:' + str(10 + len(self.hosts)), mgmt_ip=mgmt_ipaddr, forisystemid=self.system.id, subfunctions=",".join(subfunctions), **kw) else: host = dbutils.create_test_ihost( uuid=uuidutils.generate_uuid(), personality=personality, hostname='%s-%s' % (personality, unit), mgmt_mac='03:11:22:33:44:' + str(10 + len(self.hosts)), forisystemid=self.system.id, subfunctions=",".join(subfunctions), **kw) for numa_node in range(0, numa_nodes): node = self.dbapi.inode_create( host.id, dbutils.get_test_node(numa_node=numa_node, forhostid=host.id)) self.dbapi.imemory_create( host.id, dbutils.get_test_imemory(forinodeid=node.id)) disk = self.dbapi.idisk_create( host.id, dbutils.get_test_idisk(device_node=self.root_disk_device_node, device_type=self.root_disk_device_type)) self.disks[host.id] = disk self.hosts.append(host) return host
def _create_test_addresses(self, hostnames, subnet, network_type, start=1, stop=None): ips = itertools.islice(subnet, start, stop) addresses = [] for name in hostnames: address = dbutils.create_test_address( name=utils.format_address_name(name, network_type), family=subnet.version, prefix=subnet.prefixlen, address=str(next(ips))) addresses.append(address) return addresses
def _update_host_storage_address(host, interface): address_name = cutils.format_address_name(host.hostname, constants.NETWORK_TYPE_STORAGE) try: address = pecan.request.dbapi.address_get_by_name(address_name) updates = {'interface_id': interface['id']} pecan.request.dbapi.address_update(address.uuid, updates) except exception.AddressNotFoundByName: # For non-controller hosts, allocate address from pool if dynamic storage_network = pecan.request.dbapi.network_get_by_type( constants.NETWORK_TYPE_STORAGE) if storage_network.dynamic: _allocate_pool_address(interface['id'], storage_network.pool_uuid, address_name)
def test_addresses(self): overrides = self.operator.get_helm_chart_overrides( app_constants.HELM_CHART_OIDC_CLIENT, cnamespace=common.HELM_NS_KUBE_SYSTEM) oam_addr_name = utils.format_address_name( constants.CONTROLLER_HOSTNAME, constants.NETWORK_TYPE_OAM) address = self.dbapi.address_get_by_name(oam_addr_name) oam_url = utils.format_url_address(address.address) parameters = { 'config': { 'issuer': 'https://%s:30556/dex' % oam_url, 'redirect_uri': "https://%s:30555/callback" % oam_url, } } self.assertOverridesParameters(overrides, parameters)
def get_transport_url(): try: db_api = dbapi.get_instance() address = db_api.address_get_by_name( utils.format_address_name(constants.CONTROLLER_HOSTNAME, constants.NETWORK_TYPE_MGMT)) except Exception as e: LOG.error("Failed to get management IP address: %s" % str(e)) return None auth_password = keyring.get_password('amqp', 'rabbit') transport_url = "rabbit://*****:*****@%s:5672" % (auth_password, address.address) return transport_url
def _populate_network_addresses(self, pool, network, addresses): opt_fields = {} for name, address in addresses.items(): address_name = cutils.format_address_name(name, network['type']) if not address: address = address_pool.AddressPoolController.allocate_address( pool, order=address_pool.SEQUENTIAL_ALLOCATION) LOG.debug("address_name=%s address=%s" % (address_name, address)) values = { 'address_pool_id': pool.id, 'address': str(address), 'prefix': pool['prefix'], 'family': pool['family'], 'enable_dad': constants.IP_DAD_STATES[pool['family']], 'name': address_name, } # Check for address existent before creation try: address_obj = pecan.request.dbapi.address_get_by_address( str(address)) pecan.request.dbapi.address_update(address_obj.uuid, {'name': address_name}) except exception.AddressNotFoundByAddress: address_obj = pecan.request.dbapi.address_create(values) # Update address pool with associated address if name == constants.CONTROLLER_0_HOSTNAME: opt_fields.update({ address_pool.ADDRPOOL_CONTROLLER0_ADDRESS_ID: address_obj.id }) elif name == constants.CONTROLLER_1_HOSTNAME: opt_fields.update({ address_pool.ADDRPOOL_CONTROLLER1_ADDRESS_ID: address_obj.id }) elif name == constants.CONTROLLER_HOSTNAME: opt_fields.update({ address_pool.ADDRPOOL_FLOATING_ADDRESS_ID: address_obj.id }) elif name == constants.CONTROLLER_GATEWAY: opt_fields.update( {address_pool.ADDRPOOL_GATEWAY_ADDRESS_ID: address_obj.id}) if opt_fields: pecan.request.dbapi.address_pool_update(pool.uuid, opt_fields)
def test_issuer(self): overrides = self.operator.get_helm_chart_overrides( common.HELM_CHART_DEX, cnamespace=common.HELM_NS_KUBE_SYSTEM) oam_addr_name = utils.format_address_name( constants.CONTROLLER_HOSTNAME, constants.NETWORK_TYPE_OAM) oam_address = self.dbapi.address_get_by_name(oam_addr_name) config_issuer = "https://%s:30556/dex" % (utils.format_url_address( oam_address.address)) self.assertOverridesParameters( overrides, { # issuer is set properly 'config': { 'issuer': config_issuer } })
def _update_host_cluster_address(host, interface): """ Check if the host has a cluster-host IP address assigned and the address is populated against the interface. Otherwise, allocate an address from the pool. """ address_name = cutils.format_address_name( host.hostname, constants.NETWORK_TYPE_CLUSTER_HOST) try: address = pecan.request.dbapi.address_get_by_name(address_name) updates = {'interface_id': interface['id']} pecan.request.dbapi.address_update(address.uuid, updates) except exception.AddressNotFoundByName: cluster_host_network = pecan.request.dbapi.network_get_by_type( constants.NETWORK_TYPE_CLUSTER_HOST) if cluster_host_network.dynamic: _allocate_pool_address(interface['id'], cluster_host_network.pool_uuid, address_name)
def _update_host_mgmt_address(host, interface): """Check if the host has a static management IP address assigned and ensure the address is populated against the interface. Otherwise, if using dynamic address allocation, then allocate an address """ mgmt_ip = utils.lookup_static_ip_address(host.hostname, constants.NETWORK_TYPE_MGMT) if mgmt_ip: pecan.request.rpcapi.mgmt_ip_set_by_ihost(pecan.request.context, host.uuid, interface['id'], mgmt_ip) elif _dynamic_address_allocation(): mgmt_pool_uuid = pecan.request.dbapi.network_get_by_type( constants.NETWORK_TYPE_MGMT).pool_uuid address_name = cutils.format_address_name(host.hostname, constants.NETWORK_TYPE_MGMT) _allocate_pool_address(interface['id'], mgmt_pool_uuid, address_name)
def _get_oam_address(self): address_name = utils.format_address_name(constants.CONTROLLER_HOSTNAME, constants.NETWORK_TYPE_OAM) address = pecan.request.dbapi.address_get_by_name(address_name) return address.address
def _update_host_ironic_address(host, interface): address_name = cutils.format_address_name(host.hostname, constants.NETWORK_TYPE_IRONIC) address = pecan.request.dbapi.address_get_by_name(address_name) updates = {'interface_id': interface['id']} pecan.request.dbapi.address_update(address.uuid, updates)