184 lines
6.6 KiB
Python
184 lines
6.6 KiB
Python
# Copyright 2012 OpenStack Foundation
|
|
# Copyright 2013 IBM Corp.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
from novaclient import client
|
|
from novaclient.v3 import agents
|
|
from novaclient.v3 import aggregates
|
|
from novaclient.v3 import availability_zones
|
|
from novaclient.v3 import certs
|
|
from novaclient.v3 import flavor_access
|
|
from novaclient.v3 import flavors
|
|
from novaclient.v3 import hosts
|
|
from novaclient.v3 import hypervisors
|
|
from novaclient.v3 import images
|
|
from novaclient.v3 import keypairs
|
|
from novaclient.v3 import list_extensions
|
|
from novaclient.v3 import quotas
|
|
from novaclient.v3 import servers
|
|
from novaclient.v3 import services
|
|
from novaclient.v3 import usage
|
|
from novaclient.v3 import volumes
|
|
|
|
|
|
class Client(object):
|
|
"""
|
|
Top-level object to access the OpenStack Compute API.
|
|
|
|
Create an instance with your creds::
|
|
|
|
>>> client = Client(USERNAME, PASSWORD, PROJECT_ID, AUTH_URL)
|
|
|
|
Then call methods on its managers::
|
|
|
|
>>> client.servers.list()
|
|
...
|
|
>>> client.flavors.list()
|
|
...
|
|
|
|
It is also possible to use an instance as a context manager in which
|
|
case there will be a session kept alive for the duration of the with
|
|
statement::
|
|
|
|
>>> with Client(USERNAME, PASSWORD, PROJECT_ID, AUTH_URL) as client:
|
|
... client.servers.list()
|
|
... client.flavors.list()
|
|
...
|
|
|
|
It is also possible to have a permanent (process-long) connection pool,
|
|
by passing a connection_pool=True::
|
|
|
|
>>> client = Client(USERNAME, PASSWORD, PROJECT_ID,
|
|
... AUTH_URL, connection_pool=True)
|
|
"""
|
|
|
|
def __init__(self, username=None, password=None, project_id=None,
|
|
auth_url=None, insecure=False, timeout=None,
|
|
proxy_tenant_id=None, proxy_token=None, region_name=None,
|
|
endpoint_type='publicURL', extensions=None,
|
|
service_type='computev3', service_name=None,
|
|
volume_service_name=None, timings=False, bypass_url=None,
|
|
os_cache=False, no_cache=True, http_log_debug=False,
|
|
auth_system='keystone', auth_plugin=None, auth_token=None,
|
|
cacert=None, tenant_id=None, user_id=None,
|
|
connection_pool=False, session=None, auth=None,
|
|
completion_cache=None):
|
|
# NOTE(cyeoh): In the novaclient context (unlike Nova) the
|
|
# project_id is not the same as the tenant_id. Here project_id
|
|
# is a name (what the Nova API often refers to as a project or
|
|
# tenant name) and tenant_id is a UUID (what the Nova API
|
|
# often refers to as a project_id or tenant_id).
|
|
|
|
self.projectid = project_id
|
|
self.tenant_id = tenant_id
|
|
self.user_id = user_id
|
|
self.os_cache = os_cache or not no_cache
|
|
#TODO(bnemec): Add back in v3 extensions
|
|
self.agents = agents.AgentsManager(self)
|
|
self.aggregates = aggregates.AggregateManager(self)
|
|
self.availability_zones = \
|
|
availability_zones.AvailabilityZoneManager(self)
|
|
self.certs = certs.CertificateManager(self)
|
|
self.list_extensions = list_extensions.ListExtManager(self)
|
|
self.hosts = hosts.HostManager(self)
|
|
self.flavors = flavors.FlavorManager(self)
|
|
self.flavor_access = flavor_access.FlavorAccessManager(self)
|
|
self.hypervisors = hypervisors.HypervisorManager(self)
|
|
self.images = images.ImageManager(self)
|
|
self.keypairs = keypairs.KeypairManager(self)
|
|
self.quotas = quotas.QuotaSetManager(self)
|
|
self.servers = servers.ServerManager(self)
|
|
self.services = services.ServiceManager(self)
|
|
self.usage = usage.UsageManager(self)
|
|
self.volumes = volumes.VolumeManager(self)
|
|
|
|
# Add in any extensions...
|
|
if extensions:
|
|
for extension in extensions:
|
|
if extension.manager_class:
|
|
setattr(self, extension.name,
|
|
extension.manager_class(self))
|
|
|
|
self.client = client._construct_http_client(
|
|
username=username,
|
|
password=password,
|
|
user_id=user_id,
|
|
project_id=project_id,
|
|
tenant_id=tenant_id,
|
|
auth_url=auth_url,
|
|
auth_token=auth_token,
|
|
insecure=insecure,
|
|
timeout=timeout,
|
|
auth_system=auth_system,
|
|
auth_plugin=auth_plugin,
|
|
proxy_token=proxy_token,
|
|
proxy_tenant_id=proxy_tenant_id,
|
|
region_name=region_name,
|
|
endpoint_type=endpoint_type,
|
|
service_type=service_type,
|
|
service_name=service_name,
|
|
volume_service_name=volume_service_name,
|
|
timings=timings,
|
|
bypass_url=bypass_url,
|
|
os_cache=self.os_cache,
|
|
http_log_debug=http_log_debug,
|
|
cacert=cacert,
|
|
connection_pool=connection_pool,
|
|
session=session,
|
|
auth=auth)
|
|
|
|
self.completion_cache = completion_cache
|
|
|
|
def write_object_to_completion_cache(self, obj):
|
|
if self.completion_cache:
|
|
self.completion_cache.write_object(obj)
|
|
|
|
def clear_completion_cache_for_class(self, obj_class):
|
|
if self.completion_cache:
|
|
self.completion_cache.clear_class(obj_class)
|
|
|
|
@client._original_only
|
|
def __enter__(self):
|
|
self.client.open_session()
|
|
return self
|
|
|
|
@client._original_only
|
|
def __exit__(self, t, v, tb):
|
|
self.client.close_session()
|
|
|
|
@client._original_only
|
|
def set_management_url(self, url):
|
|
self.client.set_management_url(url)
|
|
|
|
@client._original_only
|
|
def get_timings(self):
|
|
return self.client.get_timings()
|
|
|
|
@client._original_only
|
|
def reset_timings(self):
|
|
self.client.reset_timings()
|
|
|
|
@client._original_only
|
|
def authenticate(self):
|
|
"""
|
|
Authenticate against the server.
|
|
|
|
Normally this is called automatically when you first access the API,
|
|
but you can call this method to force authentication right now.
|
|
|
|
Returns on success; raises :exc:`exceptions.Unauthorized` if the
|
|
credentials are wrong.
|
|
"""
|
|
self.client.authenticate()
|