openstack
/
rally-openstack
Code Issues Proposed changes

Merge "Add barbican container scenarios"

This commit is contained in:
Zuul 2019-01-24 15:20:54 +00:00 committed by Gerrit Code Review
parent 083aea869b c115286916
commit 892680d06e
20 changed files with 588 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
CHANGELOG.rst
View File

@ -23,7 +23,12 @@ Added
~~~~~
* Added neutron trunk scenarios
* Added barbican scenarios.
* Added barbican scenarios
* [scenario plugin] BarbicanContainers.list
* [scenario plugin] BarbicanContainers.create_and_delete
* [scenario plugin] BarbicanContainers.create_and_add
* [scenario plugin] BarbicanContainers.create_certificate_and_delete
* [scenario plugin] BarbicanContainers.create_rsa_and_delete
* [scenario plugin] Octavia.create_and_list_loadbalancers
* [scenario plugin] Octavia.create_and_delete_loadbalancers
* [scenario plugin] Octavia.create_and_update_loadbalancers

70
rally-jobs/barbican.yaml
View File

@ -73,3 +73,73 @@
users:
tenants: 1
users_per_tenant: 1
-
title: BarbicanContainers.list
workloads:
-
scenario:
BarbicanContainers.list: {}
runner:
constant:
times: 2
concurrency: 1
contexts:
users:
tenants: 1
users_per_tenant: 1
-
title: BarbicanContainers.create_and_delete
workloads:
-
scenario:
BarbicanContainers.create_and_delete: {}
runner:
constant:
times: 2
concurrency: 1
contexts:
users:
tenants: 1
users_per_tenant: 1
-
title: BarbicanContainers.create_certificate_and_delete
workloads:
-
scenario:
BarbicanContainers.create_certificate_and_delete: {}
runner:
constant:
times: 2
concurrency: 1
contexts:
users:
tenants: 1
users_per_tenant: 1
-
title: BarbicanContainers.create_rsa_and_delete
workloads:
-
scenario:
BarbicanContainers.create_rsa_and_delete: {}
runner:
constant:
times: 2
concurrency: 1
contexts:
users:
tenants: 1
users_per_tenant: 1
-
title: BarbicanContainers.create_and_add
workloads:
-
scenario:
BarbicanContainers.create_and_add: {}
runner:
constant:
times: 2
concurrency: 1
contexts:
users:
tenants: 1
users_per_tenant: 1

6
rally_openstack/cleanup/resources.py
View File

@ -1104,3 +1104,9 @@ class BarbicanSecrets(base.ResourceManager):
return True
return False
@base.resource("barbican", "containers", order=1500, admin_required=True,
perform_for_admin_only=True)
class BarbicanContainers(base.ResourceManager):
pass

72
rally_openstack/scenarios/barbican/containers.py Normal file
View File

@ -0,0 +1,72 @@
# Copyright 2018 Red Hat, Inc. <http://www.redhat.com>
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from rally.task import validation
from rally_openstack import consts
from rally_openstack import scenario
from rally_openstack.scenarios.barbican import utils
"""Scenarios for Barbican containers."""
@validation.add("required_services", services=[consts.Service.BARBICAN])
@validation.add("required_platform", platform="openstack", admin=True)
@scenario.configure(name="BarbicanContainers.list")
class BarbicanContainersList(utils.BarbicanBase):
def run(self):
"""List secrets."""
self.admin_barbican.list_container()
@validation.add("required_services", services=[consts.Service.BARBICAN])
@validation.add("required_platform", platform="openstack", admin=True)
@scenario.configure(name="BarbicanContainers.create_and_delete")
class BarbicanContainersGenericCreateAndDelete(utils.BarbicanBase):
def run(self):
"""Create and delete generic container."""
container = self.admin_barbican.container_create()
self.admin_barbican.container_delete(container.container_ref)
@validation.add("required_services", services=[consts.Service.BARBICAN])
@validation.add("required_platform", platform="openstack", admin=True)
@scenario.configure(name="BarbicanContainers.create_and_add")
class BarbicanContainersGenericCreateAndAddSecret(utils.BarbicanBase):
def run(self):
"""Create secret, create generic container, and delete container."""
secret = self.admin_barbican.create_secret()
secret = {"secret": secret}
container = self.admin_barbican.container_create(secrets=secret)
self.admin_barbican.container_delete(container.container_ref)
@validation.add("required_services", services=[consts.Service.BARBICAN])
@validation.add("required_platform", platform="openstack", admin=True)
@scenario.configure(name="BarbicanContainers.create_certificate_and_delete")
class BarbicanContainersCertificateCreateAndDelete(utils.BarbicanBase):
def run(self):
"""Create and delete certificate container."""
container = self.admin_barbican.create_certificate_container()
self.admin_barbican.container_delete(container.container_ref)
@validation.add("required_services", services=[consts.Service.BARBICAN])
@validation.add("required_platform", platform="openstack", admin=True)
@scenario.configure(name="BarbicanContainers.create_rsa_and_delete")
class BarbicanContainersRSACreateAndDelete(utils.BarbicanBase):
def run(self):
"""Create and delete certificate container."""
container = self.admin_barbican.create_rsa_container()
self.admin_barbican.container_delete(container.container_ref)

29
rally_openstack/scenarios/barbican/secrets.py
View File

@ -16,26 +16,15 @@ from rally.task import validation
from rally_openstack import consts
from rally_openstack import scenario
from rally_openstack.services.key_manager import barbican
from rally_openstack.scenarios.barbican import utils
"""Scenarios for Barbican secrets."""
class BarbicanBase(scenario.OpenStackScenario):
"""Base class for Barbican scenarios with basic atomic actions."""
def __init__(self, context=None, admin_context=None, clients=None):
super(BarbicanBase, self).__init__(context, admin_context, clients)
if hasattr(self, "_admin_clients"):
self.admin_barbican = barbican.BarbicanService(
self._admin_clients, name_generator=self.generate_random_name,
atomic_inst=self.atomic_actions())
@validation.add("required_services", services=[consts.Service.BARBICAN])
@validation.add("required_platform", platform="openstack", admin=True)
@scenario.configure(name="BarbicanSecrets.list")
class BarbicanSecretsList(BarbicanBase):
class BarbicanSecretsList(utils.BarbicanBase):
def run(self):
"""List secrets."""
self.admin_barbican.list_secrets()
@ -45,7 +34,7 @@ class BarbicanSecretsList(BarbicanBase):
@validation.add("required_platform", platform="openstack", admin=True)
@scenario.configure(context={"admin_cleanup@openstack": ["barbican"]},
name="BarbicanSecrets.create")
class BarbicanSecretsCreate(BarbicanBase):
class BarbicanSecretsCreate(utils.BarbicanBase):
def run(self):
"""Create secret."""
self.admin_barbican.create_secret()
@ -55,7 +44,7 @@ class BarbicanSecretsCreate(BarbicanBase):
@validation.add("required_platform", platform="openstack", admin=True)
@scenario.configure(context={"admin_cleanup@openstack": ["barbican"]},
name="BarbicanSecrets.create_and_delete")
class BarbicanSecretsCreateAndDelete(BarbicanBase):
class BarbicanSecretsCreateAndDelete(utils.BarbicanBase):
def run(self):
"""Create and Delete secret."""
secret = self.admin_barbican.create_secret()
@ -66,11 +55,9 @@ class BarbicanSecretsCreateAndDelete(BarbicanBase):
@validation.add("required_platform", platform="openstack", admin=True)
@scenario.configure(context={"admin_cleanup@openstack": ["barbican"]},
name="BarbicanSecrets.create_and_get")
class BarbicanSecretsCreateAndGet(BarbicanBase):
class BarbicanSecretsCreateAndGet(utils.BarbicanBase):
def run(self):
"""Create and Get Secret.
"""
"""Create and Get Secret."""
secret = self.admin_barbican.create_secret()
self.assertTrue(secret)
secret_info = self.admin_barbican.get_secret(secret.secret_ref)
@ -81,7 +68,7 @@ class BarbicanSecretsCreateAndGet(BarbicanBase):
@validation.add("required_platform", platform="openstack", admin=True)
@scenario.configure(context={"admin_cleanup@openstack": ["barbican"]},
name="BarbicanSecrets.get")
class BarbicanSecretsGet(BarbicanBase):
class BarbicanSecretsGet(utils.BarbicanBase):
def run(self, secret_ref=None):
"""Create and Get Secret.
@ -98,7 +85,7 @@ class BarbicanSecretsGet(BarbicanBase):
@validation.add("required_platform", platform="openstack", admin=True)
@scenario.configure(context={"admin_cleanup@openstack": ["barbican"]},
name="BarbicanSecrets.create_and_list")
class BarbicanSecretsCreateAndList(BarbicanBase):
class BarbicanSecretsCreateAndList(utils.BarbicanBase):
def run(self):
"""Create and then list all secrets."""
self.admin_barbican.create_secret()

28
rally_openstack/scenarios/barbican/utils.py Normal file
View File

@ -0,0 +1,28 @@
# Copyright 2018 Red Hat, Inc. <http://www.redhat.com>
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from rally_openstack import scenario
from rally_openstack.services.key_manager import barbican
class BarbicanBase(scenario.OpenStackScenario):
"""Base class for Barbican scenarios with basic atomic actions."""
def __init__(self, context=None, admin_context=None, clients=None):
super(BarbicanBase, self).__init__(context, admin_context, clients)
if hasattr(self, "_admin_clients"):
self.admin_barbican = barbican.BarbicanService(
self._admin_clients, name_generator=self.generate_random_name,
atomic_inst=self.atomic_actions())

66
rally_openstack/services/key_manager/barbican.py
View File

@ -47,3 +47,69 @@ class BarbicanService(service.Service):
:param secret_name: The name of the secret to delete
"""
return self._clients.barbican().secrets.delete(secret_name)
@atomic.action_timer("barbican.list_container")
def list_container(self):
"""List containers"""
return self._clients.barbican().containers.list()
@atomic.action_timer("barbican.container_delete")
def container_delete(self, container_href):
"""Delete the container
:param container_href: the container reference
"""
return self._clients.barbican().containers.delete(container_href)
@atomic.action_timer("barbican.container_create")
def container_create(self, name=None, secrets=None):
"""Create a generic container
:param name: the name of the container
:param secrets: secrets to populate when creating a container
"""
name = name or self.generate_random_name()
val = self._clients.barbican().containers.create(
name=name, secrets=secrets)
val.store()
return val
@atomic.action_timer("barbican.create_rsa_container")
def create_rsa_container(self, name=None, public_key=None,
private_key=None, private_key_passphrase=None):
"""Create a RSA container
:param name: a friendly name for the container
:param public_key: Secret object containing a Public Key
:param private_key: Secret object containing a Private Key
:param private_key_passphrase: Secret object containing
a passphrase
:returns: RSAContainer
"""
name = name or self.generate_random_name()
val = self._clients.barbican().containers.create_rsa(
name=name, public_key=public_key, private_key=private_key,
private_key_passphrase=private_key_passphrase)
val.store()
return val
@atomic.action_timer("barbican.create_certificate_container")
def create_certificate_container(self, name=None, certificate=None,
intermediates=None, private_key=None,
private_key_passphrase=None):
"""Create a certificate container
:param name: A friendly name for the CertificateContainer
:param certificate: Secret object containing a Certificate
:param intermediates: Secret object containing
Intermediate Certs
:param private_key: Secret object containing a Private Key
:param private_key_passphrase: Secret object containing a passphrase
:returns: CertificateContainer
"""
name = name or self.generate_random_name()
val = self._clients.barbican().containers.create_certificate(
name=name, certificate=certificate, intermediates=intermediates,
private_key=private_key, private_key_passphrase=None)
val.store()
return val

22
samples/tasks/scenarios/barbican/create-and-add-container.json Normal file
View File

@ -0,0 +1,22 @@
{
"BarbicanContainers.create_and_add": [
{
"runner": {
"type": "constant",
"times": 2,
"concurrency": 1
},
"context": {
"users": {
"tenants": 1,
"users_per_tenant": 1
}
},
"sla": {
"failure_rate": {
"max": 0
}
}
}
]
}

15
samples/tasks/scenarios/barbican/create-and-add-container.yaml Normal file
View File

@ -0,0 +1,15 @@
---
BarbicanContainers.create_and_add:
-
runner:
type: "constant"
times: 2
concurrency: 1
context:
users:
tenants: 1
users_per_tenant: 1
sla:
failure_rate:
max: 0

25
samples/tasks/scenarios/barbican/create-and-delete-certificate.json Normal file
View File

@ -0,0 +1,25 @@
{
"BarbicanContainers.create_certificate_and_delete": [
{
"args": {
"passphrase": "my_passphrase"
},
"runner": {
"type": "constant",
"times": 2,
"concurrency": 1
},
"context": {
"users": {
"tenants": 1,
"users_per_tenant": 1
}
},
"sla": {
"failure_rate": {
"max": 0
}
}
}
]
}

17
samples/tasks/scenarios/barbican/create-and-delete-certificate.yaml Normal file
View File

@ -0,0 +1,17 @@
---
BarbicanContainers.create_certificate_and_delete:
-
args:
passphrase: "my_passphrase"
runner:
type: "constant"
times: 2
concurrency: 1
context:
users:
tenants: 1
users_per_tenant: 1
sla:
failure_rate:
max: 0

22
samples/tasks/scenarios/barbican/create-and-delete-container.json Normal file
View File

@ -0,0 +1,22 @@
{
"BarbicanContainers.create_and_delete": [
{
"runner": {
"type": "constant",
"times": 2,
"concurrency": 1
},
"context": {
"users": {
"tenants": 1,
"users_per_tenant": 1
}
},
"sla": {
"failure_rate": {
"max": 0
}
}
}
]
}

15
samples/tasks/scenarios/barbican/create-and-delete-container.yaml Normal file
View File

@ -0,0 +1,15 @@
---
BarbicanContainers.create_and_delete:
-
runner:
type: "constant"
times: 2
concurrency: 1
context:
users:
tenants: 1
users_per_tenant: 1
sla:
failure_rate:
max: 0

22
samples/tasks/scenarios/barbican/create-and-delete-rsa-container.json Normal file
View File

@ -0,0 +1,22 @@
{
"BarbicanContainers.create_rsa_and_delete": [
{
"runner": {
"type": "constant",
"times": 2,
"concurrency": 1
},
"context": {
"users": {
"tenants": 1,
"users_per_tenant": 1
}
},
"sla": {
"failure_rate": {
"max": 0
}
}
}
]
}

15
samples/tasks/scenarios/barbican/create-and-delete-rsa-container.yaml Normal file
View File

@ -0,0 +1,15 @@
---
BarbicanContainers.create_rsa_and_delete:
-
runner:
type: "constant"
times: 2
concurrency: 1
context:
users:
tenants: 1
users_per_tenant: 1
sla:
failure_rate:
max: 0

22
samples/tasks/scenarios/barbican/list-containers.json Normal file
View File

@ -0,0 +1,22 @@
{
"BarbicanContainers.list": [
{
"runner": {
"type": "constant",
"times": 2,
"concurrency": 1
},
"context": {
"users": {
"tenants": 1,
"users_per_tenant": 1
}
},
"sla": {
"failure_rate": {
"max": 0
}
}
}
]
}

15
samples/tasks/scenarios/barbican/list-containers.yaml Normal file
View File

@ -0,0 +1,15 @@
---
BarbicanContainers.list:
-
runner:
type: "constant"
times: 2
concurrency: 1
context:
users:
tenants: 1
users_per_tenant: 1
sla:
failure_rate:
max: 0

100
tests/unit/scenarios/barbican/test_containers.py Normal file
View File

@ -0,0 +1,100 @@
# Copyright 2018 Red Hat Inc
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import mock
from rally_openstack.scenarios.barbican import containers
from tests.unit import test
class BarbicanContainersTestCase(test.ScenarioTestCase):
def get_test_context(self):
context = super(BarbicanContainersTestCase, self).get_test_context()
context.update({
"admin": {
"user_id": "fake",
"credential": mock.MagicMock()
},
"user": {
"user_id": "fake",
"credential": mock.MagicMock()
},
"tenant": {"id": "fake"}
})
return context
def setUp(self):
super(BarbicanContainersTestCase, self).setUp()
patch = mock.patch(
"rally_openstack.services.key_manager.barbican.BarbicanService")
self.addCleanup(patch.stop)
self.mock_secrets = patch.start()
def test_list_containers(self):
secrets_service = self.mock_secrets.return_value
scenario = containers.BarbicanContainersList(self.context)
scenario.run()
secrets_service.list_container.assert_called_once_with()
def test_generic_container_create_and_delete(self):
secrets_service = self.mock_secrets.return_value
fake_container = {"container_ref": "fake_container_ref"}
fake_container = secrets_service.container_create.return_value
scenario = containers.BarbicanContainersGenericCreateAndDelete(
self.context)
scenario.run()
secrets_service.container_create.assert_called_once_with()
secrets_service.container_delete.assert_called_once_with(
fake_container.container_ref)
def test_generic_container_create_and_add_secret(self):
secrets_service = self.mock_secrets.return_value
fake_container = {"container_ref": "fake_container_ref"}
fake_secrets = {"secret_ref": "fake_secret_ref"}
fake_container = secrets_service.container_create.return_value
fake_secrets = secrets_service.create_secret.return_value
scenario = containers.BarbicanContainersGenericCreateAndAddSecret(
self.context)
scenario.run()
secrets_service.create_secret.assert_called_once_with()
secrets_service.container_create.assert_called_once_with(
secrets={"secret": fake_secrets})
secrets_service.container_delete.assert_called_once_with(
fake_container.container_ref)
def test_certificate_coentaineri_create_and_delete(self):
secrets_service = self.mock_secrets.return_value
fake_container = {"container_ref": "fake_container_ref"}
fake_container = secrets_service.create_certificate_container \
.return_value
scenario = containers.BarbicanContainersCertificateCreateAndDelete(
self.context)
scenario.run()
secrets_service.create_certificate_container.assert_called_once_with()
secrets_service.container_delete.assert_called_once_with(
fake_container.container_ref)
def test_rsa_container_create_and_delete(self):
secrets_service = self.mock_secrets.return_value
fake_container = {"container_ref": "fake_container_ref"}
fake_container = secrets_service.create_rsa_container.return_value
scenario = containers.BarbicanContainersRSACreateAndDelete(
self.context)
scenario.run()
secrets_service.create_rsa_container.assert_called_once_with()
secrets_service.container_delete.assert_called_once_with(
fake_container.container_ref)

4
tests/unit/scenarios/barbican/test_utils.py
View File

@ -15,7 +15,7 @@
import mock
from rally_openstack.scenarios.barbican import secrets
from rally_openstack.scenarios.barbican import utils
from tests.unit import test
@ -42,6 +42,6 @@ class BarbicanBaseTestCase(test.ScenarioTestCase):
self.mock_service = patch.start()
def test_barbican_base(self):
base = secrets.BarbicanBase(self.context)
base = utils.BarbicanBase(self.context)
self.assertEqual(base.admin_barbican,
self.mock_service.return_value)

40
tests/unit/services/barbican/test_secrets.py
View File

@ -60,3 +60,43 @@ class BarbicanServiceTestCase(test.TestCase):
.assert_called_once_with("fake_secret")
self._test_atomic_action_timer(self.atomic_actions(),
"barbican.delete_secret")
def test__list_containers(self):
self.assertEqual(
self.service.list_container(),
self.service._clients.barbican().containers.list.return_value)
self._test_atomic_action_timer(
self.atomic_actions(), "barbican.list_container")
def test__container_delete(self):
self.service.container_delete("fake_container")
self.service._clients.barbican().containers.delete \
.assert_called_once_with("fake_container")
self._test_atomic_action_timer(
self.atomic_actions(), "barbican.container_delete")
def test__container_create(self):
self.service.generate_random_name = mock.MagicMock(
return_value="container")
self.service.container_create()
self.service._clients.barbican().containers.create \
.assert_called_once_with(name="container", secrets=None)
def test__create_rsa_container(self):
self.service.generate_random_name = mock.MagicMock(
return_value="container")
self.service.create_rsa_container()
self.service._clients.barbican().containers.create_rsa \
.assert_called_once_with(
name="container", private_key=None,
private_key_passphrase=None, public_key=None)
def test__create_generate_container(self):
self.service.generate_random_name = mock.MagicMock(
return_value="container")
self.service.create_certificate_container()
self.service._clients.barbican().containers \
.create_certificate.assert_called_once_with(
certificate=None, intermediates=None,
name="container", private_key=None,
private_key_passphrase=None)