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 >= 'mitaka':
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("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(
"--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)
add_new_charms(target_release)
mojo_utils.juju_wait_finished()
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)
mojo_utils.juju_wait_finished()
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()
default_machines = ["cirros:m1.tiny:1"]
parser.add_argument("machines", default=default_machines, nargs="*")
parser.add_argument("--active_wait", default=600)
parser.add_argument("--cloudinit_wait", default=600)
parser.add_argument("--ping_wait", default=600)
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)
logging.info("Using cacert file: {}".format(cacert))
except FileNotFoundError:
logging.info("Not using a cacert pem file")
cacert = None
logging.info("Initializing client sessions")
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(search_opts={'all_tenants': 1}):
if server.name.startswith('mojo'):
logging.info("Deleting nova instance {}".format(server.id))
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)
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 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 >= 'mitaka':
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)
