openstack
/
karbor
Code Issues Proposed changes

Update fullstack efficiency 

Parallel exec fullstack test case

Change-Id: I3d91cf01f5867db7f61b2b11496e81dfaa8aae8f
Related-On: Ibf1d00647158828a0fed55ba8c1623f0673de6b0
This commit is contained in:
zhangshuai 2017-02-24 10:43:36 +08:00
parent 08a671b135
commit f538af85bc
11 changed files with 266 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
devstack/devstackgaterc
View File

@ -32,11 +32,14 @@ s+=,karbor,karbor-api,karbor-operationengine,karbor-protection
ENABLED_SERVICES=$s
export ENABLED_SERVICES
DEVSTACK_LOCAL_CONFIG+="enable_plugin karbor git://git.openstack.org/openstack/karbor"
DEVSTACK_LOCAL_CONFIG+="API_WORKERS=8"
DEVSTACK_LOCAL_CONFIG+=$'\n'"VOLUME_BACKING_FILE_SIZE=20490M"
DEVSTACK_LOCAL_CONFIG+=$'\n'"enable_plugin karbor git://git.openstack.org/openstack/karbor"
DEVSTACK_LOCAL_CONFIG+=$'\n'"enable_plugin heat git://git.openstack.org/openstack/heat"
DEVSTACK_LOCAL_CONFIG+=$'\n'"SWIFT_HASH=66a3d6b56c1f479c8b4e70ab5c2000f5"
DEVSTACK_LOCAL_CONFIG+=$'\n'"SWIFT_REPLICAS=1"
DEVSTACK_LOCAL_CONFIG+=$'\n'"SWIFT_DATA_DIR=$DEST/data"
DEVSTACK_LOCAL_CONFIG+=$'\n'"SWIFT_LOOPBACK_DISK_SIZE=10G"
DEVSTACK_LOCAL_CONFIG+=$'\n'"DATABASE_PASSWORD=password"
DEVSTACK_LOCAL_CONFIG+=$'\n'"RABBIT_PASSWORD=password"
DEVSTACK_LOCAL_CONFIG+=$'\n'"SERVICE_PASSWORD=password"

7
karbor/services/protection/bank_plugins/swift_bank_plugin.py
View File

@ -82,14 +82,15 @@ class SwiftBankPlugin(BankPlugin, LeasePlugin):
@property
def connection(self):
if not self._connection:
self._connection = self._setup_connection()
_connection = self._setup_connection()
# create container
try:
self._put_container(self.bank_object_container)
self._put_container(self.bank_leases_container)
_connection.put_container(self.bank_object_container)
_connection.put_container(self.bank_leases_container)
except SwiftConnectionFailed as err:
LOG.error("bank plugin create container failed.")
raise exception.CreateContainerFailed(reason=err)
self._connection = _connection
# acquire lease
try:

2
karbor/services/protection/clients/swift.py
View File

@ -66,7 +66,7 @@ def create(context, conf, **kwargs):
register_opts(conf)
client_config = conf.swift_client
session = kwargs.get('session')
session = kwargs.get('session', None)
if not session:
auth = identity.Password(

57
karbor/tests/fullstack/karbor_objects.py
View File

@ -15,13 +15,14 @@ from karbor.common import constants
from karbor.tests.fullstack import karbor_base as base
from karbor.tests.fullstack import utils
SHORT_TIMEOUT = 30
MEDIUM_TIMEOUT = 90
LONG_TIMEOUT = 360
SHORT_TIMEOUT = 150
MEDIUM_TIMEOUT = 450
LONG_TIMEOUT = 900
SHORT_SLEEP = 2
MEDIUM_SLEEP = 5
LONG_SLEEP = 10
SHORT_SLEEP = 3
MEDIUM_SLEEP = 15
LONG_SLEEP = 30
HUGE_SLEEP = 100
DEFAULT_FLAVOR = "cirros256"
DEFAULT_NETWORK = "private"
@ -51,10 +52,10 @@ class Checkpoint(object):
self.id = checkpoint.id
utils.wait_until_true(partial(self._checkpoint_status,
constants.CHECKPOINT_STATUS_AVAILABLE),
timeout=timeout, sleep=LONG_SLEEP)
timeout=timeout, sleep=HUGE_SLEEP)
return self.id
def close(self, timeout=LONG_TIMEOUT):
def close(self, timeout=MEDIUM_TIMEOUT):
try:
self.karbor_client.checkpoints.delete(self._provider_id, self.id)
except Exception:
@ -80,8 +81,10 @@ class Plan(object):
return resource.to_dict()
if name is None:
name = "KarborFullstack-Plan-{id}".format(id=self._name_id)
self._name_id += 1
name = "KarborFullstack-Plan-{id}".format(
id=self.__class__._name_id
)
self.__class__._name_id += 1
resources = map(_transform_resource, resources)
plan = self.karbor_client.plans.create(name, provider_id, resources,
@ -124,7 +127,7 @@ class Restore(object):
restore_auth)
self.id = restore.id
utils.wait_until_true(partial(self._restore_status, 'success'),
timeout=timeout, sleep=LONG_SLEEP)
timeout=timeout, sleep=HUGE_SLEEP)
return self.id
def close(self):
@ -140,8 +143,10 @@ class Trigger(object):
def create(self, type, properties, name=None):
if name is None:
name = "KarborFullstack-Trigger-{id}".format(id=self._name_id)
self._name_id += 1
name = "KarborFullstack-Trigger-{id}".format(
id=self.__class__._name_id
)
self.__class__._name_id += 1
trigger = self.karbor_client.triggers.create(name, type, properties)
self.id = trigger.id
@ -165,9 +170,9 @@ class ScheduledOperation(object):
operation_definition, name=None):
if name is None:
name = "KarborFullstack-Scheduled-Operation-{id}".format(
id=self._name_id
id=self.__class__._name_id
)
self._name_id += 1
self.__class__._name_id += 1
scheduled_operation = self.karbor_client.scheduled_operations.create(
name,
@ -215,7 +220,7 @@ class Server(object):
}
def create(self, name=None, image=None, flavor=DEFAULT_FLAVOR,
network=DEFAULT_NETWORK, timeout=MEDIUM_TIMEOUT):
network=DEFAULT_NETWORK, timeout=LONG_TIMEOUT):
if not image:
images = self.glance_client.images.list()
for image_iter in images:
@ -225,8 +230,10 @@ class Server(object):
assert image
flavor = self.nova_client.flavors.find(name=flavor)
if name is None:
name = "KarborFullstack-Server-{id}".format(id=self._name_id)
self._name_id += 1
name = "KarborFullstack-Server-{id}".format(
id=self.__class__._name_id
)
self.__class__._name_id += 1
self._name = name
networks = self.neutron_client.list_networks(name=network)
@ -257,7 +264,7 @@ class Server(object):
def attach_volume(self, volume_id, timeout=MEDIUM_TIMEOUT):
self.nova_client.volumes.create_server_volume(self.id, volume_id)
utils.wait_until_true(partial(self._volume_attached, volume_id),
timeout=timeout, sleep=MEDIUM_SLEEP)
timeout=timeout, sleep=SHORT_SLEEP)
def _volume_detached(self, volume_id):
volume_item = self.cinder_client.volumes.get(volume_id)
@ -271,7 +278,7 @@ class Server(object):
def detach_volume(self, volume_id, timeout=MEDIUM_TIMEOUT):
self.nova_client.volumes.delete_server_volume(self.id, volume_id)
utils.wait_until_true(partial(self._volume_detached, volume_id),
timeout=timeout, sleep=MEDIUM_SLEEP)
timeout=timeout, sleep=SHORT_SLEEP)
def close(self, timeout=MEDIUM_TIMEOUT):
try:
@ -308,10 +315,12 @@ class Volume(object):
"name": self._name,
}
def create(self, size, name=None, timeout=MEDIUM_TIMEOUT):
def create(self, size, name=None, timeout=LONG_TIMEOUT):
if name is None:
name = "KarborFullstack-Volume-{id}".format(id=self._name_id)
self._name_id += 1
name = "KarborFullstack-Volume-{id}".format(
id=self.__class__._name_id
)
self.__class__._name_id += 1
self._name = name
volume = self.cinder_client.volumes.create(size, name=name)
@ -320,7 +329,7 @@ class Volume(object):
timeout=timeout, sleep=MEDIUM_SLEEP)
return self.id
def close(self, timeout=MEDIUM_TIMEOUT):
def close(self, timeout=LONG_TIMEOUT):
try:
self.cinder_client.volumes.delete(self.id)
except Exception:

115
karbor/tests/fullstack/test_checkpoints.py
View File

@ -27,15 +27,12 @@ class CheckpointsTest(karbor_base.KarborBaseTest):
plan = self.store(objects.Plan())
plan.create(self.provider_id_os, [volume, ])
backups = self.cinder_client.backups.list()
before_num = len(backups)
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id, plan.id)
checkpoint.create(self.provider_id, plan.id, timeout=2400)
backups = self.cinder_client.backups.list()
after_num = len(backups)
self.assertEqual(1, after_num - before_num)
search_opts = {"volume_id": volume.id}
backups = self.cinder_client.backups.list(search_opts=search_opts)
self.assertEqual(1, len(backups))
def test_checkpoint_delete(self):
volume = self.store(objects.Volume())
@ -43,22 +40,17 @@ class CheckpointsTest(karbor_base.KarborBaseTest):
plan = self.store(objects.Plan())
plan.create(self.provider_id, [volume, ])
checkpoints = self.karbor_client.checkpoints.list(self.provider_id)
before_num = len(checkpoints)
checkpoint = objects.Checkpoint()
checkpoint.create(self.provider_id, plan.id)
# sanity
checkpoint.create(self.provider_id, plan.id, timeout=2400)
checkpoint_item = self.karbor_client.checkpoints.get(self.provider_id,
checkpoint.id)
self.assertEqual(constants.CHECKPOINT_STATUS_AVAILABLE,
checkpoint_item.status)
checkpoint.close()
checkpoints = self.karbor_client.checkpoints.list(self.provider_id)
after_num = len(checkpoints)
self.assertEqual(before_num, after_num)
items = self.karbor_client.checkpoints.list(self.provider_id)
ids = [item.id for item in items]
self.assertTrue(checkpoint.id not in ids)
def test_checkpoint_list(self):
volume = self.store(objects.Volume())
@ -66,15 +58,12 @@ class CheckpointsTest(karbor_base.KarborBaseTest):
plan = self.store(objects.Plan())
plan.create(self.provider_id, [volume, ])
checkpoints = self.karbor_client.checkpoints.list(self.provider_id)
before_num = len(checkpoints)
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id, plan.id)
checkpoint.create(self.provider_id, plan.id, timeout=2400)
checkpoints = self.karbor_client.checkpoints.list(self.provider_id)
after_num = len(checkpoints)
self.assertEqual(1, after_num - before_num)
items = self.karbor_client.checkpoints.list(self.provider_id)
ids = [item.id for item in items]
self.assertTrue(checkpoint.id in ids)
def test_checkpoint_get(self):
volume = self.store(objects.Volume())
@ -83,7 +72,7 @@ class CheckpointsTest(karbor_base.KarborBaseTest):
plan.create(self.provider_id, [volume, ])
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id, plan.id)
checkpoint.create(self.provider_id, plan.id, timeout=2400)
# sanity
checkpoint_item = self.karbor_client.checkpoints.get(self.provider_id,
@ -92,50 +81,54 @@ class CheckpointsTest(karbor_base.KarborBaseTest):
checkpoint_item.status)
self.assertEqual(checkpoint.id, checkpoint_item.id)
def test_checkpoint_for_server_attached_volume(self):
"""Test checkpoint for server which has attached some volumes"""
def test_server_attached_volume_only_protect_server(self):
"""Test checkpoint for server with attached volume
Test checkpoint for server which has attached one volume,
but only add server in protect source
"""
volume = self.store(objects.Volume())
volume.create(1)
server = self.store(objects.Server())
server.create()
server.attach_volume(volume.id)
plan0 = self.store(objects.Plan())
plan0.create(self.provider_id, [server, ])
checkpoints = self.karbor_client.checkpoints.list(self.provider_id)
before_checkpoints_num = len(checkpoints)
backups = self.cinder_client.backups.list()
before_backups_num = len(backups)
plan = self.store(objects.Plan())
plan.create(self.provider_id, [server, ])
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id, plan0.id, timeout=900)
checkpoints = self.karbor_client.checkpoints.list(self.provider_id)
after_checkpoints_num = len(checkpoints)
self.assertEqual(1, after_checkpoints_num - before_checkpoints_num)
backups = self.cinder_client.backups.list()
after_backups_num = len(backups)
self.assertEqual(1, after_backups_num - before_backups_num)
plan1 = self.store(objects.Plan())
plan1.create(self.provider_id, [server, volume])
checkpoints = self.karbor_client.checkpoints.list(self.provider_id)
before_checkpoints_num = len(checkpoints)
backups = self.cinder_client.backups.list()
before_backups_num = len(backups)
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id, plan1.id, timeout=720)
checkpoints = self.karbor_client.checkpoints.list(self.provider_id)
after_checkpoints_num = len(checkpoints)
self.assertEqual(1, after_checkpoints_num - before_checkpoints_num)
backups = self.cinder_client.backups.list()
after_backups_num = len(backups)
self.assertEqual(1, after_backups_num - before_backups_num)
checkpoint.create(self.provider_id, plan.id, timeout=2400)
items = self.karbor_client.checkpoints.list(self.provider_id)
ids = [item.id for item in items]
self.assertTrue(checkpoint.id in ids)
search_opts = {"volume_id": volume.id}
backups = self.cinder_client.backups.list(search_opts=search_opts)
self.assertEqual(1, len(backups))
server.detach_volume(volume.id)
def test_server_attached_volume_protect_both(self):
"""Test checkpoint for server with attached volume
Test checkpoint for server which has attached one volume,
and add server and volume both in protect source
"""
volume = self.store(objects.Volume())
volume.create(1)
server = self.store(objects.Server())
server.create()
server.attach_volume(volume.id)
plan = self.store(objects.Plan())
plan.create(self.provider_id, [server, volume])
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id, plan.id, timeout=2400)
items = self.karbor_client.checkpoints.list(self.provider_id)
ids = [item.id for item in items]
self.assertTrue(checkpoint.id in ids)
search_opts = {"volume_id": volume.id}
backups = self.cinder_client.backups.list(search_opts=search_opts)
self.assertEqual(1, len(backups))
server.detach_volume(volume.id)

9
karbor/tests/fullstack/test_plans.py
View File

@ -22,18 +22,19 @@ class PlansTest(karbor_base.KarborBaseTest):
self.provider_id = self.provider_id_noop
def test_plans_list(self):
nplans_before = len(self.karbor_client.plans.list())
# create plan
volume = self.store(objects.Volume())
volume.create(1)
plan1 = self.store(objects.Plan())
plan2 = self.store(objects.Plan())
plan1.create(self.provider_id, [volume, ])
plan2 = self.store(objects.Plan())
plan2.create(self.provider_id, [volume, ])
# list plans after creating
nplans_after = len(self.karbor_client.plans.list())
self.assertEqual(2, nplans_after - nplans_before)
items = self.karbor_client.plans.list()
ids = [item.id for item in items]
self.assertTrue(plan1.id in ids)
self.assertTrue(plan2.id in ids)
def test_plans_get(self):
plan_name = "Fullstack Test Get"

53
karbor/tests/fullstack/test_protectables.py
View File

@ -10,6 +10,7 @@
# License for the specific language governing permissions and limitations
# under the License.
from karbor.common.constants import RESOURCE_TYPES
from karbor.tests.fullstack import karbor_base
from karbor.tests.fullstack import karbor_objects as objects
@ -17,35 +18,49 @@ from karbor.tests.fullstack import karbor_objects as objects
class ProtectablesTest(karbor_base.KarborBaseTest):
"""Test Protectables operation """
def test_protectables_get_with_project(self):
def test_protectables_list(self):
items = self.karbor_client.protectables.list()
query_types = [item.protectable_type for item in items]
self.assertItemsEqual(RESOURCE_TYPES, query_types)
def test_protectables_get(self):
protectable_type = 'OS::Keystone::Project'
res = self.karbor_client.protectables.get(protectable_type)
self.assertTrue(len(res.dependent_types))
self.assertEqual(protectable_type, res.name)
protectable_type = 'OS::Nova::Server'
res = self.karbor_client.protectables.get(protectable_type)
self.assertEqual(protectable_type, res.name)
def test_protectables_list_instances(self):
res_list = self.karbor_client.protectables.list_instances(
volume = self.store(objects.Volume())
volume.create(1)
items = self.karbor_client.protectables.list_instances(
'OS::Cinder::Volume')
before_num = len(res_list)
volume1 = self.store(objects.Volume())
volume1.create(1)
res_list = self.karbor_client.protectables.list_instances(
'OS::Cinder::Volume')
after_num = len(res_list)
self.assertEqual(1, after_num - before_num)
ids = [item.id for item in items]
self.assertTrue(volume.id in ids)
def test_protectables_get_with_server(self):
server_list = self.karbor_client.protectables.list_instances(
'OS::Nova::Server')
before_num = len(server_list)
server = self.store(objects.Server())
server.create()
server_list = self.karbor_client.protectables.list_instances(
items = self.karbor_client.protectables.list_instances(
'OS::Nova::Server')
after_num = len(server_list)
self.assertEqual(1, after_num - before_num)
ids = [item.id for item in items]
self.assertTrue(server.id in ids)
def test_protectables_get_with_attach_volume(self):
def test_protectables_get_instance(self):
volume = self.store(objects.Volume())
volume.create(1)
instance = self.karbor_client.protectables.get_instance(
'OS::Cinder::Volume', volume.id)
self.assertEqual(volume.id, instance.id)
server = self.store(objects.Server())
server.create()
instance = self.karbor_client.protectables.get_instance(
'OS::Nova::Server', server.id)
self.assertEqual(server.id, instance.id)
def test_protectables_get_attach_volume_instance(self):
server = self.store(objects.Server())
server.create()

112
karbor/tests/fullstack/test_restores.py
View File

@ -12,9 +12,17 @@
import re
from oslo_utils import importutils
from karbor.common import constants
from karbor.tests.fullstack import karbor_base
from karbor.tests.fullstack import karbor_objects as objects
DELETABLE_STATUS = {
"volume_deletable_status": ["available", "error"],
"server_deletable_status": ["available", "running"]
}
class RestoresTest(karbor_base.KarborBaseTest):
"""Test Restores operation """
@ -25,15 +33,31 @@ class RestoresTest(karbor_base.KarborBaseTest):
"password": "password",
}
def setUp(self):
super(RestoresTest, self).setUp()
def _store(self, resources_status):
if not isinstance(resources_status, dict):
return
def _store_volume(self, volumes_pre, volumes_post):
volumes = list(set(volumes_post).difference(set(volumes_pre)))
for volume in volumes:
volume_ = objects.Volume()
volume_.id = volume.id
self.store(volume_)
for resource, status in resources_status.items():
resource_type, resource_id = resource.split("#")
if resource_type is None:
continue
types = resource_type.split("::")
if len(types) < 3:
continue
try:
obj_class = importutils.import_class(
"karbor.tests.fullstack.karbor_objects.%s" % types[2])
except Exception:
continue
deletable_str = "%s_deletable_status" % types[2].lower()
deletable_list = eval(deletable_str, DELETABLE_STATUS)
if callable(obj_class) and status in deletable_list:
obj = obj_class()
obj.id = resource_id
obj.close()
@staticmethod
def get_restore_target(endpoint):
@ -53,21 +77,15 @@ class RestoresTest(karbor_base.KarborBaseTest):
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id_noop, plan.id)
restores = self.karbor_client.restores.list()
before_num = len(restores)
volumes_pre = self.cinder_client.volumes.list()
restore_target = self.get_restore_target(self.keystone_endpoint)
restore = self.store(objects.Restore())
restore.create(self.provider_id_noop, checkpoint.id,
restore_target, self.parameters, self.restore_auth)
restores = self.karbor_client.restores.list()
after_num = len(restores)
self.assertEqual(1, after_num - before_num)
volumes_post = self.cinder_client.volumes.list()
self._store_volume(volumes_pre, volumes_post)
item = self.karbor_client.restores.get(restore.id)
self.assertEqual(constants.RESTORE_STATUS_SUCCESS,
item.status)
self._store(item.resources_status)
def test_restore_create_without_target_and_auth(self):
volume = self.store(objects.Volume())
@ -77,20 +95,14 @@ class RestoresTest(karbor_base.KarborBaseTest):
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id_noop, plan.id)
restores = self.karbor_client.restores.list()
before_num = len(restores)
volumes_pre = self.cinder_client.volumes.list()
restore = self.store(objects.Restore())
restore.create(self.provider_id_noop, checkpoint.id,
None, self.parameters, None)
restores = self.karbor_client.restores.list()
after_num = len(restores)
self.assertEqual(1, after_num - before_num)
volumes_post = self.cinder_client.volumes.list()
self._store_volume(volumes_pre, volumes_post)
item = self.karbor_client.restores.get(restore.id)
self.assertEqual(constants.RESTORE_STATUS_SUCCESS,
item.status)
self._store(item.resources_status)
def test_restore_get(self):
volume = self.store(objects.Volume())
@ -100,18 +112,16 @@ class RestoresTest(karbor_base.KarborBaseTest):
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id_noop, plan.id)
volumes_pre = self.cinder_client.volumes.list()
restore_target = self.get_restore_target(self.keystone_endpoint)
restore = self.store(objects.Restore())
restore.create(self.provider_id_noop, checkpoint.id,
restore_target, self.parameters, self.restore_auth)
restore_item = self.karbor_client.restores.get(restore.id)
self.assertEqual(restore.id, restore_item.id)
volumes_post = self.cinder_client.volumes.list()
self._store_volume(volumes_pre, volumes_post)
item = self.karbor_client.restores.get(restore.id)
self.assertEqual(restore.id, item.id)
self.assertEqual(constants.RESTORE_STATUS_SUCCESS,
item.status)
self._store(item.resources_status)
def test_restore_list(self):
volume = self.store(objects.Volume())
@ -123,7 +133,6 @@ class RestoresTest(karbor_base.KarborBaseTest):
restores = self.karbor_client.restores.list()
before_num = len(restores)
volumes_pre = self.cinder_client.volumes.list()
restore_target = self.get_restore_target(self.keystone_endpoint)
restore1 = self.store(objects.Restore())
@ -135,10 +144,12 @@ class RestoresTest(karbor_base.KarborBaseTest):
restores = self.karbor_client.restores.list()
after_num = len(restores)
self.assertEqual(2, after_num - before_num)
self.assertLessEqual(2, after_num - before_num)
volumes_post = self.cinder_client.volumes.list()
self._store_volume(volumes_pre, volumes_post)
item1 = self.karbor_client.restores.get(restore1.id)
self._store(item1.resources_status)
item2 = self.karbor_client.restores.get(restore2.id)
self._store(item2.resources_status)
def test_restore_resources(self):
volume = self.store(objects.Volume())
@ -147,17 +158,14 @@ class RestoresTest(karbor_base.KarborBaseTest):
plan.create(self.provider_id_os, [volume, ])
checkpoint = self.store(objects.Checkpoint())
checkpoint.create(self.provider_id_os, plan.id)
volumes_pre = self.cinder_client.volumes.list()
restore = self.store(objects.Restore())
restore_target = self.get_restore_target(self.keystone_endpoint)
restore_id = restore.create(
self.provider_id_os,
checkpoint.id,
restore_target,
self.parameters,
self.restore_auth,
)
restore_obj = self.karbor_client.restores.get(restore_id)
self.assertEqual(len(restore_obj.resources_status), 1)
volumes_post = self.cinder_client.volumes.list()
self._store_volume(volumes_pre, volumes_post)
restore = self.store(objects.Restore())
restore.create(self.provider_id_os, checkpoint.id,
restore_target, self.parameters, self.restore_auth)
item = self.karbor_client.restores.get(restore.id)
self.assertEqual(constants.RESTORE_STATUS_SUCCESS,
item.status)
self.assertEqual(1, len(item.resources_status))
self._store(item.resources_status)

139
karbor/tests/fullstack/test_scheduled_operations.py
View File

@ -35,10 +35,15 @@ class ScheduledOperationsTest(karbor_base.KarborBaseTest):
self.assertTrue(len(providers))
self.provider_id = self.provider_id_noop
def _create_scheduled_operation(self,
trigger_properties,
operation_definition,
operation_name=None):
def _create_scheduled_operation(
self,
resources,
trigger_properties=DEFAULT_PROPERTY,
operation_name=None):
plan = self.store(objects.Plan())
plan.create(self.provider_id, resources)
operation_definition = {'plan_id': plan.id,
'provider_id': self.provider_id}
trigger = self.store(objects.Trigger())
trigger.create('time', trigger_properties)
@ -47,43 +52,34 @@ class ScheduledOperationsTest(karbor_base.KarborBaseTest):
operation_definition, operation_name)
return operation
def _create_scheduled_operation_for_volume(
self,
trigger_properties=DEFAULT_PROPERTY,
operation_name=None):
def _create_for_volume(self,
trigger_properties=DEFAULT_PROPERTY,
operation_name=None):
volume = self.store(objects.Volume())
volume.create(1)
plan = self.store(objects.Plan())
plan.create(self.provider_id, [volume, ])
operation_definition = {'plan_id': plan.id,
'provider_id': self.provider_id}
return self._create_scheduled_operation(trigger_properties,
operation_definition,
return self._create_scheduled_operation([volume, ],
trigger_properties,
operation_name)
def _create_scheduled_operation_for_server(
self,
trigger_properties=DEFAULT_PROPERTY,
operation_name=None):
def _create_for_server(self,
trigger_properties=DEFAULT_PROPERTY,
operation_name=None):
server = self.store(objects.Server())
server.create()
plan = self.store(objects.Plan())
plan.create(self.provider_id, [server, ])
operation_definition = {'plan_id': plan.id,
'provider_id': self.provider_id}
return self._create_scheduled_operation(trigger_properties,
operation_definition,
return self._create_scheduled_operation([server, ],
trigger_properties,
operation_name)
def test_scheduled_operations_create_no_scheduled(self):
operation_items = self.karbor_client.scheduled_operations.list()
before_num = len(operation_items)
name = "KarborFullstack-Scheduled-Operation-no-scheduled"
operation = self.store(self._create_for_volume(operation_name=name))
self.store(self._create_scheduled_operation_for_volume())
item = self.karbor_client.scheduled_operations.get(operation.id)
self.assertEqual(name, item.name)
operation_items = self.karbor_client.scheduled_operations.list()
after_num = len(operation_items)
self.assertEqual(1, after_num - before_num)
items = self.karbor_client.scheduled_operations.list()
ids = [item_.id for item_ in items]
self.assertTrue(operation.id in ids)
@staticmethod
def _wait_timestamp(pattern, start_time, freq):
@ -113,69 +109,56 @@ class ScheduledOperationsTest(karbor_base.KarborBaseTest):
pattern = '*/5 * * * *'
cur_property = {'pattern': pattern, 'format': 'crontab'}
before_items = self.karbor_client.checkpoints.list(self.provider_id)
before_num = len(before_items)
start_time = datetime.now().replace(microsecond=0)
self.store(self._create_scheduled_operation_for_volume(cur_property))
operation = self.store(self._create_for_volume(cur_property))
sleep_time = self._wait_timestamp(pattern, start_time, freq)
self.assertNotEqual(0, sleep_time)
eventlet.sleep(sleep_time)
after_items = self.karbor_client.checkpoints.list(self.provider_id)
after_num = len(after_items)
self.assertEqual(freq, after_num - before_num)
items = self.karbor_client.checkpoints.list(self.provider_id)
operation_item = self.karbor_client.scheduled_operations.get(
operation.id)
plan_id = operation_item.operation_definition["plan_id"]
cps = filter(lambda x: x.protection_plan["id"] == plan_id, items)
self.assertEqual(freq, len(cps))
for item in after_items:
if item not in before_items:
utils.wait_until_true(
partial(self._checkpoint_status,
item.id,
constants.CHECKPOINT_STATUS_AVAILABLE),
timeout=objects.LONG_TIMEOUT, sleep=objects.LONG_SLEEP
)
self.karbor_client.checkpoints.delete(self.provider_id,
item.id)
for cp in cps:
utils.wait_until_true(
partial(self._checkpoint_status,
cp.id,
constants.CHECKPOINT_STATUS_AVAILABLE),
timeout=objects.LONG_TIMEOUT, sleep=objects.LONG_SLEEP
)
checkpoint = self.store(objects.Checkpoint())
checkpoint._provider_id = self.provider_id
checkpoint.id = cp.id
def test_scheduled_operations_list(self):
operation_items = self.karbor_client.scheduled_operations.list()
before_num = len(operation_items)
operation1 = self.store(self._create_for_volume())
operation2 = self.store(self._create_for_server())
self.store(self._create_scheduled_operation_for_volume())
self.store(self._create_scheduled_operation_for_server())
operation_items = self.karbor_client.scheduled_operations.list()
after_num = len(operation_items)
self.assertEqual(2, after_num - before_num)
items = self.karbor_client.scheduled_operations.list()
ids = [item.id for item in items]
self.assertTrue(operation1.id in ids)
self.assertTrue(operation2.id in ids)
def test_scheduled_operations_get(self):
operation_name = "KarborFullstack-Scheduled-Operation-Test-Get"
operation = self._create_scheduled_operation_for_volume(
operation_name=operation_name
)
name = "KarborFullstack-Scheduled-Operation-Test-Get"
operation = self._create_for_volume(operation_name=name)
self.store(operation)
operation_item = self.karbor_client.scheduled_operations.get(
operation.id
)
self.assertEqual(operation_item.name, operation_name)
self.assertEqual(operation_item.id, operation.id)
item = self.karbor_client.scheduled_operations.get(operation.id)
self.assertEqual(item.name, name)
self.assertEqual(item.id, operation.id)
def test_scheduled_operations_delete(self):
operation_items = self.karbor_client.scheduled_operations.list()
before_num = len(operation_items)
name = "KarborFullstack-Scheduled-Operation-Test-Delete"
operation = self._create_for_volume(operation_name=name)
operation_name = "KarborFullstack-Scheduled-Operation-Test-Delete"
operation = self._create_scheduled_operation_for_volume(
operation_name=operation_name
)
operation_item = self.karbor_client.scheduled_operations.get(
operation.id
)
self.assertEqual(operation_name, operation_item.name)
item = self.karbor_client.scheduled_operations.get(operation.id)
self.assertEqual(name, item.name)
operation.close()
operation_items = self.karbor_client.scheduled_operations.list()
after_num = len(operation_items)
self.assertEqual(before_num, after_num)
items = self.karbor_client.scheduled_operations.list()
ids = [item_.id for item_ in items]
self.assertTrue(operation.id not in ids)

21
karbor/tests/fullstack/test_triggers.py
View File

@ -16,19 +16,18 @@ from karbor.tests.fullstack import karbor_objects as objects
class TriggersTest(karbor_base.KarborBaseTest):
"""Test Triggers operation
"""Test Triggers operation"""
"""
def test_triggers_list(self):
trigger_items = self.karbor_client.triggers.list()
before_num = len(trigger_items)
trigger1 = self.store(objects.Trigger())
trigger1.create('time', {'pattern': '0 20 * * 2', 'format': 'crontab'})
trigger2 = self.store(objects.Trigger())
trigger2.create('time', {'pattern': '0 10 * * *', 'format': 'crontab'})
trigger_items = self.karbor_client.triggers.list()
after_num = len(trigger_items)
self.assertEqual(2, after_num - before_num)
items = self.karbor_client.triggers.list()
ids = [item.id for item in items]
self.assertTrue(trigger1.id in ids)
self.assertTrue(trigger2.id in ids)
def test_triggers_get(self):
trigger_name = "FullStack Trigger Test Get"
@ -40,10 +39,8 @@ class TriggersTest(karbor_base.KarborBaseTest):
def test_triggers_delete(self):
trigger = objects.Trigger()
trigger_items = self.karbor_client.triggers.list()
before_num = len(trigger_items)
trigger.create('time', {'pattern': '0 12 * * 2', 'format': 'crontab'})
self.karbor_client.triggers.delete(trigger.id)
trigger_items = self.karbor_client.triggers.list()
after_num = len(trigger_items)
self.assertEqual(0, after_num - before_num)
items = self.karbor_client.triggers.list()
ids = [item.id for item in items]
self.assertTrue(trigger.id not in ids)

2
tox.ini
View File

@ -19,7 +19,7 @@ commands = python setup.py test --slowest --testr-args='{posargs}'
basepython = python2.7
setenv = OS_TEST_PATH=./karbor/tests/fullstack
OS_TEST_TIMEOUT=3600
commands = python setup.py test --slowest --testr-args="--concurrency=1 {posargs}"
commands = python setup.py test --slowest --testr-args="--concurrency=4 {posargs}"
[testenv:pep8]
commands = flake8