def __init__(self, args_str=None): self._args = None if not args_str: args_str = ' '.join(sys.argv[1:]) self._parse_args(args_str) httpclient = HTTPClient( username='******', tenant_name='demo', password='******', # region_name=self._region_name, auth_url='http://%s:5000/v2.0' % (self._args.api_server_ip)) httpclient.authenticate() #OS_URL = httpclient.endpoint_url OS_URL = 'http://%s:9696/' % (self._args.api_server_ip) OS_TOKEN = httpclient.auth_token self._quantum = client.Client( '2.0', endpoint_url=OS_URL, token=OS_TOKEN) self._vnc_lib = VncApi(self._args.admin_user, self._args.admin_password, self._args.admin_tenant_name, self._args.api_server_ip, self._args.api_server_port, '/') self._create_vn('public', self._args.public_subnet) self._policy_link_vns()
def __init__(self, args_str=None): self._args = None if not args_str: args_str = ' '.join(sys.argv[1:]) self._parse_args(args_str) httpclient = HTTPClient( username='******', tenant_name='demo', password='******', # region_name=self._region_name, auth_url='http://%s:5000/v2.0' % (self._args.api_server_ip)) httpclient.authenticate() #OS_URL = httpclient.endpoint_url OS_URL = 'http://%s:9696/' % (self._args.api_server_ip) OS_TOKEN = httpclient.auth_token self._quantum = client.Client('2.0', endpoint_url=OS_URL, token=OS_TOKEN) self._vnc_lib = VncApi(self._args.admin_user, self._args.admin_password, self._args.admin_tenant_name, self._args.api_server_ip, self._args.api_server_port, '/') self._create_vn('public', self._args.public_subnet) self._policy_link_vns()
def __init__(self, **kwargs): """ Initialize a new client for the Quantum v2.0 API. """ super(Client, self).__init__() self.httpclient = HTTPClient(**kwargs) self.version = '2.0' self.format = 'json' self.action_prefix = "/v%s" % (self.version) self.retries = 0 self.retry_interval = 1
def __init__(self, project, user, passwd, api_server_ip): AUTH_URL = 'http://%s:5000/v2.0' % (api_server_ip) httpclient = HTTPClient(username=user, tenant_name=project, password=passwd, auth_url=AUTH_URL) httpclient.authenticate() OS_URL = 'http://%s:9696/' % (api_server_ip) OS_TOKEN = httpclient.auth_token self._quantum = client.Client('2.0', endpoint_url=OS_URL, token=OS_TOKEN)
def _do_quantum_authentication(self): try: httpclient = HTTPClient(username=self.username, tenant_id= self.project_id, password=self.password, auth_url=self.auth_url) httpclient.authenticate() except CommonNetworkClientException, e: self.logger.exception('Exception while connection to Quantum') raise e
def initialize(self): if not self._url: httpclient = HTTPClient(username=self._username, tenant_name=self._tenant_name, password=self._password, region_name=self._region_name, auth_url=self._auth_url) httpclient.authenticate() # Populate other password flow attributes self._token = httpclient.auth_token self._url = httpclient.endpoint_url
def setUp(self): super(QuantumFixture, self).setUp() project_id = get_plain_uuid(self.project_id) try: httpclient = HTTPClient(username=self.username, tenant_id= project_id, password=self.password, auth_url=self.auth_url) httpclient.authenticate() except CommonNetworkClientException, e: self.logger.exception('Exception while connection to Quantum') raise e
def test_endpoint_type(self): resources = copy.deepcopy(KS_TOKEN_RESULT) endpoints = resources['access']['serviceCatalog'][0]['endpoints'][0] endpoints['internalURL'] = 'internal' endpoints['adminURL'] = 'admin' endpoints['publicURL'] = 'public' # Test default behavior is to choose public. self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION) self.client._extract_service_catalog(resources) self.assertEqual(self.client.endpoint_url, 'public') # Test admin url self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION, endpoint_type='adminURL') self.client._extract_service_catalog(resources) self.assertEqual(self.client.endpoint_url, 'admin') # Test public url self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION, endpoint_type='publicURL') self.client._extract_service_catalog(resources) self.assertEqual(self.client.endpoint_url, 'public') # Test internal url self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION, endpoint_type='internalURL') self.client._extract_service_catalog(resources) self.assertEqual(self.client.endpoint_url, 'internal') # Test url that isn't found in the service catalog self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION, endpoint_type='privateURL') self.assertRaises(exceptions.EndpointTypeNotFound, self.client._extract_service_catalog, resources)
def setUp(self): """Prepare the test environment""" super(CLITestAuthKeystone, self).setUp() self.mox = mox.Mox() self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION) self.addCleanup(self.mox.VerifyAll) self.addCleanup(self.mox.UnsetStubs)
def setUp(self): super(QuantumFixture, self).setUp() project_id = get_plain_uuid(self.project_id) insecure = bool(os.getenv('OS_INSECURE', True)) try: httpclient = HTTPClient(username=self.username, tenant_id=project_id, password=self.password, auth_url=self.auth_url, insecure=insecure) httpclient.authenticate() except CommonNetworkClientException as e: self.logger.exception('Exception while connection to Quantum') raise e OS_URL = httpclient.endpoint_url OS_TOKEN = httpclient.auth_token self.obj = client.Client( '2.0', endpoint_url=OS_URL, token=OS_TOKEN, insecure=insecure) self.project_id = httpclient.auth_tenant_id
def _run(self, args_str=None, oper=''): self._args = None if not args_str: args_str = ' '.join(sys.argv[1:]) self._parse_args(args_str) if self._quantum == None: httpclient = HTTPClient(username='******', tenant_name='demo', password='******', # region_name=self._region_name, auth_url='http://%s:5000/v2.0' % (self._args.api_server_ip)) httpclient.authenticate() #OS_URL = httpclient.endpoint_url OS_URL = 'http://%s:9696/' % (self._args.api_server_ip) OS_TOKEN = httpclient.auth_token self._quantum = client.Client( '2.0', endpoint_url=OS_URL, token=OS_TOKEN) self._vnc_lib = VncApi(self._args.admin_user, self._args.admin_password, self._args.admin_tenant_name, # self._args.vn_name, self._args.api_server_ip, self._args.api_server_port, '/') self._proj_obj = self._vnc_lib.project_read( fq_name=['default-domain', 'demo']) self._ipam_obj = self._vnc_lib.network_ipam_read( fq_name=['default-domain', 'default-project', 'default-network-ipam']) if self._args.oper == 'add': self._create_vn(self._args.vn_name, self._args.public_subnet) elif self._args.oper == 'del': self._delete_vn(self._args.vn_name) elif self._args.oper == 'add-list': self._create_vn_list(self._args.vn_list)
def test_get_endpoint_url_other(self): self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION, endpoint_type='otherURL') self.mox.StubOutWithMock(self.client, "request") self.client.auth_token = TOKEN res200 = self.mox.CreateMock(httplib2.Response) res200.status = 200 self.client.request(StrContains(AUTH_URL + '/tokens/%s/endpoints' % TOKEN), 'GET', headers=IsA(dict)). \ AndReturn((res200, json.dumps(ENDPOINTS_RESULT))) self.mox.ReplayAll() self.assertRaises(exceptions.EndpointTypeNotFound, self.client.do_request, '/resource', 'GET')
class Client(object): """Client for the OpenStack Quantum v2.0 API. :param string username: Username for authentication. (optional) :param string password: Password for authentication. (optional) :param string token: Token for authentication. (optional) :param string tenant_name: Tenant name. (optional) :param string auth_url: Keystone service endpoint for authorization. :param string region_name: Name of a region to select when choosing an endpoint from the service catalog. :param string endpoint_url: A user-supplied endpoint URL for the quantum service. Lazy-authentication is possible for API service calls if endpoint is set at instantiation.(optional) :param integer timeout: Allows customization of the timeout for client http requests. (optional) :param insecure: ssl certificate validation. (optional) Example:: >>> from quantumclient.v2_0 import client >>> quantum = client.Client(username=USER, password=PASS, tenant_name=TENANT_NAME, auth_url=KEYSTONE_URL) >>> nets = quantum.list_nets() ... """ #Metadata for deserializing xml _serialization_metadata = { "application/xml": { "attributes": { "network": ["id", "name"], "port": ["id", "mac_address"], "subnet": ["id", "prefix"]}, "plurals": { "networks": "network", "ports": "port", "subnets": "subnet", }, }, } networks_path = "/networks" network_path = "/networks/%s" ports_path = "/ports" port_path = "/ports/%s" subnets_path = "/subnets" subnet_path = "/subnets/%s" quotas_path = "/quotas" quota_path = "/quotas/%s" exts_path = "/extensions" ext_path = "/extensions/%s" routers_path = "/routers" router_path = "/routers/%s" floatingips_path = "/floatingips" floatingip_path = "/floatingips/%s" @APIParamsCall def get_quotas_tenant(self, **_params): """Fetch tenant info in server's context for following quota operation.""" return self.get(self.quota_path % 'tenant', params=_params) @APIParamsCall def list_quotas(self, **_params): """Fetch all tenants' quotas.""" return self.get(self.quotas_path, params=_params) @APIParamsCall def show_quota(self, tenant_id, **_params): """Fetch information of a certain tenant's quotas.""" return self.get(self.quota_path % (tenant_id), params=_params) @APIParamsCall def update_quota(self, tenant_id, body=None): """Update a tenant's quotas.""" return self.put(self.quota_path % (tenant_id), body=body) @APIParamsCall def delete_quota(self, tenant_id): """Delete the specified tenant's quota values.""" return self.delete(self.quota_path % (tenant_id)) @APIParamsCall def list_extensions(self, **_params): """Fetch a list of all exts on server side.""" return self.get(self.exts_path, params=_params) @APIParamsCall def show_extension(self, ext_alias, **_params): """Fetch a list of all exts on server side.""" return self.get(self.ext_path % ext_alias, params=_params) @APIParamsCall def list_ports(self, **_params): """ Fetches a list of all networks for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.ports_path, params=_params) @APIParamsCall def show_port(self, port, **_params): """ Fetches information of a certain network """ return self.get(self.port_path % (port), params=_params) @APIParamsCall def create_port(self, body=None): """ Creates a new port """ return self.post(self.ports_path, body=body) @APIParamsCall def update_port(self, port, body=None): """ Updates a port """ return self.put(self.port_path % (port), body=body) @APIParamsCall def delete_port(self, port): """ Deletes the specified port """ return self.delete(self.port_path % (port)) @APIParamsCall def list_networks(self, **_params): """ Fetches a list of all networks for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.networks_path, params=_params) @APIParamsCall def show_network(self, network, **_params): """ Fetches information of a certain network """ return self.get(self.network_path % (network), params=_params) @APIParamsCall def create_network(self, body=None): """ Creates a new network """ return self.post(self.networks_path, body=body) @APIParamsCall def update_network(self, network, body=None): """ Updates a network """ return self.put(self.network_path % (network), body=body) @APIParamsCall def delete_network(self, network): """ Deletes the specified network """ return self.delete(self.network_path % (network)) @APIParamsCall def list_subnets(self, **_params): """ Fetches a list of all networks for a tenant """ return self.get(self.subnets_path, params=_params) @APIParamsCall def show_subnet(self, subnet, **_params): """ Fetches information of a certain subnet """ return self.get(self.subnet_path % (subnet), params=_params) @APIParamsCall def create_subnet(self, body=None): """ Creates a new subnet """ return self.post(self.subnets_path, body=body) @APIParamsCall def update_subnet(self, subnet, body=None): """ Updates a subnet """ return self.put(self.subnet_path % (subnet), body=body) @APIParamsCall def delete_subnet(self, subnet): """ Deletes the specified subnet """ return self.delete(self.subnet_path % (subnet)) @APIParamsCall def list_routers(self, **_params): """ Fetches a list of all routers for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.routers_path, params=_params) @APIParamsCall def show_router(self, router, **_params): """ Fetches information of a certain router """ return self.get(self.router_path % (router), params=_params) @APIParamsCall def create_router(self, body=None): """ Creates a new router """ return self.post(self.routers_path, body=body) @APIParamsCall def update_router(self, router, body=None): """ Updates a router """ return self.put(self.router_path % (router), body=body) @APIParamsCall def delete_router(self, router): """ Deletes the specified router """ return self.delete(self.router_path % (router)) @APIParamsCall def add_interface_router(self, router, body=None): """ Adds an internal network interface to the specified router """ return self.put((self.router_path % router) + "/add_router_interface", body=body) @APIParamsCall def remove_interface_router(self, router, body=None): """ Removes an internal network interface from the specified router """ return self.put((self.router_path % router) + "/remove_router_interface", body=body) @APIParamsCall def add_gateway_router(self, router, body=None): """ Adds an external network gateway to the specified router """ return self.put((self.router_path % router), body={'router': {'external_gateway_info': body}}) @APIParamsCall def remove_gateway_router(self, router): """ Removes an external network gateway from the specified router """ return self.put((self.router_path % router), body={'router': {'external_gateway_info': {}}}) @APIParamsCall def list_floatingips(self, **_params): """ Fetches a list of all floatingips for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.floatingips_path, params=_params) @APIParamsCall def show_floatingip(self, floatingip, **_params): """ Fetches information of a certain floatingip """ return self.get(self.floatingip_path % (floatingip), params=_params) @APIParamsCall def create_floatingip(self, body=None): """ Creates a new floatingip """ return self.post(self.floatingips_path, body=body) @APIParamsCall def update_floatingip(self, floatingip, body=None): """ Updates a floatingip """ return self.put(self.floatingip_path % (floatingip), body=body) @APIParamsCall def delete_floatingip(self, floatingip): """ Deletes the specified floatingip """ return self.delete(self.floatingip_path % (floatingip)) def __init__(self, **kwargs): """ Initialize a new client for the Quantum v2.0 API. """ super(Client, self).__init__() self.httpclient = HTTPClient(**kwargs) self.version = '2.0' self.format = 'json' self.action_prefix = "/v%s" % (self.version) self.retries = 0 self.retry_interval = 1 def _handle_fault_response(self, status_code, response_body): # Create exception with HTTP status code and message error_message = response_body _logger.debug("Error message: %s", error_message) # Add deserialized error message to exception arguments try: des_error_body = Serializer().deserialize(error_message, self.content_type()) except: # If unable to deserialized body it is probably not a # Quantum error des_error_body = {'message': error_message} # Raise the appropriate exception exception_handler_v20(status_code, des_error_body) def do_request(self, method, action, body=None, headers=None, params=None): # Add format and tenant_id action += ".%s" % self.format action = self.action_prefix + action if type(params) is dict and params: action += '?' + urllib.urlencode(params, doseq=1) if body: body = self.serialize(body) self.httpclient.content_type = self.content_type() resp, replybody = self.httpclient.do_request(action, method, body=body) status_code = self.get_status_code(resp) if status_code in (httplib.OK, httplib.CREATED, httplib.ACCEPTED, httplib.NO_CONTENT): return self.deserialize(replybody, status_code) else: self._handle_fault_response(status_code, replybody) def get_status_code(self, response): """ Returns the integer status code from the response, which can be either a Webob.Response (used in testing) or httplib.Response """ if hasattr(response, 'status_int'): return response.status_int else: return response.status def serialize(self, data): """ Serializes a dictionary with a single key (which can contain any structure) into either xml or json """ if data is None: return None elif type(data) is dict: return Serializer().serialize(data, self.content_type()) else: raise Exception("unable to serialize object of type = '%s'" % type(data)) def deserialize(self, data, status_code): """ Deserializes an xml or json string into a dictionary """ if status_code == 204: return data return Serializer(self._serialization_metadata).deserialize( data, self.content_type()) def content_type(self, format=None): """ Returns the mime-type for either 'xml' or 'json'. Defaults to the currently set format """ if not format: format = self.format return "application/%s" % (format) def retry_request(self, method, action, body=None, headers=None, params=None): """ Call do_request with the default retry configuration. Only idempotent requests should retry failed connection attempts. :raises: ConnectionFailed if the maximum # of retries is exceeded """ max_attempts = self.retries + 1 for i in xrange(max_attempts): try: return self.do_request(method, action, body=body, headers=headers, params=params) except exceptions.ConnectionFailed: # Exception has already been logged by do_request() if i < self.retries: _logger.debug(_('Retrying connection to quantum service')) time.sleep(self.retry_interval) raise exceptions.ConnectionFailed(reason=_("Maximum attempts reached")) def delete(self, action, body=None, headers=None, params=None): return self.retry_request("DELETE", action, body=body, headers=headers, params=params) def get(self, action, body=None, headers=None, params=None): return self.retry_request("GET", action, body=body, headers=headers, params=params) def post(self, action, body=None, headers=None, params=None): # Do not retry POST requests to avoid the orphan objects problem. return self.do_request("POST", action, body=body, headers=headers, params=params) def put(self, action, body=None, headers=None, params=None): return self.retry_request("PUT", action, body=body, headers=headers, params=params)
class Client(object): """Client for the OpenStack Quantum v2.0 API. :param string username: Username for authentication. (optional) :param string password: Password for authentication. (optional) :param string token: Token for authentication. (optional) :param string tenant_name: Tenant name. (optional) :param string auth_url: Keystone service endpoint for authorization. :param string region_name: Name of a region to select when choosing an endpoint from the service catalog. :param string endpoint_url: A user-supplied endpoint URL for the quantum service. Lazy-authentication is possible for API service calls if endpoint is set at instantiation.(optional) :param integer timeout: Allows customization of the timeout for client http requests. (optional) :param insecure: ssl certificate validation. (optional) Example:: >>> from quantumclient.v2_0 import client >>> quantum = client.Client(username=USER, password=PASS, tenant_name=TENANT_NAME, auth_url=KEYSTONE_URL) >>> nets = quantum.list_networks() ... """ networks_path = "/networks" network_path = "/networks/%s" ports_path = "/ports" port_path = "/ports/%s" subnets_path = "/subnets" subnet_path = "/subnets/%s" quotas_path = "/quotas" quota_path = "/quotas/%s" exts_path = "/extensions" ext_path = "/extensions/%s" routers_path = "/routers" router_path = "/routers/%s" floatingips_path = "/floatingips" floatingip_path = "/floatingips/%s" security_groups_path = "/security-groups" security_group_path = "/security-groups/%s" security_group_rules_path = "/security-group-rules" security_group_rule_path = "/security-group-rules/%s" vips_path = "/lb/vips" vip_path = "/lb/vips/%s" pools_path = "/lb/pools" pool_path = "/lb/pools/%s" pool_path_stats = "/lb/pools/%s/stats" members_path = "/lb/members" member_path = "/lb/members/%s" health_monitors_path = "/lb/health_monitors" health_monitor_path = "/lb/health_monitors/%s" associate_pool_health_monitors_path = "/lb/pools/%s/health_monitors" disassociate_pool_health_monitors_path = ( "/lb/pools/%(pool)s/health_monitors/%(health_monitor)s") # API has no way to report plurals, so we have to hard code them EXTED_PLURALS = {'routers': 'router', 'floatingips': 'floatingip', 'service_types': 'service_type', 'service_definitions': 'service_definition', 'security_groups': 'security_group', 'security_group_rules': 'security_group_rule', 'vips': 'vip', 'pools': 'pool', 'members': 'member', 'health_monitors': 'health_monitor', 'quotas': 'quota', } def get_attr_metadata(self): if self.format == 'json': return {} old_request_format = self.format self.format = 'json' exts = self.list_extensions()['extensions'] self.format = old_request_format ns = dict([(ext['alias'], ext['namespace']) for ext in exts]) self.EXTED_PLURALS.update(constants.PLURALS) return {'plurals': self.EXTED_PLURALS, 'xmlns': constants.XML_NS_V20, constants.EXT_NS: ns} @APIParamsCall def get_quotas_tenant(self, **_params): """Fetch tenant info in server's context for following quota operation.""" return self.get(self.quota_path % 'tenant', params=_params) @APIParamsCall def list_quotas(self, **_params): """Fetch all tenants' quotas.""" return self.get(self.quotas_path, params=_params) @APIParamsCall def show_quota(self, tenant_id, **_params): """Fetch information of a certain tenant's quotas.""" return self.get(self.quota_path % (tenant_id), params=_params) @APIParamsCall def update_quota(self, tenant_id, body=None): """Update a tenant's quotas.""" return self.put(self.quota_path % (tenant_id), body=body) @APIParamsCall def delete_quota(self, tenant_id): """Delete the specified tenant's quota values.""" return self.delete(self.quota_path % (tenant_id)) @APIParamsCall def list_extensions(self, **_params): """Fetch a list of all exts on server side.""" return self.get(self.exts_path, params=_params) @APIParamsCall def show_extension(self, ext_alias, **_params): """Fetch a list of all exts on server side.""" return self.get(self.ext_path % ext_alias, params=_params) @APIParamsCall def list_ports(self, **_params): """ Fetches a list of all networks for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.ports_path, params=_params) @APIParamsCall def show_port(self, port, **_params): """ Fetches information of a certain network """ return self.get(self.port_path % (port), params=_params) @APIParamsCall def create_port(self, body=None): """ Creates a new port """ return self.post(self.ports_path, body=body) @APIParamsCall def update_port(self, port, body=None): """ Updates a port """ return self.put(self.port_path % (port), body=body) @APIParamsCall def delete_port(self, port): """ Deletes the specified port """ return self.delete(self.port_path % (port)) @APIParamsCall def list_networks(self, **_params): """ Fetches a list of all networks for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.networks_path, params=_params) @APIParamsCall def show_network(self, network, **_params): """ Fetches information of a certain network """ return self.get(self.network_path % (network), params=_params) @APIParamsCall def create_network(self, body=None): """ Creates a new network """ return self.post(self.networks_path, body=body) @APIParamsCall def update_network(self, network, body=None): """ Updates a network """ return self.put(self.network_path % (network), body=body) @APIParamsCall def delete_network(self, network): """ Deletes the specified network """ return self.delete(self.network_path % (network)) @APIParamsCall def list_subnets(self, **_params): """ Fetches a list of all networks for a tenant """ return self.get(self.subnets_path, params=_params) @APIParamsCall def show_subnet(self, subnet, **_params): """ Fetches information of a certain subnet """ return self.get(self.subnet_path % (subnet), params=_params) @APIParamsCall def create_subnet(self, body=None): """ Creates a new subnet """ return self.post(self.subnets_path, body=body) @APIParamsCall def update_subnet(self, subnet, body=None): """ Updates a subnet """ return self.put(self.subnet_path % (subnet), body=body) @APIParamsCall def delete_subnet(self, subnet): """ Deletes the specified subnet """ return self.delete(self.subnet_path % (subnet)) @APIParamsCall def list_routers(self, **_params): """ Fetches a list of all routers for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.routers_path, params=_params) @APIParamsCall def show_router(self, router, **_params): """ Fetches information of a certain router """ return self.get(self.router_path % (router), params=_params) @APIParamsCall def create_router(self, body=None): """ Creates a new router """ return self.post(self.routers_path, body=body) @APIParamsCall def update_router(self, router, body=None): """ Updates a router """ return self.put(self.router_path % (router), body=body) @APIParamsCall def delete_router(self, router): """ Deletes the specified router """ return self.delete(self.router_path % (router)) @APIParamsCall def add_interface_router(self, router, body=None): """ Adds an internal network interface to the specified router """ return self.put((self.router_path % router) + "/add_router_interface", body=body) @APIParamsCall def remove_interface_router(self, router, body=None): """ Removes an internal network interface from the specified router """ return self.put((self.router_path % router) + "/remove_router_interface", body=body) @APIParamsCall def add_gateway_router(self, router, body=None): """ Adds an external network gateway to the specified router """ return self.put((self.router_path % router), body={'router': {'external_gateway_info': body}}) @APIParamsCall def remove_gateway_router(self, router): """ Removes an external network gateway from the specified router """ return self.put((self.router_path % router), body={'router': {'external_gateway_info': {}}}) @APIParamsCall def list_floatingips(self, **_params): """ Fetches a list of all floatingips for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.floatingips_path, params=_params) @APIParamsCall def show_floatingip(self, floatingip, **_params): """ Fetches information of a certain floatingip """ return self.get(self.floatingip_path % (floatingip), params=_params) @APIParamsCall def create_floatingip(self, body=None): """ Creates a new floatingip """ return self.post(self.floatingips_path, body=body) @APIParamsCall def update_floatingip(self, floatingip, body=None): """ Updates a floatingip """ return self.put(self.floatingip_path % (floatingip), body=body) @APIParamsCall def delete_floatingip(self, floatingip): """ Deletes the specified floatingip """ return self.delete(self.floatingip_path % (floatingip)) @APIParamsCall def create_security_group(self, body=None): """ Creates a new security group """ return self.post(self.security_groups_path, body=body) @APIParamsCall def list_security_groups(self, **_params): """ Fetches a list of all security groups for a tenant """ return self.get(self.security_groups_path, params=_params) @APIParamsCall def show_security_group(self, security_group, **_params): """ Fetches information of a certain security group """ return self.get(self.security_group_path % (security_group), params=_params) @APIParamsCall def delete_security_group(self, security_group): """ Deletes the specified security group """ return self.delete(self.security_group_path % (security_group)) @APIParamsCall def create_security_group_rule(self, body=None): """ Creates a new security group rule """ return self.post(self.security_group_rules_path, body=body) @APIParamsCall def delete_security_group_rule(self, security_group_rule): """ Deletes the specified security group rule """ return self.delete(self.security_group_rule_path % (security_group_rule)) @APIParamsCall def list_security_group_rules(self, **_params): """ Fetches a list of all security group rules for a tenant """ return self.get(self.security_group_rules_path, params=_params) @APIParamsCall def show_security_group_rule(self, security_group_rule, **_params): """ Fetches information of a certain security group rule """ return self.get(self.security_group_rule_path % (security_group_rule), params=_params) @APIParamsCall def list_vips(self, **_params): """ Fetches a list of all load balancer vips for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.vips_path, params=_params) @APIParamsCall def show_vip(self, vip, **_params): """ Fetches information of a certain load balancer vip """ return self.get(self.vip_path % (vip), params=_params) @APIParamsCall def create_vip(self, body=None): """ Creates a new load balancer vip """ return self.post(self.vips_path, body=body) @APIParamsCall def update_vip(self, vip, body=None): """ Updates a load balancer vip """ return self.put(self.vip_path % (vip), body=body) @APIParamsCall def delete_vip(self, vip): """ Deletes the specified load balancer vip """ return self.delete(self.vip_path % (vip)) @APIParamsCall def list_pools(self, **_params): """ Fetches a list of all load balancer pools for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.pools_path, params=_params) @APIParamsCall def show_pool(self, pool, **_params): """ Fetches information of a certain load balancer pool """ return self.get(self.pool_path % (pool), params=_params) @APIParamsCall def create_pool(self, body=None): """ Creates a new load balancer pool """ return self.post(self.pools_path, body=body) @APIParamsCall def update_pool(self, pool, body=None): """ Updates a load balancer pool """ return self.put(self.pool_path % (pool), body=body) @APIParamsCall def delete_pool(self, pool): """ Deletes the specified load balancer pool """ return self.delete(self.pool_path % (pool)) @APIParamsCall def retrieve_pool_stats(self, pool, **_params): """ Retrieves stats for a certain load balancer pool """ return self.get(self.pool_path_stats % (pool), params=_params) @APIParamsCall def list_members(self, **_params): """ Fetches a list of all load balancer members for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.members_path, params=_params) @APIParamsCall def show_member(self, member, **_params): """ Fetches information of a certain load balancer member """ return self.get(self.member_path % (member), params=_params) @APIParamsCall def create_member(self, body=None): """ Creates a new load balancer member """ return self.post(self.members_path, body=body) @APIParamsCall def update_member(self, member, body=None): """ Updates a load balancer member """ return self.put(self.member_path % (member), body=body) @APIParamsCall def delete_member(self, member): """ Deletes the specified load balancer member """ return self.delete(self.member_path % (member)) @APIParamsCall def list_health_monitors(self, **_params): """ Fetches a list of all load balancer health monitors for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.health_monitors_path, params=_params) @APIParamsCall def show_health_monitor(self, health_monitor, **_params): """ Fetches information of a certain load balancer health monitor """ return self.get(self.health_monitor_path % (health_monitor), params=_params) @APIParamsCall def create_health_monitor(self, body=None): """ Creates a new load balancer health monitor """ return self.post(self.health_monitors_path, body=body) @APIParamsCall def update_health_monitor(self, health_monitor, body=None): """ Updates a load balancer health monitor """ return self.put(self.health_monitor_path % (health_monitor), body=body) @APIParamsCall def delete_health_monitor(self, health_monitor): """ Deletes the specified load balancer health monitor """ return self.delete(self.health_monitor_path % (health_monitor)) @APIParamsCall def associate_health_monitor(self, pool, body): """ Associate specified load balancer health monitor and pool """ return self.post(self.associate_pool_health_monitors_path % (pool), body=body) @APIParamsCall def disassociate_health_monitor(self, pool, health_monitor): """ Disassociate specified load balancer health monitor and pool """ path = (self.disassociate_pool_health_monitors_path % {'pool': pool, 'health_monitor': health_monitor}) return self.delete(path) def __init__(self, **kwargs): """ Initialize a new client for the Quantum v2.0 API. """ super(Client, self).__init__() self.httpclient = HTTPClient(**kwargs) self.version = '2.0' self.format = 'json' self.action_prefix = "/v%s" % (self.version) self.retries = 0 self.retry_interval = 1 def _handle_fault_response(self, status_code, response_body): # Create exception with HTTP status code and message _logger.debug("Error message: %s", response_body) # Add deserialized error message to exception arguments try: des_error_body = self.deserialize(response_body, status_code) except: # If unable to deserialized body it is probably not a # Quantum error des_error_body = {'message': response_body} # Raise the appropriate exception exception_handler_v20(status_code, des_error_body) def do_request(self, method, action, body=None, headers=None, params=None): # Add format and tenant_id action += ".%s" % self.format action = self.action_prefix + action if type(params) is dict and params: action += '?' + urllib.urlencode(params, doseq=1) if body: body = self.serialize(body) self.httpclient.content_type = self.content_type() resp, replybody = self.httpclient.do_request(action, method, body=body) status_code = self.get_status_code(resp) if status_code in (httplib.OK, httplib.CREATED, httplib.ACCEPTED, httplib.NO_CONTENT): return self.deserialize(replybody, status_code) else: self._handle_fault_response(status_code, replybody) def get_status_code(self, response): """ Returns the integer status code from the response, which can be either a Webob.Response (used in testing) or httplib.Response """ if hasattr(response, 'status_int'): return response.status_int else: return response.status def serialize(self, data): """ Serializes a dictionary with a single key (which can contain any structure) into either xml or json """ if data is None: return None elif type(data) is dict: return serializer.Serializer( self.get_attr_metadata()).serialize(data, self.content_type()) else: raise Exception("unable to serialize object of type = '%s'" % type(data)) def deserialize(self, data, status_code): """ Deserializes an xml or json string into a dictionary """ if status_code == 204: return data return serializer.Serializer(self.get_attr_metadata()).deserialize( data, self.content_type())['body'] def content_type(self, _format=None): """ Returns the mime-type for either 'xml' or 'json'. Defaults to the currently set format """ _format = _format or self.format return "application/%s" % (_format) def retry_request(self, method, action, body=None, headers=None, params=None): """ Call do_request with the default retry configuration. Only idempotent requests should retry failed connection attempts. :raises: ConnectionFailed if the maximum # of retries is exceeded """ max_attempts = self.retries + 1 for i in xrange(max_attempts): try: return self.do_request(method, action, body=body, headers=headers, params=params) except exceptions.ConnectionFailed: # Exception has already been logged by do_request() if i < self.retries: _logger.debug(_('Retrying connection to quantum service')) time.sleep(self.retry_interval) raise exceptions.ConnectionFailed(reason=_("Maximum attempts reached")) def delete(self, action, body=None, headers=None, params=None): return self.retry_request("DELETE", action, body=body, headers=headers, params=params) def get(self, action, body=None, headers=None, params=None): return self.retry_request("GET", action, body=body, headers=headers, params=params) def post(self, action, body=None, headers=None, params=None): # Do not retry POST requests to avoid the orphan objects problem. return self.do_request("POST", action, body=body, headers=headers, params=params) def put(self, action, body=None, headers=None, params=None): return self.retry_request("PUT", action, body=body, headers=headers, params=params)
class Client(object): """Client for the OpenStack Quantum v2.0 API. :param string username: Username for authentication. (optional) :param string password: Password for authentication. (optional) :param string token: Token for authentication. (optional) :param string tenant_name: Tenant name. (optional) :param string auth_url: Keystone service endpoint for authorization. :param string region_name: Name of a region to select when choosing an endpoint from the service catalog. :param string endpoint_url: A user-supplied endpoint URL for the quantum service. Lazy-authentication is possible for API service calls if endpoint is set at instantiation.(optional) :param integer timeout: Allows customization of the timeout for client http requests. (optional) :param insecure: ssl certificate validation. (optional) Example:: >>> from quantumclient.v2_0 import client >>> quantum = client.Client(username=USER, password=PASS, tenant_name=TENANT_NAME, auth_url=KEYSTONE_URL) >>> nets = quantum.list_nets() ... """ #Metadata for deserializing xml _serialization_metadata = { "application/xml": { "attributes": { "network": ["id", "name"], "port": ["id", "mac_address"], "subnet": ["id", "prefix"]}, "plurals": { "networks": "network", "ports": "port", "subnets": "subnet", }, }, } networks_path = "/networks" network_path = "/networks/%s" ports_path = "/ports" port_path = "/ports/%s" subnets_path = "/subnets" subnet_path = "/subnets/%s" @APIParamsCall def list_ports(self, **_params): """ Fetches a list of all networks for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.ports_path, params=_params) @APIParamsCall def show_port(self, port, **_params): """ Fetches information of a certain network """ return self.get(self.port_path % (port), params=_params) @APIParamsCall def create_port(self, body=None): """ Creates a new port """ return self.post(self.ports_path, body=body) @APIParamsCall def update_port(self, port, body=None): """ Updates a port """ return self.put(self.port_path % (port), body=body) @APIParamsCall def delete_port(self, port): """ Deletes the specified port """ return self.delete(self.port_path % (port)) @APIParamsCall def list_networks(self, **_params): """ Fetches a list of all networks for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.networks_path, params=_params) @APIParamsCall def show_network(self, network, **_params): """ Fetches information of a certain network """ return self.get(self.network_path % (network), params=_params) @APIParamsCall def create_network(self, body=None): """ Creates a new network """ return self.post(self.networks_path, body=body) @APIParamsCall def update_network(self, network, body=None): """ Updates a network """ return self.put(self.network_path % (network), body=body) @APIParamsCall def delete_network(self, network): """ Deletes the specified network """ return self.delete(self.network_path % (network)) @APIParamsCall def list_subnets(self, **_params): """ Fetches a list of all networks for a tenant """ return self.get(self.subnets_path, params=_params) @APIParamsCall def show_subnet(self, subnet, **_params): """ Fetches information of a certain subnet """ return self.get(self.subnet_path % (subnet), params=_params) @APIParamsCall def create_subnet(self, body=None): """ Creates a new subnet """ return self.post(self.subnets_path, body=body) @APIParamsCall def update_subnet(self, subnet, body=None): """ Updates a subnet """ return self.put(self.subnet_path % (subnet), body=body) @APIParamsCall def delete_subnet(self, subnet): """ Deletes the specified subnet """ return self.delete(self.subnet_path % (subnet)) def __init__(self, **kwargs): """ Initialize a new client for the Quantum v2.0 API. """ super(Client, self).__init__() self.httpclient = HTTPClient(**kwargs) self.version = '2.0' self.format = 'json' self.action_prefix = "/v%s" % (self.version) self.retries = 0 self.retry_interval = 1 def _handle_fault_response(self, status_code, response_body): # Create exception with HTTP status code and message error_message = response_body _logger.debug("Error message: %s", error_message) # Add deserialized error message to exception arguments try: des_error_body = Serializer().deserialize(error_message, self.content_type()) except: # If unable to deserialized body it is probably not a # Quantum error des_error_body = {'message': error_message} # Raise the appropriate exception exception_handler_v20(status_code, des_error_body) def do_request(self, method, action, body=None, headers=None, params=None): # Add format and tenant_id action += ".%s" % self.format action = self.action_prefix + action if type(params) is dict: action += '?' + urllib.urlencode(params, doseq=1) if body: body = self.serialize(body) self.httpclient.content_type = self.content_type() resp, replybody = self.httpclient.do_request(action, method, body=body) status_code = self.get_status_code(resp) if status_code in (httplib.OK, httplib.CREATED, httplib.ACCEPTED, httplib.NO_CONTENT): return self.deserialize(replybody, status_code) else: self._handle_fault_response(status_code, replybody) def get_status_code(self, response): """ Returns the integer status code from the response, which can be either a Webob.Response (used in testing) or httplib.Response """ if hasattr(response, 'status_int'): return response.status_int else: return response.status def serialize(self, data): """ Serializes a dictionary with a single key (which can contain any structure) into either xml or json """ if data is None: return None elif type(data) is dict: return Serializer().serialize(data, self.content_type()) else: raise Exception("unable to serialize object of type = '%s'" % type(data)) def deserialize(self, data, status_code): """ Deserializes a an xml or json string into a dictionary """ if status_code == 204: return data return Serializer(self._serialization_metadata).deserialize( data, self.content_type()) def content_type(self, format=None): """ Returns the mime-type for either 'xml' or 'json'. Defaults to the currently set format """ if not format: format = self.format return "application/%s" % (format) def retry_request(self, method, action, body=None, headers=None, params=None): """ Call do_request with the default retry configuration. Only idempotent requests should retry failed connection attempts. :raises: ConnectionFailed if the maximum # of retries is exceeded """ max_attempts = self.retries + 1 for i in xrange(max_attempts): try: return self.do_request(method, action, body=body, headers=headers, params=params) except exceptions.ConnectionFailed: # Exception has already been logged by do_request() if i < self.retries: _logger.debug(_('Retrying connection to quantum service')) time.sleep(self.retry_interval) raise exceptions.ConnectionFailed(reason=_("Maximum attempts reached")) def delete(self, action, body=None, headers=None, params=None): return self.retry_request("DELETE", action, body=body, headers=headers, params=params) def get(self, action, body=None, headers=None, params=None): return self.retry_request("GET", action, body=body, headers=headers, params=params) def post(self, action, body=None, headers=None, params=None): # Do not retry POST requests to avoid the orphan objects problem. return self.do_request("POST", action, body=body, headers=headers, params=params) def put(self, action, body=None, headers=None, params=None): return self.retry_request("PUT", action, body=body, headers=headers, params=params)
class Client(object): """Client for the OpenStack Quantum v2.0 API. :param string username: Username for authentication. (optional) :param string password: Password for authentication. (optional) :param string token: Token for authentication. (optional) :param string tenant_name: Tenant name. (optional) :param string auth_url: Keystone service endpoint for authorization. :param string region_name: Name of a region to select when choosing an endpoint from the service catalog. :param string endpoint_url: A user-supplied endpoint URL for the quantum service. Lazy-authentication is possible for API service calls if endpoint is set at instantiation.(optional) :param integer timeout: Allows customization of the timeout for client http requests. (optional) :param insecure: ssl certificate validation. (optional) Example:: >>> from quantumclient.v2_0 import client >>> quantum = client.Client(username=USER, password=PASS, tenant_name=TENANT_NAME, auth_url=KEYSTONE_URL) >>> nets = quantum.list_nets() ... """ #Metadata for deserializing xml _serialization_metadata = { "application/xml": { "attributes": { "network": ["id", "name"], "port": ["id", "mac_address"], "subnet": ["id", "prefix"], "configuration": ["id", "name"], "pool": ["id", "name"], "member": ["id", "name"], "monitor": ["id", "name"], "vip": ["id", "name"], "session": ["id", "type"]}, "plurals": { "networks": "network", "ports": "port", "subnets": "subnet", "configurations": "configuration", "pools": "pool", "members": "member", "vips": "vip", "sessions": "session",}, }, } networks_path = "/networks" network_path = "/networks/%s" ports_path = "/ports" port_path = "/ports/%s" subnets_path = "/subnets" subnet_path = "/subnets/%s" quotas_path = "/quotas" quota_path = "/quotas/%s" exts_path = "/extensions" ext_path = "/extensions/%s" routers_path = "/routers" router_path = "/routers/%s" floatingips_path = "/floatingips" floatingip_path = "/floatingips/%s" #loadbalancer_path = "/loadbalancer/vip/%s" configurations_path = "/lb/configurations" configuration_path = "/lb/configurations/%s" pools_path = "/lb/pools" pool_path = "/lb/pools/%s" members_path = "/lb/members" member_path = "/lb/members/%s" monitors_path = "/lb/monitors" monitor_path = "/lb/monitors/%s" vips_path = "/lb/vips" vip_path = "/lb/vips/%s" sessions_path = "/lb/sessions" session_path = "/lb/sessions/%s" slb_configs_path = "/lb/configs" slb_config_path = "/lb/configs/%s" networkfunctions_path = "/fns/networkfunctions" networkfunction_path = "/fns/networkfunctions/%s" categories_path = "/fns/categories" category_path = "/fns/categories/%s" category_networkfunctions_path = "/fns/category_networkfunctions" category_networkfunction_path = "/fns/category_networkfunctions/%s" vendors_path = "/fns/vendors" vendor_path = "/fns/vendors/%s" images_path = "/fns/images" image_path = "/fns/images/%s" metadatas_path = "/fns/metadatas" metadata_path = "/fns/metadatas/%s" personalities_path = "/fns/personalities" personality_path = "/fns/personalities/%s" chains_path = "/fns/chains" chain_path = "/fns/chains/%s" chain_images_path = "/fns/chain_images" chain_image_path = "/fns/chain_images/%s" chain_image_networks_path = "/fns/chain_image_networks" chain_image_network_path = "/fns/chain_image_networks/%s" chain_image_confs_path = "/fns/chain_image_confs" chain_image_conf_path = "/fns/chain_image_confs/%s" config_handles_path = "/fns/config_handles" config_handle_path = "/fns/config_handles/%s" launchs_path = "/fns/launchs" launch_path = "/fns/launchs/%s" @APIParamsCall def get_vip_list(self,**_params): """(trinath) get VIP list .. FAKE """ return self.get(self.loadbalancer_path % 'tenant', params=_params) @APIParamsCall def get_quotas_tenant(self, **_params): """Fetch tenant info in server's context for following quota operation.""" return self.get(self.quota_path % 'tenant', params=_params) @APIParamsCall def list_quotas(self, **_params): """Fetch all tenants' quotas.""" return self.get(self.quotas_path, params=_params) @APIParamsCall def show_quota(self, tenant_id, **_params): """Fetch information of a certain tenant's quotas.""" return self.get(self.quota_path % (tenant_id), params=_params) @APIParamsCall def update_quota(self, tenant_id, body=None): """Update a tenant's quotas.""" return self.put(self.quota_path % (tenant_id), body=body) @APIParamsCall def delete_quota(self, tenant_id): """Delete the specified tenant's quota values.""" return self.delete(self.quota_path % (tenant_id)) @APIParamsCall def list_extensions(self, **_params): """Fetch a list of all exts on server side.""" return self.get(self.exts_path, params=_params) @APIParamsCall def show_extension(self, ext_alias, **_params): """Fetch a list of all exts on server side.""" return self.get(self.ext_path % ext_alias, params=_params) @APIParamsCall def list_ports(self, **_params): """ Fetches a list of all networks for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.ports_path, params=_params) @APIParamsCall def show_port(self, port, **_params): """ Fetches information of a certain network """ return self.get(self.port_path % (port), params=_params) @APIParamsCall def create_port(self, body=None): """ Creates a new port """ return self.post(self.ports_path, body=body) @APIParamsCall def update_port(self, port, body=None): """ Updates a port """ return self.put(self.port_path % (port), body=body) @APIParamsCall def delete_port(self, port): """ Deletes the specified port """ return self.delete(self.port_path % (port)) @APIParamsCall def list_networks(self, **_params): """ Fetches a list of all networks for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.networks_path, params=_params) @APIParamsCall def show_network(self, network, **_params): """ Fetches information of a certain network """ return self.get(self.network_path % (network), params=_params) @APIParamsCall def create_network(self, body=None): """ Creates a new network """ return self.post(self.networks_path, body=body) @APIParamsCall def update_network(self, network, body=None): """ Updates a network """ return self.put(self.network_path % (network), body=body) @APIParamsCall def delete_network(self, network): """ Deletes the specified network """ return self.delete(self.network_path % (network)) @APIParamsCall def list_subnets(self, **_params): """ Fetches a list of all networks for a tenant """ return self.get(self.subnets_path, params=_params) @APIParamsCall def show_subnet(self, subnet, **_params): """ Fetches information of a certain subnet """ return self.get(self.subnet_path % (subnet), params=_params) @APIParamsCall def create_subnet(self, body=None): """ Creates a new subnet """ return self.post(self.subnets_path, body=body) @APIParamsCall def update_subnet(self, subnet, body=None): """ Updates a subnet """ return self.put(self.subnet_path % (subnet), body=body) @APIParamsCall def delete_subnet(self, subnet): """ Deletes the specified subnet """ return self.delete(self.subnet_path % (subnet)) @APIParamsCall def list_routers(self, **_params): """ Fetches a list of all routers for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.routers_path, params=_params) @APIParamsCall def show_router(self, router, **_params): """ Fetches information of a certain router """ return self.get(self.router_path % (router), params=_params) @APIParamsCall def create_router(self, body=None): """ Creates a new router """ return self.post(self.routers_path, body=body) @APIParamsCall def update_router(self, router, body=None): """ Updates a router """ return self.put(self.router_path % (router), body=body) @APIParamsCall def delete_router(self, router): """ Deletes the specified router """ return self.delete(self.router_path % (router)) @APIParamsCall def add_interface_router(self, router, body=None): """ Adds an internal network interface to the specified router """ return self.put((self.router_path % router) + "/add_router_interface", body=body) @APIParamsCall def remove_interface_router(self, router, body=None): """ Removes an internal network interface from the specified router """ return self.put((self.router_path % router) + "/remove_router_interface", body=body) @APIParamsCall def add_gateway_router(self, router, body=None): """ Adds an external network gateway to the specified router """ return self.put((self.router_path % router), body={'router': {'external_gateway_info': body}}) @APIParamsCall def remove_gateway_router(self, router): """ Removes an external network gateway from the specified router """ return self.put((self.router_path % router), body={'router': {'external_gateway_info': {}}}) @APIParamsCall def list_floatingips(self, **_params): """ Fetches a list of all floatingips for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.floatingips_path, params=_params) @APIParamsCall def show_floatingip(self, floatingip, **_params): """ Fetches information of a certain floatingip """ return self.get(self.floatingip_path % (floatingip), params=_params) @APIParamsCall def create_floatingip(self, body=None): """ Creates a new floatingip """ return self.post(self.floatingips_path, body=body) @APIParamsCall def update_floatingip(self, floatingip, body=None): """ Updates a floatingip """ return self.put(self.floatingip_path % (floatingip), body=body) @APIParamsCall def delete_floatingip(self, floatingip): """ Deletes the specified floatingip """ return self.delete(self.floatingip_path % (floatingip)) ###Modifications by Srikanth @APIParamsCall def list_configurations(self, **_params): """ Fetches a list of all configurations for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.configurations_path, params=_params) @APIParamsCall def create_configuration(self, body=None): """ Creates a new configuration """ return self.post(self.configurations_path, body=body) @APIParamsCall def delete_configuration(self, configuration): """ Deletes the specified configuration """ return self.delete(self.configuration_path % (configuration)) @APIParamsCall def show_configuration(self, configuration, **_params): """ Fetches information of a certain configuration """ return self.get(self.configuration_path % (configuration), params=_params) @APIParamsCall def update_configuration(self, configuration, body=None): """ Updates a configuration """ return self.put(self.configuration_path % (configuration), body=body) @APIParamsCall def list_pools(self, **_params): """ Fetches a list of all pools for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.pools_path, params=_params) @APIParamsCall def create_pool(self, body=None): """ Creates a new pool """ return self.post(self.pools_path, body=body) @APIParamsCall def delete_pool(self, pool): """ Deletes the specified pool """ return self.delete(self.pool_path % (pool)) @APIParamsCall def show_pool(self, pool, **_params): """ Fetches information of a certain pool """ return self.get(self.pool_path % (pool), params=_params) @APIParamsCall def update_pool(self, pool, body=None): """ Updates a pool """ return self.put(self.pool_path % (pool), body=body) @APIParamsCall def list_members(self, **_params): """ Fetches a list of all pool members for a pool/tenant """ return self.get(self.members_path, params=_params) @APIParamsCall def create_member(self, body=None): """ Creates a new member """ return self.post(self.members_path, body=body) @APIParamsCall def delete_member(self, member): """ Deletes the specified member """ return self.delete(self.member_path % (member)) @APIParamsCall def show_member(self, member, **_params): """ Fetches information of a certain member """ return self.get(self.member_path % (member), params=_params) @APIParamsCall def update_member(self, member, body=None): """ Updates a member """ return self.put(self.member_path % (member), body=body) ###Helath Monitors @APIParamsCall def list_monitors(self, **_params): """ Fetches a list of all pool monitors for a pool/tenant """ return self.get(self.monitors_path, params=_params) @APIParamsCall def create_monitor(self, body=None): """ Creates a new monitor """ return self.post(self.monitors_path, body=body) @APIParamsCall def delete_monitor(self, monitor): """ Deletes the specified monitor """ return self.delete(self.monitor_path % (monitor)) @APIParamsCall def show_monitor(self, monitor, **_params): """ Fetches information of a certain monitor """ return self.get(self.monitor_path % (monitor), params=_params) @APIParamsCall def update_monitor(self, monitor, body=None): """ Updates a monitor """ return self.put(self.monitor_path % (monitor), body=body) ###Virtual IP's @APIParamsCall def list_vips(self, **_params): """ Fetches a list of all pool vips for a pool/tenant """ return self.get(self.vips_path, params=_params) @APIParamsCall def create_vip(self, body=None): """ Creates a new vip """ return self.post(self.vips_path, body=body) @APIParamsCall def delete_vip(self, vip): """ Deletes the specified vip """ return self.delete(self.vip_path % (vip)) @APIParamsCall def show_vip(self, vip, **_params): """ Fetches information of a certain vip """ return self.get(self.vip_path % (vip), params=_params) @APIParamsCall def update_vip(self, vip, body=None): """ Updates a vip """ return self.put(self.vip_path % (vip), body=body) ###Session Persistance @APIParamsCall def list_sessions(self, **_params): """ Fetches a list of all pool sessions for a pool/tenant """ return self.get(self.sessions_path, params=_params) @APIParamsCall def create_session(self, body=None): """ Creates a new session """ return self.post(self.sessions_path, body=body) @APIParamsCall def delete_session(self, session): """ Deletes the specified session """ return self.delete(self.session_path % (session)) @APIParamsCall def show_session(self, session, **_params): """ Fetches information of a certain session """ return self.get(self.session_path % (session), params=_params) @APIParamsCall def update_session(self, session, body=None): """ Updates a session """ return self.put(self.session_path % (session), body=body) @APIParamsCall def list_networkfunctions(self, **_params): """ Fetches a list of all networkfunctions for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.networkfunctions_path, params=_params) @APIParamsCall def create_networkfunction(self, body=None): """ Creates a new Networkfunction """ return self.post(self.networkfunctions_path, body=body) @APIParamsCall def delete_networkfunction(self, networkfunction): """ Deletes the specified networkfunction """ return self.delete(self.networkfunction_path % (networkfunction)) @APIParamsCall def show_networkfunction(self, networkfunction, **_params): """ Fetches information of a certain networkfunction """ return self.get(self.networkfunction_path % (networkfunction), params=_params) @APIParamsCall def update_networkfunction(self, networkfunction, body=None): """ Updates a networkfunction """ return self.put(self.networkfunction_path % (networkfunction), body=body) @APIParamsCall def list_categories(self, **_params): """ Fetches a list of all categories for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.categories_path, params=_params) @APIParamsCall def create_category(self, body=None): """ Creates a new Category """ return self.post(self.categories_path, body=body) @APIParamsCall def delete_category(self, category): """ Deletes the specified category """ return self.delete(self.category_path % (category)) @APIParamsCall def show_category(self, category, **_params): """ Fetches information of a certain category """ return self.get(self.category_path % (category), params=_params) @APIParamsCall def update_category(self, category, body=None): """ Updates a category """ return self.put(self.category_path % (category), body=body) @APIParamsCall def list_category_networkfunctions(self, **_params): """ Fetches a list of all category_networkfunctions for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.category_networkfunctions_path, params=_params) @APIParamsCall def create_category_networkfunction(self, body=None): """ Creates a new Category_networkfunction """ return self.post(self.category_networkfunctions_path, body=body) @APIParamsCall def delete_category_networkfunction(self, category_networkfunction): """ Deletes the specified category_networkfunction """ return self.delete(self.category_networkfunction_path % (category_networkfunction)) @APIParamsCall def show_category_networkfunction(self, category_networkfunction, **_params): """ Fetches information of a certain category_networkfunction """ return self.get(self.category_networkfunction_path % (category_networkfunction), params=_params) @APIParamsCall def update_category_networkfunction(self, category_networkfunction, body=None): """ Updates a category_networkfunction """ return self.put(self.category_networkfunction_path % (category_networkfunction), body=body) @APIParamsCall def list_vendors(self, **_params): """ Fetches a list of all vendors for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.vendors_path, params=_params) @APIParamsCall def create_vendor(self, body=None): """ Creates a new Vendor """ return self.post(self.vendors_path, body=body) @APIParamsCall def delete_vendor(self, vendor): """ Deletes the specified vendor """ return self.delete(self.vendor_path % (vendor)) @APIParamsCall def show_vendor(self, vendor, **_params): """ Fetches information of a certain vendor """ return self.get(self.vendor_path % (vendor), params=_params) @APIParamsCall def update_vendor(self, vendor, body=None): """ Updates a vendor """ return self.put(self.vendor_path % (vendor), body=body) @APIParamsCall def list_images(self, **_params): """ Fetches a list of all images for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.images_path, params=_params) @APIParamsCall def create_image(self, body=None): """ Creates a new Images """ return self.post(self.images_path, body=body) @APIParamsCall def delete_image(self, image): """ Deletes the specified image """ return self.delete(self.image_path % (image)) @APIParamsCall def show_image(self, image, **_params): """ Fetches information of a certain image """ return self.get(self.image_path % (image), params=_params) @APIParamsCall def update_image(self, image, body=None): """ Updates a image """ return self.put(self.image_path % (image), body=body) @APIParamsCall def list_metadatas(self, **_params): """ Fetches a list of all metadatas for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.metadatas_path, params=_params) @APIParamsCall def create_metadata(self, body=None): """ Creates a new Metadata """ return self.post(self.metadatas_path, body=body) @APIParamsCall def delete_metadata(self, metadata): """ Deletes the specified metadata """ return self.delete(self.metadata_path % (metadata)) @APIParamsCall def show_metadata(self, metadata, **_params): """ Fetches information of a certain metadata """ return self.get(self.metadata_path % (metadata), params=_params) @APIParamsCall def update_metadata(self, metadata, body=None): """ Updates a metadata """ return self.put(self.metadata_path % (metadata), body=body) @APIParamsCall def list_personalities(self, **_params): """ Fetches a list of all personalities for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.personalities_path, params=_params) @APIParamsCall def create_personality(self, body=None): """ Creates a new Personality """ return self.post(self.personalities_path, body=body) @APIParamsCall def delete_personality(self, personality): """ Deletes the specified personality """ return self.delete(self.personality_path % (personality)) @APIParamsCall def show_personality(self, personality, **_params): """ Fetches information of a certain personality """ return self.get(self.personality_path % (personality), params=_params) @APIParamsCall def update_personality(self, personality, body=None): """ Updates a personality """ return self.put(self.personality_path % (personality), body=body) @APIParamsCall def list_chains(self, **_params): """ Fetches a list of all chains for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.chains_path, params=_params) @APIParamsCall def create_chain(self, body=None): """ Creates a new chain """ return self.post(self.chains_path, body=body) @APIParamsCall def delete_chain(self, chain): """ Deletes the specified chain """ return self.delete(self.chain_path % (chain)) @APIParamsCall def show_chain(self, chain, **_params): """ Fetches information of a certain chain """ return self.get(self.chain_path % (chain), params=_params) @APIParamsCall def update_chain(self, chain, body=None): """ Updates a chain """ return self.put(self.chain_path % (chain), body=body) @APIParamsCall def list_chain_images(self, **_params): """ Fetches a list of all chain_images for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.chain_images_path, params=_params) @APIParamsCall def create_chain_image(self, body=None): """ Creates a new Chain_image """ return self.post(self.chain_images_path, body=body) @APIParamsCall def delete_chain_image(self, chain_image): """ Deletes the specified chain_image """ return self.delete(self.chain_image_path % (chain_image)) @APIParamsCall def show_chain_image(self, chain_image, **_params): """ Fetches information of a certain chain_image """ return self.get(self.chain_image_path % (chain_image), params=_params) @APIParamsCall def update_chain_image(self, chain_image, body=None): """ Updates a chain_image """ return self.put(self.chain_image_path % (chain_image), body=body) @APIParamsCall def list_chain_image_networks(self, **_params): """ Fetches a list of all chain_image_networks for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.chain_image_networks_path, params=_params) @APIParamsCall def create_chain_image_network(self, body=None): """ Creates a new Chain_image_network """ return self.post(self.chain_image_networks_path, body=body) @APIParamsCall def delete_chain_image_network(self, chain_image_network): """ Deletes the specified chain_image_network """ return self.delete(self.chain_image_network_path % (chain_image_network)) @APIParamsCall def show_chain_image_network(self, chain_image_network, **_params): """ Fetches information of a certain chain_image_network """ return self.get(self.chain_image_network_path % (chain_image_network), params=_params) @APIParamsCall def update_chain_image_network(self, chain_image_network, body=None): """ Updates a chain_image_network """ return self.put(self.chain_image_network_path % (chain_image_network), body=body) @APIParamsCall def list_chain_image_confs(self, **_params): """ Fetches a list of all chain_image_confs for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.chain_image_confs_path, params=_params) @APIParamsCall def create_chain_image_conf(self, body=None): """ Creates a new Chain_image_conf """ return self.post(self.chain_image_confs_path, body=body) @APIParamsCall def delete_chain_image_conf(self, chain_image_conf): """ Deletes the specified chain_image_conf """ return self.delete(self.chain_image_conf_path % (chain_image_conf)) @APIParamsCall def show_chain_image_conf(self, chain_image_conf, **_params): """ Fetches information of a certain chain_image_conf """ return self.get(self.chain_image_conf_path % (chain_image_conf), params=_params) @APIParamsCall def update_chain_image_conf(self, chain_image_conf, body=None): """ Updates a chain_image_conf """ return self.put(self.chain_image_conf_path % (chain_image_conf), body=body) @APIParamsCall def list_config_handles(self, **_params): """ Fetches a list of all config_handles for a tenant """ # Pass filters in "params" argument to do_request return self.get(self.config_handles_path, params=_params) @APIParamsCall def create_config_handle(self, body=None): """ Creates a new Config_handle """ return self.post(self.config_handles_path, body=body) @APIParamsCall def delete_config_handle(self, config_handle): """ Deletes the specified config_handle """ return self.delete(self.config_handle_path % (config_handle)) @APIParamsCall def show_config_handle(self, config_handle, **_params): """ Fetches information of a certain config_handle """ return self.get(self.config_handle_path % (config_handle), params=_params) @APIParamsCall def update_config_handle(self, config_handle, body=None): """ Updates a config_handle """ return self.put(self.config_handle_path % (config_handle), body=body) @APIParamsCall def generate_slb_config(self, body=None): """ Generate the specified configuration """ return self.post(self.slb_configs_path, body=body) @APIParamsCall def launch_chain(self, launch, **_params): """ Generate the specified configuration """ return self.get(self.launch_path % (launch), params=_params) def __init__(self, **kwargs): """ Initialize a new client for the Quantum v2.0 API. """ super(Client, self).__init__() self.httpclient = HTTPClient(**kwargs) self.version = '2.0' self.format = 'json' self.action_prefix = "/v%s" % (self.version) self.retries = 0 self.retry_interval = 1 def _handle_fault_response(self, status_code, response_body): # Create exception with HTTP status code and message error_message = response_body _logger.debug("Error message: %s", error_message) # Add deserialized error message to exception arguments try: des_error_body = Serializer().deserialize(error_message, self.content_type()) except: # If unable to deserialized body it is probably not a # Quantum error des_error_body = {'message': error_message} # Raise the appropriate exception exception_handler_v20(status_code, des_error_body) def do_request(self, method, action, body=None, headers=None, params=None): # Add format and tenant_id action += ".%s" % self.format action = self.action_prefix + action if type(params) is dict and params: action += '?' + urllib.urlencode(params, doseq=1) if body: body = self.serialize(body) self.httpclient.content_type = self.content_type() resp, replybody = self.httpclient.do_request(action, method, body=body) status_code = self.get_status_code(resp) if status_code in (httplib.OK, httplib.CREATED, httplib.ACCEPTED, httplib.NO_CONTENT): return self.deserialize(replybody, status_code) else: self._handle_fault_response(status_code, replybody) def get_status_code(self, response): """ Returns the integer status code from the response, which can be either a Webob.Response (used in testing) or httplib.Response """ if hasattr(response, 'status_int'): return response.status_int else: return response.status def serialize(self, data): """ Serializes a dictionary with a single key (which can contain any structure) into either xml or json """ if data is None: return None elif type(data) is dict: return Serializer().serialize(data, self.content_type()) else: raise Exception("unable to serialize object of type = '%s'" % type(data)) def deserialize(self, data, status_code): """ Deserializes an xml or json string into a dictionary """ if status_code == 204: return data return Serializer(self._serialization_metadata).deserialize( data, self.content_type()) def content_type(self, format=None): """ Returns the mime-type for either 'xml' or 'json'. Defaults to the currently set format """ if not format: format = self.format return "application/%s" % (format) def retry_request(self, method, action, body=None, headers=None, params=None): """ Call do_request with the default retry configuration. Only idempotent requests should retry failed connection attempts. :raises: ConnectionFailed if the maximum # of retries is exceeded """ max_attempts = self.retries + 1 for i in xrange(max_attempts): try: return self.do_request(method, action, body=body, headers=headers, params=params) except exceptions.ConnectionFailed: # Exception has already been logged by do_request() if i < self.retries: _logger.debug(_('Retrying connection to quantum service')) time.sleep(self.retry_interval) raise exceptions.ConnectionFailed(reason=_("Maximum attempts reached")) def delete(self, action, body=None, headers=None, params=None): return self.retry_request("DELETE", action, body=body, headers=headers, params=params) def get(self, action, body=None, headers=None, params=None): return self.retry_request("GET", action, body=body, headers=headers, params=params) def post(self, action, body=None, headers=None, params=None): # Do not retry POST requests to avoid the orphan objects problem. return self.do_request("POST", action, body=body, headers=headers, params=params) def put(self, action, body=None, headers=None, params=None): return self.retry_request("PUT", action, body=body, headers=headers, params=params)
def setUp(self): """Prepare the test environment""" self.mox = mox.Mox() self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION)
class CLITestAuthKeystone(unittest.TestCase): def setUp(self): """Prepare the test environment""" self.mox = mox.Mox() self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION) def tearDown(self): """Clear the test environment""" self.mox.VerifyAll() self.mox.UnsetStubs() def test_get_token(self): self.mox.StubOutWithMock(self.client, "request") res200 = self.mox.CreateMock(httplib2.Response) res200.status = 200 self.client.request(AUTH_URL + '/tokens', 'POST', body=IsA(str), headers=IsA(dict)).\ AndReturn((res200, json.dumps(KS_TOKEN_RESULT))) self.client.request(StrContains(ENDPOINT_URL + '/resource'), 'GET', headers=ContainsKeyValue('X-Auth-Token', TOKEN)).\ AndReturn((res200, '')) self.mox.ReplayAll() self.client.do_request('/resource', 'GET') self.assertEqual(self.client.endpoint_url, ENDPOINT_URL) self.assertEqual(self.client.auth_token, TOKEN) self.assertEqual(self.client.token_retrieved, True) def test_already_token_retrieved(self): self.mox.StubOutWithMock(self.client, "request") self.client.auth_token = TOKEN self.client.endpoint_url = ENDPOINT_URL self.client.token_retrieved = True res200 = self.mox.CreateMock(httplib2.Response) res200.status = 200 self.client.request(StrContains(ENDPOINT_URL + '/resource'), 'GET', headers=ContainsKeyValue('X-Auth-Token', TOKEN)).\ AndReturn((res200, '')) self.mox.ReplayAll() self.client.do_request('/resource', 'GET') def test_refresh_token(self): self.mox.StubOutWithMock(self.client, "request") self.client.auth_token = TOKEN self.client.endpoint_url = ENDPOINT_URL self.client.token_retrieved = True res200 = self.mox.CreateMock(httplib2.Response) res200.status = 200 res401 = self.mox.CreateMock(httplib2.Response) res401.status = 401 # If a token is expired, quantum server retruns 401 self.client.request(StrContains(ENDPOINT_URL + '/resource'), 'GET', headers=ContainsKeyValue('X-Auth-Token', TOKEN)).\ AndReturn((res401, '')) self.client.request(AUTH_URL + '/tokens', 'POST', body=IsA(str), headers=IsA(dict)).\ AndReturn((res200, json.dumps(KS_TOKEN_RESULT))) self.client.request(StrContains(ENDPOINT_URL + '/resource'), 'GET', headers=ContainsKeyValue('X-Auth-Token', TOKEN)).\ AndReturn((res200, '')) self.mox.ReplayAll() self.client.do_request('/resource', 'GET')
class CLITestAuthKeystone(testtools.TestCase): def setUp(self): """Prepare the test environment.""" super(CLITestAuthKeystone, self).setUp() self.mox = mox.Mox() self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION) self.addCleanup(self.mox.VerifyAll) self.addCleanup(self.mox.UnsetStubs) def test_get_token(self): self.mox.StubOutWithMock(self.client, "request") res200 = self.mox.CreateMock(httplib2.Response) res200.status = 200 self.client.request(AUTH_URL + '/tokens', 'POST', body=IsA(str), headers=IsA(dict)).\ AndReturn((res200, json.dumps(KS_TOKEN_RESULT))) self.client.request(StrContains(ENDPOINT_URL + '/resource'), 'GET', headers=ContainsKeyValue('X-Auth-Token', TOKEN)).\ AndReturn((res200, '')) self.mox.ReplayAll() self.client.do_request('/resource', 'GET') self.assertEqual(self.client.endpoint_url, ENDPOINT_URL) self.assertEqual(self.client.auth_token, TOKEN) def test_refresh_token(self): self.mox.StubOutWithMock(self.client, "request") self.client.auth_token = TOKEN self.client.endpoint_url = ENDPOINT_URL res200 = self.mox.CreateMock(httplib2.Response) res200.status = 200 res401 = self.mox.CreateMock(httplib2.Response) res401.status = 401 # If a token is expired, quantum server retruns 401 self.client.request(StrContains(ENDPOINT_URL + '/resource'), 'GET', headers=ContainsKeyValue('X-Auth-Token', TOKEN)).\ AndReturn((res401, '')) self.client.request(AUTH_URL + '/tokens', 'POST', body=IsA(str), headers=IsA(dict)).\ AndReturn((res200, json.dumps(KS_TOKEN_RESULT))) self.client.request(StrContains(ENDPOINT_URL + '/resource'), 'GET', headers=ContainsKeyValue('X-Auth-Token', TOKEN)).\ AndReturn((res200, '')) self.mox.ReplayAll() self.client.do_request('/resource', 'GET') def test_get_endpoint_url(self): self.mox.StubOutWithMock(self.client, "request") self.client.auth_token = TOKEN res200 = self.mox.CreateMock(httplib2.Response) res200.status = 200 self.client.request(StrContains(AUTH_URL + '/tokens/%s/endpoints' % TOKEN), 'GET', headers=IsA(dict)). \ AndReturn((res200, json.dumps(ENDPOINTS_RESULT))) self.client.request(StrContains(ENDPOINT_URL + '/resource'), 'GET', headers=ContainsKeyValue('X-Auth-Token', TOKEN)). \ AndReturn((res200, '')) self.mox.ReplayAll() self.client.do_request('/resource', 'GET') def test_get_endpoint_url_other(self): self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION, endpoint_type='otherURL') self.mox.StubOutWithMock(self.client, "request") self.client.auth_token = TOKEN res200 = self.mox.CreateMock(httplib2.Response) res200.status = 200 self.client.request(StrContains(AUTH_URL + '/tokens/%s/endpoints' % TOKEN), 'GET', headers=IsA(dict)). \ AndReturn((res200, json.dumps(ENDPOINTS_RESULT))) self.mox.ReplayAll() self.assertRaises(exceptions.EndpointTypeNotFound, self.client.do_request, '/resource', 'GET') def test_get_endpoint_url_failed(self): self.mox.StubOutWithMock(self.client, "request") self.client.auth_token = TOKEN res200 = self.mox.CreateMock(httplib2.Response) res200.status = 200 res401 = self.mox.CreateMock(httplib2.Response) res401.status = 401 self.client.request(StrContains(AUTH_URL + '/tokens/%s/endpoints' % TOKEN), 'GET', headers=IsA(dict)). \ AndReturn((res401, '')) self.client.request(AUTH_URL + '/tokens', 'POST', body=IsA(str), headers=IsA(dict)). \ AndReturn((res200, json.dumps(KS_TOKEN_RESULT))) self.client.request(StrContains(ENDPOINT_URL + '/resource'), 'GET', headers=ContainsKeyValue('X-Auth-Token', TOKEN)). \ AndReturn((res200, '')) self.mox.ReplayAll() self.client.do_request('/resource', 'GET') def test_url_for(self): resources = copy.deepcopy(KS_TOKEN_RESULT) endpoints = resources['access']['serviceCatalog'][0]['endpoints'][0] endpoints['publicURL'] = 'public' endpoints['internalURL'] = 'internal' endpoints['adminURL'] = 'admin' catalog = ServiceCatalog(resources) # endpoint_type not specified url = catalog.url_for(attr='region', filter_value=REGION) self.assertEqual('public', url) # endpoint type specified (3 cases) url = catalog.url_for(attr='region', filter_value=REGION, endpoint_type='adminURL') self.assertEqual('admin', url) url = catalog.url_for(attr='region', filter_value=REGION, endpoint_type='publicURL') self.assertEqual('public', url) url = catalog.url_for(attr='region', filter_value=REGION, endpoint_type='internalURL') self.assertEqual('internal', url) # endpoint_type requested does not exist. self.assertRaises(exceptions.EndpointTypeNotFound, catalog.url_for, attr='region', filter_value=REGION, endpoint_type='privateURL') # Test scenario with url_for when the service catalog only has publicURL. def test_url_for_only_public_url(self): resources = copy.deepcopy(KS_TOKEN_RESULT) catalog = ServiceCatalog(resources) # Remove endpoints from the catalog. endpoints = resources['access']['serviceCatalog'][0]['endpoints'][0] del endpoints['internalURL'] del endpoints['adminURL'] endpoints['publicURL'] = 'public' # Use publicURL when specified explicitly. url = catalog.url_for(attr='region', filter_value=REGION, endpoint_type='publicURL') self.assertEqual('public', url) # Use publicURL when specified explicitly. url = catalog.url_for(attr='region', filter_value=REGION) self.assertEqual('public', url) # Test scenario with url_for when the service catalog only has adminURL. def test_url_for_only_admin_url(self): resources = copy.deepcopy(KS_TOKEN_RESULT) catalog = ServiceCatalog(resources) endpoints = resources['access']['serviceCatalog'][0]['endpoints'][0] del endpoints['internalURL'] del endpoints['publicURL'] endpoints['adminURL'] = 'admin' # Use publicURL when specified explicitly. url = catalog.url_for(attr='region', filter_value=REGION, endpoint_type='adminURL') self.assertEqual('admin', url) # But not when nothing is specified. self.assertRaises(exceptions.EndpointTypeNotFound, catalog.url_for, attr='region', filter_value=REGION) def test_endpoint_type(self): resources = copy.deepcopy(KS_TOKEN_RESULT) endpoints = resources['access']['serviceCatalog'][0]['endpoints'][0] endpoints['internalURL'] = 'internal' endpoints['adminURL'] = 'admin' endpoints['publicURL'] = 'public' # Test default behavior is to choose public. self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION) self.client._extract_service_catalog(resources) self.assertEqual(self.client.endpoint_url, 'public') # Test admin url self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION, endpoint_type='adminURL') self.client._extract_service_catalog(resources) self.assertEqual(self.client.endpoint_url, 'admin') # Test public url self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION, endpoint_type='publicURL') self.client._extract_service_catalog(resources) self.assertEqual(self.client.endpoint_url, 'public') # Test internal url self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION, endpoint_type='internalURL') self.client._extract_service_catalog(resources) self.assertEqual(self.client.endpoint_url, 'internal') # Test url that isn't found in the service catalog self.client = HTTPClient(username=USERNAME, tenant_name=TENANT_NAME, password=PASSWORD, auth_url=AUTH_URL, region_name=REGION, endpoint_type='privateURL') self.assertRaises(exceptions.EndpointTypeNotFound, self.client._extract_service_catalog, resources)
class Client(object): """Client for the OpenStack Quantum v2.0 API. :param string username: Username for authentication. (optional) :param string password: Password for authentication. (optional) :param string token: Token for authentication. (optional) :param string tenant_name: Tenant name. (optional) :param string auth_url: Keystone service endpoint for authorization. :param string endpoint_type: Network service endpoint type to pull from the keystone catalog (e.g. 'publicURL', 'internalURL', or 'adminURL') (optional) :param string region_name: Name of a region to select when choosing an endpoint from the service catalog. :param string endpoint_url: A user-supplied endpoint URL for the quantum service. Lazy-authentication is possible for API service calls if endpoint is set at instantiation.(optional) :param integer timeout: Allows customization of the timeout for client http requests. (optional) :param insecure: ssl certificate validation. (optional) Example:: from quantumclient.v2_0 import client quantum = client.Client(username=USER, password=PASS, tenant_name=TENANT_NAME, auth_url=KEYSTONE_URL) nets = quantum.list_networks() ... """ networks_path = "/networks" network_path = "/networks/%s" ports_path = "/ports" port_path = "/ports/%s" subnets_path = "/subnets" subnet_path = "/subnets/%s" quotas_path = "/quotas" quota_path = "/quotas/%s" exts_path = "/extensions" ext_path = "/extensions/%s" routers_path = "/routers" router_path = "/routers/%s" floatingips_path = "/floatingips" floatingip_path = "/floatingips/%s" security_groups_path = "/security-groups" security_group_path = "/security-groups/%s" security_group_rules_path = "/security-group-rules" security_group_rule_path = "/security-group-rules/%s" vips_path = "/lb/vips" vip_path = "/lb/vips/%s" pools_path = "/lb/pools" pool_path = "/lb/pools/%s" pool_path_stats = "/lb/pools/%s/stats" members_path = "/lb/members" member_path = "/lb/members/%s" health_monitors_path = "/lb/health_monitors" health_monitor_path = "/lb/health_monitors/%s" associate_pool_health_monitors_path = "/lb/pools/%s/health_monitors" disassociate_pool_health_monitors_path = ( "/lb/pools/%(pool)s/health_monitors/%(health_monitor)s") qos_queues_path = "/qos-queues" qos_queue_path = "/qos-queues/%s" agents_path = "/agents" agent_path = "/agents/%s" network_gateways_path = "/network-gateways" network_gateway_path = "/network-gateways/%s" DHCP_NETS = '/dhcp-networks' DHCP_AGENTS = '/dhcp-agents' L3_ROUTERS = '/l3-routers' L3_AGENTS = '/l3-agents' firewall_rules_path = "/firewall_rules" firewall_rule_path = "/firewall_rules/%s" firewall_policies_path = "/firewall_policies" firewall_policy_path = "/firewall_policies/%s" firewalls_path = "/firewalls" firewall_path = "/firewalls/%s" # API has no way to report plurals, so we have to hard code them EXTED_PLURALS = {'routers': 'router', 'floatingips': 'floatingip', 'service_types': 'service_type', 'service_definitions': 'service_definition', 'security_groups': 'security_group', 'security_group_rules': 'security_group_rule', 'vips': 'vip', 'pools': 'pool', 'members': 'member', 'health_monitors': 'health_monitor', 'quotas': 'quota', 'firewall_rules': 'firewall_rule', 'firewall_policies': 'firewall_policy', 'firewalls': 'firewall' } # 8192 Is the default max URI len for eventlet.wsgi.server MAX_URI_LEN = 8192 def get_attr_metadata(self): if self.format == 'json': return {} old_request_format = self.format self.format = 'json' exts = self.list_extensions()['extensions'] self.format = old_request_format ns = dict([(ext['alias'], ext['namespace']) for ext in exts]) self.EXTED_PLURALS.update(constants.PLURALS) return {'plurals': self.EXTED_PLURALS, 'xmlns': constants.XML_NS_V20, constants.EXT_NS: ns} @APIParamsCall def get_quotas_tenant(self, **_params): """Fetch tenant info in server's context for following quota operation. """ return self.get(self.quota_path % 'tenant', params=_params) @APIParamsCall def list_quotas(self, **_params): """Fetch all tenants' quotas.""" return self.get(self.quotas_path, params=_params) @APIParamsCall def show_quota(self, tenant_id, **_params): """Fetch information of a certain tenant's quotas.""" return self.get(self.quota_path % (tenant_id), params=_params) @APIParamsCall def update_quota(self, tenant_id, body=None): """Update a tenant's quotas.""" return self.put(self.quota_path % (tenant_id), body=body) @APIParamsCall def delete_quota(self, tenant_id): """Delete the specified tenant's quota values.""" return self.delete(self.quota_path % (tenant_id)) @APIParamsCall def list_extensions(self, **_params): """Fetch a list of all exts on server side.""" return self.get(self.exts_path, params=_params) @APIParamsCall def show_extension(self, ext_alias, **_params): """Fetch a list of all exts on server side.""" return self.get(self.ext_path % ext_alias, params=_params) @APIParamsCall def list_ports(self, retrieve_all=True, **_params): """ Fetches a list of all networks for a tenant """ # Pass filters in "params" argument to do_request return self.list('ports', self.ports_path, retrieve_all, **_params) @APIParamsCall def show_port(self, port, **_params): """ Fetches information of a certain network """ return self.get(self.port_path % (port), params=_params) @APIParamsCall def create_port(self, body=None): """ Creates a new port """ return self.post(self.ports_path, body=body) @APIParamsCall def update_port(self, port, body=None): """ Updates a port """ return self.put(self.port_path % (port), body=body) @APIParamsCall def delete_port(self, port): """ Deletes the specified port """ return self.delete(self.port_path % (port)) @APIParamsCall def list_networks(self, retrieve_all=True, **_params): """ Fetches a list of all networks for a tenant """ # Pass filters in "params" argument to do_request return self.list('networks', self.networks_path, retrieve_all, **_params) @APIParamsCall def show_network(self, network, **_params): """ Fetches information of a certain network """ return self.get(self.network_path % (network), params=_params) @APIParamsCall def create_network(self, body=None): """ Creates a new network """ return self.post(self.networks_path, body=body) @APIParamsCall def update_network(self, network, body=None): """ Updates a network """ return self.put(self.network_path % (network), body=body) @APIParamsCall def delete_network(self, network): """ Deletes the specified network """ return self.delete(self.network_path % (network)) @APIParamsCall def list_subnets(self, retrieve_all=True, **_params): """ Fetches a list of all networks for a tenant """ return self.list('subnets', self.subnets_path, retrieve_all, **_params) @APIParamsCall def show_subnet(self, subnet, **_params): """ Fetches information of a certain subnet """ return self.get(self.subnet_path % (subnet), params=_params) @APIParamsCall def create_subnet(self, body=None): """ Creates a new subnet """ return self.post(self.subnets_path, body=body) @APIParamsCall def update_subnet(self, subnet, body=None): """ Updates a subnet """ return self.put(self.subnet_path % (subnet), body=body) @APIParamsCall def delete_subnet(self, subnet): """ Deletes the specified subnet """ return self.delete(self.subnet_path % (subnet)) @APIParamsCall def list_routers(self, retrieve_all=True, **_params): """ Fetches a list of all routers for a tenant """ # Pass filters in "params" argument to do_request return self.list('routers', self.routers_path, retrieve_all, **_params) @APIParamsCall def show_router(self, router, **_params): """ Fetches information of a certain router """ return self.get(self.router_path % (router), params=_params) @APIParamsCall def create_router(self, body=None): """ Creates a new router """ return self.post(self.routers_path, body=body) @APIParamsCall def update_router(self, router, body=None): """ Updates a router """ return self.put(self.router_path % (router), body=body) @APIParamsCall def delete_router(self, router): """ Deletes the specified router """ return self.delete(self.router_path % (router)) @APIParamsCall def add_interface_router(self, router, body=None): """ Adds an internal network interface to the specified router """ return self.put((self.router_path % router) + "/add_router_interface", body=body) @APIParamsCall def remove_interface_router(self, router, body=None): """ Removes an internal network interface from the specified router """ return self.put((self.router_path % router) + "/remove_router_interface", body=body) @APIParamsCall def add_gateway_router(self, router, body=None): """ Adds an external network gateway to the specified router """ return self.put((self.router_path % router), body={'router': {'external_gateway_info': body}}) @APIParamsCall def remove_gateway_router(self, router): """ Removes an external network gateway from the specified router """ return self.put((self.router_path % router), body={'router': {'external_gateway_info': {}}}) @APIParamsCall def list_floatingips(self, retrieve_all=True, **_params): """ Fetches a list of all floatingips for a tenant """ # Pass filters in "params" argument to do_request return self.list('floatingips', self.floatingips_path, retrieve_all, **_params) @APIParamsCall def show_floatingip(self, floatingip, **_params): """ Fetches information of a certain floatingip """ return self.get(self.floatingip_path % (floatingip), params=_params) @APIParamsCall def create_floatingip(self, body=None): """ Creates a new floatingip """ return self.post(self.floatingips_path, body=body) @APIParamsCall def update_floatingip(self, floatingip, body=None): """ Updates a floatingip """ return self.put(self.floatingip_path % (floatingip), body=body) @APIParamsCall def delete_floatingip(self, floatingip): """ Deletes the specified floatingip """ return self.delete(self.floatingip_path % (floatingip)) @APIParamsCall def create_security_group(self, body=None): """ Creates a new security group """ return self.post(self.security_groups_path, body=body) @APIParamsCall def update_security_group(self, security_group, body=None): """ Updates a security group """ return self.put(self.security_group_path % security_group, body=body) @APIParamsCall def list_security_groups(self, retrieve_all=True, **_params): """ Fetches a list of all security groups for a tenant """ return self.list('security_groups', self.security_groups_path, retrieve_all, **_params) @APIParamsCall def show_security_group(self, security_group, **_params): """ Fetches information of a certain security group """ return self.get(self.security_group_path % (security_group), params=_params) @APIParamsCall def delete_security_group(self, security_group): """ Deletes the specified security group """ return self.delete(self.security_group_path % (security_group)) @APIParamsCall def create_security_group_rule(self, body=None): """ Creates a new security group rule """ return self.post(self.security_group_rules_path, body=body) @APIParamsCall def delete_security_group_rule(self, security_group_rule): """ Deletes the specified security group rule """ return self.delete(self.security_group_rule_path % (security_group_rule)) @APIParamsCall def list_security_group_rules(self, retrieve_all=True, **_params): """ Fetches a list of all security group rules for a tenant """ return self.list('security_group_rules', self.security_group_rules_path, retrieve_all, **_params) @APIParamsCall def show_security_group_rule(self, security_group_rule, **_params): """ Fetches information of a certain security group rule """ return self.get(self.security_group_rule_path % (security_group_rule), params=_params) @APIParamsCall def list_vips(self, retrieve_all=True, **_params): """ Fetches a list of all load balancer vips for a tenant """ # Pass filters in "params" argument to do_request return self.list('vips', self.vips_path, retrieve_all, **_params) @APIParamsCall def show_vip(self, vip, **_params): """ Fetches information of a certain load balancer vip """ return self.get(self.vip_path % (vip), params=_params) @APIParamsCall def create_vip(self, body=None): """ Creates a new load balancer vip """ return self.post(self.vips_path, body=body) @APIParamsCall def update_vip(self, vip, body=None): """ Updates a load balancer vip """ return self.put(self.vip_path % (vip), body=body) @APIParamsCall def delete_vip(self, vip): """ Deletes the specified load balancer vip """ return self.delete(self.vip_path % (vip)) @APIParamsCall def list_pools(self, retrieve_all=True, **_params): """ Fetches a list of all load balancer pools for a tenant """ # Pass filters in "params" argument to do_request return self.list('pools', self.pools_path, retrieve_all, **_params) @APIParamsCall def show_pool(self, pool, **_params): """ Fetches information of a certain load balancer pool """ return self.get(self.pool_path % (pool), params=_params) @APIParamsCall def create_pool(self, body=None): """ Creates a new load balancer pool """ return self.post(self.pools_path, body=body) @APIParamsCall def update_pool(self, pool, body=None): """ Updates a load balancer pool """ return self.put(self.pool_path % (pool), body=body) @APIParamsCall def delete_pool(self, pool): """ Deletes the specified load balancer pool """ return self.delete(self.pool_path % (pool)) @APIParamsCall def retrieve_pool_stats(self, pool, **_params): """ Retrieves stats for a certain load balancer pool """ return self.get(self.pool_path_stats % (pool), params=_params) @APIParamsCall def list_members(self, retrieve_all=True, **_params): """ Fetches a list of all load balancer members for a tenant """ # Pass filters in "params" argument to do_request return self.list('members', self.members_path, retrieve_all, **_params) @APIParamsCall def show_member(self, member, **_params): """ Fetches information of a certain load balancer member """ return self.get(self.member_path % (member), params=_params) @APIParamsCall def create_member(self, body=None): """ Creates a new load balancer member """ return self.post(self.members_path, body=body) @APIParamsCall def update_member(self, member, body=None): """ Updates a load balancer member """ return self.put(self.member_path % (member), body=body) @APIParamsCall def delete_member(self, member): """ Deletes the specified load balancer member """ return self.delete(self.member_path % (member)) @APIParamsCall def list_health_monitors(self, retrieve_all=True, **_params): """ Fetches a list of all load balancer health monitors for a tenant """ # Pass filters in "params" argument to do_request return self.list('health_monitors', self.health_monitors_path, retrieve_all, **_params) @APIParamsCall def show_health_monitor(self, health_monitor, **_params): """ Fetches information of a certain load balancer health monitor """ return self.get(self.health_monitor_path % (health_monitor), params=_params) @APIParamsCall def create_health_monitor(self, body=None): """ Creates a new load balancer health monitor """ return self.post(self.health_monitors_path, body=body) @APIParamsCall def update_health_monitor(self, health_monitor, body=None): """ Updates a load balancer health monitor """ return self.put(self.health_monitor_path % (health_monitor), body=body) @APIParamsCall def delete_health_monitor(self, health_monitor): """ Deletes the specified load balancer health monitor """ return self.delete(self.health_monitor_path % (health_monitor)) @APIParamsCall def associate_health_monitor(self, pool, body): """ Associate specified load balancer health monitor and pool """ return self.post(self.associate_pool_health_monitors_path % (pool), body=body) @APIParamsCall def disassociate_health_monitor(self, pool, health_monitor): """ Disassociate specified load balancer health monitor and pool """ path = (self.disassociate_pool_health_monitors_path % {'pool': pool, 'health_monitor': health_monitor}) return self.delete(path) @APIParamsCall def create_qos_queue(self, body=None): """ Creates a new queue """ return self.post(self.qos_queues_path, body=body) @APIParamsCall def list_qos_queues(self, **_params): """ Fetches a list of all queues for a tenant """ return self.get(self.qos_queues_path, params=_params) @APIParamsCall def show_qos_queue(self, queue, **_params): """ Fetches information of a certain queue """ return self.get(self.qos_queue_path % (queue), params=_params) @APIParamsCall def delete_qos_queue(self, queue): """ Deletes the specified queue """ return self.delete(self.qos_queue_path % (queue)) @APIParamsCall def list_agents(self, **_params): """ Fetches agents """ # Pass filters in "params" argument to do_request return self.get(self.agents_path, params=_params) @APIParamsCall def show_agent(self, agent, **_params): """ Fetches information of a certain agent """ return self.get(self.agent_path % (agent), params=_params) @APIParamsCall def update_agent(self, agent, body=None): """ Updates an agent """ return self.put(self.agent_path % (agent), body=body) @APIParamsCall def delete_agent(self, agent): """ Deletes the specified agent """ return self.delete(self.agent_path % (agent)) @APIParamsCall def list_network_gateways(self, **_params): """ Retrieve network gateways """ return self.get(self.network_gateways_path, params=_params) @APIParamsCall def show_network_gateway(self, gateway_id, **_params): """ Fetch a network gateway """ return self.get(self.network_gateway_path % gateway_id, params=_params) @APIParamsCall def create_network_gateway(self, body=None): """ Create a new network gateway """ return self.post(self.network_gateways_path, body=body) @APIParamsCall def update_network_gateway(self, gateway_id, body=None): """ Update a network gateway """ return self.put(self.network_gateway_path % gateway_id, body=body) @APIParamsCall def delete_network_gateway(self, gateway_id): """ Delete the specified network gateway """ return self.delete(self.network_gateway_path % gateway_id) @APIParamsCall def connect_network_gateway(self, gateway_id, body=None): """ Connect a network gateway to the specified network """ base_uri = self.network_gateway_path % gateway_id return self.put("%s/connect_network" % base_uri, body=body) @APIParamsCall def disconnect_network_gateway(self, gateway_id, body=None): """ Disconnect a network from the specified gateway """ base_uri = self.network_gateway_path % gateway_id return self.put("%s/disconnect_network" % base_uri, body=body) @APIParamsCall def list_dhcp_agent_hosting_networks(self, network, **_params): """ Fetches a list of dhcp agents hosting a network. """ return self.get((self.network_path + self.DHCP_AGENTS) % network, params=_params) @APIParamsCall def list_networks_on_dhcp_agent(self, dhcp_agent, **_params): """ Fetches a list of dhcp agents hosting a network. """ return self.get((self.agent_path + self.DHCP_NETS) % dhcp_agent, params=_params) @APIParamsCall def add_network_to_dhcp_agent(self, dhcp_agent, body=None): """ Adds a network to dhcp agent. """ return self.post((self.agent_path + self.DHCP_NETS) % dhcp_agent, body=body) @APIParamsCall def remove_network_from_dhcp_agent(self, dhcp_agent, network_id): """ Remove a network from dhcp agent. """ return self.delete((self.agent_path + self.DHCP_NETS + "/%s") % ( dhcp_agent, network_id)) @APIParamsCall def list_l3_agent_hosting_routers(self, router, **_params): """ Fetches a list of L3 agents hosting a router. """ return self.get((self.router_path + self.L3_AGENTS) % router, params=_params) @APIParamsCall def list_routers_on_l3_agent(self, l3_agent, **_params): """ Fetches a list of L3 agents hosting a router. """ return self.get((self.agent_path + self.L3_ROUTERS) % l3_agent, params=_params) @APIParamsCall def add_router_to_l3_agent(self, l3_agent, body): """ Adds a router to L3 agent. """ return self.post((self.agent_path + self.L3_ROUTERS) % l3_agent, body=body) @APIParamsCall def list_firewall_rules(self, retrieve_all=True, **_params): """ Fetches a list of all firewall rules for a tenant """ # Pass filters in "params" argument to do_request return self.list('firewall_rules', self.firewall_rules_path, retrieve_all, **_params) @APIParamsCall def show_firewall_rule(self, firewall_rule, **_params): """ Fetches information of a certain firewall rule """ return self.get(self.firewall_rule_path % (firewall_rule), params=_params) @APIParamsCall def create_firewall_rule(self, body=None): """ Creates a new firewall rule """ return self.post(self.firewall_rules_path, body=body) @APIParamsCall def update_firewall_rule(self, firewall_rule, body=None): """ Updates a firewall rule """ return self.put(self.firewall_rule_path % (firewall_rule), body=body) @APIParamsCall def delete_firewall_rule(self, firewall_rule): """ Deletes the specified firewall rule """ return self.delete(self.firewall_rule_path % (firewall_rule)) @APIParamsCall def list_firewall_policies(self, retrieve_all=True, **_params): """ Fetches a list of all firewall policies for a tenant """ # Pass filters in "params" argument to do_request return self.list('firewall_policies', self.firewall_policies_path, retrieve_all, **_params) @APIParamsCall def show_firewall_policy(self, firewall_policy, **_params): """ Fetches information of a certain firewall policy """ return self.get(self.firewall_policy_path % (firewall_policy), params=_params) @APIParamsCall def create_firewall_policy(self, body=None): """ Creates a new firewall policy """ return self.post(self.firewall_policies_path, body=body) @APIParamsCall def update_firewall_policy(self, firewall_policy, body=None): """ Updates a firewall policy """ return self.put(self.firewall_policy_path % (firewall_policy), body=body) @APIParamsCall def delete_firewall_policy(self, firewall_policy): """ Deletes the specified firewall policy """ return self.delete(self.firewall_policy_path % (firewall_policy)) @APIParamsCall def list_firewalls(self, retrieve_all=True, **_params): """ Fetches a list of all firewals for a tenant """ # Pass filters in "params" argument to do_request return self.list('firewalls', self.firewalls_path, retrieve_all, **_params) @APIParamsCall def show_firewall(self, firewall, **_params): """ Fetches information of a certain firewall """ return self.get(self.firewall_path % (firewall), params=_params) @APIParamsCall def create_firewall(self, body=None): """ Creates a new firewall """ return self.post(self.firewalls_path, body=body) @APIParamsCall def update_firewall(self, firewall, body=None): """ Updates a firewall """ return self.put(self.firewall_path % (firewall), body=body) @APIParamsCall def delete_firewall(self, firewall): """ Deletes the specified firewall """ return self.delete(self.firewall_path % (firewall)) @APIParamsCall def remove_router_from_l3_agent(self, l3_agent, router_id): """ Remove a router from l3 agent. """ return self.delete((self.agent_path + self.L3_ROUTERS + "/%s") % ( l3_agent, router_id)) def __init__(self, **kwargs): """Initialize a new client for the Quantum v2.0 API.""" super(Client, self).__init__() self.httpclient = HTTPClient(**kwargs) self.version = '2.0' self.format = 'json' self.action_prefix = "/v%s" % (self.version) self.retries = 0 self.retry_interval = 1 def _handle_fault_response(self, status_code, response_body): # Create exception with HTTP status code and message _logger.debug("Error message: %s", response_body) # Add deserialized error message to exception arguments try: des_error_body = self.deserialize(response_body, status_code) except Exception: # If unable to deserialized body it is probably not a # Quantum error des_error_body = {'message': response_body} # Raise the appropriate exception exception_handler_v20(status_code, des_error_body) def do_request(self, method, action, body=None, headers=None, params=None): # Add format and tenant_id action += ".%s" % self.format action = self.action_prefix + action if type(params) is dict and params: params = utils.safe_encode_dict(params) action += '?' + urllib.urlencode(params, doseq=1) # Ensure client always has correct uri - do not guesstimate anything self.httpclient.authenticate_and_fetch_endpoint_url() uri_len = len(self.httpclient.endpoint_url) + len(action) if uri_len > self.MAX_URI_LEN: raise exceptions.RequestURITooLong( excess=uri_len - self.MAX_URI_LEN) if body: body = self.serialize(body) self.httpclient.content_type = self.content_type() resp, replybody = self.httpclient.do_request(action, method, body=body) status_code = self.get_status_code(resp) if status_code in (httplib.OK, httplib.CREATED, httplib.ACCEPTED, httplib.NO_CONTENT): return self.deserialize(replybody, status_code) else: self._handle_fault_response(status_code, replybody) def get_auth_info(self): return self.httpclient.get_auth_info() def get_status_code(self, response): """ Returns the integer status code from the response, which can be either a Webob.Response (used in testing) or httplib.Response """ if hasattr(response, 'status_int'): return response.status_int else: return response.status def serialize(self, data): """ Serializes a dictionary with a single key (which can contain any structure) into either xml or json """ if data is None: return None elif type(data) is dict: return serializer.Serializer( self.get_attr_metadata()).serialize(data, self.content_type()) else: raise Exception("unable to serialize object of type = '%s'" % type(data)) def deserialize(self, data, status_code): """ Deserializes an xml or json string into a dictionary """ if status_code == 204: return data return serializer.Serializer(self.get_attr_metadata()).deserialize( data, self.content_type())['body'] def content_type(self, _format=None): """ Returns the mime-type for either 'xml' or 'json'. Defaults to the currently set format """ _format = _format or self.format return "application/%s" % (_format) def retry_request(self, method, action, body=None, headers=None, params=None): """ Call do_request with the default retry configuration. Only idempotent requests should retry failed connection attempts. :raises: ConnectionFailed if the maximum # of retries is exceeded """ max_attempts = self.retries + 1 for i in xrange(max_attempts): try: return self.do_request(method, action, body=body, headers=headers, params=params) except exceptions.ConnectionFailed: # Exception has already been logged by do_request() if i < self.retries: _logger.debug(_('Retrying connection to quantum service')) time.sleep(self.retry_interval) raise exceptions.ConnectionFailed(reason=_("Maximum attempts reached")) def delete(self, action, body=None, headers=None, params=None): return self.retry_request("DELETE", action, body=body, headers=headers, params=params) def get(self, action, body=None, headers=None, params=None): return self.retry_request("GET", action, body=body, headers=headers, params=params) def post(self, action, body=None, headers=None, params=None): # Do not retry POST requests to avoid the orphan objects problem. return self.do_request("POST", action, body=body, headers=headers, params=params) def put(self, action, body=None, headers=None, params=None): return self.retry_request("PUT", action, body=body, headers=headers, params=params) def list(self, collection, path, retrieve_all=True, **params): if retrieve_all: res = [] for r in self._pagination(collection, path, **params): res.extend(r[collection]) return {collection: res} else: return self._pagination(collection, path, **params) def _pagination(self, collection, path, **params): if params.get('page_reverse', False): linkrel = 'previous' else: linkrel = 'next' next = True while next: res = self.get(path, params=params) yield res next = False try: for link in res['%s_links' % collection]: if link['rel'] == linkrel: query_str = urlparse.urlparse(link['href']).query params = urlparse.parse_qs(query_str) next = True break except KeyError: break