def __init__(self, username=None, password=None, tenant_name=None,
api_server_host=None, api_server_port=None,
api_server_url=None, conf_file=None, user_info=None,
auth_token=None, auth_host=None, auth_port=None,
auth_protocol = None, auth_url=None, auth_type=None,
wait_for_connect=False, api_server_use_ssl=False,
domain_name=None):
# TODO allow for username/password to be present in creds file
self._obj_serializer = self._obj_serializer_diff
for object_type, resource_type in all_resource_type_tuples:
for oper_str in ('_create', '_read', '_update', '_delete',
's_list', '_get_default_id'):
method = getattr(self, '_object%s' %(oper_str))
bound_method = functools.partial(method, resource_type)
functools.update_wrapper(bound_method, method)
if oper_str == '_get_default_id':
setattr(self, 'get_default_%s_id' % (object_type),
bound_method)
else:
setattr(self, '%s%s' %(object_type, oper_str),
bound_method)
cfg_parser = ConfigParser.ConfigParser()
try:
cfg_parser.read(conf_file or
"/etc/contrail/vnc_api_lib.ini")
except Exception as e:
logger = logging.getLogger(__name__)
logger.warn("Exception: %s", str(e))
self._api_connect_protocol = VncApi._DEFAULT_API_SERVER_CONNECT
# API server SSL Support
use_ssl = api_server_use_ssl
if isinstance(api_server_use_ssl, basestring):
use_ssl = (api_server_use_ssl.lower() == 'true')
if use_ssl:
self._api_connect_protocol = VncApi._DEFAULT_API_SERVER_SSL_CONNECT
# keystone
self._authn_type = auth_type or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_TYPE',
self._DEFAULT_AUTHN_TYPE)
if self._authn_type == 'keystone':
self._authn_protocol = auth_protocol or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PROTOCOL',
self._DEFAULT_AUTHN_PROTOCOL)
self._authn_server = auth_host or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_SERVER',
self._DEFAULT_AUTHN_SERVER)
self._authn_port = auth_port or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PORT',
self._DEFAULT_AUTHN_PORT)
self._authn_url = auth_url or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_URL',
self._DEFAULT_AUTHN_URL)
self._username = username or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_USER',
self._DEFAULT_AUTHN_USER)
self._password = password or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PASSWORD',
self._DEFAULT_AUTHN_PASSWORD)
self._tenant_name = tenant_name or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_TENANT',
self._DEFAULT_AUTHN_TENANT)
self._domain_name = domain_name or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_DOMAIN',
self._DEFAULT_DOMAIN_ID)
#contrail-api SSL support
try:
self._apiinsecure = cfg_parser.getboolean('global','insecure')
except (AttributeError,
ConfigParser.NoOptionError,
ConfigParser.NoSectionError):
self._apiinsecure = False
apicertfile=_read_cfg(cfg_parser,'global','certfile','')
apikeyfile=_read_cfg(cfg_parser,'global','keyfile','')
apicafile=_read_cfg(cfg_parser,'global','cafile','')
self._use_api_certs=False
if apicertfile and apikeyfile \
and apicafile and api_server_use_ssl:
certs=[apicertfile, apikeyfile, apicafile]
self._apicertbundle=utils.getCertKeyCaBundle(VncApi._DEFAULT_API_CERT_BUNDLE,certs)
self._use_api_certs=True
# keystone SSL support
try:
self._ksinsecure = cfg_parser.getboolean('auth', 'insecure')
except (AttributeError,
ConfigParser.NoOptionError,
ConfigParser.NoSectionError):
self._ksinsecure = False
kscertfile=_read_cfg(cfg_parser,'auth','certfile','')
kskeyfile=_read_cfg(cfg_parser,'auth','keyfile','')
kscafile=_read_cfg(cfg_parser,'auth','cafile','')
self._use_ks_certs=False
if kscertfile and kskeyfile and kscafile \
and self._authn_protocol == 'https':
certs=[kscertfile, kskeyfile, kscafile]
self._kscertbundle=utils.getCertKeyCaBundle(VncApi._DEFAULT_KS_CERT_BUNDLE,certs)
self._use_ks_certs=True
if 'v2' in self._authn_url:
self._authn_body = \
'{"auth":{"passwordCredentials":{' + \
'"username": "******",' % (self._username) + \
' "password": "******"},' % (self._password) + \
' "tenantName":"%s"}}' % (self._tenant_name)
else:
self._authn_body = \
'{"auth":{"identity":{' + \
'"methods": ["password"],' + \
' "password":{' + \
' "user":{' + \
' "name": "%s",' % (self._username) + \
' "domain": { "id": "%s" },' % (self._domain_name) + \
' "password": "******"' % (self._password) + \
'}' + \
'}' + \
'},' + \
' "scope":{' + \
' "project":{' + \
' "domain": { "id": "%s" },' % (self._domain_name) + \
' "name": "%s"' % (self._username) + \
'}' + \
'}' + \
'}' + \
'}'
self._user_info = user_info
if not api_server_host:
self._web_host = _read_cfg(cfg_parser, 'global', 'WEB_SERVER',
self._DEFAULT_WEB_SERVER)
else:
self._web_host = api_server_host
if not api_server_port:
self._web_port = _read_cfg(cfg_parser, 'global', 'WEB_PORT',
self._DEFAULT_WEB_PORT)
else:
self._web_port = api_server_port
self._max_pools = int(_read_cfg(
cfg_parser, 'global', 'MAX_POOLS',
self._DEFAULT_MAX_POOLS))
self._max_conns_per_pool = int(_read_cfg(
cfg_parser, 'global', 'MAX_CONNS_PER_POOL',
self._DEFAULT_MAX_CONNS_PER_POOL))
self._curl_logging = False
if _read_cfg(cfg_parser, 'global', 'curl_log', False):
self._curl_logging=True
self._curl_logger=_cfg_curl_logging(_read_cfg(cfg_parser,'global','curl_log',False))
# Where client's view of world begins
if not api_server_url:
self._base_url = _read_cfg(cfg_parser, 'global', 'BASE_URL',
self._DEFAULT_BASE_URL)
else:
self._base_url = api_server_url
# Where server says its root is when _base_url is fetched
self._srv_root_url = None
# Type-independent actions offered by server
self._action_uri = ActionUriDict(self)
self._headers = self._DEFAULT_HEADERS.copy()
self._headers[rest.hdr_client_tenant()] = self._tenant_name
self._auth_token_input = False
self._auth_token = None
if auth_token:
self._auth_token = auth_token
self._auth_token_input = True
self._headers['X-AUTH-TOKEN'] = self._auth_token
# user information for quantum
if self._user_info:
if 'user_id' in self._user_info:
self._headers['X-API-USER-ID'] = self._user_info['user_id']
if 'user' in self._user_info:
self._headers['X-API-USER'] = self._user_info['user']
if 'role' in self._user_info:
self.set_user_roles([self._user_info['role']])
#self._http = HTTPClient(self._web_host, self._web_port,
# network_timeout = 300)
self._create_api_server_session()
retry_count = 6
while retry_count:
try:
homepage = self._request(rest.OP_GET, self._base_url,
retry_on_error=False)
self._parse_homepage(homepage)
except ServiceUnavailableError as e:
logger = logging.getLogger(__name__)
logger.warn("Exception: %s", str(e))
if wait_for_connect:
# Retry connect infinitely when http retcode 503
continue
elif retry_count:
# Retry connect 60 times when http retcode 503
retry_count -= 1
time.sleep(1)
else:
# connected succesfully
break
def __init__(self, username=None, password=None, tenant_name=None,
api_server_host='127.0.0.1', api_server_port='8082',
api_server_url=None, conf_file=None, user_info=None,
auth_token=None):
# TODO allow for username/password to be present in creds file
super(VncApi, self).__init__(self._obj_serializer_diff)
cfg_parser = ConfigParser.ConfigParser()
clen = len(cfg_parser.read(conf_file or
"/etc/contrail/vnc_api_lib.ini"))
# keystone
self._authn_type = _read_cfg(cfg_parser, 'auth', 'AUTHN_TYPE',
self._DEFAULT_AUTHN_TYPE)
if self._authn_type == 'keystone':
self._authn_protocol = _read_cfg(cfg_parser, 'auth', 'AUTHN_PROTOCOL',
self._DEFAULT_AUTHN_PROTOCOL)
self._authn_server = _read_cfg(cfg_parser, 'auth', 'AUTHN_SERVER',
self._DEFAULT_AUTHN_SERVER)
self._authn_port = _read_cfg(cfg_parser, 'auth', 'AUTHN_PORT',
self._DEFAULT_AUTHN_PORT)
self._authn_url = _read_cfg(cfg_parser, 'auth', 'AUTHN_URL',
self._DEFAULT_AUTHN_URL)
self._username = username or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_USER',
self._DEFAULT_AUTHN_USER)
self._password = password or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PASSWORD',
self._DEFAULT_AUTHN_PASSWORD)
self._tenant_name = tenant_name or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_TENANT',
self._DEFAULT_AUTHN_TENANT)
self._authn_body = \
'{"auth":{"passwordCredentials":{' + \
'"username": "******",' % (self._username) + \
' "password": "******"},' % (self._password) + \
' "tenantName":"%s"}}' % (self._tenant_name)
self._user_info = user_info
if not api_server_host:
self._web_host = _read_cfg(cfg_parser, 'global', 'WEB_SERVER',
self._DEFAULT_WEB_SERVER)
else:
self._web_host = api_server_host
if not api_server_port:
self._web_port = _read_cfg(cfg_parser, 'global', 'WEB_PORT',
self._DEFAULT_WEB_PORT)
else:
self._web_port = api_server_port
# Where client's view of world begins
if not api_server_url:
self._base_url = _read_cfg(cfg_parser, 'global', 'BASE_URL',
self._DEFAULT_BASE_URL)
else:
self._base_url = api_server_url
# Where server says its root is when _base_url is fetched
self._srv_root_url = None
# Type-independent actions offered by server
self._action_uri = {}
self._headers = self._DEFAULT_HEADERS.copy()
self._headers[rest.hdr_client_tenant()] = self._tenant_name
self._auth_token_input = False
if auth_token:
self._auth_token = auth_token
self._auth_token_input = True
self._headers['X-AUTH-TOKEN'] = self._auth_token
# user information for quantum
if self._user_info:
if 'user_id' in self._user_info:
self._headers['X-API-USER-ID'] = self._user_info['user_id']
if 'user' in self._user_info:
self._headers['X-API-USER'] = self._user_info['user']
if 'role' in self._user_info:
self._headers['X-API-ROLE'] = self._user_info['role']
#self._http = HTTPClient(self._web_host, self._web_port,
# network_timeout = 300)
self._create_api_server_session()
homepage = self._request_server(rest.OP_GET, self._base_url,
retry_on_error=False)
self._cfg_root_url = self._parse_homepage(homepage)
def __init__(self,
username=None,
password=None,
tenant_name=None,
api_server_host='127.0.0.1',
api_server_port='8082',
api_server_url=None,
conf_file=None,
user_info=None,
auth_token=None,
auth_host=None,
auth_port=None,
auth_protocol=None,
auth_url=None,
api_auth_protocol=_DEFAULT_CONTRAIL_API_PROTOCOL):
# TODO allow for username/password to be present in creds file
super(VncApi, self).__init__(self._obj_serializer_diff)
cfg_parser = ConfigParser.ConfigParser()
clen = len(
cfg_parser.read(conf_file or "/etc/contrail/vnc_api_lib.ini"))
self._api_auth_protocol = api_auth_protocol
# keystone
self._authn_type = _read_cfg(cfg_parser, 'auth', 'AUTHN_TYPE',
self._DEFAULT_AUTHN_TYPE)
if self._authn_type == 'keystone':
self._authn_protocol = auth_protocol or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PROTOCOL',
self._DEFAULT_AUTHN_PROTOCOL)
self._authn_server = auth_host or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_SERVER',
self._DEFAULT_AUTHN_SERVER)
self._authn_port = auth_port or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PORT',
self._DEFAULT_AUTHN_PORT)
self._authn_url = auth_url or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_URL',
self._DEFAULT_AUTHN_URL)
self._username = username or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_USER',
self._DEFAULT_AUTHN_USER)
self._password = password or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PASSWORD',
self._DEFAULT_AUTHN_PASSWORD)
self._tenant_name = tenant_name or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_TENANT',
self._DEFAULT_AUTHN_TENANT)
self._authn_body = \
'{"auth":{"passwordCredentials":{' + \
'"username": "******",' % (self._username) + \
' "password": "******"},' % (self._password) + \
' "tenantName":"%s"}}' % (self._tenant_name)
self._user_info = user_info
if not api_server_host:
self._web_host = _read_cfg(cfg_parser, 'global', 'WEB_SERVER',
self._DEFAULT_WEB_SERVER)
else:
self._web_host = api_server_host
if not api_server_port:
self._web_port = _read_cfg(cfg_parser, 'global', 'WEB_PORT',
self._DEFAULT_WEB_PORT)
else:
self._web_port = api_server_port
# Where client's view of world begins
if not api_server_url:
self._base_url = _read_cfg(cfg_parser, 'global', 'BASE_URL',
self._DEFAULT_BASE_URL)
else:
self._base_url = api_server_url
# Where server says its root is when _base_url is fetched
self._srv_root_url = None
# Type-independent actions offered by server
self._action_uri = {}
self._headers = self._DEFAULT_HEADERS.copy()
self._headers[rest.hdr_client_tenant()] = self._tenant_name
self._auth_token_input = False
if auth_token:
self._auth_token = auth_token
self._auth_token_input = True
self._headers['X-AUTH-TOKEN'] = self._auth_token
# user information for quantum
if self._user_info:
if 'user_id' in self._user_info:
self._headers['X-API-USER-ID'] = self._user_info['user_id']
if 'user' in self._user_info:
self._headers['X-API-USER'] = self._user_info['user']
if 'role' in self._user_info:
self._headers['X-API-ROLE'] = self._user_info['role']
#self._http = HTTPClient(self._web_host, self._web_port,
# network_timeout = 300)
self._create_api_server_session()
homepage = self._request_server(rest.OP_GET,
self._base_url,
retry_on_error=False)
self._cfg_root_url = self._parse_homepage(homepage)
def __init__(self, username=None, password=None, tenant_name=None,
api_server_host='127.0.0.1', api_server_port='8082',
api_server_url=None, conf_file=None, user_info=None,
auth_token=None, auth_host=None, auth_port=None,
auth_protocol = None, auth_url=None, auth_type=None,
wait_for_connect=False, api_server_use_ssl=False,
domain_name=None):
# TODO allow for username/password to be present in creds file
self._obj_serializer = self._obj_serializer_diff
for object_type, resource_type in all_resource_type_tuples:
for oper_str in ('_create', '_read', '_update', '_delete',
's_list', '_get_default_id'):
method = getattr(self, '_object%s' %(oper_str))
bound_method = functools.partial(method, resource_type)
functools.update_wrapper(bound_method, method)
if oper_str == '_get_default_id':
setattr(self, 'get_default_%s_id' % (object_type),
bound_method)
else:
setattr(self, '%s%s' %(object_type, oper_str),
bound_method)
cfg_parser = ConfigParser.ConfigParser()
try:
cfg_parser.read(conf_file or
"/etc/contrail/vnc_api_lib.ini")
except Exception as e:
logger = logging.getLogger(__name__)
logger.warn("Exception: %s", str(e))
self._api_connect_protocol = VncApi._DEFAULT_API_SERVER_CONNECT
# API server SSL Support
use_ssl = api_server_use_ssl
if isinstance(api_server_use_ssl, basestring):
use_ssl = (api_server_use_ssl.lower() == 'true')
if use_ssl:
self._api_connect_protocol = VncApi._DEFAULT_API_SERVER_SSL_CONNECT
# keystone
self._authn_type = auth_type or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_TYPE',
self._DEFAULT_AUTHN_TYPE)
if self._authn_type == 'keystone':
self._authn_protocol = auth_protocol or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PROTOCOL',
self._DEFAULT_AUTHN_PROTOCOL)
self._authn_server = auth_host or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_SERVER',
self._DEFAULT_AUTHN_SERVER)
self._authn_port = auth_port or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PORT',
self._DEFAULT_AUTHN_PORT)
self._authn_url = auth_url or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_URL',
self._DEFAULT_AUTHN_URL)
self._username = username or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_USER',
self._DEFAULT_AUTHN_USER)
self._password = password or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PASSWORD',
self._DEFAULT_AUTHN_PASSWORD)
self._tenant_name = tenant_name or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_TENANT',
self._DEFAULT_AUTHN_TENANT)
self._domain_name = domain_name or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_DOMAIN',
self._DEFAULT_DOMAIN_ID)
#contrail-api SSL support
try:
self._apiinsecure = cfg_parser.getboolean('global','insecure')
except (AttributeError,
ConfigParser.NoOptionError,
ConfigParser.NoSectionError):
self._apiinsecure = False
apicertfile=_read_cfg(cfg_parser,'global','certfile','')
apikeyfile=_read_cfg(cfg_parser,'global','keyfile','')
apicafile=_read_cfg(cfg_parser,'global','cafile','')
self._use_api_certs=False
if apicertfile and apikeyfile \
and apicafile and api_server_use_ssl:
certs=[apicertfile, apikeyfile, apicafile]
self._apicertbundle=utils.getCertKeyCaBundle(VncApi._DEFAULT_API_CERT_BUNDLE,certs)
self._use_api_certs=True
# keystone SSL support
try:
self._ksinsecure = cfg_parser.getboolean('auth', 'insecure')
except (AttributeError,
ConfigParser.NoOptionError,
ConfigParser.NoSectionError):
self._ksinsecure = False
kscertfile=_read_cfg(cfg_parser,'auth','certfile','')
kskeyfile=_read_cfg(cfg_parser,'auth','keyfile','')
kscafile=_read_cfg(cfg_parser,'auth','cafile','')
self._use_ks_certs=False
if kscertfile and kskeyfile and kscafile \
and self._authn_protocol == 'https':
certs=[kscertfile, kskeyfile, kscafile]
self._kscertbundle=utils.getCertKeyCaBundle(VncApi._DEFAULT_KS_CERT_BUNDLE,certs)
self._use_ks_certs=True
if 'v2' in self._authn_url:
self._authn_body = \
'{"auth":{"passwordCredentials":{' + \
'"username": "******",' % (self._username) + \
' "password": "******"},' % (self._password) + \
' "tenantName":"%s"}}' % (self._tenant_name)
else:
self._authn_body = \
'{"auth":{"identity":{' + \
'"methods": ["password"],' + \
' "password":{' + \
' "user":{' + \
' "name": "%s",' % (self._username) + \
' "domain": { "name": "%s" },' % (self._domain_name) + \
' "password": "******"' % (self._password) + \
'}' + \
'}' + \
'},' + \
' "scope":{' + \
' "project":{' + \
' "domain": { "name": "%s" },' % (self._domain_name) + \
' "name": "%s"' % (self._tenant_name) + \
'}' + \
'}' + \
'}' + \
'}'
self._user_info = user_info
if not api_server_host:
self._web_host = _read_cfg(cfg_parser, 'global', 'WEB_SERVER',
self._DEFAULT_WEB_SERVER)
else:
self._web_host = api_server_host
if not api_server_port:
self._web_port = _read_cfg(cfg_parser, 'global', 'WEB_PORT',
self._DEFAULT_WEB_PORT)
else:
self._web_port = api_server_port
self._max_pools = int(_read_cfg(
cfg_parser, 'global', 'MAX_POOLS',
self._DEFAULT_MAX_POOLS))
self._max_conns_per_pool = int(_read_cfg(
cfg_parser, 'global', 'MAX_CONNS_PER_POOL',
self._DEFAULT_MAX_CONNS_PER_POOL))
self._curl_logging = False
if _read_cfg(cfg_parser, 'global', 'curl_log', False):
self._curl_logging = True
self._curl_logger=_cfg_curl_logging(_read_cfg(cfg_parser,'global','curl_log',False))
# Where client's view of world begins
if not api_server_url:
self._base_url = _read_cfg(cfg_parser, 'global', 'BASE_URL',
self._DEFAULT_BASE_URL)
else:
self._base_url = api_server_url
# Where server says its root is when _base_url is fetched
self._srv_root_url = None
# Type-independent actions offered by server
self._action_uri = ActionUriDict(self)
self._headers = self._DEFAULT_HEADERS.copy()
self._headers[rest.hdr_client_tenant()] = self._tenant_name
self._auth_token_input = False
self._auth_token = None
if auth_token:
self._auth_token = auth_token
self._auth_token_input = True
self._headers['X-AUTH-TOKEN'] = self._auth_token
# user information for quantum
if self._user_info:
if 'user_id' in self._user_info:
self._headers['X-API-USER-ID'] = self._user_info['user_id']
if 'user' in self._user_info:
self._headers['X-API-USER'] = self._user_info['user']
if 'role' in self._user_info:
self.set_user_roles([self._user_info['role']])
#self._http = HTTPClient(self._web_host, self._web_port,
# network_timeout = 300)
self._create_api_server_session()
retry_count = 6
while retry_count:
try:
homepage = self._request(rest.OP_GET, self._base_url,
retry_on_error=False)
self._parse_homepage(homepage)
except ServiceUnavailableError as e:
logger = logging.getLogger(__name__)
logger.warn("Exception: %s", str(e))
if wait_for_connect:
# Retry connect infinitely when http retcode 503
continue
elif retry_count:
# Retry connect 60 times when http retcode 503
retry_count -= 1
time.sleep(1)
else:
# connected succesfully
break
def __init__(self, username=None, password=None, tenant_name=None,
api_server_host='127.0.0.1', api_server_port='8082',
api_server_url=None, conf_file=None, user_info=None,
auth_token=None, auth_host=None, auth_port=None,
auth_protocol = None, auth_url=None, auth_type=None,
wait_for_connect=False):
# TODO allow for username/password to be present in creds file
self._obj_serializer = self._obj_serializer_diff
for resource_type in vnc_api.gen.vnc_api_client_gen.all_resource_types:
obj_type = resource_type.replace('-', '_')
for oper_str in ('_create', '_read', '_update', '_delete',
's_list', '_get_default_id'):
method = getattr(self, '_object%s' %(oper_str))
bound_method = functools.partial(method, resource_type)
functools.update_wrapper(bound_method, method)
setattr(self, '%s%s' %(obj_type, oper_str),
bound_method)
cfg_parser = ConfigParser.ConfigParser()
try:
cfg_parser.read(conf_file or
"/etc/contrail/vnc_api_lib.ini")
except Exception as e:
logger = logging.getLogger(__name__)
logger.warn("Exception: %s", str(e))
# keystone
self._authn_type = auth_type or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_TYPE',
self._DEFAULT_AUTHN_TYPE)
if self._authn_type == 'keystone':
self._authn_protocol = auth_protocol or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PROTOCOL',
self._DEFAULT_AUTHN_PROTOCOL)
self._authn_server = auth_host or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_SERVER',
self._DEFAULT_AUTHN_SERVER)
self._authn_port = auth_port or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PORT',
self._DEFAULT_AUTHN_PORT)
self._authn_url = auth_url or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_URL',
self._DEFAULT_AUTHN_URL)
self._username = username or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_USER',
self._DEFAULT_AUTHN_USER)
self._password = password or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PASSWORD',
self._DEFAULT_AUTHN_PASSWORD)
self._tenant_name = tenant_name or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_TENANT',
self._DEFAULT_AUTHN_TENANT)
if 'v2' in self._authn_url:
self._authn_body = \
'{"auth":{"passwordCredentials":{' + \
'"username": "******",' % (self._username) + \
' "password": "******"},' % (self._password) + \
' "tenantName":"%s"}}' % (self._tenant_name)
else:
self._authn_body = \
'{"auth":{"identity":{' + \
'"methods": ["password"],' + \
' "password":{' + \
' "user":{' + \
' "name": "%s",' % (self._username) + \
' "domain": { "id": "%s" },' % (self._DEFAULT_DOMAIN_ID) + \
' "password": "******"' % (self._password) + \
'}' + \
'}' + \
'},' + \
' "scope":{' + \
' "project":{' + \
' "domain": { "id": "%s" },' % (self._DEFAULT_DOMAIN_ID) + \
' "name": "%s"' % (self._username) + \
'}' + \
'}' + \
'}' + \
'}'
self._user_info = user_info
if not api_server_host:
self._web_host = _read_cfg(cfg_parser, 'global', 'WEB_SERVER',
self._DEFAULT_WEB_SERVER)
else:
self._web_host = api_server_host
if not api_server_port:
self._web_port = _read_cfg(cfg_parser, 'global', 'WEB_PORT',
self._DEFAULT_WEB_PORT)
else:
self._web_port = api_server_port
# Where client's view of world begins
if not api_server_url:
self._base_url = _read_cfg(cfg_parser, 'global', 'BASE_URL',
self._DEFAULT_BASE_URL)
else:
self._base_url = api_server_url
# Where server says its root is when _base_url is fetched
self._srv_root_url = None
# Type-independent actions offered by server
self._action_uri = ActionUriDict(self)
self._headers = self._DEFAULT_HEADERS.copy()
self._headers[rest.hdr_client_tenant()] = self._tenant_name
self._auth_token_input = False
self._auth_token = None
if auth_token:
self._auth_token = auth_token
self._auth_token_input = True
self._headers['X-AUTH-TOKEN'] = self._auth_token
# user information for quantum
if self._user_info:
if 'user_id' in self._user_info:
self._headers['X-API-USER-ID'] = self._user_info['user_id']
if 'user' in self._user_info:
self._headers['X-API-USER'] = self._user_info['user']
if 'role' in self._user_info:
self._headers['X-API-ROLE'] = self._user_info['role']
#self._http = HTTPClient(self._web_host, self._web_port,
# network_timeout = 300)
self._create_api_server_session()
retry_count = 6
while retry_count:
try:
homepage = self._request(rest.OP_GET, self._base_url,
retry_on_error=False)
self._cfg_root_url = self._parse_homepage(homepage)
except ServiceUnavailableError as e:
logger = logging.getLogger(__name__)
logger.warn("Exception: %s", str(e))
if wait_for_connect:
# Retry connect infinitely when http retcode 503
continue
elif retry_count:
# Retry connect 60 times when http retcode 503
retry_count -= 1
time.sleep(1)
else:
# connected succesfully
break
def __init__(
self,
username=None,
password=None,
tenant_name=None,
api_server_host=None,
api_server_port=None,
api_server_url=None,
conf_file=None,
user_info=None,
auth_token=None,
auth_host=None,
auth_port=None,
auth_protocol=None,
auth_url=None,
auth_type=None,
wait_for_connect=False,
api_server_use_ssl=False,
domain_name=None,
exclude_hrefs=None,
):
# TODO allow for username/password to be present in creds file
self._obj_serializer = self._obj_serializer_diff
for object_type, resource_type in all_resource_type_tuples:
for oper_str in ("_create", "_read", "_update", "_delete", "s_list", "_get_default_id"):
method = getattr(self, "_object%s" % (oper_str))
bound_method = functools.partial(method, resource_type)
functools.update_wrapper(bound_method, method)
if oper_str == "_get_default_id":
setattr(self, "get_default_%s_id" % (object_type), bound_method)
else:
setattr(self, "%s%s" % (object_type, oper_str), bound_method)
cfg_parser = ConfigParser.ConfigParser()
try:
cfg_parser.read(conf_file or "/etc/contrail/vnc_api_lib.ini")
except Exception as e:
logger = logging.getLogger(__name__)
logger.warn("Exception: %s", str(e))
self._api_connect_protocol = VncApi._DEFAULT_API_SERVER_CONNECT
# API server SSL Support
use_ssl = api_server_use_ssl
if isinstance(api_server_use_ssl, basestring):
use_ssl = api_server_use_ssl.lower() == "true"
if use_ssl:
self._api_connect_protocol = VncApi._DEFAULT_API_SERVER_SSL_CONNECT
# keystone
self._authn_type = auth_type or _read_cfg(cfg_parser, "auth", "AUTHN_TYPE", self._DEFAULT_AUTHN_TYPE)
if self._authn_type == "keystone":
self._authn_protocol = auth_protocol or _read_cfg(
cfg_parser, "auth", "AUTHN_PROTOCOL", self._DEFAULT_AUTHN_PROTOCOL
)
self._authn_server = auth_host or _read_cfg(cfg_parser, "auth", "AUTHN_SERVER", self._DEFAULT_AUTHN_SERVER)
self._authn_port = auth_port or _read_cfg(cfg_parser, "auth", "AUTHN_PORT", self._DEFAULT_AUTHN_PORT)
self._authn_url = auth_url or _read_cfg(cfg_parser, "auth", "AUTHN_URL", self._DEFAULT_AUTHN_URL)
self._username = username or _read_cfg(cfg_parser, "auth", "AUTHN_USER", self._DEFAULT_AUTHN_USER)
self._password = password or _read_cfg(cfg_parser, "auth", "AUTHN_PASSWORD", self._DEFAULT_AUTHN_PASSWORD)
self._tenant_name = tenant_name or _read_cfg(cfg_parser, "auth", "AUTHN_TENANT", self._DEFAULT_AUTHN_TENANT)
self._domain_name = domain_name or _read_cfg(cfg_parser, "auth", "AUTHN_DOMAIN", self._DEFAULT_DOMAIN_ID)
# contrail-api SSL support
try:
self._apiinsecure = cfg_parser.getboolean("global", "insecure")
except (AttributeError, ConfigParser.NoOptionError, ConfigParser.NoSectionError):
self._apiinsecure = False
apicertfile = _read_cfg(cfg_parser, "global", "certfile", "")
apikeyfile = _read_cfg(cfg_parser, "global", "keyfile", "")
apicafile = _read_cfg(cfg_parser, "global", "cafile", "")
self._use_api_certs = False
if api_server_use_ssl:
certs = []
if apicafile:
certs.append(apicafile)
if apicertfile:
certs.append(apicertfile)
if apikeyfile:
certs.append(apikeyfile)
if certs:
self._apicertbundle = utils.getCertKeyCaBundle(VncApi._DEFAULT_API_CERT_BUNDLE, certs)
self._use_api_certs = True
# keystone SSL support
try:
self._ksinsecure = cfg_parser.getboolean("auth", "insecure")
except (AttributeError, ConfigParser.NoOptionError, ConfigParser.NoSectionError):
self._ksinsecure = False
kscertfile = _read_cfg(cfg_parser, "auth", "certfile", "")
kskeyfile = _read_cfg(cfg_parser, "auth", "keyfile", "")
kscafile = _read_cfg(cfg_parser, "auth", "cafile", "")
self._use_ks_certs = False
if self._authn_protocol == "https":
certs = []
if kscafile:
certs.append(kscafile)
if kscertfile:
certs.append(kscertfile)
if kskeyfile:
certs.append(kskeyfile)
if certs:
self._kscertbundle = utils.getCertKeyCaBundle(VncApi._DEFAULT_KS_CERT_BUNDLE, certs)
self._use_ks_certs = True
if "v2" in self._authn_url:
self._authn_body = (
'{"auth":{"passwordCredentials":{'
+ '"username": "******",' % (self._username)
+ ' "password": "******"},' % (self._password)
+ ' "tenantName":"%s"}}' % (self._tenant_name)
)
else:
self._authn_body = (
'{"auth":{"identity":{'
+ '"methods": ["password"],'
+ ' "password":{'
+ ' "user":{'
+ ' "name": "%s",' % (self._username)
+ ' "domain": { "name": "%s" },' % (self._domain_name)
+ ' "password": "******"' % (self._password)
+ "}"
+ "}"
+ "},"
+ ' "scope":{'
+ ' "project":{'
+ ' "domain": { "name": "%s" },' % (self._domain_name)
+ ' "name": "%s"' % (self._tenant_name)
+ "}"
+ "}"
+ "}"
+ "}"
)
self._user_info = user_info
if not api_server_host:
self._web_host = _read_cfg(cfg_parser, "global", "WEB_SERVER", self._DEFAULT_WEB_SERVER)
else:
self._web_host = api_server_host
if not api_server_port:
self._web_port = _read_cfg(cfg_parser, "global", "WEB_PORT", self._DEFAULT_WEB_PORT)
else:
self._web_port = api_server_port
self._max_pools = int(_read_cfg(cfg_parser, "global", "MAX_POOLS", self._DEFAULT_MAX_POOLS))
self._max_conns_per_pool = int(
_read_cfg(cfg_parser, "global", "MAX_CONNS_PER_POOL", self._DEFAULT_MAX_CONNS_PER_POOL)
)
self._curl_logging = False
if _read_cfg(cfg_parser, "global", "curl_log", False):
self._curl_logging = True
self._curl_logger = _cfg_curl_logging(_read_cfg(cfg_parser, "global", "curl_log", False))
# Where client's view of world begins
if not api_server_url:
self._base_url = _read_cfg(cfg_parser, "global", "BASE_URL", self._DEFAULT_BASE_URL)
else:
self._base_url = api_server_url
# Where server says its root is when _base_url is fetched
self._srv_root_url = None
# Type-independent actions offered by server
self._action_uri = ActionUriDict(self)
self._headers = self._DEFAULT_HEADERS.copy()
self._headers[rest.hdr_client_tenant()] = self._tenant_name
self._auth_token_input = False
self._auth_token = None
if auth_token:
self._auth_token = auth_token
self._auth_token_input = True
self._headers["X-AUTH-TOKEN"] = self._auth_token
# user information for quantum
if self._user_info:
if "user_id" in self._user_info:
self._headers["X-API-USER-ID"] = self._user_info["user_id"]
if "user" in self._user_info:
self._headers["X-API-USER"] = self._user_info["user"]
if "role" in self._user_info:
self.set_user_roles([self._user_info["role"]])
self._exclude_hrefs = exclude_hrefs
self._create_api_server_session()
retry_count = 6
while retry_count:
try:
homepage = self._request(rest.OP_GET, self._base_url, retry_on_error=False)
self._parse_homepage(homepage)
except ServiceUnavailableError as e:
logger = logging.getLogger(__name__)
logger.warn("Exception: %s", str(e))
if wait_for_connect:
# Retry connect infinitely when http retcode 503
continue
elif retry_count:
# Retry connect 60 times when http retcode 503
retry_count -= 1
time.sleep(1)
else:
# connected succesfully
break
def __init__(self,
username=None,
password=None,
tenant_name=None,
api_server_host='127.0.0.1',
api_server_port='8082',
api_server_url=None,
conf_file=None,
user_info=None,
auth_token=None,
auth_host=None,
auth_port=None,
auth_protocol=None,
auth_url=None,
auth_type=None,
wait_for_connect=False):
# TODO allow for username/password to be present in creds file
self._obj_serializer = self._obj_serializer_diff
for resource_type in vnc_api.gen.vnc_api_client_gen.all_resource_types:
obj_type = resource_type.replace('-', '_')
for oper_str in ('_create', '_read', '_update', '_delete',
's_list', '_get_default_id'):
method = getattr(self, '_object%s' % (oper_str))
bound_method = functools.partial(method, resource_type)
functools.update_wrapper(bound_method, method)
setattr(self, '%s%s' % (obj_type, oper_str), bound_method)
cfg_parser = ConfigParser.ConfigParser()
try:
cfg_parser.read(conf_file or "/etc/contrail/vnc_api_lib.ini")
except Exception as e:
logger = logging.getLogger(__name__)
logger.warn("Exception: %s", str(e))
# keystone
self._authn_type = auth_type or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_TYPE',
self._DEFAULT_AUTHN_TYPE)
if self._authn_type == 'keystone':
self._authn_protocol = auth_protocol or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PROTOCOL',
self._DEFAULT_AUTHN_PROTOCOL)
self._authn_server = auth_host or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_SERVER',
self._DEFAULT_AUTHN_SERVER)
self._authn_port = auth_port or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PORT',
self._DEFAULT_AUTHN_PORT)
self._authn_url = auth_url or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_URL',
self._DEFAULT_AUTHN_URL)
self._username = username or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_USER',
self._DEFAULT_AUTHN_USER)
self._password = password or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_PASSWORD',
self._DEFAULT_AUTHN_PASSWORD)
self._tenant_name = tenant_name or \
_read_cfg(cfg_parser, 'auth', 'AUTHN_TENANT',
self._DEFAULT_AUTHN_TENANT)
if 'v2' in self._authn_url:
self._authn_body = \
'{"auth":{"passwordCredentials":{' + \
'"username": "******",' % (self._username) + \
' "password": "******"},' % (self._password) + \
' "tenantName":"%s"}}' % (self._tenant_name)
else:
self._authn_body = \
'{"auth":{"identity":{' + \
'"methods": ["password"],' + \
' "password":{' + \
' "user":{' + \
' "name": "%s",' % (self._username) + \
' "domain": { "id": "%s" },' % (self._DEFAULT_DOMAIN_ID) + \
' "password": "******"' % (self._password) + \
'}' + \
'}' + \
'},' + \
' "scope":{' + \
' "project":{' + \
' "domain": { "id": "%s" },' % (self._DEFAULT_DOMAIN_ID) + \
' "name": "%s"' % (self._username) + \
'}' + \
'}' + \
'}' + \
'}'
self._user_info = user_info
if not api_server_host:
self._web_host = _read_cfg(cfg_parser, 'global', 'WEB_SERVER',
self._DEFAULT_WEB_SERVER)
else:
self._web_host = api_server_host
if not api_server_port:
self._web_port = _read_cfg(cfg_parser, 'global', 'WEB_PORT',
self._DEFAULT_WEB_PORT)
else:
self._web_port = api_server_port
# Where client's view of world begins
if not api_server_url:
self._base_url = _read_cfg(cfg_parser, 'global', 'BASE_URL',
self._DEFAULT_BASE_URL)
else:
self._base_url = api_server_url
# Where server says its root is when _base_url is fetched
self._srv_root_url = None
# Type-independent actions offered by server
self._action_uri = ActionUriDict(self)
self._headers = self._DEFAULT_HEADERS.copy()
self._headers[rest.hdr_client_tenant()] = self._tenant_name
self._auth_token_input = False
self._auth_token = None
if auth_token:
self._auth_token = auth_token
self._auth_token_input = True
self._headers['X-AUTH-TOKEN'] = self._auth_token
# user information for quantum
if self._user_info:
if 'user_id' in self._user_info:
self._headers['X-API-USER-ID'] = self._user_info['user_id']
if 'user' in self._user_info:
self._headers['X-API-USER'] = self._user_info['user']
if 'role' in self._user_info:
self._headers['X-API-ROLE'] = self._user_info['role']
#self._http = HTTPClient(self._web_host, self._web_port,
# network_timeout = 300)
self._create_api_server_session()
retry_count = 6
while retry_count:
try:
homepage = self._request(rest.OP_GET,
self._base_url,
retry_on_error=False)
self._cfg_root_url = self._parse_homepage(homepage)
except ServiceUnavailableError as e:
logger = logging.getLogger(__name__)
logger.warn("Exception: %s", str(e))
if wait_for_connect:
# Retry connect infinitely when http retcode 503
continue
elif retry_count:
# Retry connect 60 times when http retcode 503
retry_count -= 1
time.sleep(1)
else:
# connected succesfully
break
def __init__(
self,
username=None,
password=None,
tenant_name=None,
api_server_host="127.0.0.1",
api_server_port="8082",
api_server_url=None,
conf_file=None,
user_info=None,
auth_token=None,
):
# TODO allow for username/password to be present in creds file
super(VncApi, self).__init__(self._obj_serializer_diff)
cfg_parser = ConfigParser.ConfigParser()
clen = len(cfg_parser.read(conf_file or "/etc/contrail/vnc_api_lib.ini"))
# keystone
self._authn_type = _read_cfg(cfg_parser, "auth", "AUTHN_TYPE", self._DEFAULT_AUTHN_TYPE)
if self._authn_type == "keystone":
self._authn_protocol = _read_cfg(cfg_parser, "auth", "AUTHN_PROTOCOL", self._DEFAULT_AUTHN_PROTOCOL)
self._authn_server = _read_cfg(cfg_parser, "auth", "AUTHN_SERVER", self._DEFAULT_AUTHN_SERVER)
self._authn_port = _read_cfg(cfg_parser, "auth", "AUTHN_PORT", self._DEFAULT_AUTHN_PORT)
self._authn_url = _read_cfg(cfg_parser, "auth", "AUTHN_URL", self._DEFAULT_AUTHN_URL)
self._username = username or _read_cfg(cfg_parser, "auth", "AUTHN_USER", self._DEFAULT_AUTHN_USER)
self._password = password or _read_cfg(cfg_parser, "auth", "AUTHN_PASSWORD", self._DEFAULT_AUTHN_PASSWORD)
self._tenant_name = tenant_name or _read_cfg(cfg_parser, "auth", "AUTHN_TENANT", self._DEFAULT_AUTHN_TENANT)
self._authn_body = (
'{"auth":{"passwordCredentials":{'
+ '"username": "******",' % (self._username)
+ ' "password": "******"},' % (self._password)
+ ' "tenantName":"%s"}}' % (self._tenant_name)
)
self._user_info = user_info
if not api_server_host:
self._web_host = _read_cfg(cfg_parser, "global", "WEB_SERVER", self._DEFAULT_WEB_SERVER)
else:
self._web_host = api_server_host
if not api_server_port:
self._web_port = _read_cfg(cfg_parser, "global", "WEB_PORT", self._DEFAULT_WEB_PORT)
else:
self._web_port = api_server_port
# Where client's view of world begins
if not api_server_url:
self._base_url = _read_cfg(cfg_parser, "global", "BASE_URL", self._DEFAULT_BASE_URL)
else:
self._base_url = api_server_url
# Where server says its root is when _base_url is fetched
self._srv_root_url = None
# Type-independent actions offered by server
self._action_uri = {}
self._headers = self._DEFAULT_HEADERS.copy()
self._headers[rest.hdr_client_tenant()] = self._tenant_name
self._auth_token = auth_token
if self._auth_token:
self._headers["X-AUTH-TOKEN"] = self._auth_token
# user information for quantum
if self._user_info:
if "user_id" in self._user_info:
self._headers["X-API-USER-ID"] = self._user_info["user_id"]
if "user" in self._user_info:
self._headers["X-API-USER"] = self._user_info["user"]
if "role" in self._user_info:
self._headers["X-API-ROLE"] = self._user_info["role"]
# self._http = HTTPClient(self._web_host, self._web_port,
# network_timeout = 300)
# set when a request is retried after fetching new token, to
# prevent infinite retries
self._retry_after_authn = False
self._create_api_server_session()
homepage = self._request_server(rest.OP_GET, self._base_url, retry_on_error=False)
self._cfg_root_url = self._parse_homepage(homepage)
