openstack
/
openstacksdk
Code Issues Proposed changes

Merge "Support to wait for load balancer to be ACTIVE"

This commit is contained in:
Zuul 2018-07-11 16:08:52 +00:00 committed by Gerrit Code Review
parent 39edca1899 abfc8580f4
commit fdde1c16b6
3 changed files with 48 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
openstack/load_balancer/v2/_proxy.py
View File

@ -18,6 +18,7 @@ from openstack.load_balancer.v2 import load_balancer as _lb
from openstack.load_balancer.v2 import member as _member
from openstack.load_balancer.v2 import pool as _pool
from openstack import proxy
from openstack import resource
class Proxy(proxy.Proxy):
@ -106,6 +107,13 @@ class Proxy(proxy.Proxy):
"""
return self._update(_lb.LoadBalancer, load_balancer, **attrs)
def wait_for_load_balancer(self, name_or_id, status='ACTIVE',
failures=['ERROR'], interval=2, wait=300):
lb = self._find(_lb.LoadBalancer, name_or_id, ignore_missing=False)
return resource.wait_for_status(self, lb, status, failures, interval,
wait, attribute='provisioning_status')
def create_listener(self, **attrs):
"""Create a new listener from attributes

58
openstack/tests/functional/load_balancer/base.py
View File

@ -1,58 +0,0 @@
# Copyright 2017 Rackspace, US Inc.
# 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 time
from openstack import exceptions
from openstack.tests.functional import base
class BaseLBFunctionalTest(base.BaseFunctionalTest):
def lb_wait_for_status(self, lb, status, failures, interval=1, wait=120):
"""Wait for load balancer to be in a particular provisioning status.
:param lb: The load balancer to wait on to reach the status.
:type lb: :class:`~openstack.load_blanacer.v2.load_balancer
:param status: Desired status of the resource.
:param list failures: Statuses that would indicate the transition
failed such as 'ERROR'.
:param interval: Number of seconds to wait between checks.
:param wait: Maximum number of seconds to wait for transition.
Note, most actions should easily finish in 120 seconds,
but for load balancer create slow hosts can take up to
ten minutes for nova to fully boot a VM.
:return: None
:raises: :class:`~openstack.exceptions.ResourceTimeout` transition
to status failed to occur in wait seconds.
:raises: :class:`~openstack.exceptions.ResourceFailure` resource
transitioned to one of the failure states.
"""
total_sleep = 0
if failures is None:
failures = []
while total_sleep < wait:
lb = self.conn.load_balancer.get_load_balancer(lb.id)
if lb.provisioning_status == status:
return None
if lb.provisioning_status in failures:
msg = ("Load Balancer %s transitioned to failure state %s" %
(lb.id, lb.provisioning_status))
raise exceptions.ResourceFailure(msg)
time.sleep(interval)
total_sleep += interval
msg = "Timeout waiting for Load Balancer %s to transition to %s" % (
lb.id, status)
raise exceptions.ResourceTimeout(msg)

90
openstack/tests/functional/load_balancer/v2/test_load_balancer.py
View File

@ -17,10 +17,10 @@ from openstack.load_balancer.v2 import listener
from openstack.load_balancer.v2 import load_balancer
from openstack.load_balancer.v2 import member
from openstack.load_balancer.v2 import pool
from openstack.tests.functional.load_balancer import base as lb_base
from openstack.tests.functional import base
class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
class TestLoadBalancer(base.BaseFunctionalTest):
HM_ID = None
L7POLICY_ID = None
@ -70,8 +70,8 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
self.assertEqual(self.LB_NAME, test_lb.name)
# Wait for the LB to go ACTIVE. On non-virtualization enabled hosts
# it can take nova up to ten minutes to boot a VM.
self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR'], interval=1, wait=600)
self.conn.load_balancer.wait_for_load_balancer(test_lb.id, interval=1,
wait=600)
self.LB_ID = test_lb.id
test_listener = self.conn.load_balancer.create_listener(
@ -80,8 +80,7 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
assert isinstance(test_listener, listener.Listener)
self.assertEqual(self.LISTENER_NAME, test_listener.name)
self.LISTENER_ID = test_listener.id
self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_pool = self.conn.load_balancer.create_pool(
name=self.POOL_NAME, protocol=self.PROTOCOL,
@ -89,8 +88,7 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
assert isinstance(test_pool, pool.Pool)
self.assertEqual(self.POOL_NAME, test_pool.name)
self.POOL_ID = test_pool.id
self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_member = self.conn.load_balancer.create_member(
pool=self.POOL_ID, name=self.MEMBER_NAME,
@ -99,8 +97,7 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
assert isinstance(test_member, member.Member)
self.assertEqual(self.MEMBER_NAME, test_member.name)
self.MEMBER_ID = test_member.id
self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_hm = self.conn.load_balancer.create_health_monitor(
pool_id=self.POOL_ID, name=self.HM_NAME, delay=self.DELAY,
@ -109,8 +106,7 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
assert isinstance(test_hm, health_monitor.HealthMonitor)
self.assertEqual(self.HM_NAME, test_hm.name)
self.HM_ID = test_hm.id
self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_l7policy = self.conn.load_balancer.create_l7_policy(
listener_id=self.LISTENER_ID, name=self.L7POLICY_NAME,
@ -118,8 +114,7 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
assert isinstance(test_l7policy, l7_policy.L7Policy)
self.assertEqual(self.L7POLICY_NAME, test_l7policy.name)
self.L7POLICY_ID = test_l7policy.id
self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_l7rule = self.conn.load_balancer.create_l7_rule(
l7_policy=self.L7POLICY_ID, compare_type=self.COMPARE_TYPE,
@ -127,35 +122,34 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
assert isinstance(test_l7rule, l7_rule.L7Rule)
self.assertEqual(self.COMPARE_TYPE, test_l7rule.compare_type)
self.L7RULE_ID = test_l7rule.id
self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
def tearDown(self):
test_lb = self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
self.conn.load_balancer.delete_l7_rule(
self.L7RULE_ID, l7_policy=self.L7POLICY_ID, ignore_missing=False)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
self.conn.load_balancer.delete_l7_policy(
self.L7POLICY_ID, ignore_missing=False)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
self.conn.load_balancer.delete_health_monitor(
self.HM_ID, ignore_missing=False)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
self.conn.load_balancer.delete_member(
self.MEMBER_ID, self.POOL_ID, ignore_missing=False)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
self.conn.load_balancer.delete_pool(self.POOL_ID, ignore_missing=False)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
self.conn.load_balancer.delete_listener(self.LISTENER_ID,
ignore_missing=False)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
self.conn.load_balancer.delete_load_balancer(
self.LB_ID, ignore_missing=False)
@ -176,17 +170,15 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
self.assertIn(self.LB_NAME, names)
def test_lb_update(self):
update_lb = self.conn.load_balancer.update_load_balancer(
self.conn.load_balancer.update_load_balancer(
self.LB_ID, name=self.UPDATE_NAME)
self.lb_wait_for_status(update_lb, status='ACTIVE',
failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_lb = self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.assertEqual(self.UPDATE_NAME, test_lb.name)
update_lb = self.conn.load_balancer.update_load_balancer(
self.conn.load_balancer.update_load_balancer(
self.LB_ID, name=self.LB_NAME)
self.lb_wait_for_status(update_lb, status='ACTIVE',
failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_lb = self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.assertEqual(self.LB_NAME, test_lb.name)
@ -207,19 +199,17 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
self.assertIn(self.LISTENER_NAME, names)
def test_listener_update(self):
test_lb = self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.conn.load_balancer.update_listener(
self.LISTENER_ID, name=self.UPDATE_NAME)
self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_listener = self.conn.load_balancer.get_listener(self.LISTENER_ID)
self.assertEqual(self.UPDATE_NAME, test_listener.name)
self.conn.load_balancer.update_listener(
self.LISTENER_ID, name=self.LISTENER_NAME)
self.lb_wait_for_status(test_lb, status='ACTIVE',
failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_listener = self.conn.load_balancer.get_listener(self.LISTENER_ID)
self.assertEqual(self.LISTENER_NAME, test_listener.name)
@ -238,17 +228,17 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
self.assertIn(self.POOL_NAME, names)
def test_pool_update(self):
test_lb = self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.conn.load_balancer.update_pool(self.POOL_ID,
name=self.UPDATE_NAME)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_pool = self.conn.load_balancer.get_pool(self.POOL_ID)
self.assertEqual(self.UPDATE_NAME, test_pool.name)
self.conn.load_balancer.update_pool(self.POOL_ID,
name=self.POOL_NAME)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_pool = self.conn.load_balancer.get_pool(self.POOL_ID)
self.assertEqual(self.POOL_NAME, test_pool.name)
@ -272,18 +262,18 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
self.assertIn(self.MEMBER_NAME, names)
def test_member_update(self):
test_lb = self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.conn.load_balancer.update_member(self.MEMBER_ID, self.POOL_ID,
name=self.UPDATE_NAME)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_member = self.conn.load_balancer.get_member(self.MEMBER_ID,
self.POOL_ID)
self.assertEqual(self.UPDATE_NAME, test_member.name)
self.conn.load_balancer.update_member(self.MEMBER_ID, self.POOL_ID,
name=self.MEMBER_NAME)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_member = self.conn.load_balancer.get_member(self.MEMBER_ID,
self.POOL_ID)
self.assertEqual(self.MEMBER_NAME, test_member.name)
@ -306,17 +296,17 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
self.assertIn(self.HM_NAME, names)
def test_health_monitor_update(self):
test_lb = self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.conn.load_balancer.update_health_monitor(self.HM_ID,
name=self.UPDATE_NAME)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_hm = self.conn.load_balancer.get_health_monitor(self.HM_ID)
self.assertEqual(self.UPDATE_NAME, test_hm.name)
self.conn.load_balancer.update_health_monitor(self.HM_ID,
name=self.HM_NAME)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_hm = self.conn.load_balancer.get_health_monitor(self.HM_ID)
self.assertEqual(self.HM_NAME, test_hm.name)
@ -337,18 +327,18 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
self.assertIn(self.L7POLICY_NAME, names)
def test_l7_policy_update(self):
test_lb = self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.conn.load_balancer.update_l7_policy(
self.L7POLICY_ID, name=self.UPDATE_NAME)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_l7_policy = self.conn.load_balancer.get_l7_policy(
self.L7POLICY_ID)
self.assertEqual(self.UPDATE_NAME, test_l7_policy.name)
self.conn.load_balancer.update_l7_policy(self.L7POLICY_ID,
name=self.L7POLICY_NAME)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_l7_policy = self.conn.load_balancer.get_l7_policy(
self.L7POLICY_ID)
self.assertEqual(self.L7POLICY_NAME, test_l7_policy.name)
@ -373,12 +363,12 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
self.assertIn(self.L7RULE_ID, ids)
def test_l7_rule_update(self):
test_lb = self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.conn.load_balancer.get_load_balancer(self.LB_ID)
self.conn.load_balancer.update_l7_rule(self.L7RULE_ID,
l7_policy=self.L7POLICY_ID,
rule_value=self.UPDATE_NAME)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_l7_rule = self.conn.load_balancer.get_l7_rule(
self.L7RULE_ID, l7_policy=self.L7POLICY_ID)
self.assertEqual(self.UPDATE_NAME, test_l7_rule.rule_value)
@ -386,7 +376,7 @@ class TestLoadBalancer(lb_base.BaseLBFunctionalTest):
self.conn.load_balancer.update_l7_rule(self.L7RULE_ID,
l7_policy=self.L7POLICY_ID,
rule_value=self.L7RULE_VALUE)
self.lb_wait_for_status(test_lb, status='ACTIVE', failures=['ERROR'])
self.conn.load_balancer.wait_for_load_balancer(self.LB_ID)
test_l7_rule = self.conn.load_balancer.get_l7_rule(
self.L7RULE_ID, l7_policy=self.L7POLICY_ID,)
self.assertEqual(self.L7RULE_VALUE, test_l7_rule.rule_value)