def LoadJobs(self, environment_name=None):
"""
Load list of rule sets
Return None if OK
"""
try:
api_instance = MaskingJobApi(self.__engine.api_client)
execapi = ExecutionApi(self.__engine.api_client)
execList = paginator(
execapi,
"get_all_executions")
if execList.response_list:
for e in execList.response_list:
self.__executionList[e.job_id] = e
if environment_name:
environment_id = DxEnvironmentList.get_environmentId_by_name(
environment_name)
if environment_id:
jobs = paginator(
api_instance,
"get_all_masking_jobs",
environment_id=environment_id,
_request_timeout=self.__engine.get_timeout())
else:
return 1
else:
jobs = paginator(
api_instance,
"get_all_masking_jobs",
_request_timeout=self.__engine.get_timeout())
if jobs.response_list:
for c in jobs.response_list:
if c.masking_job_id in self.__executionList:
lastExec = self.__executionList[c.masking_job_id]
else:
lastExec = None
job = DxJob(self.__engine, lastExec)
job.from_job(c)
self.__jobsList[c.masking_job_id] = job
else:
if environment_name is None:
print_error("No jobs found")
self.__logger.error("No jobs found")
self.__logger.debug("All jobs loaded")
except ApiException as e:
print_error("Can't load job list %s" % e.body)
return 1
def LoadApplications(self):
"""
Load a list of applications into memory
return None if OK
return 1 if not OK
"""
self.__applicationList.clear()
try:
self.__api = ApplicationApi
self.__apiexc = ApiException
api_instance = self.__api(self.__engine.api_client)
a = paginator(
api_instance,
"get_all_applications",
_request_timeout=self.__engine.get_timeout())
if a.response_list:
for c in a.response_list:
application = DxApplication(self.__engine)
application.from_obj(c)
if self.__engine.version_ge("6.0.0.0") and c.application_id is not None:
self.__applicationList[c.application_id] = application
else:
self.__applicationList[c.application_name] = application
else:
print_error("No applications found")
return 1
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e.body)
return 1
def LoadEnvironments(self):
"""
Load environment list from Engine into global list
return None if OK
return 1 if error
"""
self.__environmentList.clear()
try:
api_instance = EnvironmentApi(self.__engine.api_client)
envlist = paginator(api_instance,
"get_all_environments",
_request_timeout=self.__engine.get_timeout())
if envlist.response_list:
for c in envlist.response_list:
environment = DxEnvironment(self.__engine)
environment.from_environment(c)
self.__environmentList[c.environment_id] = environment
else:
self.__logger.error("No environments found")
print_error("No environments found")
except ApiException as e:
self.__logger.error("Can't load environment %s" % e.body)
print_error("Can't load environment %s" % e.body)
return 1
def LoadUsers(self):
"""
Load users list from Engine into global list
return None if OK
return 1 if error
"""
self.__api = UserApi
self.__apiexc = ApiException
self.__userList.clear()
try:
api_instance = self.__api(self.__engine.api_client)
userlist = paginator(api_instance,
"get_all_users",
_request_timeout=self.__engine.get_timeout())
if userlist.response_list:
for c in userlist.response_list:
user = DxUser(self.__engine)
user.from_user(c)
self.__userList[c.user_id] = user
else:
self.__logger.error("No users found")
print_error("No users found")
except self.__apiexc as e:
self.__logger.error("Can't load users %s" % e.body)
print_error("Can't load users %s" % e.body)
return 1
def LoadApplications(self):
"""
Load a list of applications into memory
return None if OK
return 1 if not OK
"""
self.__applicationList.clear()
try:
api_instance = ApplicationApi(self.__engine.api_client)
a = paginator(api_instance,
"get_all_applications",
_request_timeout=self.__engine.get_timeout())
if a.response_list:
for c in a.response_list:
application = DxApplication(self.__engine)
application.application_name = c.application_name
self.__applicationList[c.application_name] = application
else:
print_error("No applications found")
return 1
except ApiException as e:
print_error(e.body)
self.__logger.error(e.body)
return 1
def LoadProfileExt(self):
"""
Load list of profiles expressions
Return None if OK
"""
try:
api_instance = ProfileExpressionApi(self.__engine.api_client)
profileexts = paginator(
api_instance,
"get_all_profile_expressions",
_request_timeout=self.__engine.get_timeout())
if profileexts.response_list:
for pe in profileexts.response_list:
proext = DxProfileExt()
proext.from_profilesetext(pe)
self.__profileexp_list[pe.profile_expression_id] = proext
else:
print_error("No Profile expression found")
self.__logger.error("No Profile expression found")
self.__logger.debug("All Profile expression loaded")
except ApiException as e:
print_error("Can't load Profile expression list %s" % e.body)
return 1
def LoadDrivers(self):
"""
Load list of drivers
Return None if OK
"""
self.__api = JdbcDriverApi
self.__apiexc = ApiException
try:
api_instance = self.__api(self.__engine.api_client)
drivers = paginator(
api_instance,
"get_all_jdbc_drivers")
if drivers.response_list:
for c in drivers.response_list:
driver = DxJDBC(self.__engine)
driver.from_driver(c)
self.__driverList[c.jdbc_driver_id] = driver
else:
print_error("No JDBC drivers found")
self.__logger.error("No JDBC drivers found")
except self.__apiexc as e:
print_error("Can't load JDBC drivers %s" % e.body)
return None
def LoadDomains(self):
"""
Load list of domains
Return None if OK
"""
self.__domainList.clear()
try:
api_instance = DomainApi(self.__engine.api_client)
domain_list = paginator(api_instance, "get_all_domains")
if domain_list.response_list:
for c in domain_list.response_list:
dom = DxDomain(self.__engine)
dom.from_domain(c)
self.__domainList[c.domain_name] = dom
else:
print_error("No domain found")
self.__logger.error("No domain found")
return 1
return None
except ApiException as e:
print_error(e.body)
self.__logger.error(e.body)
return 1
def LoadRoles(self):
"""
Load roles list from Engine into global list
return None if OK
return 1 if error
"""
self.__roleList.clear()
try:
api_instance = RoleApi(self.__engine.api_client)
rolelist = paginator(api_instance,
"get_all_roles",
_request_timeout=self.__engine.get_timeout())
if rolelist.response_list:
for c in rolelist.response_list:
role = DxRole(self.__engine)
role.from_role(c)
self.__roleList[c.role_id] = role
else:
self.__logger.error("No roles found")
print_error("No roles found")
except ApiException as e:
self.__logger.error("Can't load roles %s" % e.body)
print_error("Can't load roles %s" % e.body)
return 1
def LoadFileFormats(self):
"""
Load list of rule sets
Return None if OK
"""
if (self.__engine.version_ge('6.0.0')):
from masking_api_60.api.file_format_api import FileFormatApi
from masking_api_60.rest import ApiException
else:
from masking_api_53.api.file_format_api import FileFormatApi
from masking_api_53.rest import ApiException
self.__api = FileFormatApi
self.__apiexc = ApiException
try:
api_instance = self.__api(self.__engine.api_client)
fileformats = paginator(
api_instance,
"get_all_file_formats")
if fileformats.response_list:
for c in fileformats.response_list:
fileformat = DxFileFormat(self.__engine)
fileformat.from_filetype(c)
self.__filetypeList[c.file_format_id] = fileformat
else:
print_error("No file formats found")
self.__logger.error("No file formats found")
except self.__apiexc as e:
print_error("Can't load file formats %s" % e.body)
return None
def LoadAppSettings(self):
"""
Load application settings list from Engine into global group list
return None if OK
return 1 if error
"""
self.__appSettingGroupList.clear()
try:
api_instance = ApplicationSettingsApi(self.__engine.api_client)
applist = paginator(api_instance,
"get_all_application_settings",
_request_timeout=self.__engine.get_timeout())
if applist.response_list:
for c in applist.response_list:
setting = DxAppSetting(self.__engine)
setting.from_role(c)
if c.setting_group not in self.__appSettingGroupList:
self.__appSettingGroupList[c.setting_group] = {}
self.__appSettingGroupList[c.setting_group][
c.setting_name] = setting
else:
self.__logger.error("No application settings found")
print_error("No application settings found")
except ApiException as e:
self.__logger.error("Can't load application settings %s" % e.body)
print_error("Can't load application settings %s" % e.body)
return 1
def list_execution_component(self, execid):
"""
List an execution detalis ( tables, rows, etc)
:param1 execid: execution id to display
return a None if non error
return 1 in case of error
"""
if (execid is None):
print_error("Execution id is required")
self.__logger.error("Execution id is required")
return 1
try:
self.__logger.debug("execute component")
api_instance = self.__apicomponent(self.__engine.api_client)
execomponents = paginator(
api_instance,
"get_all_execution_components",
execution_id=execid,
_request_timeout=self.__engine.get_timeout())
return execomponents.response_list
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e)
return None
def LoadEnvironments(self):
"""
Load environment list from Engine into global list
return None if OK
return 1 if error
"""
if self.__loaded_engine is None:
self.__loaded_engine = self.__engine.get_name()
if self.__loaded_engine == self.__engine.get_name() and self.__environmentList != {}:
return None
else:
# delete a list as we can have multi engines
self.__environmentList.clear()
self.__loaded_engine = self.__engine.get_name()
appList = DxApplicationList()
appList.LoadApplications()
if (self.__engine.version_ge('6.0.0')):
from masking_api_60.api.environment_api import EnvironmentApi
from masking_api_60.rest import ApiException
else:
from masking_api_53.api.environment_api import EnvironmentApi
from masking_api_53.rest import ApiException
self.__api = EnvironmentApi
self.__apiexc = ApiException
try:
api_instance = self.__api(self.__engine.api_client)
envlist = paginator(
api_instance,
"get_all_environments",
_request_timeout=self.__engine.get_timeout())
if envlist.response_list:
for c in envlist.response_list:
environment = DxEnvironment(self.__engine)
environment.from_environment(c)
if hasattr(c, "application_id"):
app = appList.get_by_ref(c.application_id)
environment.application_name = app.application_name
self.__environmentList[c.environment_id] = environment
else:
self.__logger.error("No environments found")
print_error("No environments found")
except self.__apiexc as e:
self.__logger.error("Can't load environment %s" % e.body)
print_error("Can't load environment %s" % e.body)
return 1
def LoadProfiles(self):
"""
Load list of profiles sets
Return None if OK
"""
if (self.__engine.version_ge('6.0.0')):
from masking_api_60.api.profile_set_api import ProfileSetApi
from masking_api_60.rest import ApiException
else:
from masking_api_53.api.profile_set_api import ProfileSetApi
from masking_api_53.rest import ApiException
self.__api = ProfileSetApi
self.__apiexc = ApiException
try:
api_instance = self.__api(self.__engine.api_client)
# execapi = ExecutionApi(self.__engine.api_client)
# execList = paginator(
# execapi,
# "get_all_executions")
#
# if execList.response_list:
# for e in execList.response_list:
# self.__executionList[e.job_id] = e
profileset = paginator(
api_instance,
"get_all_profile_sets",
_request_timeout=self.__engine.get_timeout())
if profileset.response_list:
for ps in profileset.response_list:
profile = DxProfile()
profile.from_profileset(ps)
self.__profileset_list[ps.profile_set_id] = profile
else:
print_error("No Profile sets found")
self.__logger.error("No Profile sets found")
self.__logger.debug("All Profile sets loaded")
except self.__apiexc as e:
print_error("Can't load Profile sets list %s" % e.body)
return 1
def LoadProfileExt(self):
"""
Load list of profiles expressions
Return None if OK
"""
if (self.__engine.version_ge('6.0.0')):
from masking_api_60.api.profile_expression_api import ProfileExpressionApi
from masking_api_60.rest import ApiException
else:
from masking_api_53.api.profile_expression_api import ProfileExpressionApi
from masking_api_53.rest import ApiException
self.__api = ProfileExpressionApi
self.__apiexc = ApiException
try:
api_instance = self.__api(self.__engine.api_client)
profileexts = paginator(
api_instance,
"get_all_profile_expressions",
_request_timeout=self.__engine.get_timeout())
if profileexts.response_list:
for pe in profileexts.response_list:
proext = DxProfileExt()
proext.from_profilesetext(pe)
self.__profileexp_list[pe.profile_expression_id] = proext
else:
print_error("No Profile expression found")
self.__logger.error("No Profile expression found")
self.__logger.debug("All Profile expression loaded")
except self.__apiexc as e:
print_error("Can't load Profile expression list %s" % e.body)
return 1
def LoadDomains(self):
"""
Load list of domains
Return None if OK
"""
self.__domainList.clear()
if (self.__engine.version_ge('6.0.0')):
from masking_api_60.api.domain_api import DomainApi
from masking_api_60.rest import ApiException
else:
from masking_api_53.api.domain_api import DomainApi
from masking_api_53.rest import ApiException
self.__api = DomainApi
self.__apiexc = ApiException
try:
api_instance = self.__api(self.__engine.api_client)
domain_list = paginator(api_instance, "get_all_domains")
if domain_list.response_list:
for c in domain_list.response_list:
dom = DxDomain(self.__engine)
dom.from_domain(c)
self.__domainList[c.domain_name] = dom
else:
print_error("No domain found")
self.__logger.error("No domain found")
return 1
return None
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e.body)
return 1
def LoadFileFormats(self):
"""
Load list of rule sets
Return None if OK
"""
try:
api_instance = FileFormatApi(self.__engine.api_client)
fileformats = paginator(api_instance, "get_all_file_formats")
if fileformats.response_list:
for c in fileformats.response_list:
fileformat = DxFileFormat(self.__engine)
fileformat.from_filetype(c)
self.__filetypeList[c.file_format_id] = fileformat
else:
print_error("No file formats found")
self.__logger.error("No file formats found")
except ApiException as e:
print_error("Can't load file formats %s" % e.body)
return None
def LoadRoles(self):
"""
Load roles list from Engine into global list
return None if OK
return 1 if error
"""
if (self.__engine.version_ge('6.0.0')):
from masking_api_60.api.role_api import RoleApi
from masking_api_60.rest import ApiException
else:
from masking_api_53.api.role_api import RoleApi
from masking_api_53.rest import ApiException
self.__api = RoleApi
self.__apiexc = ApiException
self.__roleList.clear()
try:
api_instance = self.__api(self.__engine.api_client)
rolelist = paginator(api_instance,
"get_all_roles",
_request_timeout=self.__engine.get_timeout())
if rolelist.response_list:
for c in rolelist.response_list:
role = DxRole(self.__engine)
role.from_role(c)
self.__roleList[c.role_id] = role
else:
self.__logger.error("No roles found")
print_error("No roles found")
except self.__apiexc as e:
self.__logger.error("Can't load roles %s" % e.body)
print_error("Can't load roles %s" % e.body)
return 1
def LoadSync(self, objecttype=None):
"""
Load list of syncable objects
param1: type: load only particular type
Return None if OK
"""
self.__syncableList = {}
try:
api_sync = SyncApi(self.__engine.api_client)
if objecttype:
objecttype = objecttype.upper()
if objecttype and self.__engine.version_ge("5.3"):
if objecttype == "ALGORITHM":
api_sync_response = ExportObjectMetadataList()
for atype in [
"SEGMENT", "DATE_SHIFT", "LOOKUP", "TOKENIZATION"
]:
partres = paginator(api_sync,
"get_all_syncable_objects",
object_type=atype)
if api_sync_response.response_list is None:
api_sync_response = partres
else:
api_sync_response.response_list = \
api_sync_response.response_list + \
partres.response_list
else:
api_sync_response = paginator(api_sync,
"get_all_syncable_objects",
object_type=objecttype)
else:
if (objecttype is None) \
or (objecttype in
["LOOKUP", "DATE_SHIFT", "SEGMENT",
"TOKENIZATION", "ALGORITHM"]):
api_sync_response = paginator(api_sync,
"get_all_syncable_objects")
else:
print_error("This object type is not supported"
"in version 5.2.X")
sys.exit(1)
if api_sync_response.response_list:
for c in api_sync_response.response_list:
syncobj = DxSync(self.__engine)
syncobj.from_sync(c)
stype = syncobj.object_type
if stype in [
"LOOKUP", "DATE_SHIFT", "SEGMENT", "TOKENIZATION"
]:
stype = "ALGORITHM"
sid = syncobj.object_identifier.values()[0]
if stype not in self.__syncableList:
self.__syncableList[stype] = {}
self.__syncableList[stype][sid] = syncobj
else:
print_error("No syncobject found")
self.__logger.error("No syncobject found")
return 1
return None
except ApiException as e:
print_error(e.body)
self.__logger.error(e.body)
return 1
def LoadJobs(self, environment_name=None):
"""
Load list of rule sets
Return None if OK
"""
self.__api = ProfileJobApi
self.__apiexec = ExecutionApi
self.__apiexc = ApiException
try:
api_instance = self.__api(self.__engine.api_client)
execapi = self.__apiexec(self.__engine.api_client)
execList = paginator(execapi, "get_all_executions")
# if execList.response_list:
# for e in execList.response_list:
# self.__executionList[e.job_id] = e
if execList.response_list:
for e in execList.response_list:
if e.job_id in self.__executionList:
self.__executionList[e.job_id].append(e)
else:
self.__executionList[e.job_id] = [e]
if environment_name:
environment_id = DxEnvironmentList.get_environmentId_by_name(
environment_name)
if environment_id:
jobs = paginator(
api_instance,
"get_all_profile_jobs",
environment_id=environment_id,
_request_timeout=self.__engine.get_timeout())
else:
return 1
else:
jobs = paginator(api_instance,
"get_all_profile_jobs",
_request_timeout=self.__engine.get_timeout())
if jobs.response_list:
for c in jobs.response_list:
if c.profile_job_id in self.__executionList:
execution_list = self.__executionList[c.profile_job_id]
else:
execution_list = None
job = DxProfileJob(self.__engine, execution_list)
job.from_job(c)
self.__jobsList[c.profile_job_id] = job
else:
if environment_name is None:
print_error("No jobs found")
self.__logger.error("No jobs found")
self.__logger.debug("All jobs loaded")
except ApiException as e:
print_error("Can't load job list %s" % e.body)
return 1
def LoadColumns(self, metadata_id=None, is_masked=None):
"""
Load list of column metadata
Return None if OK
"""
notable = None
nofile = None
metaobj = DxMetaList.get_by_ref(metadata_id)
self.__api = ColumnMetadataApi
self.__fileapi = FileFieldMetadataApi
self.__apiexc = ApiException
if ((metadata_id is None) or (type(metaobj) == DxTable)):
try:
api_instance = self.__api(self.__engine.api_client)
if is_masked:
if metadata_id:
columns = paginator(api_instance,
"get_all_column_metadata",
table_metadata_id=metadata_id,
is_masked=is_masked)
else:
columns = paginator(api_instance,
"get_all_column_metadata",
is_masked=is_masked)
else:
if metadata_id:
columns = paginator(api_instance,
"get_all_column_metadata",
table_metadata_id=metadata_id)
else:
columns = paginator(api_instance,
"get_all_column_metadata")
if columns.response_list:
for c in columns.response_list:
column = DxDBColumn(self.__engine)
column.from_column(c)
self.__columnList[column.cf_metadata_id] = column
else:
# print_error("No column metadata found")
self.__logger.error("No column metadata found")
except self.__apiexc as e:
if (e.status == 404) and (metadata_id is not None):
notable = 1
else:
print_error(e.body)
self.__logger.error(e.body)
return 1
elif ((metadata_id is None) or (type(metaobj) == DxFile)):
try:
api_instance = self.__fileapi(self.__engine.api_client)
if metadata_id and (metaobj.file_format_id is None):
# File doesn't have a file type set so there is no masking
return None
if is_masked:
if metadata_id:
fields = paginator(
api_instance,
"get_all_file_field_metadata",
file_format_id=metaobj.file_format_id,
is_masked=is_masked)
else:
fields = paginator(api_instance,
"get_all_file_field_metadata",
is_masked=is_masked)
else:
if metadata_id:
fields = paginator(
api_instance,
"get_all_file_field_metadata",
file_format_id=metaobj.file_format_id)
else:
fields = paginator(api_instance,
"get_all_file_field_metadata")
if fields.response_list:
for c in fields.response_list:
column = DxFileField(self.__engine)
column.from_file(c)
self.__columnList[column.cf_metadata_id] = column
else:
print_error("No field metadata found")
self.__logger.error("No field metadata found")
except self.__apiexc as e:
if (e.status == 404) and (metadata_id is not None):
nofile = 1
else:
print_error(e.body)
self.__logger.error(e.body)
return 1
if nofile and notable:
print_error("Columns for meta id not found")
return 1
else:
return None
def LoadConnectors(self, environment_name):
"""
Load all connectors
:param1 environment_name: Limit load to particular environment name
"""
# delete a list as we can have multi engines
self.__connectorsList.clear()
try:
api_instance = DatabaseConnectorApi(self.__engine.api_client)
if environment_name:
environment_id = DxEnvironmentList.get_environmentId_by_name(
environment_name)
if environment_id:
dbconnectors = paginator(
api_instance,
"get_all_database_connectors",
environment_id=environment_id,
_request_timeout=self.__engine.get_timeout())
else:
return 1
else:
environment_id = None
dbconnectors = paginator(
api_instance,
"get_all_database_connectors",
_request_timeout=self.__engine.get_timeout())
if dbconnectors.response_list:
for c in dbconnectors.response_list:
if (c.database_type == 'ORACLE'):
connector = OracleConnector(self.__engine)
elif (c.database_type == 'MSSQL'):
connector = MSSQLConnector(self.__engine)
elif (c.database_type == 'SYBASE'):
connector = SybaseConnector(self.__engine)
else:
connector = DxConnector(self.__engine)
connector.from_connector(c)
connector.is_database = True
self.__connectorsList['d' + str(c.database_connector_id)] \
= connector
else:
self.__logger.debug("No database connectors found")
api_instance = FileConnectorApi(self.__engine.api_client)
if environment_id:
file_connectors = paginator(
api_instance,
"get_all_file_connectors",
environment_id=environment_id,
_request_timeout=self.__engine.get_timeout())
else:
file_connectors = paginator(
api_instance,
"get_all_file_connectors",
_request_timeout=self.__engine.get_timeout())
if file_connectors.response_list:
for f in file_connectors.response_list:
connector = DxFileConnector(self.__engine)
connector.from_connector(f)
connector.is_database = False
self.__connectorsList['f' + str(f.file_connector_id)] \
= connector
else:
self.__logger.debug("No file connectors found")
if len(self.__connectorsList) < 1:
print_error("No connectors found")
self.__logger.error("No connectors found")
return 1
return None
except ApiException as e:
print_error(e.body)
self.__logger.error(e.body)
return 1
def LoadConnectors(self, environment_name):
"""
Load all connectors
:param1 environment_name: Limit load to particular environment name
"""
self.__logger.debug("load connector !!!")
if self.__loaded_engine is None:
self.__loaded_engine = self.__engine.get_name()
if self.__loaded_engine == self.__engine.get_name() and self.__connectorsList != {} \
and self.__loaded_env == environment_name:
return None
else:
# delete a list as we can have multi engines
self.__connectorsList.clear()
self.__loaded_engine = self.__engine.get_name()
if (self.__engine.version_ge('6.0.0')):
from masking_api_60.api.database_connector_api import DatabaseConnectorApi
from masking_api_60.api.file_connector_api import FileConnectorApi
from masking_api_60.rest import ApiException
else:
from masking_api_53.api.database_connector_api import DatabaseConnectorApi
from masking_api_53.api.file_connector_api import FileConnectorApi
from masking_api_53.rest import ApiException
self.__api = DatabaseConnectorApi
self.__fileapi = FileConnectorApi
self.__loaded_env = environment_name
self.__apiexc = ApiException
try:
api_instance = self.__api(self.__engine.api_client)
if environment_name:
environment_id = DxEnvironmentList.get_environmentId_by_name(
environment_name)
if environment_id:
dbconnectors = paginator(
api_instance,
"get_all_database_connectors",
environment_id=environment_id,
_request_timeout=self.__engine.get_timeout())
else:
return 1
else:
environment_id = None
dbconnectors = paginator(
api_instance,
"get_all_database_connectors",
_request_timeout=self.__engine.get_timeout())
if dbconnectors.response_list:
for c in dbconnectors.response_list:
if (c.database_type == 'ORACLE'):
connector = OracleConnector(self.__engine)
elif (c.database_type == 'MSSQL'):
connector = MSSQLConnector(self.__engine)
elif (c.database_type == 'SYBASE'):
connector = SybaseConnector(self.__engine)
else:
connector = DxConnector(self.__engine)
connector.from_connector(c)
connector.is_database = True
self.__connectorsList['d' + str(c.database_connector_id)] \
= connector
else:
self.__logger.debug("No database connectors found")
api_instance = self.__fileapi(self.__engine.api_client)
if environment_id:
file_connectors = paginator(
api_instance,
"get_all_file_connectors",
environment_id=environment_id,
_request_timeout=self.__engine.get_timeout())
else:
file_connectors = paginator(
api_instance,
"get_all_file_connectors",
_request_timeout=self.__engine.get_timeout())
if file_connectors.response_list:
for f in file_connectors.response_list:
connector = DxFileConnector(self.__engine)
connector.from_connector(f)
connector.is_database = False
self.__connectorsList['f' + str(f.file_connector_id)] \
= connector
else:
self.__logger.debug("No file connectors found")
if len(self.__connectorsList) < 1:
print_error("No connectors found")
self.__logger.error("No connectors found")
return 1
return None
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e.body)
return 1
def LoadJobs(self, environment_name=None):
"""
Load list of rule sets
Return None if OK
"""
if (self.__engine.version_ge('6.0.0')):
from masking_api_60.api.profile_job_api import ProfileJobApi
from masking_api_60.api.execution_api import ExecutionApi
from masking_api_60.rest import ApiException
else:
from masking_api_53.api.profile_job_api import ProfileJobApi
from masking_api_53.api.execution_api import ExecutionApi
from masking_api_53.rest import ApiException
self.__api = ProfileJobApi
self.__apiexec = ExecutionApi
self.__apiexc = ApiException
try:
api_instance = self.__api(self.__engine.api_client)
execapi = self.__apiexec(self.__engine.api_client)
execList = paginator(execapi, "get_all_executions")
if execList.response_list:
for e in execList.response_list:
self.__executionList[e.job_id] = e
if environment_name:
environment_id = DxEnvironmentList.get_environmentId_by_name(
environment_name)
if environment_id:
jobs = paginator(
api_instance,
"get_all_profile_jobs",
environment_id=environment_id,
_request_timeout=self.__engine.get_timeout())
else:
return 1
else:
jobs = paginator(api_instance,
"get_all_profile_jobs",
_request_timeout=self.__engine.get_timeout())
if jobs.response_list:
for c in jobs.response_list:
if c.profile_job_id in self.__executionList:
lastExec = self.__executionList[c.profile_job_id]
else:
lastExec = None
job = DxProfileJob(self.__engine, lastExec)
job.from_job(c)
self.__jobsList[c.profile_job_id] = job
else:
if environment_name is None:
print_error("No jobs found")
self.__logger.error("No jobs found")
self.__logger.debug("All jobs loaded")
except ApiException as e:
print_error("Can't load job list %s" % e.body)
return 1
def LoadMeta(self, ruleset_id=None):
"""
Load list of rule sets
Return None if OK
"""
notable = None
nofile = None
self.__api = TableMetadataApi
self.__fileapi = FileMetadataApi
self.__apiexc = ApiException
self.__tableList.clear()
try:
api_instance = self.__api(self.__engine.api_client)
if ruleset_id:
table_metadata = paginator(api_instance,
"get_all_table_metadata",
ruleset_id=ruleset_id)
else:
table_metadata = paginator(api_instance,
"get_all_table_metadata")
if table_metadata.response_list:
for c in table_metadata.response_list:
table = DxTable(self.__engine)
table.from_table(c)
self.__tableList[c.table_metadata_id] = table
else:
self.__logger.error("No table metadata found")
except self.__apiexc as e:
if (e.status == 404) and (ruleset_id is not None):
notable = 1
else:
print_error(e.body)
self.__logger.error(e.body)
return 1
try:
api_instance = self.__fileapi(self.__engine.api_client)
if ruleset_id:
file_metadata = paginator(api_instance,
"get_all_file_metadata",
ruleset_id=ruleset_id)
else:
file_metadata = paginator(api_instance,
"get_all_file_metadata")
if file_metadata.response_list:
for c in file_metadata.response_list:
file = DxFile(self.__engine)
file.from_file(c)
self.__tableList[c.file_metadata_id] = file
else:
self.__logger.error("No file metadata found")
except self.__apiexc as e:
if (e.status == 404) and (ruleset_id is not None):
nofile = 1
else:
print_error(e.body)
self.__logger.error(e.body)
return 1
if nofile and notable:
print_error("Ruleset not found")
return 1
else:
return None
def LoadSync(self, objecttype=None):
"""
Load list of syncable objects
param1: type: load only particular type
Return None if OK
"""
self.__syncableList = {}
self.__api = SyncApi
self.__apiexc = ApiException
api_sync_response = None
if self.__engine.version_le("6.0.3"): # to check
alglist = supported_alg_list["5.3"]
else:
alglist = supported_alg_list["6.0.4"]
try:
api_sync = self.__api(self.__engine.api_client)
if objecttype:
objecttype = objecttype.upper()
if objecttype and self.__engine.version_ge("5.3"):
if objecttype == "ALGORITHM":
for atype in alglist:
print("trying to get {}".format(atype))
partres = paginator(api_sync,
"get_all_syncable_objects",
object_type=atype)
if api_sync_response is None:
api_sync_response = partres
else:
api_sync_response.response_list = \
api_sync_response.response_list + \
partres.response_list
else:
api_sync_response = paginator(api_sync,
"get_all_syncable_objects",
object_type=objecttype)
else:
if (objecttype is None) \
or (objecttype in
["LOOKUP", "DATE_SHIFT", "SEGMENT",
"TOKENIZATION", "ALGORITHM"]):
api_sync_response = paginator(api_sync,
"get_all_syncable_objects")
else:
print_error("This object type is not supported"
"in version 5.2.X")
sys.exit(1)
if api_sync_response.response_list:
for c in api_sync_response.response_list:
syncobj = DxSync(self.__engine)
syncobj.from_sync(c)
stype = syncobj.object_type
if stype in alglist:
stype = "ALGORITHM"
# print(type(syncobj))
# print(type(syncobj.object_identifier))
sid = list(syncobj.object_identifier.to_dict().values())[0]
if stype not in self.__syncableList:
self.__syncableList[stype] = {}
self.__syncableList[stype][sid] = syncobj
else:
print_error("No syncobject found")
self.__logger.error("No syncobject found")
return 1
return None
except self.__apiexc as e:
print_error(e.body)
self.__logger.error(e.body)
return 1
def LoadRulesets_worker(self, environment_name, env_id):
"""
Load list of rule sets
Return None if OK
"""
if self.__loaded_engine is None:
self.__loaded_engine = self.__engine.get_name()
#if self.__loaded_engine == self.__engine.get_name() and self.__rulesetList != {}:
# return None
#else:
# delete a list as we can have multi engines
self.__rulesetList.clear()
self.__loaded_engine = self.__engine.get_name()
DxConnectorsList(environment_name)
if (self.__engine.version_ge('6.0.0')):
from masking_api_60.api.database_ruleset_api import DatabaseRulesetApi
from masking_api_60.api.file_ruleset_api import FileRulesetApi
from masking_api_60.rest import ApiException
else:
from masking_api_53.api.database_ruleset_api import DatabaseRulesetApi
from masking_api_53.api.file_ruleset_api import FileRulesetApi
from masking_api_53.rest import ApiException
self.__api = DatabaseRulesetApi
self.__fileapi = FileRulesetApi
self.__apiexc = ApiException
try:
api_instance = self.__api(self.__engine.api_client)
if environment_name:
environment_id = DxEnvironmentList.get_environmentId_by_name(
environment_name)
if environment_id:
database_rulesets = paginator(
api_instance,
"get_all_database_rulesets",
environment_id=environment_id,
_request_timeout=self.__engine.get_timeout())
else:
return 1
else:
if env_id:
environment_id = env_id
database_rulesets = paginator(
api_instance,
"get_all_database_rulesets",
environment_id=environment_id,
_request_timeout=self.__engine.get_timeout())
else:
environment_id = None
database_rulesets = paginator(api_instance,
"get_all_database_rulesets")
if database_rulesets.response_list:
for c in database_rulesets.response_list:
ruleset = DxDatabaseRuleset(self.__engine)
ruleset.from_ruleset(c)
self.__rulesetList[c.database_ruleset_id] = ruleset
else:
if environment_id:
self.__logger.error("No database ruleset found for "
"environment name %s" %
environment_name)
else:
self.__logger.error("No database ruleset found")
api_instance = self.__fileapi(self.__engine.api_client)
if environment_id:
file_rulesets = paginator(api_instance,
"get_all_file_rulesets",
environment_id=environment_id)
else:
file_rulesets = paginator(api_instance,
"get_all_file_rulesets")
if file_rulesets.response_list:
for c in file_rulesets.response_list:
ruleset = DxFileRuleset(self.__engine)
ruleset.from_ruleset(c)
self.__rulesetList[c.file_ruleset_id] = ruleset
else:
if environment_id:
self.__logger.error("No file ruleset found for "
"environment name %s" %
environment_name)
else:
self.__logger.error("No file ruleset found")
except self.__apiexc as e:
print_error("Can't load ruleset %s" % e.body)
return 1
def LoadRulesets_worker(self, environment_name, env_id):
"""
Load list of rule sets
Return None if OK
"""
self.__rulesetList.clear()
DxConnectorsList(environment_name)
self.__api = DatabaseRulesetApi
self.__fileapi = FileRulesetApi
self.__apiexc = ApiException
try:
api_instance = self.__api(self.__engine.api_client)
if environment_name:
environment_id = DxEnvironmentList.get_environmentId_by_name(
environment_name)
if environment_id:
database_rulesets = paginator(
api_instance,
"get_all_database_rulesets",
environment_id=environment_id,
_request_timeout=self.__engine.get_timeout())
else:
return 1
else:
if env_id:
environment_id = env_id
database_rulesets = paginator(
api_instance,
"get_all_database_rulesets",
environment_id=environment_id,
_request_timeout=self.__engine.get_timeout())
else:
environment_id = None
database_rulesets = paginator(
api_instance,
"get_all_database_rulesets")
if database_rulesets.response_list:
for c in database_rulesets.response_list:
ruleset = DxDatabaseRuleset(self.__engine)
ruleset.from_ruleset(c)
self.__rulesetList[c.database_ruleset_id] = ruleset
else:
if environment_id:
self.__logger.error("No database ruleset found for "
"environment name %s"
% environment_name)
else:
self.__logger.error("No database ruleset found")
api_instance = self.__fileapi(self.__engine.api_client)
if environment_id:
file_rulesets = paginator(
api_instance,
"get_all_file_rulesets",
environment_id=environment_id)
else:
file_rulesets = paginator(
api_instance,
"get_all_file_rulesets")
if file_rulesets.response_list:
for c in file_rulesets.response_list:
ruleset = DxFileRuleset(self.__engine)
ruleset.from_ruleset(c)
self.__rulesetList[c.file_ruleset_id] = ruleset
else:
if environment_id:
self.__logger.error("No file ruleset found for "
"environment name %s"
% environment_name)
else:
self.__logger.error("No file ruleset found")
except self.__apiexc as e:
print_error("Can't load ruleset %s" % e.body)
return 1
