def add(self):
if (self.obj.driver_name is None):
print_error("Driver name is required")
self.__logger.error("Driver name is required")
return 1
if (self.obj.driver_class_name is None):
print_error("Driver class name is required")
self.__logger.error("Driver class name is required")
return 1
try:
self.__logger.debug("create driver input %s" % str(self))
api_instance = self.__api(self.__engine.api_client)
self.__logger.debug("API instance created")
response = api_instance.create_jdbc_driver(body=self.obj)
self.from_driver(response)
self.__logger.debug("driver response %s" % str(response))
print_message("Driver {} added".format(self.obj.driver_name))
return 0
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e)
return 1
def add(self):
"""
Add application to Masking engine and print status message
return a None if non error
return 1 in case of error
"""
if (self.application_name is None):
print "Application name is required"
self.__logger.error("Application name is required")
return 1
api_instance = ApplicationApi(self.__engine.api_client)
try:
self.__logger.debug("create application input %s" % str(self))
response = api_instance.create_application(
self, _request_timeout=self.__engine.get_timeout())
self.__logger.debug("create application response %s" %
str(response))
print_message("Application %s added" % self.application_name)
except ApiException as e:
print_error(e.body)
self.__logger.error(e)
return 1
def profile_export(p_engine, profilename, exportfile):
"""
Export list of Profile sets into csv
param1: p_engine: engine name from configuration
param2: profilename: profile name to list
param3: exportfile: file location
return 0 if profile name found
"""
data = DataFormatter()
data_header = [("Profile name", 30), ("Expression name", 30)]
data.create_header(data_header)
data.format_type = "csv"
ret = profile_worker(p_engine=p_engine,
profilename=profilename,
exportfile=exportfile,
function_to_call='do_profileexport',
data=data,
mapping=True)
if ret == 0:
output = data.data_output(False)
try:
exportfile.write(output)
exportfile.close()
print_message("Profile(s) saved to file %s" % exportfile.name)
return 0
except Exception as e:
print_error("Problem with file %s Error: %s" %
(exportfile.name, str(e)))
return 1
else:
return 1
def wait_for_task(self):
"""
"""
api_instance = self.__api(self.__engine.api_client)
try:
running = True
while (running):
self.__logger.debug("wait async input %s" % str(self))
response = api_instance.get_async_task(
self.obj.async_task_id,
_request_timeout=self.__engine.get_timeout())
self.__logger.debug("wait async response %s" % str(response))
if response.status != "RUNNING":
running = False
sleep(1)
print_message("Waiting for task %s to complete " %
self.obj.async_task_id)
if response.status == "SUCCEEDED":
print_message("Task finished sucesfully")
return 0
else:
print_error("Task finished with status %s" % response.status)
return 1
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e)
return 1
def update(self):
"""
Update file field data to Masking engine and print status message
return a None if non error
return 1 in case of error
"""
if (self.obj.file_field_metadata_id is None):
print_error("file_field_metadata_id is required")
self.__logger.error("file_field_metadata_id is required")
return 1
try:
if self.obj.date_format == '':
self.date_format = None
self.__logger.debug("create field input %s" % str(self))
api_instance = self.__api(self.__engine.api_client)
response = api_instance.update_file_field_metadata(
self.obj.file_field_metadata_id, self.obj)
self.__logger.debug("field response %s" % str(response))
print_message("Field %s updated" % self.obj.field_name)
return None
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e)
return 1
def add(self):
"""
Add table to Masking engine and print status message
return 0 if non error
return 1 in case of error
"""
if (self.table_name is None):
print "Table name is required"
self.__logger.error("Table name is required")
return 1
if (self.ruleset_id is None):
print "ruleset_id is required"
self.__logger.error("ruleset_id is required")
return 1
try:
self.__logger.debug("create table input %s" % str(self))
api_instance = TableMetadataApi(self.__engine.api_client)
self.__logger.debug("API instance created")
response = api_instance.create_table_metadata(self)
self.table_metadata_id = response.table_metadata_id
self.__logger.debug("table response %s" % str(response))
print_message("Table %s added" % self.table_name)
return 0
except ApiException as e:
print_error(e.body)
self.__logger.error(e)
return 1
def add(self):
"""
Add File type to Masking engine and print status message
return a None if non error
return 1 in case of error
"""
if (self.obj.file_format_name is None):
print_error("File format name is required")
self.__logger.error("File format name is required")
return 1
if (self.obj.file_format_type is None):
print_error("File format type is required")
self.__logger.error("File format type is required")
return 1
try:
self.__logger.debug("create filetype input %s" % str(self))
api_instance = self.__api(self.__engine.api_client)
self.__logger.debug("API instance created")
response = api_instance.create_file_format(self.obj.file_format_name,
self.obj.file_format_type)
self.from_filetype(response)
self.__logger.debug("filetype response %s"
% str(response))
print_message("Filetype %s added" % self.obj.file_format_name)
return 0
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e)
return 1
def add(self):
"""
Add connector to engine
Return 0 if OK
"""
payload_dict = self.get_properties()
if payload_dict is None:
print_error('Some required property not found')
return 1
try:
self.__logger.debug("create connector input %s" % str(self))
api_instance = DatabaseConnectorApi(self.__engine.api_client)
response = api_instance.create_database_connector(
self, _request_timeout=self.__engine.get_timeout())
self.database_connector_id = response.database_connector_id
self.__logger.debug("connector response %s" % str(response))
print_message("Connector %s added" % self.connector_name)
return 0
except ApiException as e:
print_error(e.body)
self.__logger.error(e)
return 1
def update_algorithm(**kwargs):
"""
Update algorithm
"""
colobj = kwargs.get('colobj')
algname = kwargs.get('algname')
domainname = kwargs.get('domainname')
ruleobj = kwargs.get('ruleobj')
metaobj = kwargs.get('metaobj')
is_masked = kwargs.get('is_masked')
colobj.is_masked = is_masked
if algname == 'None':
algname = None
domainname = None
colobj.is_masked = False
colobj.algorithm_name = algname
colobj.domain_name = domainname
if colobj.update():
print_error(
"Problem with updating column for "
"ruleset %s meta %s column %s" %
(ruleobj.ruleset_name, metaobj.meta_name, colobj.cf_meta_name))
return 1
else:
print_message("Algorithm %s domain %s updated for "
"ruleset %s meta %s column %s" %
(algname, domainname, ruleobj.ruleset_name,
metaobj.meta_name, colobj.cf_meta_name))
return 0
def add(self):
"""
Add ruleset to Masking engine and print status message
return a None if non error
return 1 in case of error
"""
if (self.ruleset_name is None):
print "Ruleset name is required"
self.__logger.error("Ruleset name is required")
return 1
if (self.database_connector_id is None):
print "Database connector Id is required"
self.__logger.error("Database connector ID is required")
return 1
try:
self.__logger.debug("create database ruleset input %s" % str(self))
api_instance = DatabaseRulesetApi(self.__engine.api_client)
response = api_instance.create_database_ruleset(
self, _request_timeout=self.__engine.get_timeout())
self.database_ruleset_id = response.database_ruleset_id
self.__logger.debug("ruleset response %s" % str(response))
print_message("Ruleset %s added" % self.ruleset_name)
return None
except ApiException as e:
print_error(e.body)
self.__logger.error(e)
return 1
def update(self):
"""
Update connector on engine
Return None if OK
"""
api_instance = DatabaseConnectorApi(self.__engine.api_client)
body = DatabaseConnector()
for k in self.attribute_map.keys():
if getattr(self, k) is not None:
setattr(body, k, getattr(self, k))
try:
self.__logger.debug("update connector input %s" % str(self))
response = api_instance.update_database_connector(
self.database_connector_id,
body,
_request_timeout=self.__engine.get_timeout())
self.__logger.debug("update connector response %s" % str(response))
self.database_connector_id = response.database_connector_id
print_message("Connector %s updated" % self.connector_name)
except ApiException as e:
print_error(e.body)
self.__logger.error(e)
return 1
def cancel(self):
"""
Cancel running job in Engine
return a 0 if non error
return 1 in case of error
"""
try:
execid = self.__lastExec.execution_id
exec_api = self.__apiexec(self.__engine.api_client)
self.__logger.debug("Stopping execution %s" % str(execid))
execjob = exec_api.cancel_execution(execid)
self.__logger.debug("Stopping execution response %s" %
str(execjob))
while execjob.status == 'RUNNING':
time.sleep(1)
execjob = exec_api.get_execution_by_id(execid)
print_message(execjob)
return 0
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e)
return 1
def do_check(**kwargs):
"""
Compare
"""
ruleref = kwargs.get('ruleref')
rulelist = kwargs.get('rulelist')
envlist = DxEnvironmentList
envname = kwargs.get('envname')
ruleset = kwargs.get('ruleset')
rulesetname = kwargs.get('rulesetname')
p_engine = kwargs.get('p_engine')
connname = ruleset["Connector name"]
ruleobj = rulelist.get_by_ref(ruleref)
connobj = DxConnectorsList.get_by_ref(ruleobj.connectorId)
if connobj:
envobj = envlist.get_by_ref(connobj.environment_id)
connector_name = connobj.connector_name
environment_name = envobj.environment_name
else:
connector_name = 'N/A'
environment_name = 'N/A'
retcol = 0
metalist = DxMetaList()
metalist.LoadMeta(ruleobj.ruleset_id)
rettab = 0
for meta in ruleset["Metadata"]:
metalist_ref = metalist.get_MetadataId_by_name(meta["meta_name"], 1)
if metalist_ref:
rettab = rettab + 1
else:
print_error("Missing meta %s" % meta["meta_name"])
for col in ruleset["Columns"]:
count = [
x for x in ruleset["Columns"]
if col["Metadata name"] == x["Metadata name"]
]
rc = column_check(p_engine, rulesetname, envname, col, len(count))
if rc != 0:
retcol = retcol + 1
if (ruleobj.ruleset_name == rulesetname) and \
(connector_name == connname) and \
(environment_name == envname) and \
(retcol == 0) and \
(rettab == len(ruleset["Metadata"])):
print_message("Ruleset definition in engine is matching import file")
return 0
else:
print_error("There are difference between engine and import file")
return 1
def add(self):
"""
Add job to Masking engine and print status message
return a None if non error
return 1 in case of error
"""
if (self.obj.job_name is None):
print_error("Job name is required")
self.__logger.error("Job name is required")
return 1
if (self.ruleset_id is None):
print_error("ruleset_id is required")
self.__logger.error("ruleset_id is required")
return 1
try:
self.__logger.debug("create job input %s" % str(self.obj))
api_instance = self.__api(self.__engine.api_client)
self.__logger.debug("API instance created")
response = api_instance.create_masking_job(self.obj)
self.from_job(response)
self.__logger.debug("job response %s" % str(response))
print_message("Job %s added" % self.job_name)
return 0
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e)
return 1
def test(self):
"""
Test connector connection to database
Return None if OK
"""
api_instance = self.__api(self.__engine.api_client)
try:
self.__logger.debug("test connector id %s" % self.connectorId)
if (self.__engine.version_ge('6.0.0')):
response = api_instance.test_file_connector(
self.connectorId,
body=self.obj,
_request_timeout=self.__engine.get_timeout())
else:
response = api_instance.test_file_connector(
self.connectorId,
_request_timeout=self.__engine.get_timeout())
if response.response == "Connection Failed":
print_error("Connector test %s failed" % self.connector_name)
return 1
else:
print_message("Connector test %s succeeded" %
self.connector_name)
return 0
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e)
return 1
def test(self):
"""
Test connector connection to database
Return None if OK
"""
api_instance = self.__api(self.__engine.api_client)
try:
self.__logger.debug("test connector id %s" %
self.database_connector_id)
# body added to workaround an issue with API
response = api_instance.test_database_connector(
self.database_connector_id,
body=self.obj,
_request_timeout=self.__engine.get_timeout())
if "Connection Failed" in response.response:
print_error(
"Connector test {} failed. Error message is: {}".format(
self.connector_name, response.response))
return 1
else:
print_message("Connector test {} succeeded".format(
self.connector_name))
return 0
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e)
return 1
def add(self):
"""
Add File type to Masking engine and print status message
return a None if non error
return 1 in case of error
"""
if (self.obj.domain_name is None):
print_error("Domain name is required")
self.__logger.error("Domain name is required")
return 1
if (self.obj.default_algorithm_code is None):
print_error("Domain default algorithm is required")
self.__logger.error("Domain default algorithm is required")
return 1
try:
self.__logger.debug("create domain input %s" % str(self))
api_instance = self.__api(self.__engine.api_client)
self.__logger.debug("API instance created")
response = api_instance.create_domain(
self.obj,
_request_timeout=self.__engine.get_timeout()
)
self.from_domain(response)
self.__logger.debug("domain response %s"
% str(response))
print_message("Domain %s added" % self.obj.domain_name)
return 0
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e)
return 1
def addmetafromfile(self, inputfile, bulk):
"""
Add tables from file to ruleset
:param inputfile: file with tables
return a 0 if non error
return 1 in case of error
"""
ret = 0
table_list = []
for line in inputfile:
if line.startswith('#'):
continue
columns = line.strip().split(',')
params = {
"metaname": columns[0],
"custom_sql": columns[1],
"where_clause": columns[2],
"having_clause": columns[3],
"key_column": columns[4]
}
if bulk:
table_list.append(params)
else:
ret = ret + self.addmeta(params)
if bulk:
print_message(table_list)
ret = self.addmeta_bulk(table_list)
return ret
def update(self):
"""
Update column data to Masking engine and print status message
return a None if non error
return 1 in case of error
"""
if (self.column_metadata_id is None):
print "column_metadata_id is required"
self.__logger.error("column_metadata_id is required")
return 1
try:
if self.date_format == '':
self.date_format = None
self.__logger.debug("create column input %s" % str(self))
api_instance = ColumnMetadataApi(self.__engine.api_client)
response = api_instance.update_column_metadata(
self.column_metadata_id, self)
self.__logger.debug("column response %s" % str(response))
print_message("Column %s updated" % self.column_name)
return None
except ApiException as e:
print_error(e.body)
self.__logger.error(e)
return 1
def add(self):
"""
Add ruleset to Masking engine and print status message
return a None if non error
return 1 in case of error
"""
if (self.obj.ruleset_name is None):
print_error("Ruleset name is required")
self.__logger.error("Ruleset name is required")
return 1
if (self.obj.file_connector_id is None):
print_error("File connector Id is required")
self.__logger.error("File connector ID is required")
return 1
try:
self.__logger.debug("create database ruleset input %s" % str(self))
api_instance = self.__api(self.__engine.api_client)
response = api_instance.create_file_ruleset(self.obj)
self.__obj = response
self.__logger.debug("ruleset response %s" % str(response))
print_message("Ruleset %s added" % self.ruleset_name)
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e)
return 1
def add(self):
"""
Add profile job to Masking engine and print status message
return a None if non error
return 1 in case of error
"""
if (self.job_name is None):
print_error("Job name is required")
self.__logger.error("Profile job name is required")
return 1
if (self.ruleset_id is None):
print_error("ruleset_id is required")
self.__logger.error("ruleset_id is required")
return 1
try:
self.__logger.debug("create profile job input %s" % str(self))
api_instance = ProfileJobApi(self.__engine.api_client)
response = api_instance.create_profile_job(
self, _request_timeout=self.__engine.get_timeout())
self.from_job(response)
self.__logger.debug("profile job response %s" % str(response))
print_message("Profile job %s added" % self.job_name)
return None
except ApiException as e:
print_error(e.body)
self.__logger.error(e)
return 1
def engine_add(p_engine, p_ip, p_username, p_password, p_protocol, p_port,
p_default, p_proxyurl, p_proxyuser, p_proxypassword):
"""
Add engine to a configuration
param1: p_engine: name of Masking engine
param2: p_ip: IP of Masking engine
param3: p_username: username
param4: p_password: password
param5: p_protocol: protocol (http/https)
param6: p_port: port
param7: p_default: is engine default - Y/N - default value N
param8: p_proxyurl: Proxy URL
param9: p_proxyuser: proxy username
param10: p_proxypassword: proxy password
return None if OK or integer with error
"""
config = DxConfig()
config.init_metadata()
if config.insert_engine_info(p_engine, p_ip, p_username, p_password,
p_protocol, p_port, p_default, p_proxyurl,
p_proxyuser, p_proxypassword):
print_error("Problem with adding engine to database")
config.close()
return -1
else:
print_message("Engine added to configuration")
config.close()
return None
def add(self):
"""
Add profile to Masking engine and print status message
return a None if non error
return 1 in case of error
"""
if (self.obj.profile_set_name is None):
print_error("Profile name is required")
self.__logger.error("Profile name is required")
return 1
if (self.obj.profile_expression_ids is None):
print_error("expression list is required")
self.__logger.error("expression list is required")
return 1
try:
self.__logger.debug("create profile input %s" % str(self))
api_instance = self.__api(self.__engine.api_client)
response = api_instance.create_profile_set(self.obj)
self.from_profileset(response)
self.__logger.debug("profile response %s" % str(response))
print_message("Profile %s added" % self.obj.profile_set_name)
return 0
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e)
return 1
def ruleset_export(p_engine, rulesetname, envname, outputfile, exportmeta,
metaname):
"""
Delete ruleset from Masking engine
param1: p_engine: engine name from configuration
param2: rulesetname: ruleset name
param3: envname: environment name
param4: exportmeta: export metadata with ruleset
param5: metaname: limit export to single meta object
return 0 if added, non 0 for error
"""
exp = []
ret = ruleset_worker(p_engine=p_engine,
rulesetname=rulesetname,
envname=envname,
function_to_call="do_export",
exportout=exp,
exportmeta=exportmeta,
metaname=metaname)
if ret == 0:
try:
json.dump(exp, outputfile, indent=4)
outputfile.close()
print_message("Ruleset exported to file %s" % outputfile.name)
return 0
except Exception as e:
print_error("Problem with file %s Error: %s" %
(outputfile.name, str(e)))
return 1
else:
return 1
def add(self):
"""
Add table to Masking engine and print status message
return 0 if non error
return 1 in case of error
"""
if (self.obj.file_name is None):
print_error("File name is required")
self.__logger.error("File name is required")
return 1
if (self.obj.ruleset_id is None):
print_error("ruleset_id is required")
self.__logger.error("ruleset_id is required")
return 1
try:
self.__logger.debug("create file input %s" % str(self.obj))
api_instance = self.__api(self.__engine.api_client)
response = api_instance.create_file_metadata(self.obj)
self.__obj = response
self.__logger.debug("file response %s"
% str(response))
print_message("File %s added" % self.obj.file_name)
return 0
except self._apiexc as e:
print_error(e.body)
self.__logger.error(e)
return 1
def delete(self, force):
"""
Delete user from Masking engine and print status message
:param force: if True, change user to non-admin and delete
return a None if non error
return 1 in case of error
"""
if self.is_admin and force:
self.is_admin = False
nap = self.__modelnap(environment_ids=[], role_id=1)
self.non_admin_properties = nap
if self.update() != 0:
print_error("Can't switch to non-admin in force mode")
self.__logger.debug("Can't switch to non-admin in force mode")
return 1
api_instance = self.__api(self.__engine.api_client)
try:
self.__logger.debug("delete user id %s" % self.user_id)
response = api_instance.delete_user_by_id(
self.user_id, _request_timeout=self.__engine.get_timeout())
self.__logger.debug("delete user response %s" % str(response))
print_message("User %s deleted" % self.user_name)
return 0
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e)
return 1
def add(self):
"""
Add user to Masking engine and print status message
return a None if non error
return 1 in case of error
"""
if self.user_name is None:
print_error("User name is required")
self.__logger.error("User name is required")
return 1
if self.first_name is None:
print_error("User first name is required")
self.__logger.error("User first name is required")
return 1
if self.last_name is None:
print_error("User last name is required")
self.__logger.error("User last name is required")
return 1
if self.email is None:
print_error("User email is required")
self.__logger.error("User email is required")
return 1
if self.is_admin is None:
print_error("User type (admin/non-admin) is required")
self.__logger.error("User type (admin/non-admin) is required")
return 1
if not self.is_admin and self.non_admin_properties is None:
print_error("Non admin user requires a non admin properties")
self.__logger.error(
"Non admin user requires a non admin properties")
return 1
if self.password is None:
print_error("User password is required")
self.__logger.error("User password is required")
return 1
api_instance = self.__api(self.__engine.api_client)
try:
self.__logger.debug("create user input %s" % str(self))
response = api_instance.create_user(
self.obj, _request_timeout=self.__engine.get_timeout())
self.__logger.debug("create user response %s" % str(response))
self.user_id = response.user_id
print_message("User %s added" % self.user_name)
return 0
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e)
return 1
def engine_logout(p_engine, p_engineuser):
"""
logout engine in configuration
param1: p_engine: name of Masking engine
return None if OK or integer with error
"""
config = DxConfig()
config.init_metadata()
if config.check_uniqness(p_engine, p_engineuser) == -1:
return -1
config.set_key(p_engine, p_engineuser, '')
print_message("Session logged out - auth key deleted")
return 0
def delete_engine_info(self, engine_name, user_name):
"""
Delete engine data from sqllist database for database name
and user
:param engine_name: Engine name
:param user_name: User name
return None if OK or integer is error
"""
if self.__conn:
try:
sql = "DELETE from dxm_engine_info " \
"where engine_name = ?"
data = []
if engine_name is None:
print_error("Engine name has to be specify")
return -1
if (str(engine_name).lower() == 'all'):
print_error("Engine name can't be all. Sorry")
return -1
data.append(engine_name)
if (user_name is not None):
sql = sql + "and username like ?"
data.append(user_name)
self.__logger.debug(sql)
self.__logger.debug(tuple(data))
ret = self.__cursor.execute(sql, tuple(data))
if ret.rowcount == 0:
self.__logger.debug("Engine %s not found"
% engine_name)
print_error("Engine %s not found" % engine_name)
return 1
else:
self.__conn.commit()
self.__logger.debug("Engine %s deleted" % engine_name)
print_message("Engine %s deleted" % engine_name)
return None
except lite.Error as e:
self.__logger.debug("Error %s:" % e.args)
return -1
else:
print_error("No connection to local sqllist database")
sys.exit(-1)
def engine_delete(p_engine, p_username):
"""
Delete Masking engines from configuration file
param1: p_engine: name of Masking engine
param2: p_username: username
return None if OK or integer with error, ex. no rows found
"""
config = DxConfig()
config.init_metadata()
if config.delete_engine_info(p_engine, p_username):
print_error("Problem with deleting engine from database")
config.close()
return -1
else:
print_message("Engine deleted from configuration")
config.close()
return None
