def __init__(self, username=None, password=None):
TortugaWsApi.__init__(self, username, password)
cm = ConfigManager()
self.serverHostname = cm.getInstaller()
self.serverPort = cm.getAdminPort()
self.serverScheme = cm.getAdminScheme()
class TortugaWsApi(RestApiClient):
"""
Base tortuga ws api class.
"""
def __init__(self, username: Optional[str] = None,
password: Optional[str] = None,
baseurl: Optional[str] = None,
verify: bool = True):
self._cm = ConfigManager()
if not baseurl:
baseurl = '{}://{}:{}'.format(
self._cm.getAdminScheme(),
self._cm.getInstaller(),
self._cm.getAdminPort()
)
if username is None and password is None:
logger.debug('Using built-in user credentials')
username = self._cm.getCfmUser()
password = self._cm.getCfmPassword()
super().__init__(username, password, baseurl, verify)
self.baseurl = '{}/{}'.format(self.baseurl, WS_API_VERSION)
def process_response(self, response: requests.Response):
check_status(response.headers)
return super().process_response(response)
class TortugaWsApiClient:
"""
Tortuga ws api client class.
"""
def __init__(self, endpoint: str,
username: Optional[str] = None,
password: Optional[str] = None,
base_url: Optional[str] = None,
verify: bool = True) -> None:
self._cm = ConfigManager()
if not base_url:
base_url = '{}://{}:{}'.format(
self._cm.getAdminScheme(),
self._cm.getInstaller(),
self._cm.getAdminPort()
)
if username is None and password is None:
logger.debug('Using built-in user credentials')
username = self._cm.getCfmUser()
password = self._cm.getCfmPassword()
self._client = RestApiClient(
username=username,
password=password,
baseurl=base_url,
verify=verify
)
self._client.baseurl = '{}/{}/{}/'.format(base_url, WS_API_VERSION,
endpoint)
def _build_query_string(self, params: dict) -> str: \
# pylint: disable=no-self-use
return '&'.join([f'{k}={v}' for k, v in params.items()])
def list(self, **params) -> list:
path = '/'
query_string = self._build_query_string(params)
if query_string:
path += '?{}'.format(query_string)
return self._client.get(path)
def get(self, id_: str) -> dict:
path = '/{}'.format(id_)
return self._client.get(path)
class TortugaWsApiClient:
"""
Tortuga ws api client class.
"""
def __init__(self,
endpoint: str,
token: Optional[str] = None,
username: Optional[str] = None,
password: Optional[str] = None,
base_url: Optional[str] = None,
verify: bool = True) -> None:
self._cm = ConfigManager()
if not base_url:
base_url = '{}://{}:{}'.format(self._cm.getAdminScheme(),
self._cm.getInstaller(),
self._cm.getAdminPort())
if not token:
if username is None and password is None:
logger.debug('Using built-in user credentials')
username = self._cm.getCfmUser()
password = self._cm.getCfmPassword()
self._client = RestApiClient(token=token,
username=username,
password=password,
baseurl=base_url,
verify=verify)
self._client.baseurl = '{}/{}/{}/'.format(base_url, WS_API_VERSION,
endpoint)
def _build_query_string(self, params: dict) -> str:
return '&'.join([f'{k}={v}' for k, v in params.items()])
def list(self, **params) -> list:
path = '/'
query_string = self._build_query_string(params)
if query_string:
path += '?{}'.format(query_string)
return self._client.get(path)
def get(self, id_: str) -> dict:
path = '/{}'.format(id_)
return self._client.get(path)
def post(self, data: dict) -> dict:
path = '/'
return self._client.post(path, data=data)
def put(self, data: dict) -> dict:
if not data or 'id' not in data.keys():
raise Exception('Object does not have an id field')
id_ = data['id']
if not id_:
raise Exception('Object id is invalid')
path = '/{}'.format(id_)
return self._client.put(path, data=data)
def delete(self, id_: str):
path = '/{}'.format(id_)
return self._client.delete(path)
class TortugaWsApi:
"""
Base tortuga ws api class.
"""
def __init__(self, username=None, password=None):
self._logger = logging.getLogger('tortuga.wsapi.{0}'.format(
self.__class__.__name__))
self._logger.addHandler(logging.NullHandler())
self._cm = ConfigManager()
if username is None and password is None:
self._logger.debug('[%s] Using built-in user credentials' %
(self.__module__))
username = self._cm.getCfmUser()
password = self._cm.getCfmPassword()
self._username = username
self._password = password
self._sm = None
def _getWsUrl(self, url):
"""Extract scheme and net location from provided url. Use defaults
if none exist."""
result = urlparse(url)
scheme = result.scheme if result.scheme else \
self._cm.getAdminScheme()
netloc = result.netloc if result.netloc else \
'{0}:{1}'.format(self._cm.getInstaller(), self._cm.getAdminPort())
return '{0}://{1}'.format(scheme, netloc)
def _getSessionManager(self):
if not self._sm:
self._sm = sessionManager.createSession()
return self._sm
def getLogger(self):
""" Get logger for this class. """
return self._logger
def getConfigManager(self):
""" Return configmanager reference """
return self._cm
def sendSessionRequest(self,
url,
method='GET',
contentType='application/json',
data='',
acceptType='application/json'):
"""
Send authorized session request
Raises:
UserNotAuthorized
"""
sm = self._getSessionManager()
if not sm.hasSession():
if self._username is None:
raise UserNotAuthorized('Username not supplied')
if self._password is None:
raise UserNotAuthorized('Password not supplied')
wsUrl = self._getWsUrl(url)
# establishSession() sets the 'wsUrl' so the explicit call
# to setHost() is not required
sm.establishSession(wsUrl, self._username, self._password)
return sm.sendRequest(url,
method,
contentType,
data,
acceptType=acceptType)
def sendRequest(self,
url,
method='GET',
contentType='application/json',
data='',
acceptType='application/json'):
""" Send unauthorized request. """
sm = self._getSessionManager()
# Because there's no call to establishSession(), explicitly call
# setHost()
sm.setHost(self._getWsUrl(url))
return self._getSessionManager().sendRequest(url, method, contentType,
data, acceptType)
