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 __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 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 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 __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 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
