def _bootstrap(self, blueprint_path, inputs_path=None, install_plugins=None, keep_up_on_failure=False, validate_only=False, task_retries=5, task_retry_interval=90, subgraph_retries=2, verbose=False, create_rest_client_func=None): if install_plugins is None: install_plugins = test_environment.install_plugins cfy = get_cfy() cfy.init(reset_context=True) with YamlPatcher(CLOUDIFY_CONFIG_PATH) as patch: prop_path = ('local_provider_context.' 'cloudify.workflows.subgraph_retries') patch.set_value(prop_path, subgraph_retries) if not validate_only: # TODO: add manager_blueprint_path and inputs path arguments to # openstack_plugin try: self.before_bootstrap( manager_blueprint_path=blueprint_path, inputs_path=inputs_path) except TypeError: self.before_bootstrap() cfy.bootstrap( blueprint_path, inputs=inputs_path, install_plugins=install_plugins, keep_up_on_failure=keep_up_on_failure, validate_only=validate_only, task_retries=task_retries, task_retry_interval=task_retry_interval, verbose=verbose, ) if not validate_only: self._upload_plugins() self._running_env_setup(get_profile_context().manager_ip, create_rest_client_func) # A hacky workaround where a test bootstraps a manager # using simple manager blueprint and provider context does # not contain a 'resources' key as expected by openstack's # handler after_bootstrap method. # should be probably handled better. if 'simple' not in path(blueprint_path).basename(): self.after_bootstrap(get_profile_context().provider_context)
def teardown(self): if self._global_cleanup_context is None: return self.setup() cfy = get_cfy() try: cfy.use(self.management_ip) cfy.teardown(force=True, verbose=True, ignore_deployments=True) finally: self._global_cleanup_context.cleanup() self.handler.after_teardown() if os.path.exists(self._workdir): shutil.rmtree(self._workdir)
def setUp(self): super(TwoManagersTest, self).setUp() self.cfy2 = get_cfy() second_manager_blueprint_path = '{}_existing'.format( self.env._manager_blueprint_path) shutil.copy2(self.env._manager_blueprint_path, second_manager_blueprint_path) external_resources = [ 'node_templates.management_network.properties', 'node_templates.management_subnet.properties', 'node_templates.router.properties', 'node_templates.agents_security_group.properties', 'node_templates.management_security_group.properties', ] with YamlPatcher(second_manager_blueprint_path) as patch: for prop in external_resources: patch.merge_obj(prop, {'use_external_resource': True}) second_cloudify_config_path = '{}_existing'.format( self.env.cloudify_config_path) shutil.copy2(self.env.cloudify_config_path, second_cloudify_config_path) new_resources = ['manager_server_name', 'manager_port_name'] with YamlPatcher(second_cloudify_config_path) as patch: for prop in new_resources: patch.append_value(prop, '2') self.cfy2.bootstrap( second_manager_blueprint_path, inputs=second_cloudify_config_path, install_plugins=self.env.install_plugins, keep_up_on_failure=False, task_retries=5, verbose=False ) # Bootstrap updates the active profile, so get_manager_ip returns # the IP of the second manager self.client2 = create_rest_client(self.get_manager_ip())
def prepare_manager(self): # note that we're using a separate manager checkout, so we need to # create our own utils like cfy and the rest client, rather than use # the testenv ones self.cfy_workdir = tempfile.mkdtemp(prefix='manager-upgrade-') self.addCleanup(shutil.rmtree, self.cfy_workdir) self.manager_cfy = get_cfy() self.manager_inputs = self._get_bootstrap_inputs() if self._use_external_manager: upgrade_config = self.env.handler_configuration['upgrade_manager'] self.upgrade_manager_ip = upgrade_config['public_ip'] self.manager_private_ip = upgrade_config['private_ip'] self.manager_cfy.use(self.upgrade_manager_ip) else: self.bootstrap_manager() self.rest_client = create_rest_client(self.upgrade_manager_ip) self.bootstrap_manager_version = self.get_curr_version()
def test_hello_world(self): self._deploy_manager() self.cfy = get_cfy() self.cfy.use(self.manager_public_ip) self.logger.info('Waiting for config install workflow to finish...') self.wait_for_config_to_finish(self.client) self.logger.info('...workflow finished.') # once we've managed to connect again using `cfy use` we need to update # the rest client too: self.client = create_rest_client(self.manager_public_ip) time.sleep(120) self._run( blueprint_file=self.hello_world_blueprint_file, inputs=self.hello_world_inputs, influx_host_ip=self.manager_public_ip, )
def setUp(self): self.env = test_environment.setup() self.logger = logging.getLogger(self._testMethodName) self.logger.setLevel(logging.INFO) # TODO: remove before merging # logger = logging.getLogger('sh.command') # logger.setLevel(logging.WARNING) # logger = logging.getLogger('sh.stream_bufferer') # logger.setLevel(logging.WARNING) # logger = logging.getLogger('cloudify.rest_client') # logger.setLevel(logging.WARNING) self.logger.info('Starting test setUp') self.workdir = tempfile.mkdtemp(prefix='cosmo-test-') management_user = getattr(self.env, 'management_user_name', None) management_port = getattr(self.env, 'management_port', 22) management_key_path = getattr(self.env, 'management_key_path', None) self.client = self.env.rest_client self.test_id = 'system-test-{0}-{1}'.format( self._testMethodName, time.strftime("%Y%m%d-%H%M")) self.cfy = get_cfy() if self.env.management_ip: self.cfy.use( self.env.management_ip, manager_user=management_user, manager_key=management_key_path, manager_port=management_port ) self.blueprint_yaml = None self._test_cleanup_context = self.env.handler.CleanupContext( self._testMethodName, self.env) self.addCleanup(self._cleanup) self.maxDiff = 1024 * 1024 * 10
def _upload_plugins(self): downloaded_wagon_paths = self._download_wagons() for wagon in downloaded_wagon_paths: self.logger.info('Uploading {0}'.format(wagon)) get_cfy().plugins.upload(wagon, verbose=True)
def test_hello_world(self): self._deploy_manager() os.environ[constants.CLOUDIFY_USERNAME_ENV ] = self.conf.get('new_manager_username', 'new') os.environ[constants.CLOUDIFY_PASSWORD_ENV ] = self.conf.get('new_manager_password', 'new') self.logger.info('Waiting for config install workflow to finish...') self.wait_for_config_to_finish(self.client) self.cfy = get_cfy() self.cfy.use(self.manager_public_ip, rest_port=443) self.logger.info('...workflow finished.') post_config_key = get_ssh_host_key(self.manager_public_ip) self.logger.info( 'Template was reconfigured with SSH host key: {key}'.format( key=post_config_key, ) ) self.assertNotEqual( self.template_key, post_config_key, 'SSH host key did not change when configuration blueprint ran.') post_config_cert = get_ssl_cert((self.manager_public_ip, 443)) self.logger.info( 'Template was reconfigured with SSL cert: {key}'.format( key=post_config_cert, ) ) self.assertNotEqual( self.template_ssl_cert, post_config_cert, 'SSL certificate did not change when configuration blueprint ran.') self.assertIn( 'IP Address:{}'.format(self.manager_public_ip), post_config_cert['subject_altnames'], 'SSL certificate does not contain manager public IP.') post_config_cert_path = os.path.join(self.base_temp_dir, 'new_ssl_cert.pem') with open(post_config_cert_path, 'w') as f: f.write(post_config_cert['cert']) # once we've managed to connect again using `cfy use` we need to update # the rest client too: self.logger.debug('Recreating REST client with SSL cert') self.client = create_rest_client( self.manager_public_ip, secure=True, cert=post_config_cert_path, trust_all=False, ) self.logger.debug('Reconnectiong cli client with SSL cert') del os.environ['CLOUDIFY_SSL_TRUST_ALL'] os.environ['CLOUDIFY_SSL_CERT'] = post_config_cert_path self.cfy = get_cfy() self.cfy.use(self.manager_public_ip, rest_port=443) time.sleep(120) self._run( blueprint_file=self.hello_world_blueprint_file, inputs=self.hello_world_inputs, influx_host_ip=self.manager_public_ip, )