class DxMaskingEngine(object):
api_client = None
__address = None
__name = None
__username = None
__password = None
__port = None
__protocol = None
__logger = None
@classmethod
def __init__(self, engine_tuple):
"""
Constructor
:param address: Engine addess
:param username: username
:param password: password
:param port: masking port (default 8282)
:param protocol: connection protocol (default http)
:returns: this is a description of what is returned
:raises keyError: raises an exception
tuple:
engine_name,ip_address,username,password, protocol,port, defengine, auth_id
"""
self.__address = engine_tuple[1]
self.__name = engine_tuple[0]
self.__username = engine_tuple[2]
self.__password = engine_tuple[3]
self.__port = engine_tuple[5]
self.__protocol = engine_tuple[4]
self.__version = None
self.__logger = logging.getLogger()
self.__logger.debug("creating DxMaskingEngine object")
self.__logger.debug(("parameters: %s %s %s %s %s" %
(self.__address, self.__username, self.__password,
self.__port, self.__protocol)))
self.__base_url = self.__protocol + "://" + self.__address + ":" \
+ str(self.__port) + "/masking/api"
self.config = Configuration()
self.config.host = self.__base_url
self.config.debug = False
self.config.client_side_validation = False
if engine_tuple[8]:
#proxy settings
dxconfig = DxConfig()
self.config.proxy = engine_tuple[8]
if engine_tuple[9]:
self.config.proxyuser = engine_tuple[9]
self.config.proxypass = dxconfig.get_proxy_password(
engine_tuple[9])
else:
self.config.proxyuser = None
self.config.proxypass = None
# to disable certs
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
self.config.verify_ssl = False
if self.__logger.getEffectiveLevel() == logging.DEBUG:
for name, logger in self.config.logger.items():
logger.setLevel(logging.DEBUG)
logger.removeHandler(self.config.logger_stream_handler)
@classmethod
def get_config(self):
return self.config
@classmethod
def get_username(self):
return self.__username
@classmethod
def get_name(self):
return self.__name
@classmethod
def get_session(self):
"""
Create a session with a Masking engine
:return autorization key for a session
"""
self.api_client = ApiClient(self.config)
#set number of retries to one
# set timeout on request level as it is overwritten anyway
# to do
# change all requests to add timeout
self.api_client.rest_client.pool_manager.connection_pool_kw[
'retries'] = 0
apikey = self.load()
try:
self.__logger.debug("Check if old session is valid")
if apikey is not None:
self.api_client.set_default_header(header_name='authorization',
header_value=apikey)
app = ApplicationApi(self.api_client)
app.get_all_applications(_request_timeout=self.get_timeout())
except ApiException as e:
if e.status == 401:
password = DxConfig().decrypt_password(self.__password)
if password is None:
print_error(
"Problem with password decryption. Can't connect to engine"
)
return 1
self.__logger.debug("Logging into Delphix Masking")
login_api = LoginApi(self.api_client)
login = {"username": self.__username, "password": password}
try:
self.__logger.debug("sending a login request. "
"Username {}".format(self.__username))
login_response = login_api.login(
login, _request_timeout=self.get_timeout())
self.__logger.debug("login response %s" % login_response)
self.api_client.set_default_header(
header_name='authorization',
header_value=login_response.authorization)
self.save(login_response.authorization)
return None
except ApiException as e:
print_error("Can't login to engine %s (IP: %s)" %
(self.__name, self.__address))
print_error(e.body)
return 1
else:
print_error("Something went wrong %s" % e)
self.__logger.error("Something went wrong %s" % e)
return 1
except Exception as e:
# if engine is down this one should kick off
print_error("Can't login to engine %s (IP: %s)" %
(self.__name, self.__address))
self.__logger.debug(str(e))
return 1
@classmethod
def get_version(self):
"""
Return version of engine
return: version of engine as string. ex 5.3.0.0 or 5.2.0.0
"""
if self.__version is not None:
return self.__version
try:
si = SystemInformationApi(self.api_client)
retobj = si.get_system_information()
ret = retobj.version
except ApiException:
ret = "5.2.0.0"
self.__version = ret
return ret
@classmethod
def version_ge(self, version_engine):
"""
Compare an input parameter with engine version.
param1: version_engine: version number to compare ex. "5.3"
return: True if engine has higher or equal version
"""
engine_ver = self.get_version()
return version.parse(engine_ver) >= version.parse(version_engine)
@classmethod
def version_le(self, version_engine):
"""
Compare an input parameter with engine version.
param1: version_engine: version number to compare ex. "5.3"
return: True if engine has higher or equal version
"""
engine_ver = self.get_version()
return version.parse(engine_ver) <= version.parse(version_engine)
@classmethod
def save(self, apikey):
"""
Save session to file or database
param1: apikey: Authorization key
"""
# binary_file = open('engine.bin', mode='wb')
# pickle.dump(apikey, binary_file)
# binary_file.close()
config = DxConfig()
config.set_key(self.__name, self.__username, apikey)
@classmethod
def load(self):
"""
Load session from file or database
"""
# try:
# binary_file = open('engine.bin', mode='rb')
# apikey = pickle.load(binary_file)
# binary_file.close()
# return apikey
# except IOError:
# print_error("Session file not found")
# self.__logger.error("Session file not found")
config = DxConfig()
auth_key = config.get_key(self.__name, self.__username)
return auth_key
@classmethod
def get_timeout(self):
"""
Return timeout for query
Tuple (connect_timeout, read_timeout)
"""
return (5, 15)
@classmethod
def getlogs(self, outputlog, page_size, level):
"""
Get engine logs via API
"""
file = outputlog.name
outputlog.write(" ")
outputlog.close()
try:
si = LoggingApi(self.api_client)
arr = si.get_all_logs(page_size=page_size, log_level=level)
except ApiException as e:
print_error("Problem with LoggingAPI %s Error: %s" %
(outputlog.name, str(e)))
return 1
loglist = arr.response_list
loglist.reverse()
self.__logger.debug("List of log files")
self.__logger.debug(loglist)
for l in loglist:
try:
data = FileDownloadApi(self.api_client)
data_file = data.download_file(l.file_download_id)
except ApiException as e:
print_error("Problem with FileDownloadApi %s Error: %s" %
(outputlog.name, str(e)))
return 1
try:
outputlog = open(file, "a")
outputlog.write(data_file)
outputlog.close()
except Exception as e:
print_error("Failed to write file %s because error: %s" %
(outputlog.name, str(e)))
return 1
print_message("Log saved to file %s" % outputlog.name)
return 0
def __init__(self, api_client=None):
if api_client is None:
api_client = ApiClient()
self.api_client = api_client
def get_session(self):
"""
Create a session with a Masking engine
:return autorization key for a session
"""
self.api_client = ApiClient(self.config)
#set number of retries to one
# set timeout on request level as it is overwritten anyway
# to do
# change all requests to add timeout
self.api_client.rest_client.pool_manager.connection_pool_kw[
'retries'] = 0
apikey = self.load()
try:
self.__logger.debug("Check if old session is valid")
if apikey is not None:
self.api_client.set_default_header(header_name='authorization',
header_value=apikey)
app = ApplicationApi(self.api_client)
app.get_all_applications(_request_timeout=self.get_timeout())
except ApiException as e:
if e.status == 401:
password = DxConfig().decrypt_password(self.__password)
if password is None:
print_error(
"Problem with password decryption. Can't connect to engine"
)
return 1
self.__logger.debug("Logging into Delphix Masking")
login_api = LoginApi(self.api_client)
login = {"username": self.__username, "password": password}
try:
self.__logger.debug("sending a login request. "
"Username {}".format(self.__username))
login_response = login_api.login(
login, _request_timeout=self.get_timeout())
self.__logger.debug("login response %s" % login_response)
self.api_client.set_default_header(
header_name='authorization',
header_value=login_response.authorization)
self.save(login_response.authorization)
return None
except ApiException as e:
print_error("Can't login to engine %s (IP: %s)" %
(self.__name, self.__address))
print_error(e.body)
return 1
else:
print_error("Something went wrong %s" % e)
self.__logger.error("Something went wrong %s" % e)
return 1
except Exception as e:
# if engine is down this one should kick off
print_error("Can't login to engine %s (IP: %s)" %
(self.__name, self.__address))
self.__logger.debug(str(e))
return 1
