Esempio n. 1
0
 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() ) 
Esempio n. 2
0
 def __init__(self, jConnection):
     """
        @type: java.sql.Connection or com.hp.ucmdb.discovery.probe.util.DiscoveryProbeDbConnection
     """
     assert jConnection, 'Connection should not be None'
     wrapper = self.__getJdbcConnection(jConnection)
     connection = PyConnection(wrapper)
     self._cursor = connection.cursor()
     self.queryCount = 0
Esempio n. 3
0
 def __init__(self, jConnection):
     """
        @type: java.sql.Connection or com.hp.ucmdb.discovery.probe.util.DiscoveryProbeDbConnection
     """
     assert jConnection, 'Connection should not be None'
     wrapper = self.__getJdbcConnection(jConnection)
     connection = PyConnection(wrapper)
     self._cursor = connection.cursor()
     self.queryCount = 0
Esempio n. 4
0
 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
Esempio n. 5
0
File: jdbc.py Progetto: iacxc/Misc
    def __init__(self, url, options):
        classpath = os.getenv('CLASSPATH')

        if getattr(options, 'classpath', None) is not None:
            if classpath:
                classpath = ':'.join([classpath,  options.classpath])
            else:
                classpath = options.classpath

        if classpath:
            for path in classpath.split(':'):
                if not path in sys.path:
                    sys.path.append(path)

        try:
            import importlib

            Driver = importlib.import_module(options.driver)
        except ImportError:
            raise DriverNotFound('Cannot import %s, please check CLASSPATH' %
                                  options.driver)

        props = java.util.Properties()
        for attr in ('user', 'password'):
            if hasattr(options, attr):
                props.put(attr, getattr(options, attr))
        if hasattr(options, 'dsn'):
            props.put('serverDataSource', options.dsn)

        db = Driver().connect(url, props)

        self.__conn = PyConnection(db)
Esempio n. 6
0
def getDBConnection(userName, password, driverName, connectionURL):
    """
    Return PyConnection to the database (see Jython's zxJDBC description)
    @param userName: the username to connect to DB with
    @param password: the password to connect to DB with
    @param driverName: name of the driver to connect through
    @return: com.ziclix.python.sql.PyConnection
    """
    jdbcDriver = Class.forName(
        driverName, 1,
        Thread.currentThread().getContextClassLoader()).newInstance()
    props = Properties()
    props.put('user', userName)
    props.put('password', password)
    return PyConnection(jdbcDriver.connect(connectionURL, props))
Esempio n. 7
0
File: jdbc.py Progetto: iacxc/Misc
class JDBCConnection(object):
    def __init__(self, url, options):
        classpath = os.getenv('CLASSPATH')

        if getattr(options, 'classpath', None) is not None:
            if classpath:
                classpath = ':'.join([classpath,  options.classpath])
            else:
                classpath = options.classpath

        if classpath:
            for path in classpath.split(':'):
                if not path in sys.path:
                    sys.path.append(path)

        try:
            import importlib

            Driver = importlib.import_module(options.driver)
        except ImportError:
            raise DriverNotFound('Cannot import %s, please check CLASSPATH' %
                                  options.driver)

        props = java.util.Properties()
        for attr in ('user', 'password'):
            if hasattr(options, attr):
                props.put(attr, getattr(options, attr))
        if hasattr(options, 'dsn'):
            props.put('serverDataSource', options.dsn)

        db = Driver().connect(url, props)

        self.__conn = PyConnection(db)

    def cursor(self):
        return self.__conn.cursor()

    def get_tables(self, catalog, schema='%', table='%'):
        cursor = self.cursor()
        cursor.tables(catalog, schema, table, ['TABLE'])

        return cursor.fetchall()

    def get_columns(self, catalog, schema='%', table='%', column='%'):
        cursor = self.cursor()
        cursor.columns(catalog, schema, table, column)

        return cursor.fetchall()
Esempio n. 8
0
 def process(self, millis):
     conn = PyConnection(self.ds.getConnection())
     c = conn.cursor()
     try:
         c.execute("insert into dataservice.py_script_heartbeat(beat,demo) values (%d,'%s')" % (millis, 'nonse'))
         conn.commit()
     finally:
         if c: c.close()
         if conn: conn.close()
     #self.log.info(self.name + ': success')
     return 'success'
Esempio n. 9
0
    def tick(self):
        for phrase in self.sql:
            self.startQueryCycle(phrase["id"])
            preparedStatementParams = []
            preparedStatementParamsDict = {}
            logger.info(phrase["statement"])
            numrows = 0
            conn = PyConnection(self.datasource.getConnection())
            try:
                with conn.cursor(1) as cursor:
                    #TODO: review, index out of range very possible
                    if "parameter" in phrase:
                        logger.debug("Dude, got parameters!!")
                        for parameter in phrase["parameter"]:
                            strlist = parameter.split("$cycle.")
                            if len(strlist) > 0:
                                if strlist[1] in ["qend","qstart","qlaststart","qenddt","qstartdt","qlaststartdt","qelapsed"]:
                                    value = self.getQueryParameter(phrase["id"], strlist[1])
                                    if value == None:
                                        logger.debug("Dude, couldn't fetch local parameter %s = %s, going global", parameter, value)
                                        value = self.getCycleProperty(strlist[1][1:])
                                    preparedStatementParams.append(value)
                                    preparedStatementParamsDict[parameter] = value
                                    logger.debug("Dude, got local parameter %s = %s", parameter, value)
                                else:
                                    value = self.getCycleProperty(strlist[1])
                                    if value == None:
                                        value = phrase[strlist[1]]
                                    preparedStatementParams.append(value)
                                    preparedStatementParamsDict[parameter] = value
                                    logger.debug("Dude, got global parameter %s = %s", parameter, value)
                                logger.debug(strlist[1])
                    logger.debug("Dude, preparing statement: %s", phrase["id"])
                    query = cursor.prepare(phrase["statement"])
                    logger.debug("Dude, executing statement: %s", phrase["id"])
                    cursor.execute(query, preparedStatementParams)
                    row = None
                    logger.debug("Dude, starting fetch for statement: %s", phrase["id"])
                    if cursor.description != None:
                        fields = [i[0] for i in cursor.description]
                        row = cursor.fetchone()
                    else:
                        fields = []
                        conn.commit()
                        self.processData({ '@timestamp':self.getQueryParameter(phrase["id"], "qstart"), "statement": phrase["statement"], "parameters": preparedStatementParamsDict } )
                        #TODO: process data with commit timestamp and whatnot
                    while row is not None:
                        idx = 0
                        out = {}
                        rowDict = {}
                        metrics = {}
                        terms = {}
                        for field in fields:
                            if isinstance(row[idx], str):
                                if self.getInputProperty("ignoreFieldIfEmptyString") and len(row[idx]) == 0:
                                    logger.warning("Ignoring key %s due to empty value", field)
                                else:
                                    rowDict[field] = row[idx]
                            elif isinstance(row[idx], unicode):
                                if self.getInputProperty("ignoreFieldIfEmptyString") and len(row[idx]) == 0:
                                    logger.warning("Ignoring key %s due to empty value", field)
                                else:
                                    rowDict[field] = row[idx]
                            else:
                                rowDict[field] = row[idx]
                            idx = idx + 1
                        for key in rowDict:
                            if key in self.metrics:
                                metrics[key] = rowDict[key]
                            elif key in self.terms:
                                terms[key] = rowDict[key]
                            else:
                                out[key] = rowDict[key]
                        self.processData(out)
                        for key in metrics:
                            try:
                                out["metric"] = key
                                if self.getInputProperty("decimalMark"):
                                    metrics[key] = metrics[key].replace(self.getInputProperty("decimalMark"), ".")
                                out["value"] = float(metrics[key])
                                self.processData(out)
                            except Exception, ex:
                                logger.warning("Failure to parse %s as float for metric %s", key, metrics[key])
                        #self.processData(out)
                        if 'value' in out:
                            del out['value']
                        for key in terms:
                            out["metric"] = key
                            out["term"] = str(terms[key])
                            self.processData(out)

                        row = cursor.fetchone()
                    query.close()
                    assert query.closed
            except Exception, ex:
                logger.debug("\n     _           _      _ \n  __| |_   _  __| | ___| |\n / _` | | | |/ _` |/ _ \ |\n| (_| | |_| | (_| |  __/_|\n \__,_|\__,_|\__,_|\___(_)\n")
                logger.debug(ex)
                raise
            finally: