diff --git a/libcloud/loadbalancer/drivers/rackspace.py b/libcloud/loadbalancer/drivers/rackspace.py index e5831b2..5426723 100644 --- a/libcloud/loadbalancer/drivers/rackspace.py +++ b/libcloud/loadbalancer/drivers/rackspace.py @@ -1060,17 +1060,12 @@ def ex_create_balancer_access_rule(self, balancer, rule): balancer = self._get_updated_balancer(balancer) access_list = balancer.extra['accessList'] - # LB API does not return the ID for the newly created item, so we have - # to fudge it. Rule types and addresses are unique, so this is a safe - # way to uniquely identify the new access rule. - created_rule = [r for r in access_list \ - if rule.rule_type == r.rule_type and \ - rule.address == r.address] + created_rule = self._find_matching_rule(rule, access_list) if not created_rule: raise LibcloudError('Could not find created rule') - return created_rule[0] + return created_rule def ex_create_balancer_access_rule_no_poll(self, balancer, rule): """ @@ -1094,6 +1089,76 @@ def ex_create_balancer_access_rule_no_poll(self, balancer, rule): return resp.status == httplib.ACCEPTED + def ex_create_balancer_access_rules(self, balancer, rules): + """ + Adds a list of access rules to a Balancer's access list. This method + blocks until the update request has been processed and the balancer is + in a RUNNING state again. + + @param balancer: Balancer to create the access rule for. + @type balancer: C{Balancer} + + @param rules: List of C{RackspaceAccessRule} to add to the balancer. + @type rules: C{list} + + @rtype: C{RackspaceAccessRule} + @return: The created access rules. + """ + accepted = self.ex_create_balancer_access_rules_no_poll(balancer, rules) + if not accepted: + msg = 'Create access rules not accepted' + raise LibcloudError(msg, driver=self) + + balancer = self._get_updated_balancer(balancer) + access_list = balancer.extra['accessList'] + + created_rules = [] + for r in rules: + matched_rule = self._find_matching_rule(r, access_list) + if matched_rule: + created_rules.append(matched_rule) + + if len(created_rules) != len(rules): + raise LibcloudError('Could not find all created rules') + + return created_rules + + def _find_matching_rule(self, rule_to_find, access_list): + """ + LB API does not return the ID for the newly created rules, so we have + to search the list to find the rule with a matching rule type and + address to return an object with the right identifier.it. The API + enforces rule type and address uniqueness. + """ + for r in access_list: + if rule_to_find.rule_type == r.rule_type and \ + rule_to_find.address == r.address: + return r + + return None + + def ex_create_balancer_access_rules_no_poll(self, balancer, rules): + """ + Adds a list of access rules to a Balancer's access list. This method + returns immediately. + + @param balancer: Balancer to create the access rule for. + @type balancer: C{Balancer} + + @param rules: List of C{RackspaceAccessRule} to add to the balancer. + @type rules: C{list} + + @rtype: C{bool} + @return: Returns whether the create request was accepted. + """ + uri = '/loadbalancers/%s/accesslist' % (balancer.id) + resp = self.connection.request(uri, method='POST', + data=json.dumps({ + 'accessList' : [rule._to_dict() for rule in rules] + })) + + return resp.status == httplib.ACCEPTED + def ex_destroy_balancer_access_rule(self, balancer, rule): """ Removes an access rule from a Balancer's access list. This method diff --git a/test/loadbalancer/test_rackspace.py b/test/loadbalancer/test_rackspace.py index 15e171f..455251a 100644 --- a/test/loadbalancer/test_rackspace.py +++ b/test/loadbalancer/test_rackspace.py @@ -357,6 +357,33 @@ def test_ex_create_balancer_access_rule_no_poll(self): self.assertTrue(resp) + def test_ex_create_balancer_access_rules(self): + balancer = self.driver.get_balancer(balancer_id='94699') + + rules = [RackspaceAccessRule(rule_type=RackspaceAccessRuleType.ALLOW, + address='2001:4801:7901::6/64'), + RackspaceAccessRule(rule_type=RackspaceAccessRuleType.DENY, + address='8.8.8.8/0')] + + rules = self.driver.ex_create_balancer_access_rules(balancer, rules) + + self.assertEquals(2, len(rules)) + self.assertEquals(2884, rules[0].id) + self.assertEquals(3006, rules[1].id) + + def test_ex_create_balancer_access_rules_no_poll(self): + balancer = self.driver.get_balancer(balancer_id='94699') + + rules = [RackspaceAccessRule(rule_type=RackspaceAccessRuleType.ALLOW, + address='2001:4801:7901::6/64'), + RackspaceAccessRule(rule_type=RackspaceAccessRuleType.DENY, + address='8.8.8.8/0')] + + resp = self.driver.ex_create_balancer_access_rules_no_poll(balancer, + rules) + + self.assertTrue(resp) + def test_ex_destroy_balancer_access_rule(self): balancer = self.driver.get_balancer(balancer_id='94698') @@ -1221,6 +1248,16 @@ def _v1_0_slug_loadbalancers_94699_accesslist(self, method, url, body, headers): msg='Did not delete access rule with id %d' % id) return (httplib.ACCEPTED, '', {}, httplib.responses[httplib.ACCEPTED]) + elif method == 'POST': + + json_body = json.loads(body) + access_list = json_body['accessList'] + self.assertEquals('ALLOW', access_list[0]['type']) + self.assertEquals('2001:4801:7901::6/64', access_list[0]['address']) + self.assertEquals('DENY', access_list[1]['type']) + self.assertEquals('8.8.8.8/0', access_list[1]['address']) + + return (httplib.ACCEPTED, '', {}, httplib.responses[httplib.ACCEPTED]) raise NotImplementedError