diff --git a/openstack/network/v2/_proxy.py b/openstack/network/v2/_proxy.py index de8d8491..54b27876 100644 --- a/openstack/network/v2/_proxy.py +++ b/openstack/network/v2/_proxy.py @@ -40,8 +40,20 @@ class Proxy(proxy.BaseProxy): def create_ip(self, **data): return floating_ip.FloatingIP(data).create(self.session) - def delete_ip(self, **data): - floating_ip.FloatingIP(**data).delete(self.session) + def delete_ip(self, value, ignore_missing=True): + """Delete a floating ip + + :param value: The value can be either the ID of a floating ip or a + :class:`~openstack.network.v2.floating_ip.FloatingIP` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the floating ip does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(floating_ip.FloatingIP, value, ignore_missing) def find_available_ip(self): return floating_ip.FloatingIP.find_available(self.session) @@ -61,9 +73,24 @@ class Proxy(proxy.BaseProxy): def create_health_monitor(self, **data): return health_monitor.HealthMonitor(data).create(self.session) - def delete_health_monitor(self, **data): health_monitor.HealthMonitor(data).delete(self.session) + def delete_health_monitor(self, value, ignore_missing=True): + """Delete a health monitor + + :param value: The value can be either the ID of a health monitor or a + :class:`~openstack.network.v2.health_monitor.HealthMonitor` + instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the health monitor does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(health_monitor.HealthMonitor, value, ignore_missing) + def find_health_monitor(self, name_or_id): return health_monitor.HealthMonitor.find(self.session, name_or_id) @@ -79,8 +106,20 @@ class Proxy(proxy.BaseProxy): def create_listener(self, **data): return listener.Listener(data).create(self.session) - def delete_listener(self, **data): - listener.Listener(data).delete(self.session) + def delete_listener(self, value, ignore_missing=True): + """Delete a listener + + :param value: The value can be either the ID of a listner or a + :class:`~openstack.network.v2.listener.Listener` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the listner does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(listener.Listener, value, ignore_missing) def find_listener(self, name_or_id): return listener.Listener.find(self.session, name_or_id) @@ -97,8 +136,21 @@ class Proxy(proxy.BaseProxy): def create_load_balancer(self, **data): return load_balancer.LoadBalancer(data).create(self.session) - def delete_load_balancer(self, **data): - load_balancer.LoadBalancer(data).delete(self.session) + def delete_load_balancer(self, value, ignore_missing=True): + """Delete a load balancer + + :param value: The value can be either the ID of a load balancer or a + :class:`~openstack.network.v2.load_balancer.LoadBalancer` + instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the load balancer does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(load_balancer.LoadBalancer, value, ignore_missing) def find_load_balancer(self, name_or_id): return load_balancer.LoadBalancer.find(self.session, name_or_id) @@ -115,8 +167,21 @@ class Proxy(proxy.BaseProxy): def create_metering_label(self, **data): return metering_label.MeteringLabel(data).create(self.session) - def delete_metering_label(self, **data): - metering_label.MeteringLabel(data).delete(self.session) + def delete_metering_label(self, value, ignore_missing=True): + """Delete a metering label + + :param value: The value can be either the ID of a metering label or a + :class:`~openstack.network.v2.metering_label.MeteringLabel` + instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the metering label does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(metering_label.MeteringLabel, value, ignore_missing) def find_metering_label(self, name_or_id): return metering_label.MeteringLabel.find(self.session, name_or_id) @@ -133,8 +198,23 @@ class Proxy(proxy.BaseProxy): def create_metering_label_rule(self, **data): return metering_label_rule.MeteringLabelRule(data).create(self.session) - def delete_metering_label_rule(self, **data): - metering_label_rule.MeteringLabelRule(data).delete(self.session) + def delete_metering_label_rule(self, value, ignore_missing=True): + """Delete a metering label rule + + :param value: The value can be either the ID of a metering label rule + or a + :class:`~openstack.network.v2.metering_label_rule.MeteringLabelRule` + instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the metering label rule does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(metering_label_rule.MeteringLabelRule, + value, ignore_missing) def find_metering_label_rule(self, name_or_id): return metering_label_rule.MeteringLabelRule.find(self.session, @@ -152,8 +232,20 @@ class Proxy(proxy.BaseProxy): def create_network(self, **data): return network.Network(data).create(self.session) - def delete_network(self, **data): - network.Network(data).delete(self.session) + def delete_network(self, value, ignore_missing=True): + """Delete a network + + :param value: The value can be either the ID of a network or a + :class:`~openstack.network.v2.network.Network` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the network does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(network.Network, value, ignore_missing) def find_network(self, name_or_id): return network.Network.find(self.session, name_or_id) @@ -170,8 +262,20 @@ class Proxy(proxy.BaseProxy): def create_pool(self, **data): return pool.Pool(data).create(self.session) - def delete_pool(self, **data): - pool.Pool(data).delete(self.session) + def delete_pool(self, value, ignore_missing=True): + """Delete a pool + + :param value: The value can be either the ID of a pool or a + :class:`~openstack.network.v2.pool.Pool` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the pool does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(pool.Pool, value, ignore_missing) def find_pool(self, name_or_id): return pool.Pool.find(self.session, name_or_id) @@ -188,8 +292,21 @@ class Proxy(proxy.BaseProxy): def create_pool_member(self, **data): return pool_member.PoolMember(data).create(self.session) - def delete_pool_member(self, **data): - pool_member.PoolMember(data).delete(self.session) + def delete_pool_member(self, value, ignore_missing=True): + """Delete a pool member + + :param value: The value can be either the ID of a pool member or a + :class:`~openstack.network.v2.pool_member.PoolMember` + instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the pool member does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(pool_member.PoolMember, value, ignore_missing) def find_pool_member(self, name_or_id): return pool_member.PoolMember.find(self.session, name_or_id) @@ -206,8 +323,20 @@ class Proxy(proxy.BaseProxy): def create_port(self, **data): return port.Port(data).create(self.session) - def delete_port(self, **data): - return port.Port(data).delete(self.session) + def delete_port(self, value, ignore_missing=True): + """Delete a port + + :param value: The value can be either the ID of a port or a + :class:`~openstack.network.v2.port.Port` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the port does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(port.Port, value, ignore_missing) def find_port(self, name_or_id): return port.Port.find(self.session, name_or_id) @@ -244,8 +373,20 @@ class Proxy(proxy.BaseProxy): def create_router(self, **data): return router.Router(data).create(self.session) - def delete_router(self, **data): - return router.Router(**data).delete(self.session) + def delete_router(self, value, ignore_missing=True): + """Delete a router + + :param value: The value can be either the ID of a router or a + :class:`~openstack.network.v2.router.Router` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the router does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(router.Router, value, ignore_missing) def find_router(self, name_or_id): return router.Router.find(self.session, name_or_id) @@ -268,8 +409,21 @@ class Proxy(proxy.BaseProxy): def create_security_group(self, **data): return security_group.SecurityGroup(data).create(self.session) - def delete_security_group(self, **data): - return security_group.SecurityGroup(**data).delete(self.session) + def delete_security_group(self, value, ignore_missing=True): + """Delete a security group + + :param value: The value can be either the ID of a security group or a + :class:`~openstack.network.v2.security_group.SecurityGroup` + instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the security group does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(security_group.SecurityGroup, value, ignore_missing) def find_security_group(self, name_or_id): return security_group.SecurityGroup.find(self.session, name_or_id) @@ -311,9 +465,23 @@ class Proxy(proxy.BaseProxy): obj = security_group_rule.SecurityGroupRule(data) return obj.create(self.session) - def delete_security_group_rule(self, **data): - obj = security_group_rule.SecurityGroupRule(**data) - return obj.delete(self.session) + def delete_security_group_rule(self, value, ignore_missing=True): + """Delete a security group rule + + :param value: The value can be either the ID of a security group rule + or a + :class:`~openstack.network.v2.security_group_rule.SecurityGroupRule` + instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the security group rule does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(security_group_rule.SecurityGroupRule, + value, ignore_missing) def find_security_group_rule(self, name_or_id): return security_group_rule.SecurityGroupRule.find(self.session, @@ -334,8 +502,20 @@ class Proxy(proxy.BaseProxy): def create_subnet(self, **data): return subnet.Subnet(data).create(self.session) - def delete_subnet(self, **data): - return subnet.Subnet(**data).delete(self.session) + def delete_subnet(self, value, ignore_missing=True): + """Delete a subnet + + :param value: The value can be either the ID of a subnet or a + :class:`~openstack.network.v2.subnet.Subnet` instance. + :param bool ignore_missing: When set to ``False`` + :class:`~openstack.exceptions.ResourceNotFound` will be + raised when the subnet does not exist. + When set to ``True``, no exception will be set when + attempting to delete a nonexistent server. + + :returns: ``None`` + """ + self._delete(subnet.Subnet, value, ignore_missing) def find_subnet(self, name_or_id): return subnet.Subnet.find(self.session, name_or_id) diff --git a/openstack/tests/unit/network/v2/test_proxy.py b/openstack/tests/unit/network/v2/test_proxy.py index 4207e361..f55c6aa8 100644 --- a/openstack/tests/unit/network/v2/test_proxy.py +++ b/openstack/tests/unit/network/v2/test_proxy.py @@ -13,6 +13,20 @@ import mock from openstack.network.v2 import _proxy +from openstack.network.v2 import floating_ip +from openstack.network.v2 import health_monitor +from openstack.network.v2 import listener +from openstack.network.v2 import load_balancer +from openstack.network.v2 import metering_label +from openstack.network.v2 import metering_label_rule +from openstack.network.v2 import network +from openstack.network.v2 import pool +from openstack.network.v2 import pool_member +from openstack.network.v2 import port +from openstack.network.v2 import router +from openstack.network.v2 import security_group +from openstack.network.v2 import security_group_rule +from openstack.network.v2 import subnet from openstack.tests.unit import test_proxy_base @@ -35,9 +49,12 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.proxy.create_ip) def test_floating_ip_delete(self): - self.verify_delete( - 'openstack.network.v2.floating_ip.FloatingIP.delete', - self.proxy.delete_ip) + self.verify_delete2(floating_ip.FloatingIP, self.proxy.delete_ip, + False) + + def test_floating_ip_delete_ignore(self): + self.verify_delete2(floating_ip.FloatingIP, self.proxy.delete_ip, + True) def test_floating_ip_find(self): self.verify_find('openstack.network.v2.floating_ip.FloatingIP.find', @@ -62,9 +79,12 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.proxy.create_health_monitor) def test_health_monitor_delete(self): - self.verify_delete( - 'openstack.network.v2.health_monitor.HealthMonitor.delete', - self.proxy.delete_health_monitor) + self.verify_delete2(health_monitor.HealthMonitor, + self.proxy.delete_health_monitor, False) + + def test_health_monitor_delete_ignore(self): + self.verify_delete2(health_monitor.HealthMonitor, + self.proxy.delete_health_monitor, True) def test_health_monitor_find(self): self.verify_find( @@ -91,8 +111,12 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.proxy.create_listener) def test_listener_delete(self): - self.verify_delete('openstack.network.v2.listener.Listener.delete', - self.proxy.delete_listener) + self.verify_delete2(listener.Listener, + self.proxy.delete_listener, False) + + def test_listener_delete_ignore(self): + self.verify_delete2(listener.Listener, + self.proxy.delete_listener, True) def test_listener_find(self): self.verify_find('openstack.network.v2.listener.Listener.find', @@ -116,9 +140,12 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.proxy.create_load_balancer) def test_load_balancer_delete(self): - self.verify_delete( - 'openstack.network.v2.load_balancer.LoadBalancer.delete', - self.proxy.delete_load_balancer) + self.verify_delete2(load_balancer.LoadBalancer, + self.proxy.delete_load_balancer, False) + + def test_load_balancer_delete_ignore(self): + self.verify_delete2(load_balancer.LoadBalancer, + self.proxy.delete_load_balancer, True) def test_load_balancer_find(self): self.verify_find( @@ -145,9 +172,12 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.proxy.create_metering_label) def test_metering_label_delete(self): - self.verify_delete( - 'openstack.network.v2.metering_label.MeteringLabel.delete', - self.proxy.delete_metering_label) + self.verify_delete2(metering_label.MeteringLabel, + self.proxy.delete_metering_label, False) + + def test_metering_label_delete_ignore(self): + self.verify_delete2(metering_label.MeteringLabel, + self.proxy.delete_metering_label, True) def test_metering_label_find(self): self.verify_find( @@ -176,10 +206,12 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.proxy.create_metering_label_rule) def test_metering_label_rule_delete(self): - self.verify_delete( - ('openstack.network.v2.metering_label_rule.MeteringLabelRule' + - '.delete'), - self.proxy.delete_metering_label_rule) + self.verify_delete2(metering_label_rule.MeteringLabelRule, + self.proxy.delete_metering_label_rule, False) + + def test_metering_label_rule_delete_ignore(self): + self.verify_delete2(metering_label_rule.MeteringLabelRule, + self.proxy.delete_metering_label_rule, True) def test_metering_label_rule_find(self): self.verify_find( @@ -207,8 +239,10 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.proxy.create_network) def test_network_delete(self): - self.verify_delete('openstack.network.v2.network.Network.delete', - self.proxy.delete_network) + self.verify_delete2(network.Network, self.proxy.delete_network, False) + + def test_network_delete_ignore(self): + self.verify_delete2(network.Network, self.proxy.delete_network, True) def test_network_find(self): self.verify_find('openstack.network.v2.network.Network.find', @@ -232,9 +266,12 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.proxy.create_pool_member) def test_pool_member_delete(self): - self.verify_delete( - 'openstack.network.v2.pool_member.PoolMember.delete', - self.proxy.delete_pool_member) + self.verify_delete2(pool_member.PoolMember, + self.proxy.delete_pool_member, False) + + def test_pool_member_delete_ignore(self): + self.verify_delete2(pool_member.PoolMember, + self.proxy.delete_pool_member, True) def test_pool_member_find(self): self.verify_find('openstack.network.v2.pool_member.PoolMember.find', @@ -258,8 +295,10 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.proxy.create_pool) def test_pool_delete(self): - self.verify_delete('openstack.network.v2.pool.Pool.delete', - self.proxy.delete_pool) + self.verify_delete2(pool.Pool, self.proxy.delete_pool, False) + + def test_pool_delete_ignore(self): + self.verify_delete2(pool.Pool, self.proxy.delete_pool, True) def test_pool_find(self): self.verify_find('openstack.network.v2.pool.Pool.find', @@ -282,8 +321,10 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.proxy.create_port) def test_port_delete(self): - self.verify_delete('openstack.network.v2.port.Port.delete', - self.proxy.delete_port) + self.verify_delete2(port.Port, self.proxy.delete_port, False) + + def test_port_delete_ignore(self): + self.verify_delete2(port.Port, self.proxy.delete_port, True) def test_port_find(self): self.verify_find('openstack.network.v2.port.Port.find', @@ -310,8 +351,10 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.proxy.create_router) def test_router_delete(self): - self.verify_delete('openstack.network.v2.router.Router.delete', - self.proxy.delete_router) + self.verify_delete2(router.Router, self.proxy.delete_router, False) + + def test_router_delete_ignore(self): + self.verify_delete2(router.Router, self.proxy.delete_router, True) def test_router_find(self): self.verify_find('openstack.network.v2.router.Router.find', @@ -335,9 +378,12 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.proxy.create_security_group) def test_security_group_delete(self): - self.verify_delete( - 'openstack.network.v2.security_group.SecurityGroup.delete', - self.proxy.delete_security_group) + self.verify_delete2(security_group.SecurityGroup, + self.proxy.delete_security_group, False) + + def test_security_group_delete_ignore(self): + self.verify_delete2(security_group.SecurityGroup, + self.proxy.delete_security_group, True) def test_security_group_find(self): self.verify_find( @@ -407,10 +453,12 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.proxy.create_security_group_rule) def test_security_group_rule_delete(self): - self.verify_delete( - ('openstack.network.v2.security_group_rule.SecurityGroupRule' + - '.delete'), - self.proxy.delete_security_group_rule) + self.verify_delete2(security_group_rule.SecurityGroupRule, + self.proxy.delete_security_group_rule, False) + + def test_security_group_rule_delete_ignore(self): + self.verify_delete2(security_group_rule.SecurityGroupRule, + self.proxy.delete_security_group_rule, True) def test_security_group_rule_find(self): self.verify_find( @@ -438,8 +486,10 @@ class TestNetworkProxy(test_proxy_base.TestProxyBase): self.proxy.create_subnet) def test_subnet_delete(self): - self.verify_delete('openstack.network.v2.subnet.Subnet.delete', - self.proxy.delete_subnet) + self.verify_delete2(subnet.Subnet, self.proxy.delete_subnet, False) + + def test_subnet_delete_ignore(self): + self.verify_delete2(subnet.Subnet, self.proxy.delete_subnet, True) def test_subnet_find(self): self.verify_find('openstack.network.v2.subnet.Subnet.find',