コード例 #1
0
ファイル: base.py プロジェクト: mohitsethi/rally
def _run_scenario_once(args):
    i, cls, method_name, admin, user, kwargs = args

    LOG.info("ITER: %s START" % i)

    # TODO(boris-42): remove context
    scenario = cls(
            context={},
            admin_clients=utils.create_openstack_clients(admin["endpoint"]),
            clients=utils.create_openstack_clients(user["endpoint"]))

    try:
        scenario_output = None
        with rutils.Timer() as timer:
            scenario_output = getattr(scenario, method_name)(**kwargs)
        error = None
    except Exception as e:
        error = utils.format_exc(e)
        if cfg.CONF.debug:
            LOG.exception(e)
    finally:
        status = "Error %s: %s" % tuple(error[0:2]) if error else "OK"
        LOG.info("ITER: %(i)s END: %(status)s" % {"i": i, "status": status})

        return {"time": timer.duration() - scenario.idle_time(),
                "idle_time": scenario.idle_time(),
                "error": error,
                "scenario_output": scenario_output,
                "atomic_actions_time": scenario.atomic_actions_time()}
コード例 #2
0
ファイル: test_servers.py プロジェクト: mohitsethi/rally
    def _prepare_boot(self, mock_osclients, mock_choice=None, nic=None,
                      assert_nic=False):
        fake_server = mock.MagicMock()

        fc = fakes.FakeClients()
        mock_osclients.Clients.return_value = fc
        nova = fakes.FakeNovaClient()
        fc.get_nova_client = lambda: nova

        user_endpoint = endpoint.Endpoint("url", "user", "password", "tenant")
        clients = butils.create_openstack_clients(user_endpoint)
        scenario = servers.NovaServers(clients=clients)

        scenario._boot_server = mock.MagicMock(return_value=fake_server)
        scenario._generate_random_name = mock.MagicMock(return_value="name")

        kwargs = {'fakearg': 'f'}
        expected_kwargs = {'fakearg': 'f'}

        assert_nic = nic or assert_nic
        if nic:
            kwargs['nics'] = nic
        if assert_nic:
            nova.networks.create('net-1')
            mock_choice.return_value = nova.networks.create('net-2')
            expected_kwargs['nics'] = nic or [{'net-id': 'net-2'}]

        print(kwargs)
        print(expected_kwargs)

        return scenario, kwargs, expected_kwargs
コード例 #3
0
ファイル: test_images.py プロジェクト: mohitsethi/rally
 def test_create_image_and_boot_instances(self,
                                          mock_osclients,
                                          mock_create_image,
                                          mock_boot_servers,
                                          mock_random_name):
     glance_scenario = images.GlanceImages()
     nova_scenario = servers.NovaServers()
     fc = fakes.FakeClients()
     mock_osclients.Clients.return_value = fc
     fake_glance = fakes.FakeGlanceClient()
     fc.get_glance_client = lambda: fake_glance
     fake_nova = fakes.FakeNovaClient()
     fc.get_nova_client = lambda: fake_nova
     user_endpoint = endpoint.Endpoint("url", "user", "password", "tenant")
     nova_scenario._clients = butils.create_openstack_clients(user_endpoint)
     fake_image = fakes.FakeImage()
     fake_servers = [object() for i in range(5)]
     mock_create_image.return_value = fake_image
     mock_boot_servers.return_value = fake_servers
     mock_random_name.return_value = "random_name"
     kwargs = {'fakearg': 'f'}
     with mock.patch("rally.benchmark.scenarios.glance.utils.time.sleep"):
         glance_scenario.\
             create_image_and_boot_instances("cf", "url", "df",
                                             "fid", 5, **kwargs)
         mock_create_image.assert_called_once_with("random_name", "cf",
                                                   "url", "df", **kwargs)
         mock_boot_servers.assert_called_once_with("random_name",
                                                   "image-id-0",
                                                   "fid", 5, **kwargs)
コード例 #4
0
ファイル: runner.py プロジェクト: hyunsun/rally
    def run(self, name, kwargs):
        cls_name, method_name = name.split(".")
        cls = base.Scenario.get_by_name(cls_name)

        args = kwargs.get('args', {})
        init_args = kwargs.get('init', {})
        execution_type = kwargs.get('execution', 'continuous')
        config = kwargs.get('config', {})
        tenants = config.get('tenants', 1)
        users_per_tenant = config.get('users_per_tenant', 1)

        temp_users = self._create_temp_tenants_and_users(tenants,
                                                         users_per_tenant)

        global __openstack_clients__, __scenario_context__

        # NOTE(msdubov): Call init() with admin openstack clients
        cls._clients = __admin_clients__
        __scenario_context__ = cls.init(init_args)

        # NOTE(msdubov): Launch scenarios with non-admin openstack clients
        keys = ["username", "password", "tenant_name", "uri"]
        __openstack_clients__ = utils.create_openstack_clients(temp_users,
                                                               keys)

        results = self._run_scenario(cls, method_name, args,
                                     execution_type, config)

        self._cleanup_scenario(config.get("active_users", 1))
        self._delete_temp_tenants_and_users()

        return results
コード例 #5
0
ファイル: test_servers.py プロジェクト: hughsaunders/rally
    def _verify_boot_server(self, mock_choice, mock_osclients, mock_boot,
                            mock_random_name, nic=None, assert_nic=False):
        assert_nic = nic or assert_nic
        kwargs = {'fakearg': 'f'}
        expected_kwargs = {'fakearg': 'f'}

        fc = fakes.FakeClients()
        mock_osclients.Clients.return_value = fc
        nova = fakes.FakeNovaClient()
        fc.get_nova_client = lambda: nova

        temp_keys = ["username", "password", "tenant_name", "uri"]
        users_endpoints = [dict(zip(temp_keys, temp_keys))]
        servers.NovaServers._clients = butils.create_openstack_clients(
                                                users_endpoints, temp_keys)[0]

        mock_boot.return_value = object()
        mock_random_name.return_value = "random_name"
        if nic:
            kwargs['nics'] = nic
        if assert_nic:
            nova.networks.create('net-1')
            network = nova.networks.create('net-2')
            mock_choice.return_value = network
            expected_kwargs['nics'] = nic or [{'net-id': 'net-2'}]
        servers.NovaServers.boot_server("img", 0, **kwargs)

        mock_boot.assert_called_once_with("random_name", "img", 0,
                                          **expected_kwargs)
コード例 #6
0
ファイル: engine.py プロジェクト: mohitsethi/rally
    def _validate_scenario_args(self, name, kwargs):
        cls_name, method_name = name.split(".")
        cls = base_scenario.Scenario.get_by_name(cls_name)

        method = getattr(cls, method_name)
        validators = getattr(method, "validators", [])

        args = kwargs.get("args", {})

        # NOTE(msdubov): Some scenarios may require validation from admin,
        #                while others use ordinary clients.
        admin_validators = [v for v in validators
                            if v.permission == consts.EndpointPermission.ADMIN]
        user_validators = [v for v in validators
                           if v.permission == consts.EndpointPermission.USER]

        def validate(validators, clients):
            for validator in validators:
                result = validator(clients=clients, **args)
                if not result.is_valid:
                    raise exceptions.InvalidScenarioArgument(
                                                            message=result.msg)

        # NOTE(msdubov): In case of generated users (= admin mode) - validate
        #                first the admin validators, then the user ones
        #                (with one temporarily created user).
        if self.admin_endpoint:
            admin_client = utils.create_openstack_clients(self.admin_endpoint)
            validate(admin_validators, admin_client)
            context = {
                "task": self.task,
                "admin": {"endpoint": self.admin_endpoint}
            }
            with users_ctx.UserGenerator(context) as generator:
                # TODO(boris-42): refactor this peace
                generator.setup()
                user = context["users"][0]
                user_client = utils.create_openstack_clients(user["endpoint"])
                validate(user_validators, user_client)
        # NOTE(msdubov): In case of pre-created users - validate
        #                for all of them.
        else:
            for user in self.users:
                user_client = utils.create_openstack_clients(user)
                validate(user_validators, user_client)
コード例 #7
0
ファイル: runner.py プロジェクト: hyunsun/rally
    def __init__(self, task, cloud_config):
        self.task = task
        self.endpoints = cloud_config

        global __admin_clients__
        keys = ["admin_username", "admin_password", "admin_tenant_name", "uri"]
        __admin_clients__ = utils.create_openstack_clients([self.endpoints],
                                                           keys)[0]
        base.Scenario.register()
コード例 #8
0
ファイル: cleaner.py プロジェクト: mohitsethi/rally
    def _cleanup_admin_resources(self):
        if not self.admin:
            return

        try:
            admin = utils.create_openstack_clients(self.admin)
            utils.delete_keystone_resources(admin["keystone"])
        except Exception as e:
            LOG.debug(_("Not all resources were cleaned."),
                      exc_info=sys.exc_info())
            LOG.warning(_('Unable to fully cleanup keystone service: %s') %
                        (e.message))