def main():
args = parse_args(sys.argv[1:])
cli_utils.setup_logging(log_level=args.loglevel.upper())
#session = zaza_os.get_undercloud_keystone_session()
#neutron_client = zaza_os.get_neutron_session_client(session)
#nova_client = zaza_os.get_nova_session_client(session, version=2.56)
if args.vnic_binding_type == 'dummy':
logging.warn('Running in dummy mode')
binding_type = None
else:
binding_type = args.vnic_binding_type
if args.action == 'summary':
logging.info('Running Summary')
summary(
zaza_os.get_nova_session_client(
zaza_os.get_undercloud_keystone_session(),
version=2.56),
args.application_name)
elif args.action == 'balance':
logging.info('Running balance')
balance(
zaza_os.get_nova_session_client(
zaza_os.get_undercloud_keystone_session(),
version=2.56),
args.application_name)
elif args.action == 'advertise':
logging.info('Running advertise')
advertise(
args.application_name)
elif args.action == 'listen':
logging.info('Running listen')
listen(
args.application_name,
args.cidr,
int(args.listener_count))
def test_get_undercloud_keystone_session(self):
self.patch_object(openstack_utils, "get_keystone_session")
self.patch_object(openstack_utils, "get_undercloud_auth")
_auth = "FAKE_AUTH"
self.get_undercloud_auth.return_value = _auth
openstack_utils.get_undercloud_keystone_session()
self.get_keystone_session.assert_called_once_with(_auth, verify=None)
def setUpClass(cls):
"""Run class setup for running percona-cluster cold start tests."""
super(PerconaClusterColdStartTest, cls).setUpClass()
cls.overcloud_keystone_session = (
openstack_utils.get_undercloud_keystone_session())
cls.nova_client = openstack_utils.get_nova_session_client(
cls.overcloud_keystone_session)
def __init__(self, prov_net_id=None):
try:
cacert = os.path.join(os.environ.get('MOJO_LOCAL_DIR'),
'cacert.pem')
os.stat(cacert)
except FileNotFoundError:
cacert = None
keystone_session = openstack_utils.get_undercloud_keystone_session(
verify=cacert)
neutronc = openstack_utils.get_neutron_session_client(
keystone_session)
if prov_net_id:
net = neutronc.list_networks(id=prov_net_id)['networks'][0]
else:
net = openstack_utils.get_admin_net(neutronc)
subnet_id = net['subnets'][0]
subnet = neutronc.list_subnets(id=subnet_id)['subnets'][0]
allocation_pools = subnet['allocation_pools']
self.cidr = subnet['cidr']
self.highest_assigned = netaddr.IPAddress(allocation_pools[0]['end'])
# XXX look away now, nothing to see here, move along.
# If there is less than 30 free ips in the network after the top
# dhcp ip then eat into the top of the dhcp range
available_ips = []
for element in list(netaddr.IPNetwork(self.cidr)):
if element == netaddr.IPAddress(self.highest_assigned) or \
available_ips:
available_ips.append(element)
if len(available_ips) < 30:
self.highest_assigned = self.highest_assigned - 30
def basic_overcloud_network():
"""Run setup for neutron networking.
Configure the following:
The overcloud network using subnet pools
"""
cli_utils.setup_logging()
# Get network configuration settings
network_config = {}
# Declared overcloud settings
network_config.update(OVERCLOUD_NETWORK_CONFIG)
# Default undercloud settings
network_config.update(DEFAULT_UNDERCLOUD_NETWORK_CONFIG)
# Environment specific settings
network_config.update(generic_utils.get_undercloud_env_vars())
# Deployed model settings
if (model.get_application_config('neutron-api').get('enable-dvr').get(
'value')):
network_config.update({"dvr_enabled": True})
# Get keystone session
keystone_session = openstack_utils.get_overcloud_keystone_session()
# Handle network for Openstack-on-Openstack scenarios
if juju_utils.get_provider_type() == "openstack":
undercloud_ks_sess = openstack_utils.get_undercloud_keystone_session()
network.setup_gateway_ext_port(network_config,
keystone_session=undercloud_ks_sess)
# Confugre the overcloud network
network.setup_sdn(network_config, keystone_session=keystone_session)
def basic_overcloud_network(limit_gws=None):
"""Run setup for neutron networking.
Configure the following:
The overcloud network using subnet pools
:param limit_gws: Limit the number of gateways that get a port attached
:type limit_gws: int
"""
cli_utils.setup_logging()
# Get network configuration settings
network_config = {}
# Declared overcloud settings
network_config.update(OVERCLOUD_NETWORK_CONFIG)
# Default undercloud settings
network_config.update(DEFAULT_UNDERCLOUD_NETWORK_CONFIG)
# Environment specific settings
network_config.update(generic_utils.get_undercloud_env_vars())
# Get keystone session
keystone_session = openstack_utils.get_overcloud_keystone_session()
# Handle network for Openstack-on-Openstack scenarios
if juju_utils.get_provider_type() == "openstack":
undercloud_ks_sess = openstack_utils.get_undercloud_keystone_session()
network.setup_gateway_ext_port(network_config,
keystone_session=undercloud_ks_sess,
limit_gws=None)
# Confugre the overcloud network
network.setup_sdn(network_config, keystone_session=keystone_session)
def setUpClass(cls):
"""Run class setup for running percona-cluster cold start tests."""
super().setUpClass()
cls.application = "mysql-innodb-cluster"
cls.overcloud_keystone_session = (
openstack_utils.get_undercloud_keystone_session())
cls.nova_client = openstack_utils.get_nova_session_client(
cls.overcloud_keystone_session)
def setup_gateway_ext_port(network_config,
keystone_session=None,
limit_gws=None,
use_juju_wait=True):
"""Perform setup external port on Neutron Gateway.
For OpenStack on OpenStack scenarios.
:param network_config: Network configuration dictionary
:type network_config: dict
:param keystone_session: Keystone session object for undercloud
:type keystone_session: keystoneauth1.session.Session object
:param limit_gws: Limit the number of gateways that get a port attached
:type limit_gws: Optional[int]
:param use_juju_wait: Use juju wait (default True) for model to settle
:type use_juju_wait: boolean
:returns: None
:rtype: None
"""
# If a session has not been provided, acquire one
if not keystone_session:
keystone_session = openstack_utils.get_undercloud_keystone_session()
# Get authenticated clients
nova_client = openstack_utils.get_nova_session_client(keystone_session)
neutron_client = openstack_utils.get_neutron_session_client(
keystone_session)
# Add an interface to the neutron-gateway units and tell juju to use it
# as the external port.
if "net_id" in network_config.keys():
net_id = network_config["net_id"]
else:
net_id = None
try:
# If we're using netplan, we need to add the new interface to the guest
current_release = openstack_utils.get_os_release()
bionic_queens = openstack_utils.get_os_release('bionic_queens')
if current_release >= bionic_queens:
logging.warn("Adding second interface for dataport to guest "
"netplan for bionic-queens and later")
add_dataport_to_netplan = True
else:
add_dataport_to_netplan = False
except zaza.openstack.utilities.exceptions.ApplicationNotFound:
# The setup_gateway_ext_port helper may be used with non-OpenStack
# workloads.
add_dataport_to_netplan = False
logging.info("Configuring network for OpenStack undercloud/provider")
openstack_utils.configure_gateway_ext_port(
nova_client,
neutron_client,
net_id=net_id,
add_dataport_to_netplan=add_dataport_to_netplan,
limit_gws=limit_gws,
use_juju_wait=use_juju_wait)
def main(argv):
cli_utils.setup_logging()
logging.getLogger("urllib3").setLevel(logging.WARNING)
keystone_session_uc = openstack_utils.get_undercloud_keystone_session()
under_novac = openstack_utils.get_nova_session_client(keystone_session_uc)
keystone_session_oc = openstack_utils.get_overcloud_keystone_session()
clients = {
'neutron':
openstack_utils.get_neutron_session_client(keystone_session_oc),
'nova': openstack_utils.get_nova_session_client(keystone_session_oc),
'glance': mojo_os_utils.get_glance_session_client(keystone_session_oc),
}
image_file = mojo_utils.get_mojo_file('images.yaml')
image_config = generic_utils.get_yaml_config(image_file)
image_password = image_config['cirros']['password']
# Look for existing Cirros guest
server, ip = get_cirros_server(clients, image_password)
router = (clients['neutron'].list_routers(
name='provider-router')['routers'][0])
l3_agents = clients['neutron'].list_l3_agent_hosting_routers(
router=router['id'])['agents']
logging.info('Checking there are multiple L3 agents running tenant router')
if len(l3_agents) != 2:
raise Exception('Unexpected number of l3 agents')
series = os.environ.get("MOJO_SERIES")
for agent in l3_agents:
gateway_hostname = agent['host']
gateway_server = under_novac.servers.find(name=gateway_hostname)
logging.info('Shutting down neutron gateway {} ({})'.format(
gateway_hostname, gateway_server.id))
gateway_server.stop()
if not check_server_state(
under_novac, 'SHUTOFF', server_name=gateway_hostname):
raise Exception('Server failed to reach SHUTOFF state')
logging.info('Neutron gateway %s has shutdown' % (gateway_hostname))
logging.info('Checking connectivity to cirros guest')
if not mojo_os_utils.wait_for_ping(ip, 90):
raise Exception('Cirros guest not responding to ping')
if not mojo_os_utils.ssh_test(
'cirros', ip, server.name, password=image_password):
raise Exception('Cirros guest issh connection failed')
logging.info('Starting neutron gateway: ' + gateway_hostname)
gateway_server.start()
if not check_server_state(
under_novac, 'ACTIVE', server_name=gateway_hostname):
raise Exception('Server failed to reach SHUTOFF state')
if not check_neutron_agent_states(clients['neutron'],
gateway_hostname):
raise Exception('Server agents failed to reach active state')
if series == "xenial":
logging.info(
"Concluding tests as rebooting a xenial guest can cause "
"network interfaces to be renamed which breaks the "
"gateway")
return
def basic_overcloud_network(limit_gws=None):
"""Run setup for neutron networking.
Configure the following:
The overcloud network using subnet pools
:param limit_gws: Limit the number of gateways that get a port attached
:type limit_gws: int
"""
cli_utils.setup_logging()
# Get network configuration settings
network_config = {}
# Declared overcloud settings
network_config.update(OVERCLOUD_NETWORK_CONFIG)
# Default undercloud settings
network_config.update(DEFAULT_UNDERCLOUD_NETWORK_CONFIG)
# Environment specific settings
network_config.update(generic_utils.get_undercloud_env_vars())
# Get keystone session
keystone_session = openstack_utils.get_overcloud_keystone_session()
# Get optional use_juju_wait for netw ork option
options = (lifecycle_utils
.get_charm_config(fatal=False)
.get('configure_options', {}))
use_juju_wait = options.get(
'configure_gateway_ext_port_use_juju_wait', True)
# Handle network for OpenStack-on-OpenStack scenarios
provider_type = juju_utils.get_provider_type()
if provider_type == "openstack":
undercloud_ks_sess = openstack_utils.get_undercloud_keystone_session()
network.setup_gateway_ext_port(network_config,
keystone_session=undercloud_ks_sess,
limit_gws=limit_gws,
use_juju_wait=use_juju_wait)
elif provider_type == "maas":
# NOTE(fnordahl): After validation of the MAAS+Netplan Open vSwitch
# integration support, we would most likely want to add multiple modes
# of operation with MAAS.
#
# Perform charm based OVS configuration
openstack_utils.configure_charmed_openstack_on_maas(
network_config, limit_gws=limit_gws)
else:
logging.warning('Unknown Juju provider type, "{}", will not perform'
' charm network configuration.'
.format(provider_type))
# Confugre the overcloud network
network.setup_sdn(network_config, keystone_session=keystone_session)
def setup_gateway_ext_port(network_config, keystone_session=None):
"""Perform setup external port on Neutron Gateway.
For OpenStack on OpenStack scenarios.
:param network_config: Network configuration dictionary
:type network_config: dict
:param keystone_session: Keystone session object for undercloud
:type keystone_session: keystoneauth1.session.Session object
:returns: None
:rtype: None
"""
# If a session has not been provided, acquire one
if not keystone_session:
keystone_session = openstack_utils.get_undercloud_keystone_session()
# Get authenticated clients
nova_client = openstack_utils.get_nova_session_client(keystone_session)
neutron_client = openstack_utils.get_neutron_session_client(
keystone_session)
# Add an interface to the neutron-gateway units and tell juju to use it
# as the external port.
if "net_id" in network_config.keys():
net_id = network_config["net_id"]
else:
net_id = None
# If we're using netplan, we need to add the new interface to the guest
current_release = openstack_utils.get_os_release()
bionic_queens = openstack_utils.get_os_release('bionic_queens')
if current_release >= bionic_queens:
logging.warn("Adding second interface for dataport to guest netplan "
"for bionic-queens and later")
add_dataport_to_netplan = True
else:
add_dataport_to_netplan = False
logging.info("Configuring network for OpenStack undercloud/provider")
openstack_utils.configure_gateway_ext_port(
nova_client,
neutron_client,
dvr_mode=network_config.get("dvr_enabled", False),
net_id=net_id,
add_dataport_to_netplan=add_dataport_to_netplan)
def test_gateway_failure(self):
"""Validate networking in the case of a gateway failure."""
instance_1, instance_2 = self.retrieve_guests()
if not all([instance_1, instance_2]):
self.launch_guests()
instance_1, instance_2 = self.retrieve_guests()
self.check_connectivity(instance_1, instance_2)
routers = self.neutron_client.list_routers(
name='provider-router')['routers']
assert len(routers) == 1, "Unexpected router count {}".format(
len(routers))
provider_router = routers[0]
l3_agents = self.neutron_client.list_l3_agent_hosting_routers(
router=provider_router['id'])['agents']
logging.info(
'Checking there are multiple L3 agents running tenant router')
assert len(l3_agents) == 2, "Unexpected l3 agent count {}".format(
len(l3_agents))
uc_ks_session = openstack_utils.get_undercloud_keystone_session()
uc_nova_client = openstack_utils.get_nova_session_client(uc_ks_session)
uc_neutron_client = openstack_utils.get_neutron_session_client(
uc_ks_session)
for agent in l3_agents:
gateway_hostname = agent['host']
gateway_server = uc_nova_client.servers.find(name=gateway_hostname)
logging.info("Shutting down {}".format(gateway_hostname))
gateway_server.stop()
self.check_server_state(
uc_nova_client,
'SHUTOFF',
server_name=gateway_hostname)
self.check_connectivity(instance_1, instance_2)
gateway_server.start()
self.check_server_state(
uc_nova_client,
'ACTIVE',
server_name=gateway_hostname)
self.check_neutron_agent_up(
uc_neutron_client,
gateway_hostname)
self.check_connectivity(instance_1, instance_2)
def main():
args = parse_args(sys.argv[1:])
cli_utils.setup_logging(log_level=args.loglevel.upper())
session = zaza_os.get_undercloud_keystone_session()
neutron_client = zaza_os.get_neutron_session_client(session)
nova_client = zaza_os.get_nova_session_client(session)
if args.vnic_binding_type == 'dummy':
logging.warning('Running in dummy mode')
binding_type = None
else:
binding_type = args.vnic_binding_type
if args.action == 'cleanup':
logging.info('Running cleanup')
cleanup(nova_client, neutron_client, args.network_name,
args.application_name)
elif args.action == 'add-ports':
logging.info('Adding ports')
create_ports(nova_client,
neutron_client,
args.network_name,
args.application_name,
binding_type,
shutdown_move=True)
logging.info('Adding to netplan')
add_port_to_netplan(neutron_client, args.network_name,
args.application_name)
elif args.action == 'add-servers':
add_servers(nova_client,
neutron_client,
args.network_name,
args.number_of_units,
args.flavor,
args.image_name,
vnic_type=binding_type,
port_security_enabled=args.enable_port_security)
elif args.action == 'add-manual-cloud':
add_cloud(nova_client)
elif args.action == 'add-machines':
add_machines(nova_client)
def run_from_cli(**kwargs):
"""Run network configurations from CLI.
Use a YAML file of network configuration settings to configure the
overcloud network. YAML file of the form:
topology_name:
network_type: gre
router_name: provider-router
private_net_cidr: 192.168.21.0/24
external_dns: 10.5.0.2
external_net_cidr: 10.5.0.0/16
external_net_name: ext_net
external_subnet_name: ext_net_subnet
default_gateway: 10.5.0.1
start_floating_ip: 10.5.150.0
end_floating_ip: 10.5.200.254
:param kwargs: Allow for override of argparse options
:returns: None
:rtype: None
"""
cli_utils.setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument("net_topology",
help="network topology type, default is GRE",
default="gre",
nargs="?")
parser.add_argument("--ignore_env_vars",
"-i",
help="do not override using environment variables",
action="store_true",
default=False)
parser.add_argument("--net_topology_file",
"-f",
help="Network topology file location",
default="network.yaml")
parser.add_argument("--cacert",
help="Path to CA certificate bundle file",
default=None)
parser.add_argument("--no-use-juju-wait",
help=("don't use juju wait for the model to settle "
"(default true)"),
action="store_false",
default=True)
# Handle CLI options
options = parser.parse_args()
net_topology = (kwargs.get('net_toplogoy')
or cli_utils.parse_arg(options, "net_topology"))
net_topology_file = (kwargs.get('net_topology_file')
or cli_utils.parse_arg(options, "net_topology_file"))
ignore_env_vars = (kwargs.get('ignore_env_vars')
or cli_utils.parse_arg(options, "ignore_env_vars"))
cacert = (kwargs.get('cacert') or cli_utils.parse_arg(options, "cacert"))
logging.info("Setting up %s network" % (net_topology))
network_config = generic_utils.get_network_config(net_topology,
ignore_env_vars,
net_topology_file)
# Handle network for OpenStack-on-OpenStack scenarios
if juju_utils.get_provider_type() == "openstack":
undercloud_ks_sess = openstack_utils.get_undercloud_keystone_session(
verify=cacert)
setup_gateway_ext_port(network_config,
keystone_session=undercloud_ks_sess,
use_juju_wait=cli_utils.parse_arg(
options, 'no_use_juju_wait'))
overcloud_ks_sess = openstack_utils.get_overcloud_keystone_session(
verify=cacert)
setup_sdn(network_config, keystone_session=overcloud_ks_sess)
def delete_unit_openstack(unit):
keystone_session = openstack_utils.get_undercloud_keystone_session()
nc = openstack_utils.get_nova_session_client(keystone_session)
server_id = convert_unit_to_machineno(unit)
server = nc.servers.find(id=server_id)
server.delete()
