def do_meta_copy(engine_obj, ruleref, newref):
"""
Copy a meta objects plus columns from one RS to new one
param1: p_engine: engine name from configuration
param2: ruleref: source ruleset
param3: newref: target ruleset
return 0 if no issue with copy
"""
ret = 0
metalist = DxMetaList()
metalist.LoadMeta(ruleref)
for meta_id in metalist.get_allref():
newmeta_id = metalist.copymeta(meta_id, newref)
if newmeta_id:
ret = ret + columns_copy(engine_obj, meta_id, newmeta_id)
else:
ret = ret + 1
return ret
def do_export(**kwargs):
"""
Export ruleset into external object
"""
ruleref = kwargs.get('ruleref')
rulelist = kwargs.get('rulelist')
exportout = kwargs.get('exportout')
exportmeta = kwargs.get('exportmeta')
metaname = kwargs.get('metaname')
engine_obj = kwargs.get('engine_obj')
envlist = DxEnvironmentList
ruleobj = rulelist.get_by_ref(ruleref)
connobj = DxConnectorsList.get_by_ref(ruleobj.connectorId)
logger = logging.getLogger()
ret = 0
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 = None
ruleset = {
"Ruleset name": ruleobj.ruleset_name,
"Connector name": connector_name,
"Environent name": environment_name}
if exportmeta == 'Y':
metadatalist = []
metalist = DxMetaList()
metalist.LoadMeta(ruleobj.ruleset_id)
if metaname:
metalist_ref = metalist.get_all_MetadataId_by_name(metaname, 1)
if metalist_ref is None:
logger.error("no meta %s found" % metaname)
return 1
else:
metalist_ref = metalist.get_allref()
if metalist_ref is None:
logger.error("no meta data found")
return 1
for metaid in metalist_ref:
metaobj = metalist.get_by_ref(metaid)
if connobj.is_database:
tabhash = {
"table": True,
"meta_name": metaobj.meta_name,
"key_column": metaobj.key_column,
"where_clause": repr(metaobj.where_clause),
"custom_sql": repr(metaobj.custom_sql)
}
else:
if metaobj.file_format_id is not None:
filetypelist = DxFileFormatList()
fileformatobj = filetypelist.get_by_ref(
metaobj.file_format_id)
fileformatname = fileformatobj.file_format_name
else:
fileformatname = 'N/A'
tabhash = {
"table": False,
"meta_name": metaobj.meta_name,
"file_format": fileformatname,
"file_delimiter": metaobj.delimiter,
"file_eor": metaobj.end_of_record,
"file_enclosure": metaobj.enclosure,
"file_name_regex": metaobj.name_is_regular_expression
}
metadatalist.append(tabhash)
ruleset["Metadata"] = metadatalist
columndata = column_export(
engine_obj.get_name(), None, ruleobj.ruleset_name,
environment_name, metaname, None, None)
ruleset["Columns"] = json.loads(columndata.data_output(False))
else:
ruleset["Metadata"] = []
ruleset["Columns"] = []
exportout.append(ruleset)
return ret
def ruleset_listmeta(p_engine, format, rulesetname, envname, metaname):
"""
List tables/file from ruleset
param1: p_engine: engine name from configuration
param2: format: output format
param3: rulesetname: ruleset name to display metadata from
param4: envname: environemnt name to display metadata from
param5: metamame: name of table/file to display
return 0 if added, non zero for error
"""
ret = 0
found = False
data = DataFormatter()
data_header = [
("Engine name", 30),
("Environent name", 30),
("Ruleset name", 30),
("Metadata type", 15),
("Metadata name", 32)
]
data.create_header(data_header)
data.format_type = format
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()
rulelist = DxRulesetList()
rulelist.LoadRulesets(envname)
connlist = DxConnectorsList()
connlist.LoadConnectors(envname)
if rulesetname:
rulesetref_list = rulelist.get_all_rulesetId_by_name(rulesetname)
if rulesetref_list is None:
ret = ret + 1
continue
else:
rulesetref_list = rulelist.get_allref()
if rulesetref_list is None:
continue
metalist = DxMetaList()
for ruleref in rulesetref_list:
ruleobj = rulelist.get_by_ref(ruleref)
connobj = connlist.get_by_ref(ruleobj.connectorId)
if connobj:
envobj = envlist.get_by_ref(connobj.environment_id)
environment_name = envobj.environment_name
else:
environment_name = 'N/A'
metalist.LoadMeta(ruleobj.ruleset_id)
if metaname:
metalist_ref = metalist.get_all_MetadataId_by_name(metaname, 1)
if metalist_ref is None:
ret = ret + 1
continue
found = True
else:
metalist_ref = metalist.get_allref()
if metalist_ref is None:
continue
for metaid in metalist_ref:
metaobj = metalist.get_by_ref(metaid)
data.data_insert(
engine_tuple[0],
environment_name,
ruleobj.ruleset_name,
ruleobj.type,
metaobj.meta_name
)
print("")
print (data.data_output(False))
print("")
if found:
return 0
else:
if metaname:
print_error("Table or file %s not found" % metaname)
return ret
def tab_list_details(p_engine, p_format, rulesetname, envname, metaname, what):
"""
List details of tables/file from ruleset
param1: p_engine: engine name from configuration
param2: p_format: output format
param3: rulesetname: ruleset name to display metadata from
param4: envname: environemnt name to display metadata from
param5: metamame: name of table/file to display
param6: what - Database/File
return 0 if added, non zero for error
"""
ret = 0
found = False
data = DataFormatter()
if what == 'Database':
data_header = [("Engine name", 30), ("Environent name", 30),
("Ruleset name", 30), ("Table name", 32),
("Logical key", 32), ("Where clause", 50),
("Custom SQL", 50)]
else:
data_header = [("Engine name", 30), ("Environent name", 30),
("Ruleset name", 30), ("File name", 32),
("File type", 32), ("File format name", 32),
("Delimiter", 10), ("End of record", 10)]
data.create_header(data_header)
data.format_type = p_format
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.LoadRulesets(envname)
connlist = DxConnectorsList()
connlist.LoadConnectors(envname)
if rulesetname:
rulesetref_all = rulelist.get_all_rulesetId_by_name(rulesetname)
if rulesetref_all is None:
ret = ret + 1
continue
rulesetref_list = [
x for x in rulesetref_all
if rulelist.get_by_ref(x).type == what
]
if rulesetref_list is None:
ret = ret + 1
continue
else:
if what == 'Database':
rulesetref_list = rulelist.get_all_database_rulesetIds()
if rulesetref_list is None:
continue
else:
rulesetref_list = rulelist.get_all_file_rulesetIds()
if rulesetref_list is None:
continue
filetypelist = DxFileFormatList()
metalist = DxMetaList()
for ruleref in rulesetref_list:
ruleobj = rulelist.get_by_ref(ruleref)
connobj = connlist.get_by_ref(ruleobj.connectorId)
if connobj:
envobj = envlist.get_by_ref(connobj.environment_id)
environment_name = envobj.environment_name
else:
environment_name = 'N/A'
metalist.LoadMeta(ruleobj.ruleset_id)
if metaname:
metalist_ref = metalist.get_all_MetadataId_by_name(metaname, 1)
if metalist_ref is None:
ret = ret + 1
continue
found = True
else:
metalist_ref = metalist.get_allref()
if metalist_ref is None:
continue
for metaid in metalist_ref:
metaobj = metalist.get_by_ref(metaid)
if what == 'Database':
data.data_insert(engine_tuple[0], environment_name,
ruleobj.ruleset_name, metaobj.meta_name,
metaobj.key_column,
repr(metaobj.where_clause),
repr(metaobj.custom_sql))
else:
if metaobj.file_format_id is not None:
fileformatobj = filetypelist.get_by_ref(
metaobj.file_format_id)
fileformatname = fileformatobj.file_format_name
else:
fileformatname = 'N/A'
data.data_insert(engine_tuple[0], environment_name,
ruleobj.ruleset_name, metaobj.meta_name,
metaobj.file_type, fileformatname,
metaobj.delimiter,
repr(metaobj.end_of_record))
print("")
print(data.data_output(False))
print("")
if found:
return 0
else:
if metaname:
print_error("Table %s not found" % metaname)
return ret
def column_worker(p_engine,
sortby,
rulesetname,
envname,
metaname,
columnname,
filter_algname,
filter_is_masked,
algname,
is_masked,
domainname,
function_to_call,
data=None,
inventory=None,
**kwargs):
"""
Select a column using all filter parameters
and run action defined in function_to_call
param1: p_engine: engine name from configuration
param2: sortby: sort by output if needed
param3: rulesetname: ruleset name
param4: envname: environment name
param5: metaname: meta name (table or file)
param6: columnname: column name (column or field)
param7: filter_algname: algorithm name to filter
param8: filter_is_masked: is masked fileter
param9: algname: new algorithm to set
param10: is_masked: set masking False/True
param11: domainname: new domain to set
param12: function_to_call: function name to call
param13: data: output object
return 0 action is processed without issues
"""
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
envlist = DxEnvironmentList()
envlist.LoadEnvironments()
rulelist = DxRulesetList(envname)
connlist = DxConnectorsList(envname)
metalist = DxMetaList()
rulesetref_list = []
if rulesetname:
ruleref = rulelist.get_rulesetId_by_name(rulesetname)
if ruleref:
rulesetref_list.append(ruleref)
else:
rulesetref_list = rulelist.get_allref()
for ruleref in rulesetref_list:
ruleobj = rulelist.get_by_ref(ruleref)
connobj = connlist.get_by_ref(ruleobj.connectorId)
if connobj:
envobj = envlist.get_by_ref(connobj.environment_id)
else:
envobj = None
metalist.LoadMeta(ruleobj.ruleset_id)
metasetref_list = []
if metaname:
metaref = metalist.get_MetadataId_by_name(metaname, 1)
if metaref:
metasetref_list.append(metaref)
else:
metasetref_list = metalist.get_allref()
for metaid in metasetref_list:
metaobj = metalist.get_by_ref(metaid)
collist = DxColumnList()
collist.LoadColumns(metadata_id=metaid,
is_masked=filter_is_masked)
colsetref_list = []
colcount = kwargs.get("colcount")
if colcount is not None:
colcount.extend(collist.get_allref())
if columnname:
colref = collist.get_column_id_by_name(columnname)
logger.debug("Column ref with name %s : %s" %
(columnname, colref))
if colref:
colsetref_list.append(colref)
else:
colsetref_list = collist.get_allref()
logger.debug("List of columns to process : %s" %
colsetref_list)
if filter_algname:
colsetref_masked = collist.get_column_id_by_algorithm(
filter_algname)
logger.debug("List of columns with algorithm %s : %s" %
(filter_algname, colsetref_masked))
colsetref_list = list(
set(colsetref_list)
& set(colsetref_masked))
logger.debug("Intersection with column name filter %s" %
colsetref_masked)
for colref in colsetref_list:
colobj = collist.get_by_ref(colref)
dynfunc = globals()[function_to_call]
ret = ret + dynfunc(data=data,
engine=engine_tuple,
envobj=envobj,
ruleobj=ruleobj,
metaobj=metaobj,
colobj=colobj,
algname=algname,
is_masked=is_masked,
domainname=domainname,
inventory=inventory,
**kwargs)
return ret