def configure_cinder_backup(): """Configure cinder-backup-swift-proxy.""" keystone_ip = zaza_model.get_app_ips( 'swift-keystone')[0] swift_ip = zaza_model.get_app_ips( 'swift-proxy')[0] auth_ver = (zaza_model.get_application_config('swift-keystone') .get('preferred-api-version').get('value')) if auth_ver == 2: auth_url = 'http://{}:5000/v2.0'.format(keystone_ip) endpoint_url = 'http://{}:8080/v1/AUTH_'.format(swift_ip) else: auth_url = 'http://{}:5000/v3'.format(keystone_ip) endpoint_url = 'http://{}:8080/v1/AUTH'.format(swift_ip) cinder_backup_swift_proxy_conf = { 'endpoint-url': endpoint_url, 'auth-url': auth_url } juju_service = 'cinder-backup-swift-proxy' zaza_model.set_application_config(juju_service, cinder_backup_swift_proxy_conf) zaza_model.wait_for_agent_status() zaza_model.wait_for_application_states() _singleton = zaza.openstack.charm_tests.test_utils.OpenStackBaseTest() _singleton.setUpClass() with _singleton.config_change(cinder_backup_swift_proxy_conf, cinder_backup_swift_proxy_conf): # wait for configuration to be applied then return pass
def nfs_setup(): """Run setup for testing Trilio. Setup for testing Trilio is currently part of functional tests. """ logging.info("Configuring NFS Server") nfs_server_ip = zaza_model.get_app_ips("nfs-server-test-fixture")[0] trilio_wlm_unit = zaza_model.get_first_unit_name("trilio-wlm") nfs_shares_conf = {"nfs-shares": "{}:/srv/testing".format(nfs_server_ip)} logging.info("NFS share config: {}".format(nfs_shares_conf)) _trilio_services = ["trilio-wlm", "trilio-data-mover"] conf_changed = False for juju_service in _trilio_services: app_config = zaza_model.get_application_config(juju_service) if app_config["nfs-shares"] != nfs_shares_conf["nfs-shares"]: logging.info("Updating nfs-shares config option") zaza_model.set_application_config(juju_service, nfs_shares_conf) conf_changed = True if conf_changed: zaza_model.wait_for_agent_status() # NOTE(jamespage): wlm-api service must be running in order # to execute the setup actions zaza_model.block_until_service_status( unit_name=trilio_wlm_unit, services=["wlm-api"], target_status="active", )
def basic_setup(): """Run setup for testing Trilio. Setup for testing Trilio is currently part of functional tests. """ logging.info("Configuring NFS Server") nfs_server_ip = zaza_model.get_app_ips("nfs-server-test-fixture")[0] trilio_wlm_unit = zaza_model.get_first_unit_name("trilio-wlm") nfs_shares_conf = {"nfs-shares": "{}:/srv/testing".format(nfs_server_ip)} _trilio_services = ["trilio-wlm", "trilio-data-mover"] conf_changed = False for juju_service in _trilio_services: app_config = zaza_model.get_application_config(juju_service) if app_config["nfs-shares"] != nfs_shares_conf["nfs-shares"]: zaza_model.set_application_config(juju_service, nfs_shares_conf) conf_changed = True if conf_changed: zaza_model.wait_for_agent_status() # NOTE(jamespage): wlm-api service must be running in order # to execute the setup actions zaza_model.block_until_service_status( unit_name=trilio_wlm_unit, services=["wlm-api"], target_status="active", ) logging.info("Executing create-cloud-admin-trust") password = juju_utils.leader_get("keystone", "admin_passwd") generic_utils.assertActionRanOK( zaza_model.run_action_on_leader( "trilio-wlm", "create-cloud-admin-trust", raise_on_failure=True, action_params={"password": password}, ) ) logging.info("Executing create-license") test_license = os.environ.get("TEST_TRILIO_LICENSE") if test_license and os.path.exists(test_license): zaza_model.attach_resource("trilio-wlm", resource_name='license', resource_path=test_license) generic_utils.assertActionRanOK( zaza_model.run_action_on_leader( "trilio-wlm", "create-license", raise_on_failure=True ) ) else: logging.error("Unable to find Trilio License file")
def test_wait_for_agent_status_timeout(self): 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 with self.assertRaises(asyncio.futures.TimeoutError): model.wait_for_agent_status(timeout=0.1)
def test_wait_for_agent_status(self): 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.unit1.data = {'agent-status': {'current': 'idle'}} self.unit2.data = {'agent-status': {'current': 'executing'}} self.Model.return_value = self.Model_mock self.Model_mock.block_until.side_effect = _block_until model.wait_for_agent_status(timeout=0.1)
def configure_external_s3_backend(): """Set up Ceph-radosgw as an external S3 backend for Glance.""" logging.info("Creating a test S3 user and credentials for Glance") username, displayname = "zaza-glance-test", "Zaza Glance Test User" cmd = "radosgw-admin user create --uid='{}' --display-name='{}'".format( username, displayname) results = model.run_on_leader("ceph-mon", cmd) stdout = json.loads(results["stdout"]) keys = stdout["keys"][0] access_key, secret_key = keys["access_key"], keys["secret_key"] logging.info("Getting S3 endpoint URL of Radosgw from Keystone") keystone_auth = openstack_utils.get_overcloud_auth() keystone_client = openstack_utils.get_keystone_client(keystone_auth) endpoint_url = keystone_client.session.get_endpoint( service_type="s3", interface="public", region="RegionOne", ) logging.info("Creating a test S3 bucket for Glance") bucket_name = "zaza-glance-s3-test" s3_client = boto3.client( "s3", endpoint_url=endpoint_url, aws_access_key_id=access_key, aws_secret_access_key=secret_key, ) s3_client.create_bucket(Bucket=bucket_name) logging.info("Updating Glance configs with S3 endpoint information") model.set_application_config( "glance", { "s3-store-host": endpoint_url, "s3-store-access-key": access_key, "s3-store-secret-key": secret_key, "s3-store-bucket": bucket_name, }, ) model.wait_for_agent_status() logging.info("Waiting for units to reach target states") model.wait_for_application_states( states={ "glance": { "workload-status": "active", "workload-status-message": "Unit is ready", } }) model.block_until_all_units_idle()
def configure_s3_backend(): """Inject S3 parameters from Swift for Gnocchi config.""" session = openstack_utils.get_overcloud_keystone_session() ks_client = openstack_utils.get_keystone_session_client(session) logging.info('Retrieving S3 connection data from Swift') token_data = ks_client.tokens.get_token_data(session.get_token()) project_id = token_data['token']['project']['id'] user_id = token_data['token']['user']['id'] # Store URL to service providing S3 compatible API for entry in token_data['token']['catalog']: if entry['type'] == 's3': for endpoint in entry['endpoints']: if endpoint['interface'] == 'public': s3_region = endpoint['region'] s3_endpoint = endpoint['url'] # Create AWS compatible application credentials in Keystone ec2_creds = ks_client.ec2.create(user_id, project_id) logging.info('Changing Gnocchi charm config to connect to S3') model.set_application_config( 'gnocchi', { 's3-endpoint-url': s3_endpoint, 's3-region-name': s3_region, 's3-access-key-id': ec2_creds.access, 's3-secret-access-key': ec2_creds.secret }) logging.info('Waiting for units to execute config-changed hook') model.wait_for_agent_status() logging.info('Waiting for units to reach target states') model.wait_for_application_states( states={ 'gnocchi': { 'workload-status-': 'active', 'workload-status-message': 'Unit is ready' }, 'ceilometer': { 'workload-status': 'blocked', 'workload-status-message': 'Run the ' + 'ceilometer-upgrade action on the leader ' + 'to initialize ceilometer and gnocchi' } }) model.block_until_all_units_idle()
def upgrade_non_base_services(juju_status=None, switch=None): if not juju_status: juju_status = get_juju_status() # Upgrade the rest for svc in juju_status['applications']: if svc not in BASE_CHARMS: charm_name = charm_to_charm_name( juju_status['applications'][svc]['charm']) upgrade_service(svc, charm_name=charm_name, switch=switch) model.wait_for_agent_status(status='executing') if not model.get_relation_id('rabbitmq-server', 'ceilometer-agent', remote_interface_name='amqp'): logging.info("Adding rabbitmq-server ceilometer-agent relation") model.add_relation('ceilometer-agent', 'amqp', 'rabbitmq-server:amqp') model.wait_for_agent_status(status='executing') if not model.get_relation_id('memcached', 'nova-cloud-controller', remote_interface_name='memcache'): logging.info("Adding nova-cloud-controller memcached relation") model.add_relation('memcached', 'nova-cloud-controller', 'nova-cloud-controller:memcache') model.wait_for_agent_status(status='executing') logging.info("Waiting for units to be idle") model.block_until_all_units_idle()
def _set_config(self, state): s = "True" if state else "False" config = {"use-policyd-override": s} logging.info("Setting config to {}".format(config)) zaza_model.set_application_config(self.application_name, config) zaza_model.wait_for_agent_status()
def config_change(self, default_config, alternate_config, application_name=None): """Run change config tests. Change config to `alternate_config`, wait for idle workload status, yield, return config to `default_config` and wait for idle workload status before return from function. Example usage: with self.config_change({'preferred-api-version': '2'}, {'preferred-api-version': '3'}): do_something() :param default_config: Dict of charm settings to set on completion :type default_config: dict :param alternate_config: Dict of charm settings to change to :type alternate_config: dict :param application_name: String application name for use when called by a charm under test other than the object's application. :type application_name: str """ if not application_name: application_name = self.application_name # we need to compare config values to what is already applied before # attempting to set them. otherwise the model will behave differently # than we would expect while waiting for completion of the change app_config = self.config_current(application_name, keys=alternate_config.keys()) if all(item in app_config.items() for item in alternate_config.items()): logging.debug('alternate_config equals what is already applied ' 'config') yield if default_config == alternate_config: logging.debug('default_config also equals what is already ' 'applied config') return logging.debug('alternate_config already set, and default_config ' 'needs to be applied before return') else: logging.debug( 'Changing charm setting to {}'.format(alternate_config)) model.set_application_config( application_name, self._stringed_value_config(alternate_config), model_name=self.model_name) logging.debug('Waiting for units to execute config-changed hook') model.wait_for_agent_status(model_name=self.model_name) logging.debug('Waiting for units to reach target states') model.wait_for_application_states(model_name=self.model_name, states=self.test_config.get( 'target_deploy_status', {})) # TODO: Optimize with a block on a specific application until idle. model.block_until_all_units_idle() yield logging.debug('Restoring charm setting to {}'.format(default_config)) model.set_application_config( application_name, self._stringed_value_config(default_config), model_name=self.model_name) logging.debug('Waiting for units to reach target states') model.wait_for_application_states(model_name=self.model_name, states=self.test_config.get( 'target_deploy_status', {})) # TODO: Optimize with a block on a specific application until idle. model.block_until_all_units_idle()
def config_change(self, default_config, alternate_config): """Run change config tests. Change config to `alternate_config`, wait for idle workload status, yield, return config to `default_config` and wait for idle workload status before return from function. Example usage: with self.config_change({'preferred-api-version': '2'}, {'preferred-api-version': '3'}): do_something() :param default_config: Dict of charm settings to set on completion :type default_config: dict :param alternate_config: Dict of charm settings to change to :type alternate_config: dict """ # we need to compare config values to what is already applied before # attempting to set them. otherwise the model will behave differently # than we would expect while waiting for completion of the change _app_config = model.get_application_config(self.application_name) app_config = {} # convert the more elaborate config structure from libjuju to something # we can compare to what the caller supplies to this function for k in alternate_config.keys(): # note that conversion to string for all values is due to # attempting to set any config with other types lead to Traceback app_config[k] = str(_app_config.get(k, {}).get('value', '')) if all(item in app_config.items() for item in alternate_config.items()): logging.debug('alternate_config equals what is already applied ' 'config') yield if default_config == alternate_config: logging.debug('default_config also equals what is already ' 'applied config') return logging.debug('alternate_config already set, and default_config ' 'needs to be applied before return') else: logging.debug( 'Changing charm setting to {}'.format(alternate_config)) model.set_application_config(self.application_name, alternate_config, model_name=self.model_name) logging.debug('Waiting for units to execute config-changed hook') model.wait_for_agent_status(model_name=self.model_name) logging.debug('Waiting for units to reach target states') model.wait_for_application_states(model_name=self.model_name, states=self.test_config.get( 'target_deploy_status', {})) # TODO: Optimize with a block on a specific application until idle. model.block_until_all_units_idle() yield logging.debug('Restoring charm setting to {}'.format(default_config)) model.set_application_config(self.application_name, default_config, model_name=self.model_name) logging.debug('Waiting for units to reach target states') model.wait_for_application_states(model_name=self.model_name, states=self.test_config.get( 'target_deploy_status', {})) # TODO: Optimize with a block on a specific application until idle. model.block_until_all_units_idle()