def _copy_terraform_files(self): shutil.copy(get_resource_path( 'terraform/aws-osx-cli-test.tf'), self.tmpdir / 'aws-osx-cli-test.tf') shutil.copy(get_resource_path( 'terraform/scripts/osx-cli-test.sh'), self.tmpdir / 'scripts/osx-cli-test.sh')
def _copy_terraform_files(self): shutil.copy(get_resource_path( 'terraform/openstack-linux-cli-test.tf'), self.tmpdir / 'openstack-linux-cli-test.tf') shutil.copy(get_resource_path( 'terraform/scripts/linux-cli-test.sh'), self.tmpdir / 'scripts/linux-cli-test.sh')
def _copy_terraform_files(self): shutil.copy( get_resource_path('terraform/openstack-windows-cli-test.tf'), self.tmpdir / 'openstack-windows-cli-test.tf') shutil.copy( get_resource_path('terraform/scripts/windows-userdata.ps1'), self.tmpdir / 'scripts/windows-userdata.ps1')
def _copy_terraform_files(self): shutil.copy(get_resource_path( 'terraform/openstack-windows-cli-test.tf'), self.tmpdir / 'openstack-windows-cli-test.tf') shutil.copy(get_resource_path( 'terraform/scripts/windows-userdata.ps1'), self.tmpdir / 'scripts/windows-userdata.ps1')
def _test_agent(agent_type, cfy, manager, attributes): agent_blueprints = { 'a3_2': 'agent/3-2-agent-blueprint/3-2-agent-mispelled-blprint.yaml', 'ssh': 'agent/ssh-agent-blueprint/ssh-agent-blueprint.yaml', } blueprint_path = util.get_resource_path(agent_blueprints[agent_type]) tenant = prepare_and_get_test_tenant( 'agent_{}'.format(agent_type), manager, cfy, ) blueprint_id = deployment_id = agent_type with set_client_tenant(manager, tenant): manager.client.blueprints.upload(blueprint_path, blueprint_id) manager.client.deployments.create( deployment_id, blueprint_id, inputs={ 'ip_address': manager.ip_address, 'user': attributes.default_linux_username, 'private_key_path': manager.remote_private_key_path }, skip_plugins_validation=True) try: cfy.executions.start.install(['-d', deployment_id, '--tenant-name', tenant]) finally: cfy.executions.start.uninstall(['-d', deployment_id, '--tenant-name', tenant])
def _test_userdata_agent(cfy, manager, inputs, tenant): blueprint_id = deployment_id = 'userdata{0}'.format(time.time()) blueprint_path = util.get_resource_path( 'agent/userdata-agent-blueprint/userdata-agent-blueprint.yaml') with set_client_tenant(manager, tenant): manager.client.blueprints.upload(blueprint_path, blueprint_id) manager.client.deployments.create( deployment_id, blueprint_id, inputs=inputs, skip_plugins_validation=True) cfy.executions.start.install(['-d', deployment_id, '--tenant-name', tenant]) try: with set_client_tenant(manager, tenant): assert { 'MY_ENV_VAR': 'MY_ENV_VAR_VALUE', 'file_content': EXPECTED_FILE_CONTENT } == manager.client.deployments.outputs.get(deployment_id).outputs finally: cfy.executions.start.uninstall(['-d', deployment_id, '--tenant-name', tenant])
def bootstrap(self, enter_sanity_mode=True, upload_license=False): manager_install_rpm = \ ATTRIBUTES.cloudify_manager_install_rpm_url.strip() or \ util.get_manager_install_rpm_url() install_config = self._create_config_file(upload_license) install_rpm_file = 'cloudify-manager-install.rpm' with self.ssh() as fabric_ssh: fabric_ssh.run( 'curl -S {0} -o {1}'.format( manager_install_rpm, install_rpm_file ) ) fabric_ssh.sudo('yum install -y {0}'.format(install_rpm_file)) fabric_ssh.put( install_config, '/etc/cloudify/config.yaml' ) if upload_license: fabric_ssh.put( util.get_resource_path('test_valid_paying_license.yaml'), '/tmp/test_valid_paying_license.yaml' ) fabric_ssh.run('cfy_manager install') if enter_sanity_mode: self.enter_sanity_mode()
def _test_agent_alive_after_reboot(cfy, manager, attributes, os_name, suffix=None): suffix = suffix or os_name os_blueprints = { 'centos_7': 'agent/reboot-vm-blueprint/reboot-unix-vm-blueprint.yaml', 'ubuntu_14_04': ( 'agent/reboot-vm-blueprint/reboot-unix-vm-blueprint.yaml' ), 'windows_2012': ( 'agent/reboot-vm-blueprint/reboot-winrm-vm-blueprint.yaml' ), } blueprint_name = os_blueprints[os_name] tenant = prepare_and_get_test_tenant(suffix, manager, cfy) inputs = { 'image': attributes['{os}_image_name'.format(os=os_name)], 'flavor': attributes['medium_flavor_name'], 'user': attributes['{os}_username'.format(os=os_name)], 'network_name': attributes['network_name'], 'private_key_path': manager.remote_private_key_path, 'keypair_name': attributes['keypair_name'], } blueprint_path = util.get_resource_path(blueprint_name) inputs['value'] = os_name blueprint_id = deployment_id = os_name with set_client_tenant(manager, tenant): manager.client.blueprints.upload(blueprint_path, blueprint_id) manager.client.deployments.create( deployment_id, blueprint_id, inputs=inputs, skip_plugins_validation=True) try: cfy.executions.start.install(['-d', deployment_id, '--tenant-name', tenant]) cfy.executions.start.execute_operation( deployment_id=deployment_id, parameters={ 'operation': 'cloudify.interfaces.reboot_test.reboot', 'node_ids': ['host'] }, tenant_name=tenant) finally: cfy.executions.start.uninstall(['-d', deployment_id, '--tenant-name', tenant]) with set_client_tenant(manager, tenant): app = manager.client.node_instances.list( node_id='application', deployment_id=deployment_id, )[0] assert os_name == app.runtime_properties['value']
def _test_windows_common( cfy, manager, attributes, blueprint_path, inputs, os_name, tenant, deployment_id_prefix): user = attributes.windows_2012_username if not tenant: tenant = prepare_and_get_test_tenant( '{0}_{1}'.format(deployment_id_prefix, os_name), manager, cfy ) effective_inputs = { 'image': attributes.windows_2012_image_name, 'flavor': attributes.medium_flavor_name, 'user': user, 'network_name': attributes.network_name, 'private_key_path': manager.remote_private_key_path, 'keypair_name': attributes.keypair_name, } if inputs: effective_inputs.update(inputs) blueprint_id = deployment_id = '{0}_{1}'.format( deployment_id_prefix, time.time()) blueprint_path = util.get_resource_path(blueprint_path) with set_client_tenant(manager, tenant): manager.client.blueprints.upload(blueprint_path, blueprint_id) manager.client.deployments.create( deployment_id, blueprint_id, inputs=effective_inputs, skip_plugins_validation=True) cfy.executions.start.install(['-d', deployment_id, '--tenant-name', tenant]) try: cfy.executions.start.execute_operation( deployment_id=deployment_id, parameters={ 'operation': 'test.interface.test', 'node_ids': ['test_app'] }, tenant_name=tenant) finally: cfy.executions.start.uninstall(['-d', deployment_id, '--tenant-name', tenant])
def test_winrm_agent(self): self.blueprint_yaml = util.get_resource_path( 'agent/winrm-agent-blueprint/winrm-agent-blueprint.yaml') self.upload_deploy_and_execute_install( inputs={ 'image': self.env.windows_image_name, 'flavor': self.env.medium_flavor_id } ) self.execute_uninstall()
def test_ssh_agent(self): self.blueprint_yaml = util.get_resource_path( 'agent/ssh-agent-blueprint/ssh-agent-blueprint.yaml') self.upload_deploy_and_execute_install( inputs={ 'image': self.env.ubuntu_trusty_image_id, 'flavor': self.env.small_flavor_id } ) self.execute_uninstall()
def additional_setup(self): if self.package_parameter_name not in os.environ: raise ValueError( '{0} environment variable not set' .format(self.package_parameter_name)) blueprint_filename = self.local_env_blueprint_file_name relative_blueprint_path = os.path.join('blueprints', 'cli', blueprint_filename) blueprint_path = util.get_resource_path(relative_blueprint_path) self.test_id = 'stest-{0}'.format( time.strftime("%Y%m%d-%H%M")) self.prefix = '{0}-cli-host'.format(self.test_id) self.bootstrap_prefix = 'cloudify-{0}'.format(self.test_id) self.branch = os.environ.get('BRANCH_NAME_CORE', 'master') self.logger.info('Using branch/tag: {0}'.format(self.branch)) self.logger.info('initialize local env for running the ' 'blueprint that starts a vm') self.local_env = local.init_env( blueprint_path, inputs=self.local_env_inputs, name=self._testMethodName, ignored_modules=cli_constants.IGNORED_LOCAL_WORKFLOW_MODULES) self.logger.info('Starting vm to install CLI package on it later on') self.addCleanup(self.cleanup) self.local_env.execute('install', task_retries=40, task_retry_interval=30) self.get_local_env_outputs() self.logger.info('Outputs: {0}'.format(self.local_env.outputs())) self.centos_client_env = { 'timeout': 30, 'user': self.client_user, 'key_filename': self.local_env_inputs['key_pair_path'], 'host_string': self.public_ip_address, 'connection_attempts': 10, 'abort_on_prompts': True } self.verify_connection() # Since different IAAS providers enable some default DNS which enables # internet access, by this call we make sure that all of the tests # begin with no dns based internet connection. In online tests, the # dns is being set by the dns() context manager. self.go_offline(self.centos_client_env)
def web_app(cfy, manager, attributes, ssh_key, logger, tmpdir): hw = centos_hello_world(cfy, manager, attributes, ssh_key, logger, tmpdir) hw.blueprint_file = util.get_resource_path( 'blueprints/deployment_proxy/web_app.yaml' ) hw.inputs.clear() yield hw hw.cleanup()
def vm_infrastructure(cfy, manager, attributes, ssh_key, logger, tmpdir): hw = centos_hello_world(cfy, manager, attributes, ssh_key, logger, tmpdir) hw.blueprint_file = util.get_resource_path( 'blueprints/deployment_proxy/vm_infrastructure.yaml' ) hw.blueprint_id = 'os_infra' hw.deployment_id = 'os_infra' yield hw hw.cleanup()
def _test_verify_wrong_cert(self): cert_path = os.path.join(self.workdir, 'wrong.cert') key_path = os.path.join(self.workdir, 'wrong.key') self.create_self_signed_certificate(cert_path, key_path, 'test') client = CloudifyClient(host=self.env.management_ip, port=constants.SECURED_REST_PORT, protocol=constants.SECURED_PROTOCOL, headers=util.get_auth_header( username=TEST_CFY_USERNAME, password=TEST_CFY_PASSWORD), cert=util.get_resource_path(cert_path), trust_all=False) try: client.manager.get_status() self.fail('certification verification expected to fail') except SSLError as e: self.assertIn('certificate verify failed', str(e.message))
def hostpool(cfy, manager, attributes, ssh_key, logger, tmpdir): tenant = util.prepare_and_get_test_tenant('hostpool', manager, cfy) hp = HostPoolExample(cfy, manager, attributes, ssh_key, logger, tmpdir, tenant=tenant, suffix='hostpool') hp.blueprint_file = util.get_resource_path('hostpool/service-blueprint.yaml') # noqa hp.skip_plugins_validation = True # verification is unrolled here because we want to validate and yield # the service for further testing before uninstalling it hp.upload_blueprint() hp.create_deployment() hp.install() hp.verify_installation() yield hp hp.uninstall() hp.delete_deployment() hp.cleanup()
def _test_verify_wrong_cert(self): cert_path = os.path.join(self.workdir, 'wrong.cert') key_path = os.path.join(self.workdir, 'wrong.key') self.create_self_signed_certificate(cert_path, key_path, 'test') client = CloudifyClient( host=self.env.management_ip, port=constants.SECURED_REST_PORT, protocol=constants.SECURED_PROTOCOL, headers=util.get_auth_header(username=TEST_CFY_USERNAME, password=TEST_CFY_PASSWORD), cert=util.get_resource_path(cert_path), trust_all=False) try: client.manager.get_status() self.fail('certification verification expected to fail') except SSLError as e: self.assertIn('certificate verify failed', str(e.message))
def _assert_plugins_installed(self): manager_key_path = util.get_actual_keypath( self.env, self.env.management_key_path) local_script_path = util.get_resource_path( 'scripts/test_rest_plugins.sh') remote_script_path = ('/home/{0}/test_rest_plugins.sh'.format( self.env.management_user_name)) with fabric_api.settings(timeout=30, user=self.env.management_user_name, key_filename=manager_key_path, host_string=self.cfy.get_management_ip(), warn_only=False): fabric_api.put(local_script_path, remote_script_path) output = fabric_api.run( 'chmod +x {0} && {0}'.format(remote_script_path)) # This tells us that plugin-template was successfully installed self.assertIn('imported_plugin_tasks', output) # This tells us that mock-rest-plugin was successfully installed self.assertIn('mock_attribute_value', output)
def _assert_plugins_installed(self): manager_key_path = util.get_actual_keypath( self.env, self.env.management_key_path) local_script_path = util.get_resource_path( 'scripts/test_rest_plugins.sh') remote_script_path = ('/home/{0}/test_rest_plugins.sh' .format(self.env.management_user_name)) with fabric_api.settings( timeout=30, user=self.env.management_user_name, key_filename=manager_key_path, host_string=self.cfy.get_management_ip(), warn_only=False): fabric_api.put(local_script_path, remote_script_path) output = fabric_api.run( 'chmod +x {0} && {0}'.format(remote_script_path)) # This tells us that plugin-template was successfully installed self.assertIn('imported_plugin_tasks', output) # This tells us that mock-rest-plugin was successfully installed self.assertIn('mock_attribute_value', output)
def _test_agent_alive_after_reboot(self, blueprint, inputs): self.blueprint_yaml = util.get_resource_path(blueprint) value = str(uuid.uuid4()) inputs['value'] = value deployment_id = self.test_id self.upload_deploy_and_execute_install( deployment_id=deployment_id, inputs=inputs) self.cfy.executions.start( 'execute_operation', deployment_id=deployment_id, parameters={ 'operation': 'cloudify.interfaces.reboot_test.reboot', 'node_ids': ['host'] }, include_logs=True) self.execute_uninstall(deployment_id=deployment_id) app = self.client.node_instances.list(node_id='application', deployment_id=deployment_id)[0] self.assertEquals(value, app.runtime_properties['value'])
def _test_userdata_agent(self, image, flavor, user, os_family, userdata, file_path, install_method, name=None): deployment_id = 'userdata{0}'.format(time.time()) self.blueprint_yaml = util.get_resource_path( 'agent/userdata-agent-blueprint/userdata-agent-blueprint.yaml') self.upload_deploy_and_execute_install( deployment_id=deployment_id, inputs={ 'image': image, 'flavor': flavor, 'agent_user': user, 'os_family': os_family, 'userdata': userdata, 'file_path': file_path, 'install_method': install_method, 'name': name } ) self.assert_outputs({'MY_ENV_VAR': 'MY_ENV_VAR_VALUE', 'file_content': self.expected_file_content}, deployment_id=deployment_id) self.execute_uninstall(deployment_id=deployment_id)
def create(self): """Creates the infrastructure for a Cloudify manager. The credentials file and private key file for SSHing to provisioned VMs are uploaded to the server.""" self._logger.info('Creating image based cloudify instances: ' '[number_of_instances=%d]', len(self.instances)) terraform_template_file = self._tmpdir / 'openstack-vm.tf' input_file = util.get_resource_path( 'terraform/{0}'.format(self._tf_template) ) with open(input_file, 'r') as f: tf_template = f.read() output = jinja2.Template(tf_template).render(self._template_inputs) terraform_template_file.write_text(output) self._terraform_inputs_file.write_text(json.dumps({ 'resource_suffix': str(uuid.uuid4()), 'public_key_path': self._ssh_key.public_key_path, 'private_key_path': self._ssh_key.private_key_path, 'flavor': self._get_server_flavor() }, indent=2)) try: with self._tmpdir: self._terraform.apply(['-var-file', self._terraform_inputs_file]) outputs = util.AttributesDict( {k: v['value'] for k, v in yaml.safe_load( self._terraform.output( ['-json']).stdout).items()}) self._attributes.update(outputs) self._update_instances_list(outputs) if self.preconfigure_callback: self.preconfigure_callback(self.instances) self._bootstrap_managers() for instance in self.instances: instance.verify_services_are_running() instance.upload_necessary_files() if instance.upload_plugins: instance.upload_plugin( self._attributes.default_openstack_plugin) self._logger.info('Test hosts successfully created!') except Exception as e: self._logger.error( 'Error creating image based hosts: %s', e) try: self.destroy() except sh.ErrorReturnCode as ex: self._logger.error('Error on terraform destroy: %s', ex) raise
def _create_sample_wheel(self): src = util.get_resource_path('plugins/{0}'.format(TEST_PACKAGE_NAME)) wagon_client = Wagon(src) return wagon_client.create( archive_destination_dir=tempfile.mkdtemp(dir=self.workdir), force=True)
def create(self): """Creates the infrastructure for a Cloudify manager. The credentials file and private key file for SSHing to provisioned VMs are uploaded to the server.""" self._logger.info( 'Creating image based cloudify instances: ' '[number_of_instances=%d]', len(self.instances)) terraform_template_file = self._tmpdir / 'openstack-vm.tf' input_file = util.get_resource_path('terraform/{0}'.format( self._tf_template)) with open(input_file, 'r') as f: tf_template = f.read() output = jinja2.Template(tf_template).render(self._template_inputs) terraform_template_file.write_text(output) self._terraform_inputs_file.write_text( json.dumps( { 'resource_suffix': str(uuid.uuid4()), 'public_key_path': self._ssh_key.public_key_path, 'private_key_path': self._ssh_key.private_key_path, 'flavor': self._get_server_flavor() }, indent=2)) try: with self._tmpdir: self._terraform.apply( ['-var-file', self._terraform_inputs_file]) outputs = util.AttributesDict({ k: v['value'] for k, v in yaml.safe_load( self._terraform.output(['-json']).stdout).items() }) self._attributes.update(outputs) self._update_instances_list(outputs) if self.preconfigure_callback: self.preconfigure_callback(self.instances) self._bootstrap_managers() for instance in self.instances: instance.verify_services_are_running() instance.upload_necessary_files() if instance.upload_plugins: instance.upload_plugin( self._attributes.default_openstack_plugin) self._logger.info('Test hosts successfully created!') except Exception as e: self._logger.error('Error creating image based hosts: %s', e) try: self.destroy() except sh.ErrorReturnCode as ex: self._logger.error('Error on terraform destroy: %s', ex) raise
def _copy_terraform_files(self): shutil.copy(get_resource_path('terraform/aws-osx-cli-test.tf'), self.tmpdir / 'aws-osx-cli-test.tf') shutil.copy(get_resource_path('terraform/scripts/osx-cli-test.sh'), self.tmpdir / 'scripts/osx-cli-test.sh')
def _copy_terraform_files(self): shutil.copy(get_resource_path('terraform/openstack-linux-cli-test.tf'), self.tmpdir / 'openstack-linux-cli-test.tf') shutil.copy(get_resource_path('terraform/scripts/linux-cli-test.sh'), self.tmpdir / 'scripts/linux-cli-test.sh')
def create(self): """Creates the OpenStack infrastructure for a Cloudify manager. The openstack credentials file and private key file for SSHing to provisioned VMs are uploaded to the server.""" self._logger.info( 'Creating an image based cloudify cluster ' '[number_of_managers=%d]', self._number_of_managers) openstack_config_file = self._tmpdir / 'openstack_config.json' openstack_config_file.write_text( json.dumps( { 'username': os.environ['OS_USERNAME'], 'password': os.environ['OS_PASSWORD'], 'tenant_name': os.environ.get('OS_TENANT_NAME', os.environ['OS_PROJECT_NAME']), 'auth_url': os.environ['OS_AUTH_URL'] }, indent=2)) terraform_template_file = self._tmpdir / 'openstack-vm.tf' input_file = util.get_resource_path( 'terraform/openstack-vm.tf.template') with open(input_file, 'r') as f: terraform_template = f.read() output = jinja2.Template(terraform_template).render( {'servers': self.managers_config}) terraform_template_file.write_text(output) self._terraform_inputs_file.write_text( json.dumps( { 'resource_suffix': str(uuid.uuid4()), 'public_key_path': self._ssh_key.public_key_path, 'private_key_path': self._ssh_key.private_key_path, 'flavor': self._get_server_flavor() }, indent=2)) try: with self._tmpdir: self._terraform.apply( ['-var-file', self._terraform_inputs_file]) outputs = util.AttributesDict({ k: v['value'] for k, v in json.loads( self._terraform.output(['-json']).stdout).items() }) self._attributes.update(outputs) self._create_managers_list(outputs) if self.preconfigure_callback: self.preconfigure_callback(self.managers) self._bootstrap_managers() for manager in self.managers: manager.verify_services_are_running() for i, manager in enumerate(self._managers): manager.use() self._upload_necessary_files_to_manager( manager, openstack_config_file) if self.managers_config[i].upload_plugins: self._upload_plugin_to_manager(manager, 'openstack_centos_core') self._logger.info('Cloudify cluster successfully created!') except Exception as e: self._logger.error( 'Error creating image based cloudify cluster: %s', e) try: self.destroy() except sh.ErrorReturnCode as ex: self._logger.error('Error on terraform destroy: %s', ex) raise