arif/zaza-openstack-tests
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move call to get_juju_model() down to run_in_model

Browse Source 
Currently interacting with functions in zaza.model requires the
model to be passed in. This has resulted in multiple calls to
get_juju_model(). It is cleaner to push these calls down into
the model wrapper and make the model_name an optional
argument. In addition, the current model name is now cached
without having to check the os.env each time.

Unfortunately this has resulted in the signature changing on a
great many function so this diff is bigger than would normally
be desirable.
This commit is contained in:
Liam Young
2018-06-12 11:04:35 +01:00
parent 7b10df57d8
commit 9d06bb890f
16 changed files with 181 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
unit_tests/test_zaza_charm_lifecycle_utils.py
View File

@@ -30,22 +30,3 @@ class TestCharmLifecycleUtils(ut_utils.BaseTestCase):
'test_zaza_charm_lifecycle_utils.'
'TestCharmLifecycleUtils')()),
type(self))
def test_get_juju_model(self):
self.patch_object(lc_utils.os, 'environ')
self.patch_object(lc_utils.model, 'get_current_model')
self.get_current_model.return_value = 'modelsmodel'
def _get_env(key):
return _env.get(key)
self.environ.__getitem__.side_effect = _get_env
_env = {"JUJU_MODEL": 'envmodel'}
# JUJU_ENV environment variable set
self.assertEqual(lc_utils.get_juju_model(), 'envmodel')
self.get_current_model.assert_not_called()
# No envirnment variable
self.environ.__getitem__.side_effect = KeyError
self.assertEqual(lc_utils.get_juju_model(), 'modelsmodel')
self.get_current_model.assert_called_once()

97
unit_tests/test_zaza_model.py
View File

@@ -123,6 +123,26 @@ class TestModel(ut_utils.BaseTestCase):
self.Controller_mock.add_model.side_effect = _ctrl_add_model
self.Controller_mock.destroy_models.side_effect = _ctrl_destroy_models
def test_get_juju_model(self):
self.patch_object(model.os, 'environ')
self.patch_object(model, 'get_current_model')
model.CURRENT_MODEL = None
self.get_current_model.return_value = 'modelsmodel'
def _get_env(key):
return _env.get(key)
self.environ.__getitem__.side_effect = _get_env
_env = {"JUJU_MODEL": 'envmodel'}
# JUJU_ENV environment variable set
self.assertEqual(model.get_juju_model(), 'envmodel')
self.get_current_model.assert_not_called()
# No envirnment variable
self.environ.__getitem__.side_effect = KeyError
self.assertEqual(model.get_juju_model(), 'modelsmodel')
self.get_current_model.assert_called_once()
def test_run_in_model(self):
self.patch_object(model, 'Model')
self.Model.return_value = self.Model_mock
@@ -135,47 +155,53 @@ class TestModel(ut_utils.BaseTestCase):
self.Model_mock.disconnect.assert_called_once_with()
def test_scp_to_unit(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model, 'Model')
self.patch_object(model, 'get_unit_from_name')
self.get_unit_from_name.return_value = self.unit1
self.Model.return_value = self.Model_mock
model.scp_to_unit('modelname', 'app/1', '/tmp/src', '/tmp/dest')
model.scp_to_unit('app/1', '/tmp/src', '/tmp/dest')
self.unit1.scp_to.assert_called_once_with(
'/tmp/src', '/tmp/dest', proxy=False, scp_opts='', user='ubuntu')
def test_scp_to_all_units(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model, 'Model')
self.Model.return_value = self.Model_mock
model.scp_to_all_units('modelname', 'app', '/tmp/src', '/tmp/dest')
model.scp_to_all_units('app', '/tmp/src', '/tmp/dest')
self.unit1.scp_to.assert_called_once_with(
'/tmp/src', '/tmp/dest', proxy=False, scp_opts='', user='ubuntu')
self.unit2.scp_to.assert_called_once_with(
'/tmp/src', '/tmp/dest', proxy=False, scp_opts='', user='ubuntu')
def test_scp_from_unit(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model, 'Model')
self.patch_object(model, 'get_unit_from_name')
self.get_unit_from_name.return_value = self.unit1
self.Model.return_value = self.Model_mock
model.scp_from_unit('modelname', 'app/1', '/tmp/src', '/tmp/dest')
model.scp_from_unit('app/1', '/tmp/src', '/tmp/dest')
self.unit1.scp_from.assert_called_once_with(
'/tmp/src', '/tmp/dest', proxy=False, scp_opts='', user='ubuntu')
def test_get_units(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model, 'Model')
self.Model.return_value = self.Model_mock
self.assertEqual(
model.get_units('modelname', 'app'),
model.get_units('app'),
self.units)
def test_get_machines(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model, 'Model')
self.Model.return_value = self.Model_mock
self.assertEqual(
model.get_machines('modelname', 'app'),
model.get_machines('app'),
['machine3', 'machine7'])
def test_get_first_unit_name(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model, 'get_units')
self.get_units.return_value = self.units
self.assertEqual(
@@ -183,62 +209,76 @@ class TestModel(ut_utils.BaseTestCase):
'app/2')
def test_get_unit_from_name(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.assertEqual(
model.get_unit_from_name('app/4', self.mymodel),
self.unit2)
def test_get_app_ips(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model, 'get_units')
self.get_units.return_value = self.units
self.assertEqual(model.get_app_ips('model', 'app'), ['ip1', 'ip2'])
def test_run_on_unit(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
expected = {'Code': '0', 'Stderr': '', 'Stdout': 'RESULT'}
self.cmd = cmd = 'somecommand someargument'
self.patch_object(model, 'Model')
self.patch_object(model, 'get_unit_from_name')
self.get_unit_from_name.return_value = self.unit1
self.Model.return_value = self.Model_mock
self.assertEqual(model.run_on_unit('app/2', 'modelname', cmd),
self.assertEqual(model.run_on_unit('app/2', cmd),
expected)
self.unit1.run.assert_called_once_with(cmd, timeout=None)
def test_get_relation_id(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model, 'Model')
self.Model.return_value = self.Model_mock
self.assertEqual(model.get_relation_id('testmodel', 'app', 'app'), 42)
self.assertEqual(model.get_relation_id('app', 'app'), 42)
def test_get_relation_id_interface(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model, 'Model')
self.Model.return_value = self.Model_mock
self.assertEqual(model.get_relation_id('testmodel', 'app', 'app',
'interface'), 51)
self.assertEqual(
model.get_relation_id('app', 'app',
remote_interface_name='interface'),
51)
def test_run_action(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model, 'Model')
self.patch_object(model, 'get_unit_from_name')
self.get_unit_from_name.return_value = self.unit1
self.Model.return_value = self.Model_mock
model.run_action('app/2', 'modelname', 'backup',
{'backup_dir': '/dev/null'})
model.run_action(
'app/2',
'backup',
action_params={'backup_dir': '/dev/null'})
self.unit1.run_action.assert_called_once_with(
'backup',
backup_dir='/dev/null')
def test_get_actions(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model.subprocess, 'check_output')
self.check_output.return_value = 'action: "action desc"'
self.assertEqual(
model.get_actions('mname', 'myapp'),
model.get_actions('myapp'),
{'action': "action desc"})
self.check_output.assert_called_once_with(
['juju', 'actions', '-m', 'mname', 'myapp', '--format', 'yaml'])
def test_run_action_on_leader(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model, 'Model')
self.Model.return_value = self.Model_mock
model.run_action_on_leader('modelname', 'app', 'backup',
{'backup_dir': '/dev/null'})
model.run_action_on_leader(
'app',
'backup',
action_params={'backup_dir': '/dev/null'})
self.assertFalse(self.unit1.called)
self.unit2.run_action.assert_called_once_with(
'backup',
@@ -419,6 +459,7 @@ class TestModel(ut_utils.BaseTestCase):
def test_block_until_file_has_contents(self):
self.patch_object(model, 'Model')
self.Model.return_value = self.Model_mock
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch("builtins.open",
new_callable=mock.mock_open(),
name="_open")
@@ -426,7 +467,6 @@ class TestModel(ut_utils.BaseTestCase):
_fileobj.__enter__().read.return_value = "somestring"
self._open.return_value = _fileobj
model.block_until_file_has_contents(
'modelname',
'app',
'/tmp/src/myfile.txt',
'somestring',
@@ -439,6 +479,7 @@ class TestModel(ut_utils.BaseTestCase):
def test_block_until_file_has_contents_missing(self):
self.patch_object(model, 'Model')
self.Model.return_value = self.Model_mock
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch("builtins.open",
new_callable=mock.mock_open(),
name="_open")
@@ -447,7 +488,6 @@ class TestModel(ut_utils.BaseTestCase):
self._open.return_value = _fileobj
with self.assertRaises(asyncio.futures.TimeoutError):
model.block_until_file_has_contents(
'modelname',
'app',
'/tmp/src/myfile.txt',
'somestring',
@@ -503,35 +543,35 @@ class TestModel(ut_utils.BaseTestCase):
self.async_block_until.side_effect = _block_until
def test_block_until_service_status_check_running(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.block_until_service_status_base({'Stdout': '152 409 54'})
model.block_until_service_status(
'modelname',
'app/2',
['test_svc'],
'running')
def test_block_until_service_status_check_running_fail(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.block_until_service_status_base({'Stdout': ''})
with self.assertRaises(asyncio.futures.TimeoutError):
model.block_until_service_status(
'modelname',
'app/2',
['test_svc'],
'running')
def test_block_until_service_status_check_stopped(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.block_until_service_status_base({'Stdout': ''})
model.block_until_service_status(
'modelname',
'app/2',
['test_svc'],
'stopped')
def test_block_until_service_status_check_stopped_fail(self):
self.patch_object(model, 'get_juju_model', return_value='mname')
self.block_until_service_status_base({'Stdout': '152 409 54'})
with self.assertRaises(asyncio.futures.TimeoutError):
model.block_until_service_status(
'modelname',
'app/2',
['test_svc'],
'stopped')
@@ -542,7 +582,7 @@ class TestModel(ut_utils.BaseTestCase):
self.patch_object(model, 'async_run_on_unit')
self.async_run_on_unit.side_effect = _run_on_unit
self.assertEqual(
model.get_unit_time('mymodel', 'app/2'),
model.get_unit_time('app/2'),
1524409654)
def test_get_unit_service_start_time(self):
@@ -551,8 +591,7 @@ class TestModel(ut_utils.BaseTestCase):
self.patch_object(model, 'async_run_on_unit')
self.async_run_on_unit.side_effect = _run_on_unit
self.assertEqual(
model.get_unit_service_start_time('mymodel', 'app/2', 'mysvc1'),
1524409654)
model.get_unit_service_start_time('app/2', 'mysvc1'), 1524409654)
def test_get_unit_service_start_time_not_running(self):
async def _run_on_unit(model_name, unit_name, cmd, timeout=None):
@@ -560,7 +599,7 @@ class TestModel(ut_utils.BaseTestCase):
self.patch_object(model, 'async_run_on_unit')
self.async_run_on_unit.side_effect = _run_on_unit
with self.assertRaises(model.ServiceNotRunning):
model.get_unit_service_start_time('mymodel', 'app/2', 'mysvc1')
model.get_unit_service_start_time('app/2', 'mysvc1')
def block_until_oslo_config_entries_match_base(self, file_contents,
expected_contents):
@@ -568,11 +607,11 @@ class TestModel(ut_utils.BaseTestCase):
with open('{}/myfile.txt'.format(tmpdir), 'w') as f:
f.write(file_contents)
self.patch_object(model, 'Model')
self.patch_object(model, 'get_juju_model', return_value='mname')
self.Model.return_value = self.Model_mock
self.unit1.scp_from.side_effect = _scp_from
self.unit2.scp_from.side_effect = _scp_from
model.block_until_oslo_config_entries_match(
'modelname',
'app',
'/tmp/src/myfile.txt',
expected_contents,
@@ -706,6 +745,7 @@ disk_formats = ami,ari,aki,vhd,vmdk,raw,qcow2,vdi,iso,root-tar
raise model.ServiceNotRunning('sv1')
else:
return gu_return
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model, 'async_get_unit_service_start_time')
self.async_get_unit_service_start_time.side_effect = \
_async_get_unit_service_start_time
@@ -715,7 +755,6 @@ disk_formats = ami,ari,aki,vhd,vmdk,raw,qcow2,vdi,iso,root-tar
def test_block_until_services_restarted(self):
self.block_until_services_restarted_base(gu_return=10)
model.block_until_services_restarted(
'modelname',
'app',
8,
['svc1', 'svc2'])
@@ -724,7 +763,6 @@ disk_formats = ami,ari,aki,vhd,vmdk,raw,qcow2,vdi,iso,root-tar
self.block_until_services_restarted_base(gu_return=10)
with self.assertRaises(asyncio.futures.TimeoutError):
model.block_until_services_restarted(
'modelname',
'app',
12,
['svc1', 'svc2'])
@@ -733,7 +771,6 @@ disk_formats = ami,ari,aki,vhd,vmdk,raw,qcow2,vdi,iso,root-tar
self.block_until_services_restarted_base(gu_raise_exception=True)
with self.assertRaises(asyncio.futures.TimeoutError):
model.block_until_services_restarted(
'modelname',
'app',
12,
['svc1', 'svc2'])
@@ -742,6 +779,7 @@ disk_formats = ami,ari,aki,vhd,vmdk,raw,qcow2,vdi,iso,root-tar
async def _block_until(f, timeout=None):
if not f():
raise asyncio.futures.TimeoutError
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model, 'Model')
self.Model.return_value = self.Model_mock
self.Model_mock.block_until.side_effect = _block_until
@@ -749,7 +787,6 @@ disk_formats = ami,ari,aki,vhd,vmdk,raw,qcow2,vdi,iso,root-tar
self.get_unit_from_name.return_value = mock.MagicMock(
workload_status='active')
model.block_until_unit_wl_status(
'modelname',
'app/2',
'active',
timeout=0.1)
@@ -758,6 +795,7 @@ disk_formats = ami,ari,aki,vhd,vmdk,raw,qcow2,vdi,iso,root-tar
async def _block_until(f, timeout=None):
if not f():
raise asyncio.futures.TimeoutError
self.patch_object(model, 'get_juju_model', return_value='mname')
self.patch_object(model, 'Model')
self.Model.return_value = self.Model_mock
self.Model_mock.block_until.side_effect = _block_until
@@ -766,7 +804,6 @@ disk_formats = ami,ari,aki,vhd,vmdk,raw,qcow2,vdi,iso,root-tar
workload_status='maintenance')
with self.assertRaises(asyncio.futures.TimeoutError):
model.block_until_unit_wl_status(
'modelname',
'app/2',
'active',
timeout=0.1)

3
unit_tests/utilities/test_zaza_utilities_generic.py
View File

@@ -48,15 +48,12 @@ class TestGenericUtils(ut_utils.BaseTestCase):
def test_get_pkg_version(self):
self.patch_object(generic_utils.model, "get_units")
self.patch_object(generic_utils.lifecycle_utils, "get_juju_model")
self.patch_object(generic_utils.juju_utils, "remote_run")
_pkg = "os-thingy"
_version = "2:27.0.0-0ubuntu1~cloud0"
_dpkg_output = ("ii {} {} all OpenStack thingy\n"
.format(_pkg, _version))
self.remote_run.return_value = _dpkg_output
_model_name = "model-name"
self.get_juju_model.return_value = _model_name
_unit1 = mock.MagicMock()
_unit1.entity_id = "os-thingy/7"
_unit2 = mock.MagicMock()

12
unit_tests/utilities/test_zaza_utilities_juju.py
View File

@@ -27,9 +27,7 @@ class TestJujuUtils(ut_utils.BaseTestCase):
# Model
self.patch_object(juju_utils, "model")
self.patch_object(juju_utils.lifecycle_utils, "get_juju_model")
self.model_name = "model-name"
self.get_juju_model.return_value = self.model_name
self.model.get_status.return_value = self.juju_status
self.run_output = {"Code": "0", "Stderr": "", "Stdout": "RESULT"}
self.error_run_output = {"Code": "1", "Stderr": "ERROR", "Stdout": ""}
@@ -80,7 +78,7 @@ class TestJujuUtils(ut_utils.BaseTestCase):
def test_get_full_juju_status(self):
self.assertEqual(juju_utils.get_full_juju_status(), self.juju_status)
self.model.get_status.assert_called_once_with(self.model_name)
self.model.get_status.assert_called_once_with()
def test_get_machines_for_application(self):
self.patch_object(juju_utils, "get_application_status")
@@ -145,7 +143,7 @@ class TestJujuUtils(ut_utils.BaseTestCase):
self.assertEqual(juju_utils.remote_run(self.unit, _cmd),
self.run_output["Stdout"])
self.model.run_on_unit.assert_called_once_with(
self.model_name, self.unit, _cmd, timeout=None)
self.unit, _cmd, timeout=None)
# Non-fatal failure
self.model.run_on_unit.return_value = self.error_run_output
@@ -168,7 +166,6 @@ class TestJujuUtils(ut_utils.BaseTestCase):
self.model.get_first_unit_name.assert_called()
def test_get_relation_from_unit(self):
self.patch_object(juju_utils, 'lifecycle_utils')
self.patch_object(juju_utils, '_get_unit_names')
self.patch_object(juju_utils, 'yaml')
self.patch_object(juju_utils, 'model')
@@ -179,12 +176,11 @@ class TestJujuUtils(ut_utils.BaseTestCase):
juju_utils.get_relation_from_unit('aunit/0', 'otherunit/0',
'arelation')
self.model.run_on_unit.assert_called_with(
self.lifecycle_utils.get_juju_model(), 'aunit/0',
'aunit/0',
'relation-get --format=yaml -r "42" - "otherunit/0"')
self.yaml.load.assert_called_with(str(data))
def test_get_relation_from_unit_fails(self):
self.patch_object(juju_utils, 'lifecycle_utils')
self.patch_object(juju_utils, '_get_unit_names')
self.patch_object(juju_utils, 'yaml')
self.patch_object(juju_utils, 'model')
@@ -195,6 +191,6 @@ class TestJujuUtils(ut_utils.BaseTestCase):
juju_utils.get_relation_from_unit('aunit/0', 'otherunit/0',
'arelation')
self.model.run_on_unit.assert_called_with(
self.lifecycle_utils.get_juju_model(), 'aunit/0',
'aunit/0',
'relation-get --format=yaml -r "42" - "otherunit/0"')
self.assertFalse(self.yaml.load.called)

2
unit_tests/utils.py
View File

@@ -47,6 +47,7 @@ class BaseTestCase(unittest.TestCase):
def tearDown(self):
for k, v in self._patches.items():
print("Stopping patch {} {}".format(k, v))
v.stop()
setattr(self, k, None)
self._patches = None
@@ -65,6 +66,7 @@ class BaseTestCase(unittest.TestCase):
if new is None:
started.return_value = return_value
self._patches_start[name] = started
print("Starting patch {}".format(name))
setattr(self, name, started)
def patch(self, item, return_value=None, name=None, new=None, **kwargs):

3
zaza/charm_lifecycle/configure.py
View File

@@ -4,6 +4,7 @@ import argparse
import logging
import sys
import zaza.model
import zaza.charm_lifecycle.utils as utils
@@ -26,7 +27,7 @@ def configure(model_name, functions):
:param functions: List of configure functions functions
:type tests: ['zaza.charms_tests.svc.setup', ...]
"""
utils.set_juju_model(model_name)
zaza.model.set_juju_model(model_name)
run_configure_list(functions)

2
zaza/charm_lifecycle/deploy.py
View File

@@ -225,7 +225,7 @@ def deploy(bundle, model, wait=True):
if wait:
test_config = utils.get_charm_config()
logging.info("Waiting for environment to settle")
utils.set_juju_model(model)
zaza.model.set_juju_model(model)
zaza.model.wait_for_application_states(
model,
test_config.get('target_deploy_status', {}))

29
zaza/charm_lifecycle/utils.py
View File

@@ -1,10 +1,7 @@
"""Utilities to support running lifecycle phases."""
import importlib
import os
import yaml
from zaza import model
BUNDLE_DIR = "./tests/bundles/"
DEFAULT_TEST_CONFIG = "./tests/tests.yaml"
@@ -38,29 +35,3 @@ def get_class(class_str):
class_name = class_str.split('.')[-1]
module = importlib.import_module(module_name)
return getattr(module, class_name)
def set_juju_model(model_name):
"""Point environment at the given model.
:param model_name: Model to point environment at
:type model_name: str
"""
os.environ["JUJU_MODEL"] = model_name
def get_juju_model():
"""Retrieve current model.
First check the environment for JUJU_MODEL. If this is not set, get the
current active model.
:returns: In focus model name
:rtype: str
"""
try:
# Check the environment
return os.environ["JUJU_MODEL"]
except KeyError:
# If unset connect get the current active model
return model.get_current_model()

4
zaza/charm_tests/dragent/test.py
View File

@@ -6,7 +6,6 @@ import sys
import tenacity
from zaza import model
from zaza.charm_lifecycle import utils as lifecycle_utils
from zaza.utilities import (
cli as cli_utils,
juju as juju_utils,
@@ -35,8 +34,7 @@ def test_bgp_routes(peer_application_name="quagga", keystone_session=None):
keystone_session)
# Get the peer unit
peer_unit = model.get_units(
lifecycle_utils.get_juju_model(), peer_application_name)[0].entity_id
peer_unit = model.get_units(peer_application_name)[0].entity_id
# Get expected advertised routes
private_cidr = neutron_client.list_subnets(

3
zaza/charm_tests/test_utils.py
View File

@@ -11,7 +11,6 @@ def skipIfNotHA(service_name):
def _skipIfNotHA_inner_1(f):
def _skipIfNotHA_inner_2(*args, **kwargs):
ips = zaza.model.get_app_ips(
lifecycle_utils.get_juju_model(),
service_name)
if len(ips) > 1:
return f(*args, **kwargs)
@@ -29,7 +28,7 @@ class OpenStackBaseTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.keystone_session = openstack_utils.get_overcloud_keystone_session()
cls.model_name = lifecycle_utils.get_juju_model()
cls.model_name = model.get_juju_model()
cls.test_config = lifecycle_utils.get_charm_config()
cls.application_name = cls.test_config['charm_name']
cls.first_unit = model.get_first_unit_name(

6
zaza/charm_tests/vault/tests.py
View File

@@ -28,13 +28,11 @@ class VaultTest(unittest.TestCase):
def test_csr(self):
vault_actions = zaza.model.get_actions(
lifecycle_utils.get_juju_model(),
'vault')
if 'get-csr' not in vault_actions:
raise unittest.SkipTest('Action not defined')
try:
zaza.model.get_application(
lifecycle_utils.get_juju_model(),
'keystone')
except KeyError:
raise unittest.SkipTest('No client to test csr')
@@ -59,15 +57,12 @@ class VaultTest(unittest.TestCase):
test_config = lifecycle_utils.get_charm_config()
del test_config['target_deploy_status']['vault']
zaza.model.block_until_file_has_contents(
lifecycle_utils.get_juju_model(),
'keystone',
'/usr/local/share/ca-certificates/keystone_juju_ca_cert.crt',
cacert.decode().strip())
zaza.model.wait_for_application_states(
lifecycle_utils.get_juju_model(),
test_config.get('target_deploy_status', {}))
ip = zaza.model.get_app_ips(
lifecycle_utils.get_juju_model(),
'keystone')[0]
with tempfile.NamedTemporaryFile(mode='w') as fp:
fp.write(cacert.decode())
@@ -127,7 +122,6 @@ class VaultTest(unittest.TestCase):
def test_vault_authorize_charm_action(self):
vault_actions = zaza.model.get_actions(
lifecycle_utils.get_juju_model(),
'vault')
if 'authorize-charm' not in vault_actions:
raise unittest.SkipTest('Action not defined')

15
zaza/charm_tests/vault/utils.py
View File

@@ -10,7 +10,6 @@ import yaml
import collections
import zaza.charm_lifecycle.utils as utils
import zaza.model
AUTH_FILE = "vault_tests.yaml"
@@ -47,8 +46,7 @@ def get_vip_client():
:rtype: CharmVaultClient or None
"""
client = None
vault_config = zaza.model.get_application_config(
utils.get_juju_model(), 'vault')
vault_config = zaza.model.get_application_config('vault')
vip = vault_config.get('vip', {}).get('value')
if vip:
client = CharmVaultClient(
@@ -82,7 +80,7 @@ def get_clients(units=None):
:rtype: [CharmVaultClient, ...]
"""
if not units:
units = zaza.model.get_app_ips(utils.get_juju_model(), 'vault')
units = zaza.model.get_app_ips('vault')
clients = []
for unit in units:
vault_url = get_unit_api_url(unit)
@@ -124,11 +122,10 @@ def get_credentails():
:returns: Tokens and keys for accessing test environment
:rtype: dict
"""
unit = zaza.model.get_first_unit_name(utils.get_juju_model(), 'vault')
unit = zaza.model.get_first_unit_name('vault')
with tempfile.TemporaryDirectory() as tmpdirname:
tmp_file = '{}/{}'.format(tmpdirname, AUTH_FILE)
zaza.model.scp_from_unit(
utils.get_juju_model(),
unit,
'~/{}'.format(AUTH_FILE),
tmp_file)
@@ -144,12 +141,11 @@ def store_credentails(creds):
:param creds: Keys and token to store
:type creds: dict
"""
unit = zaza.model.get_first_unit_name(utils.get_juju_model(), 'vault')
unit = zaza.model.get_first_unit_name('vault')
with tempfile.NamedTemporaryFile(mode='w') as fp:
fp.write(yaml.dump(creds))
fp.flush()
zaza.model.scp_to_unit(
utils.get_juju_model(),
unit,
fp.name,
'~/{}'.format(AUTH_FILE))
@@ -205,7 +201,6 @@ def auth_all(clients, token):
def run_charm_authorize(token):
return zaza.model.run_action_on_leader(
utils.get_juju_model(),
'vault',
'authorize-charm',
action_params={'token': token})
@@ -213,7 +208,6 @@ def run_charm_authorize(token):
def run_get_csr():
return zaza.model.run_action_on_leader(
utils.get_juju_model(),
'vault',
'get-csr',
action_params={})
@@ -221,7 +215,6 @@ def run_get_csr():
def run_upload_signed_csr(pem, root_ca, allowed_domains):
return zaza.model.run_action_on_leader(
utils.get_juju_model(),
'vault',
'upload-signed-csr',
action_params={

128
zaza/model.py
View File

@@ -13,6 +13,39 @@ from juju.model import Model
from zaza import sync_wrapper
CURRENT_MODEL = None
def set_juju_model(model_name):
"""Point environment at the given model
:param model_name: Model to point environment at
:type model_name: str
"""
os.environ["JUJU_MODEL"] = model_name
def get_juju_model():
"""Retrieve current model
First check the environment for JUJU_MODEL. If this is not set, get the
current active model.
:returns: In focus model name
:rtype: str
"""
if CURRENT_MODEL:
return CURRENT_MODEL
# LY: I think we should remove the KeyError handling. I don't think we
# should ever fall back to the model in focus because it will lead
# to functions being added which do not explicitly set a model and
# zaza will loose the ability to do concurrent runs.
try:
# Check the environment
return os.environ["JUJU_MODEL"]
except KeyError:
# If unset connect get the current active model
return get_current_model()
async def deployed(filter=None):
# Create a Model instance. We need to connect our Model to a Juju api
@@ -63,12 +96,14 @@ async def run_in_model(model_name):
:rtype: Iterator[:class:'juju.Model()']
"""
model = Model()
if not model_name:
model_name = get_juju_model()
await model.connect_model(model_name)
await yield_(model)
await model.disconnect()
async def async_scp_to_unit(model_name, unit_name, source, destination,
async def async_scp_to_unit(unit_name, source, destination, model_name=None,
user='ubuntu', proxy=False, scp_opts=''):
"""Transfer files to unit_name in model_name.
@@ -95,8 +130,8 @@ async def async_scp_to_unit(model_name, unit_name, source, destination,
scp_to_unit = sync_wrapper(async_scp_to_unit)
async def async_scp_to_all_units(model_name, application_name, source,
destination, user='ubuntu', proxy=False,
async def async_scp_to_all_units(application_name, source, destination,
model_name=None, user='ubuntu', proxy=False,
scp_opts=''):
"""Transfer files from to all units of an application
@@ -124,7 +159,7 @@ async def async_scp_to_all_units(model_name, application_name, source,
scp_to_all_units = sync_wrapper(async_scp_to_all_units)
async def async_scp_from_unit(model_name, unit_name, source, destination,
async def async_scp_from_unit(unit_name, source, destination, model_name=None,
user='ubuntu', proxy=False, scp_opts=''):
"""Transfer files from to unit_name in model_name.
@@ -152,7 +187,7 @@ async def async_scp_from_unit(model_name, unit_name, source, destination,
scp_from_unit = sync_wrapper(async_scp_from_unit)
async def async_run_on_unit(model_name, unit_name, command, timeout=None):
async def async_run_on_unit(unit_name, command, model_name=None, timeout=None):
"""Juju run on unit
:param model_name: Name of model unit is in
@@ -177,7 +212,7 @@ async def async_run_on_unit(model_name, unit_name, command, timeout=None):
run_on_unit = sync_wrapper(async_run_on_unit)
async def async_get_unit_time(model_name, unit_name, timeout=None):
async def async_get_unit_time(unit_name, model_name=None, timeout=None):
""" Get the current time (in seconds since Epoch) on the given unit
:param model_name: Name of model to query.
@@ -197,8 +232,8 @@ async def async_get_unit_time(model_name, unit_name, timeout=None):
get_unit_time = sync_wrapper(async_get_unit_time)
async def async_get_unit_service_start_time(model_name, unit_name, service,
timeout=None):
async def async_get_unit_service_start_time(unit_name, service,
model_name=None, timeout=None):
"""Return the time that the given service was started on a unit.
Return the time (in seconds since Epoch) that the given service was
@@ -228,7 +263,7 @@ async def async_get_unit_service_start_time(model_name, unit_name, service,
get_unit_service_start_time = sync_wrapper(async_get_unit_service_start_time)
async def async_get_application(model_name, application_name):
async def async_get_application(application_name, model_name=None):
"""Return an application object
:param model_name: Name of model to query.
@@ -244,7 +279,7 @@ async def async_get_application(model_name, application_name):
get_application = sync_wrapper(async_get_application)
async def async_get_units(model_name, application_name):
async def async_get_units(application_name, model_name=None):
"""Return all the units of a given application
:param model_name: Name of model to query.
@@ -260,7 +295,7 @@ async def async_get_units(model_name, application_name):
get_units = sync_wrapper(async_get_units)
async def async_get_machines(model_name, application_name):
async def async_get_machines(application_name, model_name=None):
"""Return all the machines of a given application
:param model_name: Name of model to query.
@@ -279,7 +314,7 @@ async def async_get_machines(model_name, application_name):
get_machines = sync_wrapper(async_get_machines)
def get_first_unit_name(model_name, application_name):
def get_first_unit_name(application_name, model_name=None):
"""Return name of lowest numbered unit of given application
:param model_name: Name of model to query.
@@ -292,7 +327,7 @@ def get_first_unit_name(model_name, application_name):
return get_units(model_name, application_name)[0].name
def get_app_ips(model_name, application_name):
def get_app_ips(application_name, model_name=None):
"""Return public address of all units of an application
:param model_name: Name of model to query.
@@ -305,7 +340,7 @@ def get_app_ips(model_name, application_name):
return [u.public_address for u in get_units(model_name, application_name)]
async def async_get_application_config(model_name, application_name):
async def async_get_application_config(application_name, model_name=None):
"""Return application configuration
:param model_name: Name of model to query.
@@ -321,8 +356,8 @@ async def async_get_application_config(model_name, application_name):
get_application_config = sync_wrapper(async_get_application_config)
async def async_set_application_config(model_name, application_name,
configuration):
async def async_set_application_config(application_name, configuration,
model_name=None):
"""Set application configuration
:param model_name: Name of model to query.
@@ -339,7 +374,7 @@ async def async_set_application_config(model_name, application_name,
set_application_config = sync_wrapper(async_set_application_config)
async def async_get_status(model_name):
async def async_get_status(model_name=None):
"""Return full status
:param model_name: Name of model to query.
@@ -353,7 +388,7 @@ async def async_get_status(model_name):
get_status = sync_wrapper(async_get_status)
async def async_run_action(model_name, unit_name, action_name,
async def async_run_action(unit_name, action_name, model_name=None,
action_params=None):
"""Run action on given unit
@@ -377,8 +412,8 @@ async def async_run_action(model_name, unit_name, action_name,
run_action = sync_wrapper(async_run_action)
async def async_run_action_on_leader(model_name, application_name, action_name,
action_params=None):
async def async_run_action_on_leader(application_name, action_name,
model_name=None, action_params=None):
"""Run action on lead unit of the given application
:param model_name: Name of model to query.
@@ -501,7 +536,7 @@ def check_unit_workload_status_message(model, unit, message=None,
raise ValueError("Must be called with message or prefixes")
async def async_wait_for_application_states(model_name, states=None,
async def async_wait_for_application_states(model_name=None, states=None,
timeout=2700):
"""Wait for model to achieve the desired state
@@ -568,7 +603,7 @@ async def async_wait_for_application_states(model_name, states=None,
wait_for_application_states = sync_wrapper(async_wait_for_application_states)
async def async_block_until_all_units_idle(model_name, timeout=2700):
async def async_block_until_all_units_idle(model_name=None, timeout=2700):
"""Block until all units in the given model are idle
An example accessing this function via its sync wrapper::
@@ -587,8 +622,8 @@ async def async_block_until_all_units_idle(model_name, timeout=2700):
block_until_all_units_idle = sync_wrapper(async_block_until_all_units_idle)
async def async_block_until_service_status(model_name, unit_name, services,
target_status, timeout=2700):
async def async_block_until_service_status(unit_name, services, target_status,
model_name=None, timeout=2700):
"""Block until all services on the unit are in the desired state.
Block until all services on the unit are in the desired state (stopped
@@ -630,7 +665,7 @@ async def async_block_until_service_status(model_name, unit_name, services,
block_until_service_status = sync_wrapper(async_block_until_service_status)
def get_actions(model_name, application_name):
def get_actions(application_name, model_name=None):
"""Get the actions an applications supports
:param model_name: Name of model to query.
@@ -640,6 +675,8 @@ def get_actions(model_name, application_name):
:returns: Dictionary of actions and their descriptions
:rtype: dict
"""
if not model_name:
model_name = get_juju_model()
# libjuju has not implemented get_actions yet
# https://github.com/juju/python-libjuju/issues/226
cmd = ['juju', 'actions', '-m', model_name, application_name,
@@ -696,8 +733,8 @@ async def async_block_until(*conditions, timeout=None, wait_period=0.5,
await asyncio.wait_for(_block(), timeout, loop=loop)
async def async_block_until_file_ready(model_name, application_name,
remote_file, check_function,
async def async_block_until_file_ready(application_name, remote_file,
check_function, model_name=None,
timeout=2700):
"""Block until the check_function passes against.
@@ -740,9 +777,9 @@ async def async_block_until_file_ready(model_name, application_name,
await async_block_until(_check_file, timeout=timeout)
async def async_block_until_file_has_contents(model_name, application_name,
remote_file, expected_contents,
timeout=2700):
async def async_block_until_file_has_contents(application_name, remote_file,
expected_contents,
model_name=None, timeout=2700):
"""Block until the expected_contents are present on all units
Block until the given string (expected_contents) is present in the file
@@ -770,17 +807,21 @@ async def async_block_until_file_has_contents(model_name, application_name,
"""
def f(x):
return expected_contents in x
return await async_block_until_file_ready(model_name, application_name,
remote_file, f, timeout)
return await async_block_until_file_ready(
application_name,
remote_file,
f,
timeout=timeout,
model_name=model_name)
block_until_file_has_contents = sync_wrapper(
async_block_until_file_has_contents)
async def async_block_until_oslo_config_entries_match(model_name,
application_name,
async def async_block_until_oslo_config_entries_match(application_name,
remote_file,
expected_contents,
model_name=None,
timeout=2700):
"""Block until dict is represented in the file using oslo.config parser
@@ -835,16 +876,21 @@ async def async_block_until_oslo_config_entries_match(model_name,
if sections.get(section, {}).get(key) != value:
return False
return True
return await async_block_until_file_ready(model_name, application_name,
remote_file, f, timeout)
return await async_block_until_file_ready(
application_name,
remote_file,
f,
timeout=timeout,
model_name=model_name)
block_until_oslo_config_entries_match = sync_wrapper(
async_block_until_oslo_config_entries_match)
async def async_block_until_services_restarted(model_name, application_name,
mtime, services, timeout=2700):
async def async_block_until_services_restarted(application_name, mtime,
services, model_name=None,
timeout=2700):
"""Block until the given services have a start time later then mtime
For example to check that the glance-api service has been restarted::
@@ -888,7 +934,7 @@ block_until_services_restarted = sync_wrapper(
async_block_until_services_restarted)
async def async_block_until_unit_wl_status(model_name, unit_name, status,
async def async_block_until_unit_wl_status(unit_name, status, model_name=None,
timeout=2700):
"""Block until the given unit has the desired workload status
@@ -920,8 +966,8 @@ block_until_unit_wl_status = sync_wrapper(
async_block_until_unit_wl_status)
async def async_get_relation_id(model_name, application_name,
remote_application_name,
async def async_get_relation_id(application_name, remote_application_name,
model_name=None,
remote_interface_name=None):
"""
Get relation id of relation from model

4
zaza/utilities/generic.py
View File

@@ -5,7 +5,6 @@ import os
import yaml
from zaza import model
from zaza.charm_lifecycle import utils as lifecycle_utils
from zaza.utilities import juju as juju_utils
@@ -63,8 +62,7 @@ def get_pkg_version(application, pkg):
:rtype: list
"""
versions = []
units = model.get_units(
lifecycle_utils.get_juju_model(), application)
units = model.get_units(application)
for unit in units:
cmd = 'dpkg -l | grep {}'.format(pkg)
out = juju_utils.remote_run(unit.entity_id, cmd)

21
zaza/utilities/juju.py
View File

@@ -22,7 +22,6 @@ from zaza import (
model,
controller,
)
from zaza.charm_lifecycle import utils as lifecycle_utils
from zaza.utilities import generic as generic_utils
@@ -73,7 +72,7 @@ def get_full_juju_status():
:returns: Full juju status output
:rtype: dict
"""
status = model.get_status(lifecycle_utils.get_juju_model())
status = model.get_status()
return status
@@ -165,10 +164,7 @@ def remote_run(unit, remote_cmd, timeout=None, fatal=None):
"""
if fatal is None:
fatal = True
result = model.run_on_unit(lifecycle_utils.get_juju_model(),
unit,
remote_cmd,
timeout=timeout)
result = model.run_on_unit(unit, remote_cmd, timeout=timeout)
if result:
if int(result.get("Code")) == 0:
return result.get("Stdout")
@@ -195,9 +191,7 @@ def _get_unit_names(names):
if '/' in name:
result.append(name)
else:
result.append(
model.get_first_unit_name(lifecycle_utils.get_juju_model(),
name))
result.append(model.get_first_unit_name(name))
return result
@@ -223,15 +217,12 @@ def get_relation_from_unit(entity, remote_entity, remote_interface_name):
"""
application = entity.split('/')[0]
remote_application = remote_entity.split('/')[0]
rid = model.get_relation_id(lifecycle_utils.get_juju_model(), application,
remote_application,
rid = model.get_relation_id(application, remote_application,
remote_interface_name=remote_interface_name)
(unit, remote_unit) = _get_unit_names([entity, remote_entity])
result = model.run_on_unit(
lifecycle_utils.get_juju_model(), unit,
'relation-get --format=yaml -r "{}" - "{}"'
.format(rid, remote_unit)
)
unit,
'relation-get --format=yaml -r "{}" - "{}"' .format(rid, remote_unit))
if result and int(result.get('Code')) == 0:
return yaml.load(result.get('Stdout'))
else:

15
zaza/utilities/openstack.py
View File

@@ -30,7 +30,6 @@ import tenacity
import urllib
from zaza import model
from zaza.charm_lifecycle import utils as lifecycle_utils
from zaza.utilities import (
exceptions,
generic as generic_utils,
@@ -413,7 +412,7 @@ def configure_gateway_ext_port(novaclient, neutronclient,
logging.info('Config already set to value')
return
model.set_application_config(
lifecycle_utils.get_juju_model(), application_name,
application_name,
configuration={config_key: ext_br_macs_str})
juju_wait.wait(wait_for_workload=True)
@@ -848,8 +847,7 @@ def create_bgp_peer(neutron_client, peer_application_name='quagga',
:returns: BGP peer object
:rtype: dict
"""
peer_unit = model.get_units(
lifecycle_utils.get_juju_model(), peer_application_name)[0]
peer_unit = model.get_units(peer_application_name)[0]
peer_ip = peer_unit.public_address
bgp_peers = neutron_client.list_bgp_peers(name=peer_application_name)
if len(bgp_peers['bgp_peers']) == 0:
@@ -1086,8 +1084,7 @@ def get_application_config_keys(application):
:returns: List of aplication configuration keys
:rtype: list
"""
application_config = model.get_application_config(
lifecycle_utils.get_juju_model(), application)
application_config = model.get_application_config(application)
return list(application_config.keys())
@@ -1101,8 +1098,7 @@ def get_application_config_option(application, option):
:returns: Value of configuration option
:rtype: Configuration option value type
"""
application_config = model.get_application_config(
lifecycle_utils.get_juju_model(), application)
application_config = model.get_application_config(application)
try:
return application_config.get(option).get('value')
except AttributeError:
@@ -1184,8 +1180,7 @@ def get_keystone_ip():
"""
if get_application_config_option('keystone', 'vip'):
return get_application_config_option('keystone', 'vip')
unit = model.get_units(
lifecycle_utils.get_juju_model(), 'keystone')[0]
unit = model.get_units('keystone')[0]
return unit.public_address