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 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 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 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 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 user_update(p_engine, username, firstname, lastname, email, password,
user_type, user_environments, user_role):
"""
Update user in Engine
param1: p_engine: engine name from configuration
param2: username: user name to add
param3: firstname: user first name to add
param4: lastname: user last name to add
param5: email: user email to add
param6: password: user password to add
param7: user_type: user type (admin / nonadmin)
param8: user_environments: list of comma separated environments
param9: user_role: user role name
return 0 if user updated
"""
ret = 0
update = 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 None:
print_error("User %s not found" % username)
logger.debug("User %s not found" % username)
ret = ret + 1
continue
userobj = userlist.get_by_ref(userref)
if user_type is not None:
update = 1
if user_type == 'nonadmin':
if user_role is None:
print_error("User role is required for non-admin user")
return 1
rolelist = DxRoleList()
roleref = rolelist.get_roleId_by_name(user_role)
if roleref is None:
print_error("Role name %s not found" % user_role)
logger.debug("Role name %s not found" % user_role)
ret = ret + 1
continue
envreflist = []
if user_environments is not None:
envlist = DxEnvironmentList()
envnamelist = user_environments.split(',')
for envname in envnamelist:
envref = envlist.get_environmentId_by_name(envname)
if envref is None:
ret = ret + 1
return 1
else:
envreflist.append(envref)
userobj.is_admin = False
nap = NonAdminProperties()
nap.role_id = roleref
nap.environment_ids = envreflist
userobj.non_admin_properties = nap
else:
userobj.is_admin = True
userobj.delete_nap()
print userobj
if firstname is not None:
update = 1
userobj.first_name = firstname
if lastname is not None:
update = 1
userobj.last_name = lastname
if email is not None:
update = 1
userobj.email = email
if password is not None:
update = 1
try:
userobj.password = password
except ValueError as e:
print str(e)
ret = ret + 1
return ret
if update == 1:
ret = ret + userobj.update()
else:
print_error("No values set for update.")
ret = ret + 1
return ret
def connector_add(p_engine, params):
"""
Add application to Masking engine
param1: p_engine: engine name from configuration
param2: params: dict of parameters needed for connector to add
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
envname = params['envname']
schemaName = params['schemaName']
host = params['host']
port = params['port']
password = params['password']
username = params['username']
connname = params['connname']
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
envlist = DxEnvironmentList()
envlist.LoadEnvironments()
logger.debug("Envname is %s" % envname)
envref = envlist.get_environmentId_by_name(envname)
if envref is None:
ret = ret + 1
continue
connlist = DxConnectorsList()
if params['type'] in database_types:
if params['type'] == 'oracle':
connobj = OracleConnector(engine_obj)
elif params['type'] == 'mssql':
connobj = MSSQLConnector(engine_obj)
elif params['type'] == 'sybase':
connobj = SybaseConnector(engine_obj)
else:
connobj = DxConnector(engine_obj)
connobj.database_type = params['type'].upper()
connobj.connector_name = connname
connobj.schema_name = schemaName
connobj.username = username
connobj.password = password
connobj.host = host
if port:
connobj.port = port + 0
connobj.sid = params['sid']
connobj.jdbc = params['jdbc']
connobj.environment_id = envref
connobj.instance_name = params['instancename']
connobj.database_name = params['databasename']
elif params['type'] in file_types:
path = params['path']
connmode = params['servertype']
connobj = DxFileConnector(engine_obj)
connobj.is_database = False
connobj.connector_name = connname
connobj.environment_id = envref
connobj.file_type = params['type'].upper()
ci = ConnectionInfo()
ci.host = host
ci.port = port
ci.login_name = username
ci.password = password
ci.path = path
ci.connection_mode = connmode.upper()
connobj.connection_info = ci
else:
print_error('Wrong connector type %s' % params['type'])
logger.error('Wrong connector type %s' % params['type'])
return 1
if connlist.add(connobj):
ret = ret + 1
return ret
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
def user_add(p_engine, p_username, username, firstname, lastname, email,
password, user_type, user_environments, user_role):
"""
Add user to Engine
param1: p_engine: engine name from configuration
param2: username: user name to add
param3: firstname: user first name to add
param4: lastname: user last name to add
param5: email: user email to add
param6: password: user password to add
param7: user_type: user type (admin / nonadmin)
param8: user_environments: list of comma separated environments
param9: user_role: user role name
return 0 if user added
"""
ret = 0
logger = logging.getLogger()
if user_type == 'nonadmin':
if user_role is None:
print_error("User role is required for non-admin user")
return 1
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 (engine_obj.version_ge('6.0.0')):
from masking_api_60.models.non_admin_properties import NonAdminProperties
else:
from masking_api_53.models.non_admin_properties import NonAdminProperties
userobj = DxUser(engine_obj)
if user_type == 'nonadmin':
rolelist = DxRoleList()
roleref = rolelist.get_roleId_by_name(user_role)
if roleref is None:
print_error("Role name %s not found" % user_role)
logger.debug("Role name %s not found" % user_role)
ret = ret + 1
continue
envreflist = []
if user_environments is not None:
envlist = DxEnvironmentList()
envnamelist = user_environments.split(',')
for envname in envnamelist:
envref = envlist.get_environmentId_by_name(envname)
if envref is None:
ret = ret + 1
return 1
else:
envreflist.append(envref)
is_admin = False
nap = DxUserNonAdmin(roleref, envreflist)
else:
is_admin = True
nap = None
try:
userobj.create_user(user_name=username,
password=password,
first_name=firstname,
last_name=lastname,
email=email,
is_admin=is_admin,
non_admin_properties=nap)
except ValueError as e:
print_error(str(e))
ret = ret + 1
return ret
userlist = DxUserList()
ret = ret + userlist.add(userobj)
return ret
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 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 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 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 connector_add(p_engine, p_username, params):
"""
Add application to Masking engine
param1: p_engine: engine name from configuration
param2: params: dict of parameters needed for connector to add
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
envname = params['envname']
schemaName = params['schemaName']
host = params['host']
port = params['port']
password = params['password']
username = params['username']
connname = params['connname']
for engine_tuple in enginelist:
engine_obj = DxMaskingEngine(engine_tuple)
if engine_obj.get_session():
continue
envlist = DxEnvironmentList()
envlist.LoadEnvironments()
logger.debug("Envname is %s" % envname)
envref = envlist.get_environmentId_by_name(envname)
if envref is None:
ret = ret + 1
continue
connlist = DxConnectorsList()
if params['type'] in database_types:
if params['type'] == 'oracle':
connobj = OracleConnector(engine_obj)
dbtype = 'ORACLE'
elif params['type'] == 'mssql':
connobj = MSSQLConnector(engine_obj)
dbtype = 'MSSQL'
elif params['type'] == 'sybase':
connobj = SybaseConnector(engine_obj)
dbtype = 'SYBASE'
elif params['type'] == 'extended':
connobj = ExtendedConnector(engine_obj)
dbtype = 'EXTENDED'
else:
connobj = DxConnector(engine_obj)
dbtype = params['type'].upper()
connobj.create_connector(
connector_name = connname,
database_type = dbtype,
environment_id = envref
)
connobj.schema_name = schemaName
connobj.username = username
connobj.password = password
connobj.host = host
if port:
connobj.port = int(port)
connobj.sid = params['sid']
connobj.jdbc = params['jdbc']
connobj.instance_name = params['instancename']
connobj.database_name = params['databasename']
if params['jdbc_driver_name']:
jdbclist = DxJDBCList()
driver_id = jdbclist.get_driver_id_by_name(params['jdbc_driver_name'])
connobj.jdbc_driver_id = driver_id
elif params['type'] in file_types:
path = params['path']
connmode = params['servertype']
connobj = DxFileConnector(engine_obj)
connobj.is_database = False
connobj.create_connector(
connector_name = connname,
file_type = params['type'].upper(),
environment_id = envref,
host=host,
port=port,
login_name=username,
password=password,
path=path,
connection_mode=connmode.upper()
)
else:
print_error('Wrong connector type %s' % params['type'])
logger.error('Wrong connector type %s' % params['type'])
return 1
if connlist.add(connobj):
ret = ret + 1
return ret