def tearDownClass(cls): job = cls.conn.load_balancer.delete_load_balancer(cls.lb) job = _job.Job(id=job.job_id) resource2.wait_for_status(cls.conn.load_balancer._session, job, "SUCCESS", interval=3, failures=["FAIL"])
def tearDownClass(cls): # delete listener created in setup cls.conn.load_balancer.delete_listener(cls.listener) # delete load balancer created in setup job = cls.conn.load_balancer.delete_load_balancer(cls.lb) job = _job.Job(id=job.job_id) resource2.wait_for_status(cls.conn.load_balancer._session, job, "SUCCESS", interval=5, failures=["FAIL"])
def test_5_remove_router_of_zone(self): resource2.wait_for_status(self.conn.dns._session, self.zone, "ACTIVE", interval=5, failures=["ERROR"]) result = self.conn.dns.remove_router_from_zone(self.zone, **{ "router_id": self.router.id, "router_region": "eu-de" }) self.assertEqual(result.router_id, self.router.id) self.assertEqual(result.router_region, "eu-de")
def setUpClass(cls): super(TestRecordset, cls).setUpClass() # get a router cls.router = cls.get_first_router() # create zone for test cls.zone = test_zone.auto_create_private_zone(cls.conn, cls.ZONE_NAME, cls.router.id, "eu-de") # waiting until zone's status turn into ACTIVE resource2.wait_for_status(cls.conn.dns._session, cls.zone, "ACTIVE", interval=5, failures=["ERROR"]) cls.recordset = auto_create_recordset(cls.conn, cls.zone, cls.NAME)
def wait_for_status(self, value, status, failures=[], interval=2, wait=120): """Wait for a resource to be in a particular status. :param value: The resource to wait on to reach the status. The resource must have a status attribute. :type value: :class:`~openstack.resource2.Resource` :param status: Desired status of the resource2. :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 the change. :return: Method returns resource on success. :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. :raises: :class:`~AttributeError` if the resource does not have a status attribute """ return resource2.wait_for_status(self._session, value, status, failures, interval, wait)
def wait_for_status(self, resource, status, failures=[], interval=2, wait=120): """Wait for a resource to be in a particular status. :param resource: The resource to wait on to reach the specified status. The resource must have a ``status`` attribute. :type resource: A :class:`~openstack.resource2.Resource` object. :param status: Desired status. :param failures: Statuses that would be interpreted as failures. :type failures: :py:class:`list` :param interval: Number of seconds to wait before to consecutive checks. Default to 2. :param wait: Maximum number of seconds to wait before the change. Default to 120. :returns: The resource is returned on success. :raises: :class:`~openstack.exceptions.ResourceTimeout` if transition to the desired status failed to occur in specified seconds. :raises: :class:`~openstack.exceptions.ResourceFailure` if the resource has transited to one of the failure statuses. :raises: :class:`~AttributeError` if the resource does not have a ``status`` attribute. """ return resource2.wait_for_status(self._session, resource, status, failures, interval, wait)
def test_4_add_router_to_zone(self): resource2.wait_for_status(self.conn.dns._session, self.zone, "ACTIVE", interval=5, failures=["ERROR"]) result = self.conn.dns.add_router_to_zone(self.zone, **{ "router_id": self.router2.id, "router_region": "eu-de" }) self.assertEqual(result.router_id, self.router2.id) self.assertEqual(result.router_region, "eu-de") zone = self.conn.dns.get_zone(self.zone) self.assertEqual(2, len(zone.routers)) router_ids = [_router["router_id"] for _router in zone.routers] self.assertIn(self.router.id, router_ids)
def wait_for_execution(self, execution, status='SUCCESS', failures=['ERROR'], interval=2, wait=120): return resource2.wait_for_status(self.session, execution, status, failures, interval, wait)
def wait_for_server(self, server, status='ACTIVE', failures=['ERROR'], interval=2, wait=120): return resource2.wait_for_status(self._session, server, status, failures, interval, wait)
def test_immediate_status(self): status = "loling" resource = mock.Mock() resource.status = status result = resource2.wait_for_status("session", resource, status, "failures", "interval", "wait") self.assertEqual(result, resource)
def test_update_lb(self): updated = { "description": "lb created by functional test", "bandwidth": 2, "admin_state_up": True } job = self.conn.load_balancer.update_load_balancer(self.lb, **updated) job = _job.Job(id=job.job_id) resource2.wait_for_status(self.conn.load_balancer._session, job, "SUCCESS", interval=3, failures=["FAIL"]) self.conn.load_balancer.wait_for_status(job, "SUCCESS", interval=2) lb = self.conn.load_balancer.get_load_balancer(self.lb) self.assertEqual(updated["description"], lb.description) self.assertEqual(updated["bandwidth"], lb.bandwidth) self.assertEqual(updated["admin_state_up"], lb.is_admin_state_up) self.lb = lb
def test_status_match(self, mock_sleep): status = "loling" resource = mock.Mock() # other gets past the first check, two anothers gets through # the sleep loop, and the third matches statuses = ["other", "another", "another", status] type(resource).status = mock.PropertyMock(side_effect=statuses) result = resource2.wait_for_status("session", resource, status, None, 1, 5) self.assertEqual(result, resource)
def auto_create_external_lb(conn, name, vpc_id): """auto create a lb for functional test :param conn: :param name: :return: """ _lb = { "name": name, "vpc_id": vpc_id, "bandwidth": 1, "type": "External", "is_admin_state_up": True } job = conn.load_balancer.create_load_balancer(**_lb) job = _job.Job(id=job.job_id) resource2.wait_for_status(conn.load_balancer._session, job, "SUCCESS", interval=3, failures=["FAIL"]) elb_id = job.entities["elb"]["id"] return conn.load_balancer.get_load_balancer(elb_id)
def test_operate_members(self): members = [] servers = self.conn.compute.servers() for server in servers: vpc_list = server.addresses.keys() if self.router.id in vpc_list: addr = server.addresses[self.router.id][0]["addr"] members.append(dict(server_id=server.id, address=addr)) if len(members) == 2: break job = self.conn.load_balancer.add_members_to_listener( self.listener, members) # waiting for add members job done job = _job.Job(id=job.id) resource2.wait_for_status(self.conn.load_balancer._session, job, "SUCCESS", interval=5, failures=["FAIL"]) added_members = self.conn.load_balancer.listener_members(self.listener) self.assertEqual(2, len(list(added_members))) member_ids = [member["server_id"] for member in members] job = self.conn.load_balancer.remove_members_of_listener( self.listener, member_ids) job = _job.Job(id=job.id) resource2.wait_for_status(self.conn.load_balancer._session, job, "SUCCESS", interval=5, failures=["FAIL"]) added_members = self.conn.load_balancer.listener_members(self.listener) self.assertEqual(0, len(list(added_members)))
def wait_for_status(self, value, status, failures=[], interval=2, wait=120): """Wait for a resource to be in a particular status. :param value: The resource to wait on to reach the status. The resource must have a status attribute. :type value: :class:`~openstack.resource2.Resource` :param status: Desired status of the resource2. :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 the change. :return: Method returns resource on success. :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. :raises: :class:`~AttributeError` if the resource does not have a status attribute """ return resource2.wait_for_status(self.session, value, status, failures, interval, wait)
def wait_for_server(self, server, status='ACTIVE', failures=['ERROR'], interval=2, wait=120): return resource2.wait_for_status(self.session, server, status, failures, interval, wait)