def main(argv): parser = argparse.ArgumentParser() parser.add_argument("application", default="ceph-mon", nargs="*") parser.add_argument("units", default=[0, 1], nargs="*") options = parser.parse_args() application = cli_utils.parse_arg(options, 'application', multiargs=False) units = cli_utils.parse_arg(options, 'units', multiargs=True) juju_utils.remote_run('{}/{}'.format(application, units[-1]), remote_cmd='ceph osd pool create rbd 128') # Check juju_utils.remote_run('{}/{}'.format(application, units[0]), remote_cmd='echo 123456789 > /tmp/input.txt') juju_utils.remote_run( '{}/{}'.format(application, units[0]), remote_cmd='rados put -p rbd test_input /tmp/input.txt') # Check output = juju_utils.remote_run( '{}/{}'.format(application, units[-1]), remote_cmd='rados get -p rbd test_input /dev/stdout') # Cleanup juju_utils.remote_run('{}/{}'.format(application, units[-1]), remote_cmd='rados rm -p rbd test_input') if output.strip() != "123456789": sys.exit(1)
def main(argv): cli_utils.setup_logging() parser = argparse.ArgumentParser() parser.add_argument("--service") parser.add_argument("--resource") options = parser.parse_args() service = cli_utils.parse_arg(options, 'service') resource = cli_utils.parse_arg(options, 'resource') xenial = distro_info.UbuntuDistroInfo().all.index('xenial') series = os.environ.get('MOJO_SERIES') mojo_env = distro_info.UbuntuDistroInfo().all.index(series) if mojo_env >= xenial: resource = resource.replace('eth0', 'ens2') mojo_os_utils.delete_crm_leader(service, resource)
def main(argv): cli_utils.setup_logging() parser = argparse.ArgumentParser() parser.add_argument('-d', '--domain_name', help='DNS Domain Name. ' 'Must end in a .', default='mojo.serverstack.') options = parser.parse_args() domain_name = cli_utils.parse_arg(options, 'domain_name') os_version = openstack_utils.get_current_os_versions( 'keystone')['keystone'] if os_version >= 'queens': designate_api = '2' else: designate_api = '1' keystone_session = openstack_utils.get_overcloud_keystone_session() nova_client = openstack_utils.get_nova_session_client(keystone_session) des_client = mojo_os_utils.get_designate_session_client( keystone_session, all_tenants=True, client_version=designate_api) for server in nova_client.servers.list(): for addr_info in server.addresses['private']: if addr_info['OS-EXT-IPS:type'] == 'floating': mojo_os_utils.check_dns_entry( des_client, addr_info['addr'], domain_name, '{}.{}'.format(server.name, domain_name))
def main(argv): cli_utils.setup_logging() parser = argparse.ArgumentParser() parser.add_argument("application", nargs="*") options = parser.parse_args() unit_args = cli_utils.parse_arg(options, 'application', multiargs=True) for application in unit_args: mojo_utils.delete_application(application)
def main(argv): cli_utils.setup_logging() parser = argparse.ArgumentParser() parser.add_argument("services", nargs="*") options = parser.parse_args() services = cli_utils.parse_arg(options, 'services', multiargs=True) for service in services: mojo_utils.upgrade_service(service)
def main(argv): parser = argparse.ArgumentParser() parser.add_argument("--service") parser.add_argument("--kv") parser.add_argument("--wait") options = parser.parse_args() application = cli_utils.parse_arg(options, 'service') key, value = cli_utils.parse_arg(options, 'kv').split("=") wait = cli_utils.parse_arg(options, 'wait') print("Wait: {}".format(wait)) if wait is not None: wait = wait == 'True' print("Applicatoin: {}".format(application)) print("Option: {}={}".format(key, value)) print("Wait: {}".format(wait)) model.set_application_config(application, {key: value}) if wait: mojo_utils.juju_wait_finished()
def test_parse_arg(self): _options = mock.MagicMock() _arg_property = "property-value" _options.property = _arg_property # Argparse value self.assertEqual(cli_utils.parse_arg(_options, "property"), _arg_property) # Single value environment _environ_value = "environ-value" _env = {"PROPERTY": _environ_value} with mock.patch.dict(cli_utils.os.environ, _env): self.assertEqual(cli_utils.parse_arg(_options, "property"), _environ_value) # Multi value environment _multi_value = "val1 val2" _env = {"PROPERTY": _multi_value} with mock.patch.dict(cli_utils.os.environ, _env): self.assertEqual( cli_utils.parse_arg(_options, "property", multiargs=True), _multi_value.split())
def run_from_cli(): """Run test for BGP routes from CLI. :returns: None :rtype: None """ cli_utils.setup_logging() parser = argparse.ArgumentParser() parser.add_argument("--peer-application", "-a", help="BGP Peer application name. Default: quagga", default="quagga") options = parser.parse_args() peer_application_name = cli_utils.parse_arg(options, "peer_application") test_bgp_routes(peer_application_name)
def main(argv): cli_utils.setup_logging() parser = argparse.ArgumentParser() parser.add_argument( "--target_release", default='auto', help="Openstack release name to upgrade to or 'auto' " "to have script upgrade based on the lowest value" "across all services") options = parser.parse_args() target_release = cli_utils.parse_arg(options, 'target_release') principle_services = mojo_utils.get_principle_applications() current_versions = openstack_utils.get_current_os_versions( principle_services) if target_release == 'auto': # If in auto mode find the lowest value openstack release across all # services and make sure all servcies are upgraded to one release # higher than the lowest lowest_release = mojo_os_utils.get_lowest_os_version(current_versions) target_release = mojo_os_utils.next_release(lowest_release)[1] # Get a list of services that need upgrading needs_upgrade = get_upgrade_targets(target_release, current_versions) for application in openstack_utils.UPGRADE_SERVICES: if application['name'] not in principle_services: continue if application['name'] not in needs_upgrade: logging.info('Not upgrading {} it is at {} or higher'.format( application['name'], target_release) ) continue logging.info('Upgrading {} to {}'.format(application['name'], target_release)) # Update required relations update_relations(application['name'], target_release) ubuntu_version = mojo_utils.get_ubuntu_version(application['name']) config = {application['type']['origin_setting']: "cloud:{}-{}/proposed" .format(ubuntu_version, target_release)} model.set_application_config(application['name'], config) # NOTE: For liberty->mitaka upgrade ceilometer-agent gets stuck at # 'Services not running that should be: memcached' after nova-compute # upgrade, and test would wait forever. Therefore we upgrade # ceilometer-agent immediately after nova-compute. if application['name'] == 'nova-compute': model.set_application_config('ceilometer-agent', config) mojo_utils.juju_wait_finished()
def main(argv): cli_utils.setup_logging() parser = argparse.ArgumentParser() parser.add_argument("router", nargs="?") options = parser.parse_args() router_name = cli_utils.parse_arg(options, 'router') 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_overcloud_keystone_session( verify=cacert) neutron_client = openstack_utils.get_neutron_session_client( keystone_session) router = neutron_client.list_routers(name=router_name)['routers'][0]['id'] l3_agent = neutron_client.list_l3_agent_hosting_routers(router=router) hosting_machine = l3_agent['agents'][0]['host'] mojo_utils.delete_machine(hosting_machine)
def main(argv): cli_utils.setup_logging() parser = argparse.ArgumentParser() parser.add_argument("units", nargs="*") options = parser.parse_args() unit_args = cli_utils.parse_arg(options, 'units', multiargs=True) for unitreq in unit_args: if ':' in unitreq: application, unitcount = unitreq.split(':') units = mojo_utils.get_juju_units(application) i = 0 for unit in units: if i >= int(unitcount): break mojo_utils.delete_unit(unit) i = i + 1 elif '/' in unitreq: units = mojo_utils.get_juju_units(unitreq.split('/')[0]) if unitreq in units: mojo_utils.delete_unit(unitreq)
def main(argv): cli_utils.setup_logging() parser = argparse.ArgumentParser() parser.add_argument('-r', '--resolver', help='Resolver address. ' 'Usually designate-bind address.', required=False) parser.add_argument('-d', '--domain_name', help='DNS Domain Name. ' 'Must end in a .', default='mojo.serverstack.') parser.add_argument('-e', '--email', help='Email address', default='*****@*****.**') parser.add_argument('-b', '--bind-service', help='Bind Service Name', default='designate-bind') options = parser.parse_args() bind_service_name = cli_utils.parse_arg(options, 'bind_service') resolver = cli_utils.parse_arg(options, 'resolver') bind_unit = mojo_utils.get_juju_units(bind_service_name)[0] if not resolver: resolver = mojo_utils.get_juju_unit_ip(bind_unit) domain_name = cli_utils.parse_arg(options, 'domain_name') email = cli_utils.parse_arg(options, 'email') nameserver = 'ns1.{}'.format(domain_name) logging.info('Setting up designate {} {}'.format(nameserver, resolver)) os_version = openstack_utils.get_current_os_versions( 'keystone')['keystone'] 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_overcloud_keystone_session( verify=cacert) neutronc = openstack_utils.get_neutron_session_client(keystone_session) if os_version >= 'queens': designatec = mojo_os_utils.get_designate_session_client( keystone_session, client_version='2') zone = mojo_os_utils.create_or_return_zone(designatec, domain_name, email) mojo_os_utils.create_or_return_recordset(designatec, zone['id'], 'www', 'A', [resolver]) else: designatec = mojo_os_utils.get_designate_session_client( keystone_session, client_version='1') if not mojo_os_utils.get_designate_server_id(designatec, nameserver): logging.info('Creating server {}'.format(nameserver)) server = Server(name=nameserver) server_id = designatec.servers.create(server) assert (server_id is not None) else: logging.info('{} server already exists.'.format(nameserver)) domain_id = mojo_os_utils.get_designate_domain_id( designatec, domain_name) if not domain_id: logging.info('Creating domain {}'.format(domain_name)) domain = Domain(name=domain_name, email=email) domain_id = designatec.domains.create(domain) assert (domain_id is not None) else: logging.info('{} domain already exists.'.format(domain_name)) if not mojo_os_utils.get_designate_record_id(designatec, domain_id, nameserver): logging.info('Creating NS record {}'.format(nameserver)) ns_record = Record(name=nameserver, type="A", data=resolver) record_id = designatec.records.create(domain_id, ns_record) assert (record_id is not None) else: logging.info('{} record already exists.'.format(nameserver)) logging.info('Update network to use domain {}'.format(domain_name)) net_uuid = openstack_utils.get_net_uuid(neutronc, 'private') mojo_os_utils.update_network_dns(neutronc, net_uuid, domain_name)
def main(argv): cli_utils.setup_logging() parser = argparse.ArgumentParser() default_machines = ["cirros:m1.tiny:1"] parser.add_argument("machines", default=default_machines, nargs="*") parser.add_argument("--active_wait", default=180) parser.add_argument("--cloudinit_wait", default=180) parser.add_argument("--ping_wait", default=180) options = parser.parse_args() machines = cli_utils.parse_arg(options, 'machines', multiargs=True) active_wait = int(cli_utils.parse_arg(options, 'active_wait')) cloudinit_wait = int(cli_utils.parse_arg(options, 'cloudinit_wait')) ping_wait = int(cli_utils.parse_arg(options, 'ping_wait')) overcloud_novarc = openstack_utils.get_overcloud_auth() 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_overcloud_keystone_session( verify=cacert) keystonec = openstack_utils.get_keystone_session_client(keystone_session) domain = overcloud_novarc.get('OS_PROJECT_DOMAIN_NAME') project_id = openstack_utils.get_project_id( keystonec, 'admin', api_version=overcloud_novarc['API_VERSION'], domain_name=domain) novac = openstack_utils.get_nova_session_client(keystone_session) neutronc = openstack_utils.get_neutron_session_client(keystone_session) init_flavors(novac) priv_key = mojo_os_utils.create_keypair(novac, 'mojo') openstack_utils.add_neutron_secgroup_rules(neutronc, project_id) for server in novac.servers.list(): novac.servers.delete(server.id) for instanceset in machines: image_name, flavor_name, count = instanceset.split(":") # when instance count allows boot instances off both regular instance # storage and volume storage # # account for count=1 and odd numbers # NOTE(fnordahl) temporarilly disable test while tests settle # regular_boot_count = int(int(count) / 2) + (int(count) % 2) # volume_boot_count = int(int(count) / 2) regular_boot_count = int(count) volume_boot_count = 0 mojo_os_utils.boot_and_test( novac, neutronc, image_name=image_name, flavor_name=flavor_name, number=regular_boot_count, privkey=priv_key, active_wait=active_wait, cloudinit_wait=cloudinit_wait, ping_wait=ping_wait, ) mojo_os_utils.boot_and_test( novac, neutronc, image_name=image_name, flavor_name=flavor_name, number=volume_boot_count, privkey=priv_key, active_wait=active_wait, cloudinit_wait=cloudinit_wait, ping_wait=ping_wait, boot_from_volume=True, )
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) # 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) overcloud_ks_sess = openstack_utils.get_overcloud_keystone_session( verify=cacert) setup_sdn(network_config, keystone_session=overcloud_ks_sess)