def application_add(p_engine, appname):
"""
Add application to Masking engine
param1: p_engine: engine name from configuration
param2: appname: application name
return 0 if added, non 0 for error
"""
ret = 0
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
# create new object of Application class
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
applist = DxApplicationList()
appnew = DxApplication(engine_obj)
# set a name
appnew.create_application(application_name=appname)
# add Application to engine and list
# rc is None all is OK
if applist.add(appnew):
ret = ret + 1
return ret
def profile_add(p_engine, profilename, expname, description):
"""
Add profile to engine
param1: p_engine: engine name from configuration
param2: profilename: profile name
param3: expname: expression list names
param4: description: profile description
return 0 if profile was added
"""
ret = 0
logger = logging.getLogger()
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
# load all objects
profilelist = DxProfilesList()
probj = DxProfile()
probj.profile_set_name = profilename
probj.created_by = engine_obj.get_username()
probj.description = description
if probj.set_expressions_using_names(expname):
ret = ret + 1
else:
if profilelist.add(probj):
ret = ret + 1
return ret
def driver_delete(p_engine, p_username, driver_name):
"""
Delete driver from engine
"""
ret = 0
logger = logging.getLogger()
enginelist = get_list_of_engines(p_engine, p_username)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
if not feature_support(engine_obj, "5.3.9"):
ret = ret + 1
continue
driver_list = DxJDBCList()
driver_ref = driver_list.get_driver_id_by_name(driver_name)
if driver_list.delete(driver_ref):
ret = ret + 1
return ret
def domain_add(p_engine, domain_name, classification, default_algname):
"""
Add the domain to the Masking Engine
param1: p_engine: engine name from configuration
param2: domain_name: domain name
param3: classification: domain classification
param4: default_algname: default algorithm name
return 0 if added, non 0 for error
"""
ret = 0
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
domainlist = DxDomainList()
domobj = DxDomain(engine_obj)
# set required properties
domobj.create_domain(domain_name = domain_name, domain_classification=classification, default_algorithm_code = default_algname)
if domainlist.add(domobj):
ret = ret + 1
return ret
def fileformat_add(p_engine, fileformat_type, fileformat_file):
"""
Add application to Masking engine
param1: p_engine: engine name from configuration
param2: params: job parameters
return 0 if added, non 0 for error
"""
ret = 0
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple[0], engine_tuple[1],
engine_tuple[2], engine_tuple[3])
if engine_obj.get_session():
continue
fileformatList = DxFileFormatList()
fileformat = DxFileFormat(engine_obj)
fileformat.file_format_type = fileformat_type.upper()
fileformat.file_format_name = fileformat_file.name
if fileformatList.add(fileformat):
ret = ret + 1
return ret
def ruleset_addmeta(p_engine, p_username, params, inputfile, fromconnector,
bulk):
"""
Add matadata to Masking engine
param1: p_engine: engine name from configuration
param2: params: set of required parameters to add meta
param3: inputfile: file with table/file definition
return 0 if added, non 0 for error
"""
ret = 0
rulesetname = params["rulesetname"]
envname = params["envname"]
enginelist = get_list_of_engines(p_engine, p_username)
if (params["metaname"] is None) and (inputfile is None) and (fromconnector
is None):
print_error("Option metaname, inputfile or fromconnector is required")
return 1
if ((params["metaname"]) and inputfile) or \
((params["metaname"]) and fromconnector) or \
(inputfile and fromconnector):
print_error(
"Option metaname, fromconnector and inputfile are mutally exclusive"
)
return 1
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
envlist = DxEnvironmentList()
envlist.LoadEnvironments()
rulelist = DxRulesetList(envname)
#rulelist.LoadRulesets()
ruleref = rulelist.get_rulesetId_by_name(rulesetname)
if ruleref:
ruleobj = rulelist.get_by_ref(ruleref)
if (params["metaname"]):
ret = ret + ruleobj.addmeta(params)
elif inputfile:
ret = ret + ruleobj.addmetafromfile(inputfile, bulk)
elif fromconnector:
ret = ret + ruleobj.addmetafromfetch(params["fetchfilter"],
bulk)
else:
print_error("Source for add meta is not specified")
else:
ret = ret + 1
return ret
def fileformat_delete(p_engine, fileformat_name):
"""
Delete application from Masking engine
param1: p_engine: engine name from configuration
param2: fileformat_name: file format name
return 0 if added, non 0 for error
"""
ret = 0
logger = logging.getLogger()
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple[0], engine_tuple[1],
engine_tuple[2], engine_tuple[3])
if engine_obj.get_session():
continue
fileformatList = DxFileFormatList()
fileformatid = fileformatList.get_file_format_id_by_name(
fileformat_name)
if fileformatList.delete(fileformatid):
ret = ret + 1
return ret
def environment_delete(p_engine, envname):
"""
Delete application from Masking engine
param1: p_engine: engine name from configuration
param2: envname: environment name
return 0 if added, non 0 for error
"""
ret = 0
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple[0], engine_tuple[1],
engine_tuple[2], engine_tuple[3])
if engine_obj.get_session():
continue
envlist = DxEnvironmentList()
envlist.LoadEnvironments()
envref = envlist.get_environmentId_by_name(envname)
if envlist.delete(envref):
ret = ret + 1
return ret
def domain_delete(p_engine, domain_name):
"""
Delete the domain from the Masking Engine
param1: p_engine: engine name from configuration
param2: domain_name: domain name
return 0 if added, non 0 for error
"""
ret = 0
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
domainlist = DxDomainList()
if domainlist.delete(domain_name):
ret = ret + 1
return ret
def environment_add(p_engine, envname, appname, purpose):
"""
Add application to Masking engine
param1: p_engine: engine name from configuration
param2: envname: environment name
param3: appname: application name
param4: purpose: environment purpose ( MASK )
return 0 if added, non 0 for error
"""
ret = 0
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple[0], engine_tuple[1],
engine_tuple[2], engine_tuple[3])
if engine_obj.get_session():
continue
envlist = DxEnvironmentList()
env = DxEnvironment(engine_obj)
# set required properties
env.environment_name = envname
env.application = appname
env.purpose = purpose
if envlist.add(env):
ret = ret + 1
return ret
def user_delete(p_engine, username, force):
"""
Delete user from Engine
param1: p_engine: engine name from configuration
param2: username: user name to delete
param3: force: force deletion of user with admin privilege
return 0 if user deleted
"""
ret = 0
logger = logging.getLogger()
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
userlist = DxUserList()
userref = userlist.get_userId_by_name(username)
if userref is not None:
if userlist.delete(userref, force) is not None:
print_error("Problem with deleting user %s" % username)
logger.debug("Problem with deleting user %s" % username)
ret = ret + 1
continue
else:
print_error("User %s not found" % username)
logger.debug("User %s not found" % username)
def algorithm_list(p_engine, algname):
"""
Print list of algorithms
param1: p_engine: engine name from configuration
param2: algname: algname name to list, all if None
return 0 if algname found
"""
ret = 0
logger = logging.getLogger()
data = DataFormatter()
data_header = [("Engine name", 30), ("Algorithm name", 30),
("Domain name", 32), ("Syncable", 3)]
data.create_header(data_header)
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple[0], engine_tuple[1],
engine_tuple[2], engine_tuple[3])
if engine_obj.get_session():
continue
alglist = DxAlgorithmList()
alglist.LoadAlgorithms()
algref_list = []
if algname:
algobj = alglist.get_by_ref(algname)
if algobj:
algref_list.append(algobj.algorithm_name)
else:
algref_list = alglist.get_allref()
for algref in algref_list:
algobj = alglist.get_by_ref(algref)
if algobj.sync:
syncable = 'Y'
else:
syncable = 'N'
data.data_insert(engine_tuple[0], algobj.algorithm_name, 'domain',
syncable)
algobj.export()
print("")
print(data.data_output(False))
print("")
return ret
def driver_list(p_engine, p_username, format, driver_name):
"""
Print list of file formats
param1: p_engine: engine name from configuration
param2: format: output format
param3: drver_name: driver name
return 0 if environment found
"""
ret = 0
logger = logging.getLogger()
logger.debug("driver_name {}".format(driver_name))
enginelist = get_list_of_engines(p_engine, p_username)
if enginelist is None:
return 1
data = DataFormatter()
data_header = [("Engine name", 30), ("Driver name", 30),
("Driver class name", 50), ("Built-in", 10)]
data.create_header(data_header)
data.format_type = format
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
if not feature_support(engine_obj, "5.3.9"):
ret = ret + 1
continue
driver_list = DxJDBCList()
# load all objects
if driver_name:
drivers = driver_list.get_all_driver_id_by_name(driver_name)
if drivers is None:
ret = ret + 1
else:
drivers = driver_list.get_allref()
for driver_ref in drivers:
driver_obj = driver_list.get_by_ref(driver_ref)
if driver_obj.built_in:
builtin = "True"
else:
builtin = "False"
data.data_insert(engine_tuple[0], driver_obj.driver_name,
driver_obj.driver_class_name, builtin)
print("")
print(data.data_output(False))
print("")
return ret
def ruleset_list_worker(**kwargs):
"""
Print list of ruleset by ruleset name or environment name
param1: p_engine: engine name from configuration
param2: format: output format
param2: ruleset: name of ruleset to display
param3: envname: name of environment to list ruleset
return 0 if environment found
"""
p_engine = kwargs.get('p_engine')
format = kwargs.get('format')
rulesetName = kwargs.get('rulesetName')
envname = kwargs.get('envname')
function_to_call = kwargs.get('function_to_call')
data = kwargs.get('data')
ret = 0
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
#envlist = DxEnvironmentList()
rulelist = DxRulesetList()
rulelist.LoadRulesets(envname)
if rulesetName is None:
rulesets = rulelist.get_allref()
if len(rulesets) == 0:
ret = ret + 1
continue
else:
rulesets = rulelist.get_all_rulesetId_by_name(rulesetName)
if rulesets is None:
ret = ret + 1
continue
# connlist = DxConnectorsList(envname)
# connlist.LoadConnectors(envname)
for ruleid in rulesets:
ruleobj = rulelist.get_by_ref(ruleid)
connobj = DxConnectorsList.get_by_ref(ruleobj.connectorId)
dynfunc = globals()[function_to_call]
if dynfunc(ruleobj=ruleobj, connobj=connobj,
# envlist=envlist,
engine_obj=engine_obj, **kwargs):
ret = ret + 1
continue
return ret
def domain_list(p_engine, format, domainname):
"""
Print list of algorithms
param1: p_engine: engine name from configuration
param2: domainname: domain name to list, all if None
return 0 if domain name found
"""
ret = 0
logger = logging.getLogger()
data = DataFormatter()
data_header = [
("Engine name", 30),
("Domain name", 32)
]
data.format_type = format
data.create_header(data_header)
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
domainlist = DxDomainList()
domainref_list = []
if domainname:
domobj = domainlist.get_by_ref(domainname)
if domobj:
domainref_list.append(domobj.domain_name)
else:
print_error("Domain {} not found".format(domainname))
return 1
else:
domainref_list = domainlist.get_allref()
for domainref in domainref_list:
domobj = domainlist.get_by_ref(domainref)
data.data_insert(
engine_tuple[0],
domobj.domain_name,
)
print("")
print (data.data_output(False))
print("")
return ret
def profilejob_add(p_engine, params):
"""
Add profile job to Masking engine
param1: p_engine: engine name from configuration
param2: params: job parameters
return 0 if added, non 0 for error
"""
ret = 0
enginelist = get_list_of_engines(p_engine)
logger = logging.getLogger()
envname = params['envname']
jobname = params['jobname']
rulesetname = params['rulesetname']
profilename = params['profilename']
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
joblist = DxProfileJobsList()
envlist = DxEnvironmentList()
rulesetlist = DxRulesetList()
profilesetlist = DxProfilesList()
profileref = profilesetlist.get_profileSetId_by_name(profilename)
envlist.LoadEnvironments()
logger.debug("Envname is %s, job name is %s" % (envname, jobname))
rulesetlist.LoadRulesets(envname)
rulesetref = rulesetlist.get_rulesetId_by_name(rulesetname)
job = DxProfileJob(engine_obj, None)
job.ruleset_id = rulesetref
job.job_name = jobname
job.profile_set_id = profileref
for p in masking_params_list:
if params[p] is not None:
if params[p] == 'Y':
value = True
elif params[p] == 'N':
value = False
else:
value = params[p]
setattr(job, p, value)
if joblist.add(job):
ret = ret + 1
return ret
def job_selector(**kwargs):
"""
Select unique job from Masking engine and run function on it
param1: p_engine: engine name from configuration
param2: jobname: job name
param3: envname: environment name
param4: function_to_call: name of function to call on connector
return 0 if added, non 0 for error
"""
p_engine = kwargs.get('p_engine')
jobname = kwargs.get('jobname')
envname = kwargs.get('envname')
function_to_call = kwargs.get('function_to_call')
joblist_class = kwargs.get('joblist_class')
lock = kwargs.get('lock')
p_username = kwargs.get('p_username')
ret = 0
enginelist = get_list_of_engines(p_engine, p_username)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
envlist = DxEnvironmentList()
envlist.LoadEnvironments()
joblist = globals()[joblist_class]()
joblist.LoadJobs(envname)
jobref = joblist.get_jobId_by_name(jobname)
if jobref:
dynfunc = globals()[function_to_call]
ret = ret + dynfunc(
jobref=jobref,
engine_obj=engine_obj,
joblist=joblist, **kwargs)
else:
if lock:
lock.acquire()
dxm.lib.DxJobs.DxJobCounter.ret = \
dxm.lib.DxJobs.DxJobCounter.ret + 1
if lock:
lock.release()
continue
return ret
def engine_logs(p_engine, outputlog):
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple[0], engine_tuple[1],
engine_tuple[2], engine_tuple[3])
engine_obj.getlogs(outputlog)
def expression_worker(**kwargs):
"""
Expression worker - run a dynamic action on expression object
p_engine: engine name from configuration
expname: expression name to list
function_to_call: function name to call for every expression object
kwargs: passed to dynamic action
return sum of return codes of dynamic action run on all selected
expressions
"""
p_engine = kwargs.get('p_engine')
expname = kwargs.get('expname')
p_username = kwargs.get('p_username')
function_to_call = kwargs.get('function_to_call')
enginelist = get_list_of_engines(p_engine, p_username)
if enginelist is None:
return 1
ret = 0
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
# load all objects
profileexplist = DxProfileExpList()
expressions = []
if expname is None:
expressions = profileexplist.get_allref()
else:
expression = profileexplist.get_profileExpId_by_name(expname)
expressions.append(expression)
if expression is None:
ret = ret + 1
continue
for peref in expressions:
proexpobj = profileexplist.get_by_ref(peref)
dynfunc = globals()[function_to_call]
ret = ret + dynfunc(
proexpobj=proexpobj,
profileexplist=profileexplist,
engine_obj=engine_obj,
**kwargs)
return ret
def engine_logs(p_engine, outputlog, page_size, level):
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
engine_obj.getlogs(outputlog, page_size, level)
def environment_list(p_engine, format, envname):
"""
Print list of environments
param1: p_engine: engine name from configuration
param2: format: output format
param3: envname: environemnt name to list, all if None
return 0 if environment found
"""
ret = 0
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
data = DataFormatter()
data_header = [
("Engine name", 30),
("Environment name", 30),
("Application name", 30)
]
data.create_header(data_header)
data.format_type = format
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
envlist = DxEnvironmentList()
# load all objects
envlist.LoadEnvironments()
if envname is None:
environments = envlist.get_allref()
else:
environment = envlist.get_environmentId_by_name(envname)
if environment is None:
ret = ret + 1
continue
environments = [environment]
for envref in environments:
envobj = envlist.get_by_ref(envref)
data.data_insert(
engine_tuple[0],
envobj.environment_name,
envobj.application
)
print("")
print (data.data_output(False))
print("")
return ret
def ruleset_add(p_engine, p_username, rulesetname, connectorname, envname):
"""
Add ruleset to Masking engine
param1: p_engine: engine name from configuration
param2: rulesetname: ruleset name
param3: connectorname: connectorname name
param4: envname: environment name
return 0 if added, non 0 for error
"""
ret = 0
logger = logging.getLogger()
enginelist = get_list_of_engines(p_engine, p_username)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
envlist = DxEnvironmentList()
envlist.LoadEnvironments()
rulelist = DxRulesetList()
connlist = DxConnectorsList(envname)
#connlist.LoadConnectors()
logger.debug("Connector is %s" % connectorname)
connref = connlist.get_connectorId_by_name(connectorname)
connobj = connlist.get_by_ref(connref)
if connobj:
if connobj.is_database:
ruleset = DxDatabaseRuleset(engine_obj)
ruleset.create_database_ruleset(
ruleset_name=rulesetname,
database_connector_id=connobj.connectorId,
refresh_drops_tables=None)
else:
ruleset = DxFileRuleset(engine_obj)
ruleset.create_file_ruleset(
ruleset_name=rulesetname,
file_connector_id=connobj.connectorId)
if rulelist.add(ruleset):
ret = ret + 1
else:
ret = ret + 1
return ret
def engine_upload(p_engine, p_engineuser, filename):
enginelist = get_list_of_engines(p_engine, p_engineuser)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
files_obj = DxEngineFiles()
print(files_obj.upload_file(filename))
def ruleset_addmeta(p_engine, params, inputfile):
"""
Add matadata to Masking engine
param1: p_engine: engine name from configuration
param2: params: set of required parameters to add meta
param3: inputfile: file with table/file definition
return 0 if added, non 0 for error
"""
ret = 0
rulesetname = params["rulesetname"]
envname = params["envname"]
enginelist = get_list_of_engines(p_engine)
if (params["metaname"] is None) and (inputfile is None):
print_error("Option metaname or inputfile is required")
return 1
if (params["metaname"]) and (inputfile):
print_error("Option metaname and inputfile are mutally exclusive")
return 1
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple[0], engine_tuple[1],
engine_tuple[2], engine_tuple[3])
if engine_obj.get_session():
continue
envlist = DxEnvironmentList()
envlist.LoadEnvironments()
rulelist = DxRulesetList()
rulelist.LoadRulesets(envname)
ruleref = rulelist.get_rulesetId_by_name(rulesetname)
if ruleref:
ruleobj = rulelist.get_by_ref(ruleref)
if (params["metaname"]):
ret = ret + ruleobj.addmeta(params)
else:
ret = ret + ruleobj.addmetafromfile(inputfile)
else:
ret = ret + 1
return ret
def application_list(p_engine, format, appname):
"""
Print list of applications
param1: p_engine: engine name from configuration
param2: format: output format
param3: appname: application name to list, all if None
return 0 if application found
"""
ret = 0
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
data = DataFormatter()
data_header = [
("Engine name", 30),
("Application name", 30),
]
data.create_header(data_header)
data.format_type = format
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
applist = DxApplicationList()
# load all objects
applist.LoadApplications()
if appname is None:
applications = applist.get_allref()
else:
applications = applist.get_applicationId_by_name(appname)
if len(applications) == 0:
ret = ret + 1
for appref in applications:
appobj = applist.get_by_ref(appref)
data.data_insert(
engine_tuple[0],
appobj.application_name
)
print("")
print (data.data_output(False))
print("")
return ret
def sync_import(p_engine, p_username, envname, inputfile, inputpath, force):
"""
Load algorithm from file
param1: p_engine: engine name from configuration
param2: inputfile: input file
param3: force: overwrite object
return 0 if OK
"""
ret = 0
enginelist = get_list_of_engines(p_engine, p_username)
if inputfile is None and inputpath is None:
print_error("Inputfile or inputpath parameter is required")
return 1
list_of_opened_files = []
if inputpath:
for f in os.listdir(inputpath):
fullpath = os.path.join(inputpath, f)
if os.path.isfile(fullpath):
fh = open(fullpath, "rb")
list_of_opened_files.append(fh)
else:
if inputfile:
list_of_opened_files = [inputfile]
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
envlist = DxEnvironmentList()
if envname:
environment_id = envlist.get_environmentId_by_name(envname)
else:
environment_id = None
for i in list_of_opened_files:
syncobj = DxSync(engine_obj)
ret = ret + syncobj.importsync(i, environment_id, force)
return ret
def connector_selector(p_engine,
connectorname,
envname,
function_to_call,
format='fixed'):
"""
Select unique connector from Masking engine and run function on it
param1: p_engine: engine name from configuration
param2: connectorname: connectorname name
param3: envname: environment name
param4: function_to_call: name of function to call on connector
param5: format: format of output, set to fixed
return 0 if added, non 0 for error
"""
ret = 0
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
envlist = DxEnvironmentList()
envlist.LoadEnvironments()
connlist = DxConnectorsList()
connlist.LoadConnectors(envname)
connref = connlist.get_connectorId_by_name(connectorname)
if connref:
dynfunc = globals()[function_to_call]
ret = ret + dynfunc(connref=connref,
engine_obj=engine_obj,
connlist=connlist,
format=format)
else:
ret = ret + 1
continue
return ret
def role_list(p_engine, p_username, format, rolename):
"""
Print list of roles
param1: p_engine: engine name from configuration
param2: format: output format
param3: rolename: role name to list, all if None
return 0 if role found
"""
ret = 0
enginelist = get_list_of_engines(p_engine, p_username)
if enginelist is None:
return 1
data = DataFormatter()
data_header = [("Engine name", 30), ("Role name", 30)]
data.create_header(data_header)
data.format_type = format
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
rolelist = DxRoleList()
# load all objects
if rolename is None:
roles = rolelist.get_allref()
else:
role = rolelist.get_roleId_by_name(rolename)
if role is None:
ret = ret + 1
continue
roles = [role]
for roleref in roles:
roleobj = rolelist.get_by_ref(roleref)
data.data_insert(engine_tuple[0], roleobj.role_name)
print("")
print(data.data_output(False))
print("")
return ret
def expression_add(p_engine, expname, domainname, level, regex):
"""
Add expression to engine
param1: p_engine: engine name from configuration
param2: expname: expression name
param3: domainname: domain name
param4: datalevel: data level
param5: regex: regular expression
return 0 if expression was added
"""
ret = 0
logger = logging.getLogger()
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
# load all objects
profileexplist = DxProfileExpList()
peobj = DxProfileExt()
if level:
if level == 'data':
data_level_profiling = True
else:
data_level_profiling = False
else:
data_level_profiling = False
peobj.create_profile_expression(
expression_name=expname,
domain_name=domainname,
regular_expression=regex,
data_level_profiling=data_level_profiling)
if profileexplist.add(peobj):
ret = ret + 1
return ret
def ruleset_worker(**kwargs):
"""
Delete ruleset from Masking engine
param1: p_engine: engine name from configuration
param2: rulesetname: ruleset name
param3: function_to_call: function to call for particual ruleset
return 0 if added, non 0 for error
"""
p_engine = kwargs.get('p_engine')
rulesetname = kwargs.get('rulesetname')
envname = kwargs.get('envname')
function_to_call = kwargs.get('function_to_call')
ret = 0
enginelist = get_list_of_engines(p_engine)
if enginelist is None:
return 1
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple[0], engine_tuple[1],
engine_tuple[2], engine_tuple[3])
if engine_obj.get_session():
continue
# envlist = DxEnvironmentList()
# envlist.LoadEnvironments()
# rulelist = DxRulesetList()
rulelist = DxRulesetList(envname)
ruleref = rulelist.get_rulesetId_by_name(rulesetname)
if ruleref:
dynfunc = globals()[function_to_call]
if dynfunc(ruleref=ruleref,
rulelist=rulelist,
engine_obj=engine_obj,
**kwargs):
ret = ret + 1
else:
ret = ret + 1
return ret