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)
