def init_jdbc():
############################
# Purpose: open a JDBC connection to
# this Actor's pgSQL dbase
# Caller: main
#############################
module = "utils: init_jdbc"
# print "in ", module
d, u, p, v = "jdbc:postgresql://localhost/rsnadb", "edge", "edge01", "org.postgresql.Driver"
# d,u,p,v = "jdbc:postgresql://172.22.3.85/rsnadb","edge","edge01","org.postgresql.Driver"
try:
# if called from command line with .login CLASSPATH setup right, this works
db = zxJDBC.connect(d, u, p, v)
except:
# if called from Apache or account where the .login has not set CLASSPATH
# need to use run-time classPathHacker
try:
jarLoad = classPathHacker()
a = jarLoad.addFile("postgresql.jar")
db = zxJDBC.connect(d, u, p, v)
except:
sys.exit("still failed \n%s" % (db))
sys.exit("still failed \n%s" % (sys.exc_info()))
return db
def addPlant(args):
if len(args) != 3:
usage()
name = args[0]
descrip = args[1]
rating = args[2]
con = zxJDBC.connect(*CONNECT_ARGS)
cur = con.cursor()
cur.execute("select * from Plant_DB where p_name = '%s'" % name)
row = cur.fetchone()
if row:
#if cur.rowcount == 1:
sql = "update Plant_DB set p_desc='%s', p_rating='%s' where p_name='%s'" % \
(descrip, rating, name)
print 'sql:', sql
cur.execute(sql)
con.commit()
print 'Updated'
else:
cur.execute("insert into Plant_DB values ('%s', '%s', '%s')" %
(name, descrip, rating))
con.commit()
print 'Added'
showPlants1(cur)
cur.close()
con.close()
def __init__(self, args):
username = args[Constant.WH_DB_USERNAME_KEY]
password = args[Constant.WH_DB_PASSWORD_KEY]
jdbc_driver = args[Constant.WH_DB_DRIVER_KEY]
jdbc_url = args[Constant.WH_DB_URL_KEY]
conn_mysql = zxJDBC.connect(jdbc_url, username, password, jdbc_driver)
cur = conn_mysql.cursor()
try:
query = "select distinct f.flow_id, f.flow_name, f.flow_group, ca.app_code from flow f join cfg_application ca on f.app_id = ca.app_id order by app_code, flow_name"
cur.execute(query)
flows = cur.fetchall()
self.flow_dict = dict()
for flow in flows:
current = self.flow_dict
# if needed, use flow[3].replace(' ', '.')
current = current.setdefault(flow[3], {})
if flow[2] is not None:
current = current.setdefault(flow[2], {})
# for oozie
else:
current = current.setdefault('NA', {})
current = current.setdefault(flow[1], {})
current["__ID_OF_FLOW__"] = flow[0]
self.file_name = args[Constant.FLOW_TREE_FILE_NAME_KEY]
self.value = []
finally:
cur.close()
conn_mysql.close()
def _cursor( self, connection, kwargs ):
if not connection:
self.connectionFactory = kwargs.get( 'options' ) and kwargs.get( 'options' ).get( 'CONNECTION_FACTORY' ) or None
if self.connectionFactory:
con = self.connectionFactory.getConnection()
connection = PyConnection( con )
else:
host = kwargs.get( 'host' ) or 'localhost'
port = kwargs.get( 'port' ) and ( ':%s' % kwargs.get( 'port' )) or ''
if not ( host.lower() == 'localhost' ):
conn_string = "jdbc:db2://%s%s/%s" % ( host, port, kwargs.get( 'database' ) )
else:
conn_string = "jdbc:db2:%s" % ( kwargs.get( 'database' ) )
# for Setting default AUTO COMMIT off on connection.
autocommit = False
if kwargs.get( 'options' ) and kwargs.get( 'options' ).keys().__contains__( 'autocommit' ):
autocommit = kwargs.get( 'options' ).get( 'autocommit' )
del kwargs.get( 'options' )['autocommit']
connection = zxJDBC.connect( conn_string,
kwargs.get( 'user' ),
kwargs.get( 'password' ),
'com.ibm.db2.jcc.DB2Driver', kwargs.get( 'options' ) )
# To prevent dirty reads
self.__prevent_dirty_reads( connection )
connection.__connection__.setAutoCommit( autocommit )
return connection, DB2CursorWrapper( connection.cursor() )
else:
return DB2CursorWrapper( connection.cursor() )
def test(user, pwd):
conn = zxJDBC.connect("jdbc:mysql://localhost/flycircuit", user, pwd, "org.gjt.mm.mysql.Driver") # For local testing
cursor = conn.cursor()
cursor.execute("SELECT * FROM flycircuit_driver_map")
dc = dict_cursor(cursor)
for d in dc:
print d.items()
def get_new_connection(self, kwargs):
self.connectionFactory = kwargs.get( 'options' ) and kwargs.get( 'options' ).get( 'CONNECTION_FACTORY' ) or None
if self.connectionFactory:
con = self.connectionFactory.getConnection()
connection = PyConnection( con )
else:
host = kwargs.get( 'host' ) or 'localhost'
port = kwargs.get( 'port' ) and ( ':%s' % kwargs.get( 'port' )) or ''
DriverType = 4
kwargsKeys = kwargs.keys()
if kwargsKeys.__contains__( 'DriverType' ):
DriverType = kwargs['DriverType']
if DriverType == 4:
conn_string = "jdbc:db2://%s%s/%s" % ( host, port, kwargs.get( 'database' ) )
elif DriverType == 2:
conn_string = "jdbc:db2:%s" % ( kwargs.get( 'database' ) )
else:
raise ImproperlyConfigured( "Wrong Driver type" )
# for Setting default AUTO COMMIT off on connection.
autocommit = False
if kwargs.get( 'options' ) and kwargs.get( 'options' ).keys().__contains__( 'autocommit' ):
autocommit = kwargs.get( 'options' ).get( 'autocommit' )
del kwargs.get( 'options' )['autocommit']
connection = zxJDBC.connect( conn_string,
kwargs.get( 'user' ),
kwargs.get( 'password' ),
'com.ibm.db2.jcc.DB2Driver', kwargs.get( 'options' ) )
# To prevent dirty reads
self.__prevent_dirty_reads( connection )
connection.__connection__.setAutoCommit( autocommit )
return connection
def _cursor_from_settings_dict(self, settings_dict):
cursor = None
if self.connection is None:
# Configure and connect to database using zxJDBC
if settings_dict['NAME'] == '':
from django.core.exceptions import ImproperlyConfigured
raise ImproperlyConfigured("You need to specify NAME in your Django settings file.")
host = settings_dict['HOST'] or 'localhost'
port = (settings_dict['PORT']
and (':%s' % settings_dict['PORT'])
or '')
conn_string = "jdbc:oracle:thin:@%s%s:%s" % (host, port,
settings_dict['NAME'])
self.connection = Database.connect(
conn_string,
settings_dict['USER'],
settings_dict['PASSWORD'],
"oracle.jdbc.OracleDriver",
**settings_dict['OPTIONS'])
# make transactions transparent to all cursors
cursor = CursorWrapper(self.connection.cursor())
# Set oracle date to ansi date format. This only needs to execute
# once when we create a new connection.
cursor.execute("ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD' "
"NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF'")
try:
self.connection.stmtcachesize = 20
except:
pass
if not cursor:
cursor = CursorWrapper(self.connection.cursor())
return cursor
def GetConnector():
if (ConnectorPool.cursor == 0):
ConnectorPool.connection = zxJDBC.connect(
"jdbc:mysql://localhost/Project", "root", "1234",
"org.gjt.mm.mysql.Driver")
ConnectorPool.cursor = ConnectorPool.connection.cursor()
return ConnectorPool.cursor
def readDatabase(self, station):
import datetime
self.clearBoard()
dow = datetime.datetime.now().strftime("%a")
connectionUrl = "jdbc:mysql://192.168.0.12:3306"
with zxJDBC.connect(connectionUrl, "foggyhollow", "foggyhollow",
"com.mysql.jdbc.Driver") as conn:
query = "select * from foggyhollow.station_schedules where station=? and arlv='Lv' and (trainDays like ? or trainDays like 'Daily') order by str_to_date(scheduleTime, '%l:%i %p') ;"
with conn:
with conn.cursor() as c:
c.execute(query, [station, "%" + dow + "%"])
try:
i = 1
row = c.fetchone()
while row != None and i < 11:
memories.getMemory("Train Number:" +
str(i)).setValue(str(row[1]))
memories.getMemory("Direction:" + str(i)).setValue(
str(row[5]))
memories.getMemory("Train Name:" +
str(i)).setValue(str(row[2]))
memories.getMemory("Time:" + str(i)).setValue(
str(row[4]))
memories.getMemory("Destination:" +
str(i)).setValue(str(row[7]))
row = c.fetchone()
i = i + 1
except StopIteration:
print ""
def change_pass(uuid, pw):
conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
curs = conn.cursor()
curs.execute("UPDATE secret SET pass = ? WHERE uuid = ?", (pw,uuid,))
conn.commit()
curs.close()
conn.close()
def run(userid, terreinid, landscapename):
#Connect to postgres
conn = zxJDBC.connect(jdbc_url,username, password, driver)
cur = conn.cursor()
query = """
INSERT INTO administration.runs ("user", model, status, percentage, lastupdate) VALUES (?,?,?, ?, now());
"""
data = [1,4,"scheduled",0]
cur.execute(query, data)
conn.commit()
query = """SELECT MAX(id) FROM administration.runs;"""
cur.execute(query)
result = cur.fetchone()
runid = result[0]
query = """
INSERT INTO administration.params_makelcp
(run, terrein_id, terrein_name)
VALUES
(?, ?, ?);
"""
data = [runid,terreinid,landscapename]
cur.execute(query, data )
conn.commit()
import subprocess
p = subprocess.Popen(['/usr/bin/curl','-u', 'demo:demo','http://model.geodan.nl/main/gmi/cgi-bin/makeLcp.py'])
p.daemon = True
return '{"runid":'+str(runid)+',"status":"scheduled","percentage":0}'
def getCodeFolder(id):
# try:
ret = None
d,u,p,v = "jdbc:mysql://localhost/cmd_main",'root',"","org.gjt.mm.mysql.Driver"
with zxJDBCA.connect(d,u,p,v,CHARSET='utf-8') as conn:
with conn:
with conn.cursor() as c:
c.datahandler = PyHandler(c.datahandler)
pId = id;
if pId is None:
pId = ''
str = "select * from codefolder where parentid = '" + pId + "'"
print 'get folder sql string ',str
# str = "select * from codefolder "
# print str
c.execute(str)
# print json.dumps(c.fetchall()).decode('unicode-escape')
# print c.rowcount
# while (c.next()):
all = c.fetchall()
print 'get all folder:....',all
# print json.dumps(all).decode('unicode-escape')
return json.dumps(all).decode('unicode-escape')
def init(context):
global db
db = zxJDBC.connect("jdbc:h2:" + context.storageFolder.getPath() +
"/quotedb/db", "sa", "", "org.h2.Driver")
execute("create table if not exists quotes (quotegroup text, "
"quotenumber int, quotetext text, hidden boolean)")
execute("create table if not exists quoteinfo (quotegroup text, "
"quotenumber int,key text, value text)")
execute("create table if not exists quotesequence (quotegroup text, "
"nextquote int)")
Configuration.register(None, "quote", "This folder holds configuration "
"variables related to the quote plugin.",
VarType.folder, None)
Configuration.register(None, "quote/groupnames", "A space-separated list "
"of groups that quotes can be added to.",
VarType.text, "")
Configuration.register(None, "quote/port", "The port to listen for HTTP "
"requests on. If this is unset, the HTTP server "
"will not be started. This only takes effect "
"at restart.", VarType.integer, None)
if Configuration.isSet(None, "quote/port"):
server = HTTPServer(("", Configuration.getInt(None, "quote/port")),
HTTPHandler)
class ServerThread(Thread):
def run(self):
server.serve_forever()
ServerThread().start()
def createInstans(i):
cnxn = zxJDBC.connect(jdbc_url, username, password, driver_class)
crsr = cnxn.cursor()
for iInsert in range(50):
gender = random.randrange(2)
mark = random.randrange(2)
if gender == 1: # мужик или не мужик вот в чем вопрос ¯\_(ツ)_/¯
firstName = getRandNameMan()
familyName = getRandFamilyName()
otch = getRandOtchMan()
else:
firstName = getRandNameFemale()
familyName = getRandFamilyName() + 'a'
otch = getRandOtchWomen()
fio = firstName + " " + familyName + " " + otch
execIns = "INSERT INTO " + nameTable + str(
i + 1) + " (ID, FIO, nameSup, DT, mark) VALUES (" + str(
iInsert + 1) + ", '" + fio + "', '" + getRandSubject(
) + "', '" + getRandDate() + "', " + str(mark) + ")"
listLog.append(execIns.encode("utf-8"))
print(
str(iInsert + 1) + ")Создан запрос запросом: ",
execIns.encode("utf-8"))
crsr.execute(execIns)
crsr.close()
cnxn.commit()
cnxn.close()
def db_connect(self, init=False):
if init or (datetime.now() - self.connect_time).total_seconds() > self.connection_interval:
if self.conn_hms:
self.conn_hms.close()
self.conn_hms = zxJDBC.connect(self.jdbc_url, self.username, self.password, self.jdbc_driver)
self.logger.info("Connected to Hive metadata-store DB")
self.connect_time = datetime.now()
def __init__(self, args):
self.logger = LoggerFactory.getLogger('jython script : ' +
self.__class__.__name__)
self.app_id = int(args[Constant.APP_ID_KEY])
self.wh_exec_id = long(args[Constant.WH_EXEC_ID_KEY])
self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
args[Constant.WH_DB_USERNAME_KEY],
args[Constant.WH_DB_PASSWORD_KEY],
args[Constant.WH_DB_DRIVER_KEY])
self.wh_cursor = self.wh_con.cursor()
self.aw_con = self.get_connection(args[Constant.AW_DB_URL_KEY],
args[Constant.AW_DB_PORT_KEY],
args[Constant.AW_DB_NAME_KEY],
args[Constant.AW_DB_USERNAME_KEY],
args[Constant.AW_DB_PASSWORD_KEY],
args[Constant.AW_DB_DRIVER_KEY])
self.aw_cursor = self.aw_con.cursor()
self.lookback_period = args[Constant.AW_EXEC_ETL_LOOKBACK_KEY]
self.app_folder = args[Constant.WH_APP_FOLDER_KEY]
self.metadata_folder = self.app_folder + "/" + str(
SchedulerType.APPWORX) + "/" + str(self.app_id)
self.last_execution_unix_time = None
self.get_last_execution_unix_time()
if not os.path.exists(self.metadata_folder):
try:
os.makedirs(self.metadata_folder)
except Exception as e:
self.logger.error(e)
def __init__(self, args):
SchedulerTransform.__init__(self, args, SchedulerType.LHOTSE)
self.wh_con_1 = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
args[Constant.WH_DB_USERNAME_KEY],
args[Constant.WH_DB_PASSWORD_KEY],
args[Constant.WH_DB_DRIVER_KEY])
self.wh_cursor_1 = self.wh_con_1.cursor()
def __init__(self, args):
self.logger = LoggerFactory.getLogger('jython script : ' +
self.__class__.__name__)
username = args[Constant.WH_DB_USERNAME_KEY]
password = args[Constant.WH_DB_PASSWORD_KEY]
JDBC_DRIVER = args[Constant.WH_DB_DRIVER_KEY]
JDBC_URL = args[Constant.WH_DB_URL_KEY]
self.input_table_file = args[Constant.ORA_SCHEMA_OUTPUT_KEY]
self.input_field_file = args[Constant.ORA_FIELD_OUTPUT_KEY]
self.input_sample_file = args[Constant.ORA_SAMPLE_OUTPUT_KEY]
self.db_id = args[Constant.DB_ID_KEY]
self.wh_etl_exec_id = args[Constant.WH_EXEC_ID_KEY]
self.conn_mysql = zxJDBC.connect(JDBC_URL, username, password,
JDBC_DRIVER)
self.conn_cursor = self.conn_mysql.cursor()
if Constant.INNODB_LOCK_WAIT_TIMEOUT in args:
lock_wait_time = args[Constant.INNODB_LOCK_WAIT_TIMEOUT]
self.conn_cursor.execute("SET innodb_lock_wait_timeout = %s;" %
lock_wait_time)
self.logger.info(
"Load Oracle Metadata into {}, db_id {}, wh_exec_id {}".format(
JDBC_URL, self.db_id, self.wh_etl_exec_id))
def delete_pass(uuid):
conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
curs = conn.cursor()
curs.execute("DELETE FROM secret WHERE uuid = ?", (uuid,))
conn.commit()
curs.close()
conn.close()
def init_db_conn(connect_string, username, passwd):
"""initializes db connections"""
global _CONN
if not _CONN:
global _CONNECT_STRING
global _USERNAME
global _PASSWD
_CONNECT_STRING = connect_string
_USERNAME = username
_PASSWD = passwd
dbinfo = connect_string
try:
if USE_JYTHON:
print(dbinfo)
_CONN = zxJDBC.connect(connect_string, username, passwd,
'com.informix.jdbc.IfxDriver')
else:
(dbname, dbuser, _) = connect_string.split('/', 3)
dbinfo = 'db: %s:%s' % (dbname, dbuser)
try:
_CONN = odbc.odbc(connect_string)
print(dbinfo)
except KeyboardInterrupt:
raise
except:
ex = sys.exc_info()
s = 'Exception: %s: %s\n%s' % (ex[0], ex[1], dbinfo)
print(s)
return None
return _CONN
def test():
d, u, p, v = (
"jdbc:postgresql://thrush:5432/test", # ... host, port, database
"postgres", # user name
"Flicker", # pass word
"org.postgresql.Driver", # driver
)
db = zxJDBC.connect(d, u, p, v, CHARSET='iso_1')
cur = db.cursor()
cur.execute('select * from plant_db')
rows = cur.fetchall()
s1 = '%s %s %s' % (
'Name'.ljust(12),
'Description'.ljust(24),
'Rating'.ljust(10),
)
print s1
s1 = '%s %s %s' % (
'===='.ljust(12),
'==========='.ljust(24),
'======'.ljust(10),
)
print s1
for row in rows:
rating = str(row[2])
print '%s %s %s' % (
row[0].ljust(12),
row[1].ljust(24),
rating.ljust(10),
)
cur.close()
db.close()
def __init__(self, args):
self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
self.app_id = int(args[Constant.JOB_REF_ID_KEY])
self.wh_exec_id = long(args[Constant.WH_EXEC_ID_KEY])
self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
args[Constant.WH_DB_USERNAME_KEY],
args[Constant.WH_DB_PASSWORD_KEY],
args[Constant.WH_DB_DRIVER_KEY])
self.wh_cursor = self.wh_con.cursor()
self.aw_con = self.get_connection(args[Constant.AW_DB_URL_KEY],
args[Constant.AW_DB_PORT_KEY],
args[Constant.AW_DB_NAME_KEY],
args[Constant.AW_DB_USERNAME_KEY],
args[Constant.AW_DB_PASSWORD_KEY],
args[Constant.AW_DB_DRIVER_KEY])
self.aw_cursor = self.aw_con.cursor()
self.lookback_period = args[Constant.AW_EXEC_ETL_LOOKBACK_KEY]
self.app_folder = args[Constant.WH_APP_FOLDER_KEY]
self.metadata_folder = self.app_folder + "/" + str(SchedulerType.APPWORX) + "/" + str(self.app_id)
self.last_execution_unix_time = None
self.get_last_execution_unix_time()
if not os.path.exists(self.metadata_folder):
try:
os.makedirs(self.metadata_folder)
except Exception as e:
self.logger.error(e)
def __init__(self, args):
self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
username = args[Constant.WH_DB_USERNAME_KEY]
password = args[Constant.WH_DB_PASSWORD_KEY]
JDBC_DRIVER = args[Constant.WH_DB_DRIVER_KEY]
JDBC_URL = args[Constant.WH_DB_URL_KEY]
self.input_table_file = args[Constant.ORA_SCHEMA_OUTPUT_KEY]
self.input_field_file = args[Constant.ORA_FIELD_OUTPUT_KEY]
self.input_sample_file = args[Constant.ORA_SAMPLE_OUTPUT_KEY]
self.db_id = args[Constant.DB_ID_KEY]
self.wh_etl_exec_id = args[Constant.WH_EXEC_ID_KEY]
self.conn_mysql = zxJDBC.connect(JDBC_URL, username, password, JDBC_DRIVER)
self.conn_cursor = self.conn_mysql.cursor()
if Constant.INNODB_LOCK_WAIT_TIMEOUT in args:
lock_wait_time = args[Constant.INNODB_LOCK_WAIT_TIMEOUT]
self.conn_cursor.execute("SET innodb_lock_wait_timeout = %s;" % lock_wait_time)
self.logger.info("Load Oracle Metadata into {}, db_id {}, wh_exec_id {}"
.format(JDBC_URL, self.db_id, self.wh_etl_exec_id))
self.dict_dataset_table = 'dict_dataset'
self.field_comments_table = 'field_comments'
self.dict_field_table = 'dict_field_detail'
self.dict_field_comment_table = 'dict_dataset_field_comment'
self.dict_dataset_sample_table = 'dict_dataset_sample'
def __init__(self, args):
self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
username = args[Constant.WH_DB_USERNAME_KEY]
password = args[Constant.WH_DB_PASSWORD_KEY]
JDBC_DRIVER = args[Constant.WH_DB_DRIVER_KEY]
JDBC_URL = args[Constant.WH_DB_URL_KEY]
self.db_id = args[Constant.JOB_REF_ID_KEY]
self.wh_etl_exec_id = args[Constant.WH_EXEC_ID_KEY]
self.conn_mysql = zxJDBC.connect(JDBC_URL, username, password, JDBC_DRIVER)
self.conn_cursor = self.conn_mysql.cursor()
if Constant.INNODB_LOCK_WAIT_TIMEOUT in args:
lock_wait_time = args[Constant.INNODB_LOCK_WAIT_TIMEOUT]
self.conn_cursor.execute("SET innodb_lock_wait_timeout = %s;" % lock_wait_time)
temp_dir = FileUtil.etl_temp_dir(args, "ORACLE")
self.input_table_file = os.path.join(temp_dir, args[Constant.ORA_SCHEMA_OUTPUT_KEY])
self.input_field_file = os.path.join(temp_dir, args[Constant.ORA_FIELD_OUTPUT_KEY])
self.input_sample_file = os.path.join(temp_dir, args[Constant.ORA_SAMPLE_OUTPUT_KEY])
self.collect_sample = False
if Constant.ORA_LOAD_SAMPLE in args:
self.collect_sample = FileUtil.parse_bool(args[Constant.ORA_LOAD_SAMPLE], False)
self.logger.info("Load Oracle Metadata into {}, db_id {}, wh_exec_id {}"
.format(JDBC_URL, self.db_id, self.wh_etl_exec_id))
def run(userid,geom, name, fuelmodel, weatherstring, windstring, startmonth, startday, starthour, stoplines):
#Connect to postgres
conn = zxJDBC.connect(jdbc_url,username, password, driver)
cur = conn.cursor()
query = """
INSERT INTO administration.runs ("user", model, status, percentage, lastupdate) VALUES (?,?,?,?, now());
"""
data = [1,5,"scheduled",0]
cur.execute(query, data)
conn.commit()
query = """SELECT MAX(id) FROM administration.runs;"""
cur.execute(query)
result = cur.fetchone()
runid = result[0]
cur = conn.cursor()
query = """
INSERT INTO administration.params_farsiterun
(run, name, fuelmodel, point, weatherstring, windstring, startmonth, startday, starthour, stoplines)
VALUES
(?,?,?,?,?,?,?,?,?,?);
"""
data = [runid,name,fuelmodel,geom,weatherstring,windstring,startmonth,startday,starthour, stoplines]
cur.execute(query, data )
conn.commit()
runid_out = runid
modelname = 'farsiteRun'
status_out = "scheduled"
percentage_out = 0
import subprocess
p = subprocess.Popen(['/usr/bin/curl','-u','demo:demo', 'http://model.geodan.nl/main/gmi/cgi-bin/farsiteRun2.py'])
return '{"runid":%i,"status":"%s", "percentage":%i}' % (runid_out,status_out, percentage_out)
def get_new_connection(self, kwargs):
self.connectionFactory = kwargs.get( 'options' ) and kwargs.get( 'options' ).get( 'CONNECTION_FACTORY' ) or None
if self.connectionFactory:
con = self.connectionFactory.getConnection()
connection = PyConnection( con )
else:
host = kwargs.get( 'host' ) or 'localhost'
port = kwargs.get( 'port' ) and ( ':%s' % kwargs.get( 'port' )) or ''
DriverType = 4
kwargsKeys = kwargs.keys()
if kwargsKeys.__contains__( 'DriverType' ):
DriverType = kwargs['DriverType']
if DriverType == 4:
conn_string = "jdbc:db2://%s%s/%s" % ( host, port, kwargs.get( 'database' ) )
elif DriverType == 2:
conn_string = "jdbc:db2:%s" % ( kwargs.get( 'database' ) )
else:
raise ImproperlyConfigured( "Wrong Driver type" )
# for Setting default AUTO COMMIT off on connection.
autocommit = False
if kwargs.get( 'options' ) and kwargs.get( 'options' ).keys().__contains__( 'autocommit' ):
autocommit = kwargs.get( 'options' ).get( 'autocommit' )
del kwargs.get( 'options' )['autocommit']
connection = zxJDBC.connect( conn_string,
kwargs.get( 'user' ),
kwargs.get( 'password' ),
'com.ibm.db2.jcc.DB2Driver', kwargs.get( 'options' ) )
# To prevent dirty reads
self.__prevent_dirty_reads( connection )
connection.__connection__.setAutoCommit( autocommit )
return connection
def __init__(self, args):
self.logger = LoggerFactory.getLogger('jython script : ' +
self.__class__.__name__)
username = args[Constant.WH_DB_USERNAME_KEY]
password = args[Constant.WH_DB_PASSWORD_KEY]
JDBC_DRIVER = args[Constant.WH_DB_DRIVER_KEY]
JDBC_URL = args[Constant.WH_DB_URL_KEY]
self.db_id = args[Constant.JOB_REF_ID_KEY]
self.wh_etl_exec_id = args[Constant.WH_EXEC_ID_KEY]
self.conn_mysql = zxJDBC.connect(JDBC_URL, username, password,
JDBC_DRIVER)
self.conn_cursor = self.conn_mysql.cursor()
if Constant.INNODB_LOCK_WAIT_TIMEOUT in args:
lock_wait_time = args[Constant.INNODB_LOCK_WAIT_TIMEOUT]
self.conn_cursor.execute("SET innodb_lock_wait_timeout = %s;" %
lock_wait_time)
temp_dir = FileUtil.etl_temp_dir(args, "REDSHIFT")
self.input_table_file = os.path.join(
temp_dir, args[Constant.RED_SCHEMA_OUTPUT_KEY])
self.input_field_file = os.path.join(
temp_dir, args[Constant.RED_FIELD_OUTPUT_KEY])
self.logger.info(
"Load Redshift Metadata into {}, db_id {}, wh_exec_id {}".format(
JDBC_URL, self.db_id, self.wh_etl_exec_id))
def _cursor(self, settings):
set_tz = False
if self.connection is None:
set_tz = True
if settings.DATABASE_NAME == '':
from django.core.exceptions import ImproperlyConfigured
raise ImproperlyConfigured("You need to specify DATABASE_NAME in your Django settings file.")
host = settings.DATABASE_HOST or 'localhost'
port = settings.DATABASE_PORT and (':' + settings.DATABASE_PORT) or ''
conn_string = "jdbc:postgresql://%s%s/%s" % (host, port,
settings.DATABASE_NAME)
self.connection = Database.connect(conn_string,
settings.DATABASE_USER,
settings.DATABASE_PASSWORD,
'org.postgresql.Driver',
**self.options)
# make transactions transparent to all cursors
from java.sql import Connection
jdbc_conn = self.connection.__connection__
jdbc_conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED)
real_cursor = self.connection.cursor()
# setup the JDBC3 DataHandler and our data handler
real_cursor.datahandler = JDBC30DataHandler(DjangoDataHandler(real_cursor.datahandler))
cursor = CursorWrapper(real_cursor)
if set_tz:
# XXX: settings.TIME_ZONE could inject SQL
# Does it matter? If someone can edit settings.py, it already
# have the user and password!
cursor.execute("SET TIME ZONE %s" %
self.ops.quote_name(settings.TIME_ZONE))
return cursor
def __init__(self, args):
self.logger = LoggerFactory.getLogger('jython script : ' +
self.__class__.__name__)
username = args[Constant.WH_DB_USERNAME_KEY]
password = args[Constant.WH_DB_PASSWORD_KEY]
JDBC_DRIVER = args[Constant.WH_DB_DRIVER_KEY]
JDBC_URL = args[Constant.WH_DB_URL_KEY]
self.mp_gitli_project_file = args[Constant.GIT_PROJECT_OUTPUT_KEY]
self.product_repo_file = args[Constant.PRODUCT_REPO_OUTPUT_KEY]
self.product_repo_owner_file = args[
Constant.PRODUCT_REPO_OWNER_OUTPUT_KEY]
self.app_id = args[Constant.APP_ID_KEY]
self.wh_etl_exec_id = args[Constant.WH_EXEC_ID_KEY]
self.conn_mysql = zxJDBC.connect(JDBC_URL, username, password,
JDBC_DRIVER)
self.conn_cursor = self.conn_mysql.cursor()
if Constant.INNODB_LOCK_WAIT_TIMEOUT in args:
lock_wait_time = args[Constant.INNODB_LOCK_WAIT_TIMEOUT]
self.conn_cursor.execute("SET innodb_lock_wait_timeout = %s;" %
lock_wait_time)
self.logger.info(
"Load Multiproduct Metadata into {}, app_id {}, wh_exec_id {}".
format(JDBC_URL, self.app_id, self.wh_etl_exec_id))
def saveDDL(self):
try:
driver = "oracle.jdbc.driver.OracleDriver"
jdbc_url= "jdbc:oracle:thin:@"+self.connectserverip+":"+self.connectserverport+":"+self.connectservicename
driver = "cn.x.db.oracle.driver.wrapper.CommonDriver"
jdbc_url = "jdbc:oracle:thin:@192.168.192.135:1521:orcl?characterEncoding=utf-8"
connection = zxJDBC.connect(jdbc_url, self.connectusername, self.connectpassword, driver)
generator.normalizeArguments(connection)
cursor = connection.cursor()
sql=self.composeSQL()
if (self.argObjectInFile==""):
sql2=sql%(self.argOwner,"%")
cursor.execute(sql2)
#cursor.execute(sql, {'Owner':self.argOwner, 'ObjectName':"%"})
self.saveRowset(cursor)
else:
for object1 in self.objectList:
sql2=sql%(self.argOwner,object1)
cursor.execute(sql2)
#cursor.execute(sql, {'Owner':self.argOwner, 'ObjectName':object1})
self.saveRowset(cursor)
except Exception , ex:
print ex
def init(self, config):
"""servlet startup"""
self.props = self.read_dspace_config(DSPACE_DIR + '/config/dspace.cfg')
self.conn = zxJDBC.connect(
self.props.getProperty('db.url'),
self.props.getProperty('db.username'),
self.props.getProperty('db.password'),
self.props.getProperty('db.driver'),
)
self.conn.autocommit = True
self.cursor = self.conn.cursor()
self.client = self.read_orcid_config_db()
self.orcid_pattern = re.compile(r"^\d{4}-\d{4}-\d{4}-(\d{3}X|\d{4})$")
self.token_pattern = re.compile(
r"^[0-f]{8}-[0-f]{4}-[0-f]{4}-[0-f]{4}-[0-f]{12}$")
self.available_scopes = [
'/authenticate',
'/activities/update',
'/person/update',
'/read-limited',
'/read-public',
'/webhook',
]
self.available_envs = [
'sandbox',
'production',
]
self.logger = Logger.getLogger("orcid/auth.py")
self.logger.info("initialized")
def __init__(self, args):
username = args[Constant.WH_DB_USERNAME_KEY]
password = args[Constant.WH_DB_PASSWORD_KEY]
jdbc_driver = args[Constant.WH_DB_DRIVER_KEY]
jdbc_url = args[Constant.WH_DB_URL_KEY]
conn_mysql = zxJDBC.connect(jdbc_url, username, password, jdbc_driver)
cur = conn_mysql.cursor()
try:
query = "select distinct f.flow_id, f.flow_name, f.flow_group, ca.app_code from flow f join cfg_application ca on f.app_id = ca.app_id order by app_code, flow_name"
cur.execute(query)
flows = cur.fetchall()
self.flow_dict = dict()
for flow in flows:
current = self.flow_dict
# if needed, use flow[3].replace(' ', '.')
current = current.setdefault(flow[3], {})
if flow[2] is not None:
current = current.setdefault(flow[2], {})
# for oozie
else:
current = current.setdefault('NA', {})
current = current.setdefault(flow[1], {})
current["__ID_OF_FLOW__"] = flow[0]
self.file_name = args[Constant.FLOW_TREE_FILE_NAME_KEY]
self.value = []
finally:
cur.close()
conn_mysql.close()
def __init__(self, args):
self.logger = LoggerFactory.getLogger('jython script : ' +
self.__class__.__name__)
username = args[Constant.WH_DB_USERNAME_KEY]
password = args[Constant.WH_DB_PASSWORD_KEY]
JDBC_DRIVER = args[Constant.WH_DB_DRIVER_KEY]
JDBC_URL = args[Constant.WH_DB_URL_KEY]
self.database_scm_repo_file = args[
Constant.DATABASE_SCM_REPO_OUTPUT_KEY]
self.app_id = args[Constant.APP_ID_KEY]
self.wh_etl_exec_id = args[Constant.WH_EXEC_ID_KEY]
self.conn_mysql = zxJDBC.connect(JDBC_URL, username, password,
JDBC_DRIVER)
self.conn_cursor = self.conn_mysql.cursor()
if Constant.INNODB_LOCK_WAIT_TIMEOUT in args:
lock_wait_time = args[Constant.INNODB_LOCK_WAIT_TIMEOUT]
self.conn_cursor.execute("SET innodb_lock_wait_timeout = %s;" %
lock_wait_time)
self.logger.info(
"Load Code Search CSV into {}, app_id {}, wh_exec_id {}".format(
JDBC_URL, self.app_id, self.wh_etl_exec_id))
def get_pass(uuid):
conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
curs = conn.cursor()
curs.execute("SELECT pass FROM secret WHERE uuid = ?", (uuid,))
results = curs.fetchall()
curs.close()
conn.close()
return results[0][0]
def saveConnection(args):
if len(args) != 1:
usage()
fileName = args[0]
con = zxJDBC.connect(*CONNECT_ARGS)
cur = con.cursor()
cur.execute("select * from Plant_DB order by p_name")
save(con, fileName)
def create_pass_thread(uuid, pw):
pw = crypt.encrypt(pw, rounds=200000, salt_size=16)
conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
curs = conn.cursor()
curs.execute("INSERT INTO secret VALUES (?,?)", (uuid,pw,))
conn.commit()
curs.close()
conn.close()
def delete_pass(uuid):
conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass,
"com.mysql.jdbc.Driver")
curs = conn.cursor()
curs.execute("DELETE FROM secret WHERE uuid = ?", (uuid, ))
conn.commit()
curs.close()
conn.close()
def execute_query(query, uuid):
conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
curs = conn.cursor()
curs.execute(query, (uuid,))
results = curs.fetchall()
curs.close()
conn.close()
return results
def execute_update(update, uuid):
conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass,
"com.mysql.jdbc.Driver")
curs = conn.cursor()
curs.execute(update, (uuid, ))
conn.commit()
curs.close()
conn.close()
def __init__(self, args):
self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
args[Constant.WH_DB_USERNAME_KEY],
args[Constant.WH_DB_PASSWORD_KEY],
args[Constant.WH_DB_DRIVER_KEY])
self.wh_cursor = self.wh_con.cursor()
self.app_id = int(args[Constant.APP_ID_KEY])
def __init__(self, args):
self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
args[Constant.WH_DB_USERNAME_KEY],
args[Constant.WH_DB_PASSWORD_KEY],
args[Constant.WH_DB_DRIVER_KEY])
self.wh_cursor = self.wh_con.cursor()
self.app_id = int(args[Constant.JOB_REF_ID_KEY])
def __init__(self, args):
self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
self.elasticsearch_index_url = args[Constant.WH_ELASTICSEARCH_URL_KEY]
self.elasticsearch_port = args[Constant.WH_ELASTICSEARCH_PORT_KEY]
self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
args[Constant.WH_DB_USERNAME_KEY],
args[Constant.WH_DB_PASSWORD_KEY],
args[Constant.WH_DB_DRIVER_KEY])
self.wh_cursor = self.wh_con.cursor()
def __init__(self, args):
self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
args[Constant.WH_DB_USERNAME_KEY],
args[Constant.WH_DB_PASSWORD_KEY],
args[Constant.WH_DB_DRIVER_KEY])
self.wh_cursor = self.wh_con.cursor()
self.wh_exec_id = long(args[Constant.WH_EXEC_ID_KEY])
self.app_folder = args[Constant.WH_APP_FOLDER_KEY]
def __init__(self, args):
self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
self.elasticsearch_index_url = args[Constant.WH_ELASTICSEARCH_URL_KEY]
self.elasticsearch_port = args[Constant.WH_ELASTICSEARCH_PORT_KEY]
self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
args[Constant.WH_DB_USERNAME_KEY],
args[Constant.WH_DB_PASSWORD_KEY],
args[Constant.WH_DB_DRIVER_KEY])
self.wh_cursor = self.wh_con.cursor(1)
def db_connect(self, init=False):
if init or (datetime.now() - self.connect_time
).total_seconds() > self.connection_interval:
if self.conn_hms:
self.conn_hms.close()
self.conn_hms = zxJDBC.connect(self.jdbc_url, self.username,
self.password, self.jdbc_driver)
self.logger.info("Connected to Hive metadata-store DB")
self.connect_time = datetime.now()
def execute_query(query, uuid):
conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass,
"com.mysql.jdbc.Driver")
curs = conn.cursor()
curs.execute(query, (uuid, ))
results = curs.fetchall()
curs.close()
conn.close()
return results
def get_pass(uuid):
conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass,
"com.mysql.jdbc.Driver")
curs = conn.cursor()
curs.execute("SELECT pass FROM secret WHERE uuid = ?", (uuid, ))
results = curs.fetchall()
curs.close()
conn.close()
return results[0][0]
def getDbConnection(self):
driver = "org.gjt.mm.mysql.Driver"
jdbc_url = "jdbc:mysql://localhost/sapdb?useUnicode=yes&characterEncoding=utf-8"
username = "******"
password = ""
conn = zxJDBC.connect(jdbc_url, username, password, driver)
return conn
def get_website_data(player):
conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
curs = conn.cursor()
uuid = str(uid(player)).replace("-", "")
curs.execute("SELECT DISTINCT `id`, `email` FROM users WHERE `uuid` = ? LIMIT 1", (uuid,))
results = curs.fetchall()
curs.close()
conn.close()
return ("http://redstoner.com/users/%s" % results[0][0], results[0][1]) if results else (None, None)
def async_query_t(mysql_database,query,query_args,target,target_args,target_kwargs):
db_conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
db_curs = db_conn.cursor()
db_curs.execute(query,query_args)
db_conn.commit()
fetchall = db_curs.fetchall()
db_curs.close()
db_conn.close()
target(fetchall,target_args,target_kwargs)
def async_query_t(mysql_database,query,query_args,target,target_args,target_kwargs):
db_conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass, "com.mysql.jdbc.Driver")
db_curs = db_conn.cursor()
db_curs.execute(query,query_args)
db_conn.commit()
fetchall = db_curs.fetchall()
db_curs.close()
db_conn.close()
target(fetchall,target_args,target_kwargs)
def __init__(self, args, scheduler_type):
self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
self.app_id = int(args[Constant.APP_ID_KEY])
self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
args[Constant.WH_DB_USERNAME_KEY],
args[Constant.WH_DB_PASSWORD_KEY],
args[Constant.WH_DB_DRIVER_KEY])
self.wh_cursor = self.wh_con.cursor()
self.app_folder = args[Constant.WH_APP_FOLDER_KEY]
self.metadata_folder = self.app_folder + "/" + str(scheduler_type) + "/" + str(self.app_id)
def __init__(self, args, scheduler_type):
self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
self.app_id = int(args[Constant.APP_ID_KEY])
self.wh_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
args[Constant.WH_DB_USERNAME_KEY],
args[Constant.WH_DB_PASSWORD_KEY],
args[Constant.WH_DB_DRIVER_KEY])
self.wh_cursor = self.wh_con.cursor()
self.app_folder = args[Constant.WH_APP_FOLDER_KEY]
self.metadata_folder = self.app_folder + "/" + str(scheduler_type) + "/" + str(self.app_id)
def __init__(self):
self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
username = args[Constant.HIVE_METASTORE_USERNAME]
password = args[Constant.HIVE_METASTORE_PASSWORD]
jdbc_driver = args[Constant.HIVE_METASTORE_JDBC_DRIVER]
jdbc_url = args[Constant.HIVE_METASTORE_JDBC_URL]
self.conn_hms = zxJDBC.connect(jdbc_url, username, password, jdbc_driver)
self.curs = self.conn_hms.cursor()
dependency_instance_file = args[Constant.HIVE_DEPENDENCY_CSV_FILE_KEY]
self.instance_writer = FileWriter(dependency_instance_file)
def __init__(self):
self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
username = args[Constant.HIVE_METASTORE_USERNAME]
password = args[Constant.HIVE_METASTORE_PASSWORD]
jdbc_driver = args[Constant.HIVE_METASTORE_JDBC_DRIVER]
jdbc_url = args[Constant.HIVE_METASTORE_JDBC_URL]
self.conn_hms = zxJDBC.connect(jdbc_url, username, password, jdbc_driver)
self.curs = self.conn_hms.cursor()
dependency_instance_file = args[Constant.HIVE_DEPENDENCY_CSV_FILE_KEY]
self.instance_writer = FileWriter(dependency_instance_file)
def get_new_connection(self, conn_params):
connection = self.get_new_jndi_connection()
if not connection:
connection = zxJDBC.connect(self.get_jdbc_connection_url(),
conn_params['USER'],
conn_params['PASSWORD'],
self.jdbc_driver_class_name,
**conn_params['OPTIONS'])
self._set_default_isolation_level(connection)
return connection
def change_pass(uuid, pw):
conn = zxJDBC.connect(mysql_database, mysql_user, mysql_pass,
"com.mysql.jdbc.Driver")
curs = conn.cursor()
curs.execute("UPDATE secret SET pass = ? WHERE uuid = ?", (
pw,
uuid,
))
conn.commit()
curs.close()
conn.close()
def __init__(self, dsURL, user, password, dsDriver):
self.dsURL = dsURL
self.user = user
self.password = password
self.dsDriver = dsDriver
try:
self.connection = zxJDBC.connect(self.dsURL, self.user,
self.password, self.dsDriver)
except Exception, e:
print e
def createTables(iTable):
cnxn = zxJDBC.connect(jdbc_url, username, password, driver_class)
crsr = cnxn.cursor()
execTab = "CREATE TABLE " + nameTable + str(
iTable + 1
) + " (ID INT NOT NULL PRIMARY KEY, FIO CHAR(200) NOT NULL, nameSup CHAR(200) NOT NULL, DT DATE NOT NULL, mark BIT DEFAULT 0 NOT NULL)"
listLog.append(execTab)
print(str(iTable + 1) + ")Создана таблица запросом: " + execTab)
crsr.execute(execTab)
crsr.close()
cnxn.commit()
cnxn.close()
def init_db_conn(connect_string, username, passwd):
"""initializes db connections"""
global _CONN
if not _CONN:
global _CONNECT_STRING
global _USERNAME
global _PASSWD
_CONNECT_STRING = connect_string
_USERNAME = username
_PASSWD = passwd
dbinfo = connect_string
try:
if USE_JYTHON:
print(dbinfo)
_CONN = zxJDBC.connect(connect_string, username, passwd, 'com.informix.jdbc.IfxDriver')
else:
(dbname, dbuser, _) = connect_string.split('/', 3)
dbinfo = 'db: %s:%s' % (dbname, dbuser)
try:
_CONN = odbc.odbc(connect_string)
print(dbinfo)
except KeyboardInterrupt:
raise
except:
ex = sys.exc_info()
s = 'Exception: %s: %s\n%s' % (ex[0], ex[1], dbinfo)
print(s)
return None
return _CONN
