Пример #1
0
    def _test_nodecellar_impl(self, blueprint_file):
        self.repo_dir = clone(self.repo_url, self.workdir)
        self.blueprint_yaml = self.repo_dir / blueprint_file

        self.modify_blueprint()

        before_install, after_install = self.upload_deploy_and_execute_install(
            inputs=self.get_inputs())

        self.post_install_assertions(before_install, after_install)

        self.kill_nodejs_vm()

        # make sure nodecellar is down
        self.assert_nodecellar_down(self.public_ip)

        self.wait_for_autoheal(after_install)

        after_autoheal = self.get_manager_state()

        self.post_autoheal_assertions(after_install, after_autoheal)

        self.execute_uninstall()

        self.post_uninstall_assertions()
    def bootstrap_simple_manager_blueprint(self):
        self.manager_blueprints_repo_dir = clone(MANAGER_BLUEPRINTS_REPO_URL,
                                                 self.workdir)
        self.test_manager_blueprint_path = \
            os.path.join(self.manager_blueprints_repo_dir,
                         'simple', 'simple-manager-blueprint.yaml')

        # using the updated handler configuration blueprint to update the
        # package urls in the simple manager blueprint
        self._update_manager_blueprint()

        self.bootstrap_inputs = {
            'public_ip': self.public_ip_address,
            'private_ip': self.private_ip_address,
            'ssh_user': '******',
            'ssh_key_filename': self.inputs['key_pair_path'],
            'agents_user': '******',
            'resources_prefix': ''
        }

        # preparing inputs file for bootstrap
        self.test_inputs_path = \
            self.cfy._get_inputs_in_temp_file(self.bootstrap_inputs,
                                              self._testMethodName)
        self._bootstrap()
        self._running_env_setup(self.public_ip_address)
    def _prepare_manager_blueprint(self, version):
        blueprints_repo_path = clone(BLUEPRINTS_REPO,
                                     self._get_manager_dir(version), version)

        if version == V3_2_1:
            blueprint_path = os.path.join(blueprints_repo_path, 'openstack',
                                          'openstack-manager-blueprint.yaml')
        else:
            blueprint_path = os.path.join(blueprints_repo_path,
                                          'openstack-manager-blueprint.yaml')

        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(blueprint_path) as patch:
            patch.merge_obj(
                'node_templates.management_subnet.properties.subnet',
                {'dns_nameservers': ['8.8.8.8', '8.8.4.4']}
            )

            for prop in external_resources:
                patch.merge_obj(prop, {'use_external_resource': True})

        return blueprint_path
    def bootstrap_simple_manager_blueprint(self):
        self.manager_blueprints_repo_dir = clone(MANAGER_BLUEPRINTS_REPO_URL,
                                                 self.workdir)
        self.test_manager_blueprint_path = \
            os.path.join(self.manager_blueprints_repo_dir,
                         'new', 'simple-manager-blueprint.yaml')

        self.bootstrap_inputs = {
            'public_ip': self.public_ip_address,
            'private_ip': self.private_ip_address,
            'ssh_user': self.env.centos_7_image_user,
            'ssh_key_filename': self.inputs['key_pair_path'],
            'agents_user': self.env.centos_7_image_user,
            'resources_prefix': ''
        }

        # preparing inputs file for bootstrap
        self.test_inputs_path = \
            self.cfy._get_inputs_in_temp_file(self.bootstrap_inputs,
                                              self._testMethodName)
        self._bootstrap()
        self._running_env_setup(self.public_ip_address)

        self.logger.info('Uploading key file to manager...')
        with fabric_api.settings(host_string=self.public_ip_address,
                                 user=self.env.centos_7_image_user,
                                 key_filename=self.inputs['key_pair_path']):
            fabric_api.put(self.inputs['key_pair_path'],
                           self.remote_manager_key_path)
    def _run(self, image_name, user, is_existing_deployment=False):
        if not is_existing_deployment:
            self.repo_dir = clone(CLOUDIFY_HELLO_WORLD_EXAMPLE_URL,
                                  self.workdir)
            self.blueprint_path = self.repo_dir / 'hello-world'
            self.blueprint_yaml = self.blueprint_path / 'blueprint.yaml'
            self.upload_deploy_and_execute_install(
                fetch_state=False,
                inputs=dict(
                    agent_user=user,
                    image_name=image_name,
                    flavor_name=self.env.flavor_name))
        else:
            self.execute_install(deployment_id=self.test_id, fetch_state=False)

        # We assert for events to test events are actually
        # sent in a real world environment.
        # This is the only test that needs to make this assertion.
        self.assert_events()

        floating_ip_id, neutron, nova, sg_id, server_id =\
            self._verify_deployment_installed()

        self._uninstall_and_make_assertions(floating_ip_id, neutron, nova,
                                            sg_id, server_id)
    def _test_nodecellar_impl(self, blueprint_file):
        self.repo_dir = clone(self.repo_url, self.workdir)
        self.blueprint_yaml = self.repo_dir / blueprint_file

        self.modify_blueprint()

        before_install, after_install = self.upload_deploy_and_execute_install(
            inputs=self.get_inputs()
        )

        self.post_install_assertions(before_install, after_install)

        self.kill_nodejs_vm()

        # make sure nodecellar is down
        self.assert_nodecellar_down(self.public_ip)

        self.wait_for_autoheal(after_install)

        after_autoheal = self.get_manager_state()

        self.post_autoheal_assertions(after_install, after_autoheal)

        self.execute_uninstall()

        self.post_uninstall_assertions()
    def test_resources_available(self):
        blueprint_name = 'openstack-blueprint.yaml'
        self.repo_dir = clone(self.repo_url, self.workdir)
        self.blueprint_yaml = self.repo_dir / blueprint_name

        self.upload_blueprint(self.test_id)

        invalid_resource_url = 'http://{0}/resources/blueprints/{1}/{2}' \
            .format(self.env.management_ip, self.test_id, blueprint_name)

        try:
            result = requests.head(invalid_resource_url)
            self.assertNotEqual(
                result.status_code, 200,
                "Resources are available through a different port than 53229.")
        except ConnectionError:
            pass

        valid_resource_url = 'http://{0}:53229/blueprints/{1}/{2}' \
            .format(self.env.management_ip, self.test_id, blueprint_name)

        try:
            result = requests.head(valid_resource_url)
            self.assertEqual(
                result.status_code, 200,
                "Resources are not available through the port 53229.")
        except ConnectionError:
            self.fail("Resources are not available through the port 53229.")

        self.cfy.delete_blueprint(self.test_id)
    def _install_hello_world(self, version):
        manager_dir = self._get_manager_dir(version)

        hello_repo_dir = clone(HELLO_WORLD_REPO, manager_dir, version)
        hello_blueprint_path = os.path.join(hello_repo_dir, 'blueprint.yaml')

        with YamlPatcher(hello_blueprint_path) as patch:
            patch.merge_obj(
                'node_templates.security_group.interfaces',
                {'cloudify.interfaces.lifecycle': {
                    'create': {
                        'inputs': {
                            'args': {'description': 'hello security group'}
                        }
                    }
                }}
            )

        arguments = {
            'manager_dir': manager_dir,
            'activate_path': os.path.join(self._get_activate_path(version)),
            'hello_blueprint_path': hello_blueprint_path,
            'inputs_path': self._prepare_hello_world_inputs()
        }

        self._run_script('install_hello_world.sh', arguments)
    def deploy_hello_world(self, prefix=''):
        """Install the hello world app."""
        blueprint_id = prefix + self.test_id
        deployment_id = prefix + self.test_id
        hello_repo_dir = tempfile.mkdtemp(prefix='manager-upgrade-')
        hello_repo_path = clone(
            'https://github.com/cloudify-cosmo/'
            'cloudify-hello-world-example.git',
            hello_repo_dir
        )
        self.addCleanup(shutil.rmtree, hello_repo_dir)
        hello_blueprint_path = hello_repo_path / 'blueprint.yaml'
        self.cfy.blueprints.upload(
            hello_blueprint_path,
            blueprint_id=blueprint_id
        )

        inputs = {
            'agent_user': self.env.ubuntu_image_user,
            'image': self.env.ubuntu_trusty_image_name,
            'flavor': self.env.flavor_name
        }
        inputs = self.get_inputs_in_temp_file(inputs, deployment_id)
        self.manager_cfy.deployments.create(
            deployment_id,
            blueprint_id=blueprint_id,
            inputs=inputs
        )

        self.manager_cfy.executions.start(
            'install',
            deployment_id=deployment_id
        )
        return deployment_id
Пример #10
0
    def bootstrap_simple_manager_blueprint(self, override_inputs=None):
        self.manager_blueprints_repo_dir = clone(MANAGER_BLUEPRINTS_REPO_URL,
                                                 self.workdir)
        self.test_manager_blueprint_path = \
            os.path.join(self.manager_blueprints_repo_dir,
                         'simple-manager-blueprint.yaml')

        self.bootstrap_inputs = {
            'public_ip': self.public_ip_address,
            'private_ip': self.private_ip_address,
            'ssh_user': self.env.centos_7_image_user,
            'ssh_key_filename': self.inputs['key_pair_path'],
            'agents_user': self.env.centos_7_image_user,
            'resources_prefix': ''
        }

        if override_inputs is not None:
            self.bootstrap_inputs.update(override_inputs)

        # preparing inputs file for bootstrap
        self.test_inputs_path = \
            self.cfy._get_inputs_in_temp_file(self.bootstrap_inputs,
                                              self._testMethodName)
        self._bootstrap()
        self._running_env_setup(self.public_ip_address)

        self.logger.info('Uploading key file to manager...')
        with fabric_api.settings(host_string=self.public_ip_address,
                                 user=self.env.centos_7_image_user,
                                 key_filename=self.inputs['key_pair_path']):
            fabric_api.put(self.inputs['key_pair_path'],
                           self.remote_manager_key_path)
Пример #11
0
    def _run(self, image_name, user, is_existing_deployment=False):
        if not is_existing_deployment:
            self.repo_dir = clone(CLOUDIFY_HELLO_WORLD_EXAMPLE_URL,
                                  self.workdir)
            self.blueprint_yaml = self.repo_dir / 'blueprint.yaml'
            self.upload_deploy_and_execute_install(
                fetch_state=False,
                inputs=dict(
                    agent_user=user,
                    image=image_name,
                    flavor=self.env.flavor_name))
        else:
            self.execute_install(deployment_id=self.test_id, fetch_state=False)

        # We assert for events to test events are actually
        # sent in a real world environment.
        # This is the only test that needs to make this assertion.
        self.assert_events()

        floating_ip_id, neutron, nova, sg_id, server_id =\
            self._verify_deployment_installed()
        self.assert_deployment_monitoring_data_exists()
        floating_ip = neutron.show_floatingip(floating_ip_id)
        ip = floating_ip['floatingip']['floating_ip_address']
        web_server_node = get_web_server_node(self.client, self.test_id)
        port = web_server_node.properties['port']
        expected_output = \
            {u'http_endpoint': u'http://{0}:{1}'.format(ip, port)}
        self.assert_outputs(expected_output)
        self._uninstall_and_make_assertions(floating_ip_id, neutron, nova,
                                            sg_id, server_id)
    def _install_hello_world_on_3_2_1(self):
        self.logger.info('Installing HelloWorld application on manager 3.2.1')

        # generate inputs file
        inputs_template_vars = {
            'agent_user': self.env.cloudify_agent_user,
            'image':      self.env.ubuntu_trusty_image_name,
            'flavor':     self.env.flavor_name
        }

        self._render_script(
            HELLOWORLD_TEMPLATE_NAME,
            inputs_template_vars,
            HELLOWORLD_INPUTS_NAME
        )

        hello_repo_path = clone(
            'https://github.com/cloudify-cosmo/'
            'cloudify-hello-world-example.git',
            self.workdir,
            '3.2.1-build'
        )

        hello_blueprint_path = os.path.join(hello_repo_path, 'blueprint.yaml')

        with YamlPatcher(hello_blueprint_path) as patch:
            patch.merge_obj(
                'node_templates.security_group.interfaces',
                {'cloudify.interfaces.lifecycle': {
                    'create': {
                        'inputs': {
                            'args': {'description': 'hello security group'}
                        }
                    }
                }}
            )

        template_vars = {
            'work_dir':   self.workdir,
            'venv_name':  VIRTUALENV_NAME,
            'repo_path': hello_repo_path,
            'helloworld_inputs_file': HELLOWORLD_INPUTS_NAME,
            'app_name': HELLOWORLD_APP_NAME,
            'runtime_property_name': RUNTIME_PROPERTY_NAME,
            'runtime_property_value': self.runtime_property_value
        }

        self._render_script(
            INSTALL_TEMPLATE_NAME,
            template_vars,
            INSTALL_SCRIPT_NAME
        )

        rc = self._run_script(INSTALL_SCRIPT_NAME)
        if rc:
            self.fail(
                'Installing HelloWorld application on manager 3.2.1 failed '
                'with exit code: {0}'.format(rc)
            )
    def get_upgrade_blueprint(self):
        repo_dir = tempfile.mkdtemp(prefix='manager-upgrade-')
        self.addCleanup(shutil.rmtree, repo_dir)
        upgrade_blueprint_path = clone(UPGRADE_REPO_URL,
                                       repo_dir,
                                       branch=UPGRADE_BRANCH)

        return upgrade_blueprint_path / 'simple-manager-blueprint.yaml'
    def get_simple_blueprint(self):
        """Blueprint to run the upgrade with.

        We use the simple blueprint for upgrading the manager, no matter
        which blueprint was originally used for bootstrapping.
        """
        blueprint_dir = clone(UPGRADE_REPO_URL, self.workdir,
                              branch=UPGRADE_BRANCH)
        blueprint_path = (blueprint_dir /
                          'simple-manager-blueprint.yaml')
        self.addCleanup(shutil.rmtree, blueprint_dir)
        return blueprint_path
    def _get_marketplace_image_bakery_repo(self):
        self.base_temp_dir = tempfile.mkdtemp()

        url = self.env.cloudify_config.get(
            'image_bakery_url',
            DEFAULT_IMAGE_BAKERY_REPO_URL
        )

        git.clone(
            url=url,
            basedir=self.base_temp_dir,
            branch=self.env.cloudify_config.get('image_bakery_branch'),
        )

        self.addCleanup(self.clean_temp_dir)

        repo_path = os.path.join(
            self.base_temp_dir,
            'git',
            'cloudify-image-bakery',
        )
        return repo_path
Пример #16
0
    def test_two_deployments(self):
        repo_dir = clone(bash.CLOUDIFY_HELLO_WORLD_EXAMPLE_URL, self.workdir)
        self.blueprint_path = repo_dir
        self.blueprint_yaml = self.blueprint_path / 'blueprint.yaml'

        count = 2

        deployments = [self.Deployment(self, i) for i in range(count)]

        for deployment in deployments:
            deployment.run()

        for deployment in deployments:
            deployment.wait_for()
    def test_two_deployments(self):
        repo_dir = clone(bash.CLOUDIFY_HELLO_WORLD_EXAMPLE_URL, self.workdir)
        self.blueprint_path = repo_dir / 'hello-world'
        self.blueprint_yaml = self.blueprint_path / 'blueprint.yaml'

        count = 2

        deployments = [self.Deployment(self, i) for i in range(count)]

        for deployment in deployments:
            deployment.run()

        for deployment in deployments:
            deployment.wait_for()
    def get_upgrade_blueprint(self):
        """Path to the blueprint using for upgrading the manager.

        Note that upgrade uses a simple blueprint, even though the manager
        was installed using the openstack blueprint. Upgrade does not need to
        use the same blueprint.
        """
        repo_dir = tempfile.mkdtemp(prefix='manager-upgrade-')
        self.addCleanup(shutil.rmtree, repo_dir)
        upgrade_blueprint_path = clone(UPGRADE_REPO_URL,
                                       repo_dir,
                                       branch=UPGRADE_BRANCH)

        return upgrade_blueprint_path / 'simple-manager-blueprint.yaml'
    def setUp(self):
        super(HelloWorldSnapshotMigrationFrom_3_2_1_To_3_3_Test, self).setUp()

        try:
            self.manager_3_2_1_ip = \
                self.env.handler_configuration['manager_3_2_1_ip']

            msg = "In case of using existing 3.2.1 manager, providing '{0}' " \
                  "is also required."
            try:
                self.manager_cred_path = \
                    self.env.handler_configuration[
                        'manager_3_2_1_credentials_path'
                    ]
            except KeyError as e:
                self.fail(msg.format(e.args[0]))

            self.bootstrap_managers = False

            if not self.env.management_ip:
                self.fail('Manager 3.3 is required to be bootstrapped in case'
                          'of using existing manager 3.2.1.')

        except KeyError:
            self.manager_3_2_1_ip = None
            self.bootstrap_managers = True

        self.snapshot = None

        self.manager_public_key_name = self.test_id + '-manager-kp'
        self.agent_public_key_name = self.test_id + '-agents-kp'
        self.manager_key_path = os.path.join(self.workdir,
                                             MANAGER_KEY_FILE_NAME)
        self.agents_key_path = os.path.join(self.workdir, AGENTS_KEY_FILE_NAME)

        self.management_network_name = self.test_id + '-network'
        self.management_subnet_name = self.test_id + '-subnet'
        self.management_router = self.test_id + '-router'

        self.agents_user = '******'

        self.repo_path = clone(
            'https://github.com/cloudify-cosmo/'
            'cloudify-manager-blueprints.git',
            self.workdir,
            '3.3'
        )

        self.runtime_property_value = self.test_id + '-runtime-property'
Пример #20
0
    def _test_nodecellar_impl(self, blueprint_file):
        self.repo_dir = clone(self.repo_url, self.workdir, self.repo_branch)
        self.blueprint_yaml = self.repo_dir / blueprint_file

        self.modify_blueprint()

        before, after = self.upload_deploy_and_execute_install(
            inputs=self.get_inputs()
        )

        self.post_install_assertions(before, after)

        self.execute_uninstall()

        self.post_uninstall_assertions()
Пример #21
0
    def clone_example(self):
        if not self._cloned_to:
            # Destination will be e.g.
            # /tmp/pytest_generated_tempdir_for_test_1/examples/bootstrap_ssl/
            destination = os.path.join(
                str(self.tmpdir),
                'examples',
                self.suffix,
            )

            self.branch = self.branch or os.environ.get(
                'BRANCH_NAME_CORE', git_helper.MASTER_BRANCH)

            self._cloned_to = git_helper.clone(self.REPOSITORY_URL,
                                               destination, self.branch)
    def _test_nodecellar_impl(self, blueprint_file, execute_timeout=DEFAULT_EXECUTE_TIMEOUT):
        self.repo_dir = clone(self.repo_url, self.workdir, self.repo_branch)
        self.blueprint_yaml = self.repo_dir / blueprint_file

        self.modify_blueprint()

        before, after = self.upload_deploy_and_execute_install(
            inputs=self.get_inputs(), execute_timeout=execute_timeout
        )

        self.post_install_assertions(before, after)

        self.execute_uninstall()

        self.post_uninstall_assertions()
    def clone_example(self):
        if not self._cloned_to:
            # Destination will be e.g.
            # /tmp/pytest_generated_tempdir_for_test_1/examples/bootstrap_ssl/
            destination = os.path.join(
                str(self.tmpdir), 'examples', self.suffix,
            )

            self.branch = self.branch or os.environ.get(
                'BRANCH_NAME_CORE',
                git_helper.MASTER_BRANCH)

            self._cloned_to = git_helper.clone(self.REPOSITORY_URL,
                                               destination,
                                               self.branch)
    def _create_and_download_snapshot(self, version):
        manager_dir = self._get_manager_dir(version)

        arguments = {
            'manager_dir': self._get_manager_dir(version),
            'activate_path': os.path.join(
                self._get_activate_path(version)),
            'snapshot_path': self._get_snapshots_path(version)
        }

        if version == V3_2_1:
            arguments['snapshot_tool_dir'] = clone(SNAPSHOT_TOOL_REPO,
                                                   manager_dir)
            self._run_script('download_snapshot_321.sh', arguments)
        else:
            self._run_script('download_snapshot_33plus.sh', arguments)
Пример #25
0
    def setUp(self):
        super(HelloWorldSnapshotMigrationFrom_3_2_1_To_3_3_Test, self).setUp()

        try:
            self.manager_3_2_1_ip = \
                self.env.handler_configuration['manager_3_2_1_ip']

            msg = "In case of using existing 3.2.1 manager, providing '{0}' " \
                  "is also required."
            try:
                self.manager_cred_path = \
                    self.env.handler_configuration[
                        'manager_3_2_1_credentials_path'
                    ]
            except KeyError as e:
                self.fail(msg.format(e.args[0]))

            self.bootstrap_managers = False

            if not self.env.management_ip:
                self.fail('Manager 3.3 is required to be bootstrapped in case'
                          'of using existing manager 3.2.1.')

        except KeyError:
            self.manager_3_2_1_ip = None
            self.bootstrap_managers = True

        self.snapshot = None

        self.manager_public_key_name = self.test_id + '-manager-kp'
        self.agent_public_key_name = self.test_id + '-agents-kp'
        self.manager_key_path = os.path.join(self.workdir,
                                             MANAGER_KEY_FILE_NAME)
        self.agents_key_path = os.path.join(self.workdir, AGENTS_KEY_FILE_NAME)

        self.management_network_name = self.test_id + '-network'
        self.management_subnet_name = self.test_id + '-subnet'
        self.management_router = self.test_id + '-router'

        self.agents_user = '******'

        self.repo_path = clone(
            'https://github.com/cloudify-cosmo/'
            'cloudify-manager-blueprints.git', self.workdir, '3.3')

        self.runtime_property_value = self.test_id + '-runtime-property'
    def _bootstrap_manager(self, version):
        manager_dir = self._get_manager_dir(version)
        cli_repo_dir = clone(CLI_REPO, manager_dir, version)
        blueprint_path = self._prepare_manager_blueprint(version)

        arguments = {
            'manager_dir': manager_dir,
            'venv_dir': self._get_venv_dir(version),
            'activate_path': self._get_activate_path(version),
            'cli_repo_dir': cli_repo_dir,
            'cli_requirements_path': os.path.join(cli_repo_dir,
                                                  'dev-requirements.txt'),
            'blueprint_path': blueprint_path,
            'inputs_path': self._prepare_manager_inputs(
                os.path.dirname(blueprint_path), version)
        }

        self._run_script('bootstrap_manager.sh', arguments)
    def _test_nodecellar_impl(self, blueprint_file):
        self.addCleanup(self._test_cleanup)
        self.repo_dir = clone(self.repo_url, self.workdir)
        self.blueprint_yaml = self.repo_dir / blueprint_file

        # install
        before_install, after_install = self.upload_deploy_and_execute_install(
            inputs=self.get_inputs())
        self.post_install_assertions(before_install, after_install)

        # scale out (+1)
        self._scale(delta=1)
        self.post_scale_assertions(expected_instances=3)

        # scale in (-2)
        self._scale(delta=-2)
        self.post_scale_assertions(expected_instances=1)

        # uninstall
        self.execute_uninstall()
        self.post_uninstall_assertions()
    def _test_nodecellar_impl(self, blueprint_file):
        self.addCleanup(self._test_cleanup)
        self.repo_dir = clone(self.repo_url, self.workdir)
        self.blueprint_yaml = self.repo_dir / blueprint_file

        # install
        before_install, after_install = self.upload_deploy_and_execute_install(
            inputs=self.get_inputs())
        self.post_install_assertions(before_install, after_install)

        # scale out (+1)
        self._scale(delta=1)
        self.post_scale_assertions(expected_instances=3)

        # scale in (-2)
        self._scale(delta=-2)
        self.post_scale_assertions(expected_instances=1)

        # uninstall
        self.execute_uninstall()
        self.post_uninstall_assertions()
    def _run(self,
             inputs=None,
             blueprint_file='blueprint.yaml',
             is_existing_deployment=False,
             influx_host_ip=None):
        if not is_existing_deployment:
            self.repo_dir = clone(CLOUDIFY_HELLO_WORLD_EXAMPLE_URL,
                                  self.workdir)
            self.blueprint_yaml = self.repo_dir / blueprint_file
            self.upload_deploy_and_execute_install(
                fetch_state=False,
                inputs=inputs)
        else:
            self.execute_install(deployment_id=self.test_id, fetch_state=False)

        # We assert for events to test events are actually
        # sent in a real world environment.
        # This is the only test that needs to make this assertion.
        self.logger.info('Asserting events...')
        self.assert_events()

        outputs = self.client.deployments.outputs.get(self.test_id)['outputs']
        self.logger.info('Deployment outputs: {0}'.format(outputs))
        self.logger.info('Verifying web server is running on: {0}'.format(
            outputs['http_endpoint']))
        verify_webserver_running(outputs['http_endpoint'])

        self.logger.info('Performing post install assertions...')
        context = self._do_post_install_assertions()

        self.logger.info('Asserting deployment monitoring data exists...')
        self.assert_deployment_monitoring_data_exists(
            influx_host_ip=influx_host_ip)

        self.logger.info('Uninstalling deployment...')
        self.execute_uninstall()

        self.logger.info('Performing post uninstall assertions...')
        self._do_post_uninstall_assertions(context)
    def get_bootstrap_blueprint(self):
        manager_repo_dir = tempfile.mkdtemp(prefix='manager-upgrade-')
        self.addCleanup(shutil.rmtree, manager_repo_dir)
        manager_repo = clone(BOOTSTRAP_REPO_URL,
                             manager_repo_dir,
                             branch=BOOTSTRAP_BRANCH)
        yaml_path = manager_repo / 'openstack-manager-blueprint.yaml'

        # allow the ports that we're going to connect to from the tests,
        # when doing checks
        for port in [8086, 9200, 9900]:
            secgroup_cfg = [{
                'port_range_min': port,
                'port_range_max': port,
                'remote_ip_prefix': '0.0.0.0/0'
            }]
            secgroup_cfg_path = 'node_templates.management_security_group' \
                                '.properties.rules'
            with YamlPatcher(yaml_path) as patch:
                patch.append_value(secgroup_cfg_path, secgroup_cfg)

        return yaml_path
def clone_hello_world(workdir):
    return clone(CLOUDIFY_HELLO_WORLD_EXAMPLE_URL, workdir)
Пример #32
0
 def _clone_manager_blueprints(self):
     self._manager_blueprints_path = git_helper.clone(
         MANAGER_BLUEPRINTS_REPO_URL, str(self._tmpdir))
 def setUp(self):
     super(HelloWorldBashTest, self).setUp()
     from cosmo_tester.framework.git_helper import clone
     self.repo_dir = clone(self.CLOUDIFY_EXAMPLES_URL, self.workdir)
def clone_hello_world(workdir):
    return clone(CLOUDIFY_HELLO_WORLD_EXAMPLE_URL, workdir)