Python ChorusGlobals.get_logger方法代码示例

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
def execute_sql_dict(sql, db_handler = None, keep_connection = True):
    '''execute sql and return a dict format data'''
    try:
        data = []
        datadict=[]
        if db_handler:
            conn = db_handler
        else:
            if "default_handler" in globals().keys():
                conn = default_handler
            else:
                keep_connection = False
                conn = __init_connection(db_info)
        cursor = conn.cursor()
        ChorusGlobals.get_logger().info("Execute SQL '%s'" % sql)
        cursor.execute(sql)
        for row in cursor:
            data.append(row)
        for row in data:
            rid=data.index(row)
            celldict={}
            for i in range(len(row)):
                celldict[cursor.column_names[i]]=row[i]
            datadict.append(celldict)
        conn.commit()
        
    except Exception, e:
        traceback.print_exc()
        ChorusGlobals.get_logger().critical("Errors in sql execution: %s" % e)
        raise Exception("Errors in sql execution: %s" % e)

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
def close_connection(db_handler = None):
    if not db_handler:
        db_handler = default_handler
    cursor = db_handler.cursor()   
    cursor.close()
    db_handler.close()
    ChorusGlobals.get_logger().info("close mysql connection")

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
 def generate_json(detail):
     try:
         finaldetail = Utils.parse_description(detail) if type(detail)==str else detail
         jsdata = json.dumps(finaldetail)
     except Exception,e:
         message = "The input detail cannot be transfer into json type, error is %s" % str(e)
         ChorusGlobals.get_logger().warning(message)
         jsdata = json.dumps({"message":message})

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
 def add(cls, name, detail, time_taken, timeout=30):
     status = True if time_taken <= timeout else False
     if not status:
         cls.status = False
         cls.failed += 1
     else:
         cls.passed += 1
     js_detail = cls.generate_json(detail)
     cls.data.append(Performance_Object(name, status, js_detail, time_taken, timeout))
     ChorusGlobals.get_logger().info("Add Performance Result %s, status %s, time_taken %s" % (name, status, str(time_taken)))
     cls.number += 1

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
def __init_connection(connection):
    host = connection["host"]
    port = connection["port"]
    user = connection["username"]
    passwd = connection["password"]
    database = connection["database"]
    db_handler = mysql.connector.connect(host = host,
                                   port = int(port),
                                   user = user,
                                   passwd = passwd,
                                   database = database)
    ChorusGlobals.get_logger().info("start mysql connection")
    return db_handler

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
def execute_sql(sql, db_info):
    '''execute sql and return a list format data'''
    try:
        data = []
        conn_info = __get_db_info(db_info)
        print conn_info
        conn = __init_connection(conn_info)
        cursor = conn.cursor()            
        cursor.execute(sql)
        for row in cursor:
            data.append(row) 
        conn.commit()
                      
    except Exception, e:
        ChorusGlobals.get_logger().critical("Errors in sql execution: %s" % e)
        raise Exception("Errors in sql execution: %s" % e)

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
 def setUpClass(cls):        
     '''
     setUpClass is executed every time before run a test suite
     '''
     suite_dependency = cls.get_suite_dependency()
     if len(suite_dependency) > 0:
         suites = ChorusGlobals.get_testresult().suites
         mapping = {}
         for key, value in suites.iteritems():
             mapping[key] = value.statusflag
         for d in suite_dependency:
             if mapping.has_key(d) and not mapping[d]:
                 raise Exception("Has failed dependency test suite %s" %(str(d)))   
     cls.suite_starttime = time.time() 
     cls.logserver = ChorusGlobals.get_logserver()
     cls.logserver.flush_console()
     super(MyTestCase,cls).setUpClass()
     cls.logger = ChorusGlobals.get_logger()
     cls.suite_name = Utils.get_current_classname(cls)
     ChorusGlobals.set_current_suitename(cls.suite_name)
     from VerificationManagement import VerificationManagement
     cls.vm = VerificationManagement()
     cls.result = cls.vm.check_suitebaseline(cls.suite_name)
     cls.result.description = Utils.parse_description(cls.__doc__)
     cls.timestamp = Utils.get_timestamp()
     cls.config = ChorusGlobals.get_configinfo()
     cls.parameters = ChorusGlobals.get_parameters()

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
 def __init__(self):
     self.suite_dict = ChorusGlobals.get_suitedict()
     self.logger = ChorusGlobals.get_logger()
     self.configinfo = ChorusGlobals.get_configinfo()
     self.baseline_path = ChorusGlobals.get_baselinepath()
     self.outputdir = ChorusGlobals.get_outputdir()
     self.result = ChorusGlobals.get_testresult()
     self.known_issue_list = ChorusGlobals.get_knownissuelist()

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
def __get_db_info(db_info):
    parameters = ChorusGlobals.get_parameters()
    try:
        db_config = parameters[db_info]

        connection = {
                      "host": db_config['addr'],
                      "port": db_config['port'],
                      "username": db_config['username'],
                      "password": db_config['password'],
                      "database": db_config['database']
                      }

        return connection
    except Exception,e:
        ChorusGlobals.get_logger().critical("The %s in config file is not correctly configured, errors: %s" % (db_info,str(e)))
        raise Exception("The %s in config file is not correctly configured, errors: %s" % (db_info,str(e)))

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
 def __init__(self):
     self.logger = ChorusGlobals.get_logger()
     self.suiteinfo = ChorusGlobals.get_suiteinfo()
     self.set_baselinepath()
     self.suite_dict = self.get_test_mapping()
     self.filter_test_mapping()
     self.set_scope()
     self.get_testsuites()

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
def get_parameters(*args):
    import ChorusGlobals
    parameters = ChorusGlobals.get_parameters()
    result = None
    if parameters.has_key(args[0]):
        result = parameters[args[0]]
    if len(args)==1:
        return result    
    for path in args[1:]:
        if result:
            if result.has_key(path):
                result = result[path]
            else:
                result = None
    if not result:
        ChorusGlobals.get_logger().warning("No value retrieved for path %s" % str(args))
    return result

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
 def __init__(self, imga, imgb, lb=1, tol=15):
     """Store the images in the instance."""
     self.logger = ChorusGlobals.get_logger()
     sizea, sizeb = imga.size, imgb.size
     if sizea != sizeb: #sizea=sizeb in most cases  
         newx = min(sizea[0], sizeb[0])
         newy = min(sizea[1], sizeb[1])
         
         ''' Rescale to a common size:'''
         imga = imga.resize((newx, newy), Image.ANTIALIAS)
         imgb = imgb.resize((newx, newy), Image.ANTIALIAS)
     self._imga, self._imgb, self._lb, self._tol = imga, imgb, lb, tol

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
def set_base_db_info(db_config, keep_connection = True):
    global db_info
    try:
        db_info = {
                    "host": db_config['db_addr'],
                    "port": db_config['db_port'],
                    "username": db_config['db_username'],
                    "password": db_config['db_password'],
                    "database": db_config['db_database']
                  }
        if keep_connection:
            db_handler = __init_connection(db_info)
            global default_handler
            default_handler = db_handler
            return db_handler
        else:
            return None
    except Exception, e:
        traceback.print_exc()
        ChorusGlobals.get_logger().critical("Errors %s in db_info format: %s" % (str(e),str(db_info)))
        raise Exception("Errors %s in db_info format: %s" % (str(e),str(db_info)))

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
 def __init__(self):
     self.job = "Test Result"
     self.startuser = "Start by N/A"
     self.joblink = ""
     self.starttime = 0
     self.duration = 0
     self.htmllink = ""
     self.consolelink = ""
     self.knownissueflag = False
     self.machine_name = ""
     self.suites={}
     self.logger = ChorusGlobals.get_logger()

# 需要导入模块: import ChorusGlobals [as 别名]
# 或者: from ChorusGlobals import get_logger [as 别名]
def execute_sql_dict(sql,db_info):
    '''execute sql and return a dict format data'''
    try:
        data = []
        datadict=[]
        conn_info = __get_db_info(db_info)
        conn = __init_connection(conn_info)
        cursor = conn.cursor()            
        cursor.execute(sql)
        for row in cursor:
            data.append(row)
        for row in data:
            rid=data.index(row)
            celldict={}
            for i in range(len(row)):
                celldict[cursor.column_names[i]]=row[i]
            datadict.append(celldict)
        conn.commit()
                      
    except Exception, e:
        ChorusGlobals.get_logger().critical("Errors in sql execution: %s" % e)
        raise Exception("Errors in sql execution: %s" % e)