Python Log 예제들

예제 #1

파일: LoginDao.py 프로젝트: jessica-wong/engineering

# -*- coding: utf-8 -*-

import inspect
from src.main.master.util.dbUtil.dbBaseHelper import DbBaseHelper
from src.main.master.util.logUtil.log import Log
from src.main.master.common.constants import SystemConfig
from src.main.master.mapping.LoginMapper import LoginSQLMapper

#set log
logger = Log('LoginDao')
logger.write_to_file(SystemConfig.logPathPrefix + "LoginDao.log")


class LoginDaoInterface:
    def getUserInfo(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = LoginSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.read()

예제 #2

# -*- coding: utf-8 -*-

import sys
import requests
import json
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.core.AdminDecorator import AdminDecoratorServer
from src.main.master.entity.DataResult import DataResult
from src.main.master.dao.SessionManageDao import SessionManageDaoInterface

#content-type: multipart/form-data
#set log
logger = Log('requestUtil')
logger.write_to_file(SystemConfig.logPathPrefix + "requestUtil.log")


class RequestBase(object):
    def __init__(self,
                 url,
                 method="GET",
                 format="application/json",
                 params={},
                 timeout=1000,
                 object=None,
                 saveSession=False,
                 userId=None):
        self.url = url
        self.method = method
        self.format = format
        self.params = params

예제 #3

파일: DatabaseServiceImpl.py 프로젝트: jessica-wong/engineering

# -*- coding: utf-8 -*-

import json, itertools
from copy import deepcopy
import traceback
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult
from src.main.master.dao.DatabaseDao import DatabaseDaoInterface
from src.main.master.core.AdminDecorator import AdminDecoratorServer

#set log
logger = Log('DatabaseServiceImpl')
logger.write_to_file(SystemConfig.logPathPrefix + "DatabaseServiceImpl.log")

#新建和编辑做非空校验


class DatabaseService(object):
    def __init__(self):
        self.DatabaseDaoInterface = DatabaseDaoInterface()

    @AdminDecoratorServer.execImplDecorator()
    def addDatabase(self, args):
        result = self.DatabaseDaoInterface.addDatabase(args)
        # todo 要处理，用事务,none判断
        # 添加默认表分组
        db_id = result.getMessage()
        group_dict = {}
        group_dict["db_id"] = db_id
        group_dict["name"] = "未分组"

예제 #4

# -*- coding: utf-8 -*-

import inspect
from src.main.master.util.dbUtil.dbBaseHelper import DbBaseHelper
from src.main.master.util.logUtil.log import Log
from src.main.master.common.constants import SystemConfig
from src.main.master.mapping.TestCaseInstanceMapper import TestInstanceSQLMapper

#set log
logger = Log('TestCaseInstanceDao')
logger.write_to_file(SystemConfig.logPathPrefix + "TestCaseInstanceDao.log")


class TestCaseInstanceDaoInterface:
    def addTestInstance(self, args):
        logger.info(inspect.stack()[0][3])
        sql = TestInstanceSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.write()

    def getTestInstanceInfoById(self, args):
        logger.info(inspect.stack()[0][3])
        sql = TestInstanceSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.read()

    def updateTestInstance(self, args):
        logger.info(inspect.stack()[0][3])
        sql = TestInstanceSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.write()

예제 #5

파일: TaskCenterServiceImpl.py 프로젝트: jessica-wong/engineering

from src.main.master.core.AdminDecorator import AdminDecoratorServer
from src.main.master.dao.TestCaseInstanceDao import TestCaseInstanceDaoInterface
from src.main.master.dao.TestSuiteDao import TestSuiteDaoInterface
from src.main.master.dao.TestCaseDao import TestCaseDaoInterface
from src.main.master.dao.CaseContentDao import CaseContentDaoInterface
from src.main.master.dao.AssertDao import AssertDaoInterface
from src.main.master.dao.CaseResultDao import CaseResultDaoInterface
from src.main.master.dao.EnvironmentDao import EnvironmentDaoInterface
from operator import attrgetter
from src.main.master.util.requestUtil.httpRequestUtil import RequestBase
from src.main.master.util.dbUtil.dbBaseHelper import DbBaseHelper
from src.main.master.util.assertUtil.assertUtil import AssertInstance
from src.main.master.service.impl.AssertServiceImpl import AssertService

#set log
logger = Log('TaskCenterServiceImpl')
logger.write_to_file(SystemConfig.logPathPrefix + "TaskCenterServiceImpl.log")

#global
pool = threadpool.ThreadPool(20)


class TaskCenterService(object):
    def __init__(self):
        pass

    #2
    @staticmethod
    @AdminDecoratorServer.execImplDecorator()
    def __sendTaskJob(taskInfo):
        #set task queue status is send

예제 #6

import json
import traceback
import tornado.web
import tornado.gen
from tornado.concurrent import run_on_executor
from concurrent.futures import ThreadPoolExecutor
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult
from src.main.master.service.impl.GroupServiceImpl import GroupService
from src.main.master.util.jsonUtil.JsonUtil import CJsonEncoder
from src.main.master.core.AdminDecorator import AdminDecoratorServer

#set log
logger = Log('GroupController')
logger.write_to_file(SystemConfig.logPathPrefix + "GroupController.log")


class GroupHandler(tornado.web.RequestHandler):
    executor = ThreadPoolExecutor(30)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self, APIName):
        yield self.execute_get(APIName)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def post(self, APIName):
        yield self.execute_post(APIName)

예제 #7

파일: WebApiDao.py 프로젝트: jessica-wong/mytools

# -*- coding: utf-8 -*-

import inspect
from src.main.master.util.dbUtil.dbBaseHelper import DbBaseHelper
from src.main.master.util.logUtil.log import Log
from src.main.master.common.constants import SystemConfig
from src.main.master.mapping.WebApiMapper import WebApiSQLMapper

#set log
logger = Log('WebApiDao')
logger.write_to_file(SystemConfig.logPathPrefix + "WebApiDao.log")


class WebApiDaoInterface:
    def addWebApi(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = WebApiSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.write()

    def getWebApiForVersion(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = WebApiSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.read()

    def deleteWebApi(self, args):
        logger.info(inspect.stack()[0][3])
        sql = WebApiSQLMapper().getSQL(inspect.stack()[0][3])

예제 #8

# -*- coding: utf-8 -*-

from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.dao.TestCaseInstanceDao import TestCaseInstanceDaoInterface
from src.main.master.core.AdminDecorator import AdminDecoratorServer

#set log
logger = Log('TestCaseInstanceServiceImpl')
logger.write_to_file(SystemConfig.logPathPrefix +
                     "TestCaseInstanceServiceImpl.log")


class TestCaseInstanceService(object):
    def __init__(self):
        self.testCaseInstanceDaoInterface = TestCaseInstanceDaoInterface()

    @AdminDecoratorServer.execImplDecorator()
    def addTestInstance(self, args):
        if "triggerType" not in args:
            args.setdefault("triggerType", 0)
        return self.testCaseInstanceDaoInterface.addTestInstance(args)

    @AdminDecoratorServer.execImplDecorator()
    def getTestInstanceInfoById(self, instanceId):
        args = {}
        args.setdefault("instanceId", instanceId)
        return self.testCaseInstanceDaoInterface.getTestInstanceInfoById(args)

    @AdminDecoratorServer.execImplDecorator()
    def updateTestInstance(self, args):

예제 #9

# -*- coding: utf-8 -*-

import inspect
from src.main.master.util.dbUtil.dbBaseHelper import DbBaseHelper
from src.main.master.util.logUtil.log import Log
from src.main.master.common.constants import SystemConfig
from src.main.master.mapping.CaseResultMapper import CaseResultSQLMapper

#set log
logger = Log('CaseResultDao')
logger.write_to_file(SystemConfig.logPathPrefix + "CaseResultDao.log")


class CaseResultDaoInterface:
    def addCaseResult(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = CaseResultSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.write()

    def getCaseResultInfoByCaseId(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = CaseResultSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.read()

    def deleteCaseResult(self, args):
        logger.info(inspect.stack()[0][3])
        sql = CaseResultSQLMapper().getSQL(inspect.stack()[0][3])

예제 #10

파일: ApplicationServiceImpl.py 프로젝트: jessica-wong/engineering

# -*- coding: utf-8 -*-

import json
import traceback
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult
from src.main.master.dao.ApplicationDao import ApplicationDaoInterface
from src.main.master.core.AdminDecorator import AdminDecoratorServer

#set log
logger = Log('ApplicationServiceImpl')
logger.write_to_file(SystemConfig.logPathPrefix+"ApplicationServiceImpl.log")

class ApplicationService(object):

    def __init__(self):
        self.ApplicationDaoInterface = ApplicationDaoInterface()

    @AdminDecoratorServer.execImplDecorator()
    def addApplication(self,args):

        return self.ApplicationDaoInterface.addApplication(args)

    def addApplicationVersion(self,args):
        logger.info(args)
        return self.ApplicationDaoInterface.addApplicationVersion(args)

    def getApplicationList(self,userId):
        args={}
        args.setdefault("userId",userId)

예제 #11

파일: CommomController.py 프로젝트: jessica-wong/engineering

import tornado.web
import tornado.gen
from tornado.concurrent import run_on_executor
from concurrent.futures import ThreadPoolExecutor
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult
from src.main.master.service.impl.UserServiceImpl import UserService
from src.main.master.service.impl.ProjectServiceImpl import ProjectService
from src.main.master.service.impl.ApplicationServiceImpl import ApplicationService
from src.main.master.service.impl.TestCaseServiceImpl import TestCaseService
from src.main.master.util.jsonUtil.JsonUtil import CJsonEncoder
from src.main.master.core.AdminDecorator import AdminDecoratorServer

#set log
logger = Log('CommonController')
logger.write_to_file(SystemConfig.logPathPrefix + "CommonController.log")


class CommonHandler(tornado.web.RequestHandler):
    executor = ThreadPoolExecutor(30)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self, APIName):
        yield self.execute_get(APIName)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def post(self, APIName):
        yield self.execute_post(APIName)

예제 #12

파일: dbBaseUtil.py 프로젝트: jessica-wong/engineering

# -*- coding: utf-8 -*-

import sys
import pymysql
import pymysql.cursors
from src.main.master.common.constants import DbConfig,SystemConfig
from src.main.master.util.logUtil.log import Log

#set log
logger = Log('dbBaseUtil')
logger.write_to_file(SystemConfig.logPathPrefix +"dbBaseUtil.log")

#set
dbinfo ={'host':DbConfig.host,'user':DbConfig.user,'passwd':DbConfig.passwd,'db':DbConfig.db,'port' :DbConfig.port}

class Connection(object):
    """
    General mysql read/write class
    example:
    dbinfo = {
          'host': '127.0.0.1',
          'user': '******',
          'passwd': '123456',
          'db': 'testservice'
           }
    db = Connection(**dbinfo)

    """
    def __init__(self, autocommit = True,**kwargs):
        self.autocommit = autocommit
        if kwargs == None or len(kwargs) == 0:

예제 #13

파일: ProjectDao.py 프로젝트: jessica-wong/engineering

# -*- coding: utf-8 -*-

import inspect
from src.main.master.util.dbUtil.dbBaseHelper import DbBaseHelper
from src.main.master.util.logUtil.log import Log
from src.main.master.common.constants import SystemConfig
from src.main.master.mapping.ProjectMapper import ProjectSQLMapper

#set log
logger = Log('ProjectDao')
logger.write_to_file(SystemConfig.logPathPrefix + "ProjectDao.log")


class ProjectDaoInterface:
    def addProject(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = ProjectSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.write()

    def getProjectInfoByName(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = ProjectSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.read()

    def deleteProject(self, args):
        logger.info(inspect.stack()[0][3])
        sql = ProjectSQLMapper().getSQL(inspect.stack()[0][3])

예제 #14

파일: SessionManageDao.py 프로젝트: witskeeper/shareDDD

# -*- coding: utf-8 -*-

import inspect
from src.main.master.util.dbUtil.dbBaseHelper import DbBaseHelper
from src.main.master.util.logUtil.log import Log
from src.main.master.common.constants import SystemConfig
from src.main.master.mapping.SessionManageMapper import SessionManageSQLMapper

#set log
logger = Log('SessionManageDao')
logger.write_to_file(SystemConfig.logPathPrefix + "SessionManageDao.log")


class SessionManageDaoInterface:
    def addSession(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = SessionManageSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.write()

    def getSessionInfo(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = SessionManageSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.read()

    def updateSession(self, args):
        logger.info(inspect.stack()[0][3])
        sql = SessionManageSQLMapper().getSQL(inspect.stack()[0][3])

예제 #15

파일: GroupDao.py 프로젝트: witskeeper/shareDDD

# -*- coding: utf-8 -*-

import inspect
from src.main.master.util.dbUtil.dbBaseHelper import DbBaseHelper
from src.main.master.util.logUtil.log import Log
from src.main.master.common.constants import SystemConfig
from src.main.master.mapping.GroupMapper import GroupSQLMapper

#set log
logger = Log('GroupDao')
logger.write_to_file(SystemConfig.logPathPrefix + "GroupDao.log")


class GroupDaoInterface:
    def addParentGroup(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = GroupSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.write()

    def addChildGroup(self, args):
        logger.info(inspect.stack()[0][3])
        sql = GroupSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.write()

    def getGroupInfoByProjectId(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = GroupSQLMapper().getSQL(inspect.stack()[0][3])

예제 #16

파일: DatabaseController.py 프로젝트: witskeeper/shareDDD

import json
import traceback
import tornado.web
import tornado.gen
from tornado.concurrent import run_on_executor
from concurrent.futures import ThreadPoolExecutor
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult
from src.main.master.service.impl.DatabaseServiceImpl import DatabaseService
from src.main.master.util.jsonUtil.JsonUtil import CJsonEncoder
from src.main.master.core.AdminDecorator import AdminDecoratorServer

#set log
logger = Log('DatabaseController')
logger.write_to_file(SystemConfig.logPathPrefix + "DatabaseController.log")


class DatabaseHandler(tornado.web.RequestHandler):
    executor = ThreadPoolExecutor(30)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self, APIName):
        yield self.execute_get(APIName)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def post(self, APIName):
        yield self.execute_post(APIName)

예제 #17

파일: ProjectController.py 프로젝트: witskeeper/shareDDD

import json
import traceback
import tornado.web
import tornado.gen
from tornado.concurrent import run_on_executor
from concurrent.futures import ThreadPoolExecutor
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult
from src.main.master.service.impl.ProjectServiceImpl import ProjectService
from src.main.master.util.jsonUtil.JsonUtil import CJsonEncoder
from src.main.master.core.AdminDecorator import AdminDecoratorServer

#set log
logger = Log('ProjectController')
logger.write_to_file(SystemConfig.logPathPrefix+"ProjectController.log")

class ProjectHandler(tornado.web.RequestHandler):
    executor = ThreadPoolExecutor(30)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self,APIName):
        yield self.execute_get(APIName)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def post(self,APIName):
        yield self.execute_post(APIName)

예제 #18

파일: dbBaseHelper.py 프로젝트: daydayhappya/shareDDD

# -*- coding: utf-8 -*-
from src.main.master.util.dbUtil.dbBaseUtil import Connection
from src.main.master.entity.DataResult import DataResult
from src.main.master.util.logUtil.log import Log
from src.main.master.common.constants import SystemConfig
import traceback

#set log
logger = Log('dbBaseHelper')
logger.write_to_file(SystemConfig.logPathPrefix+"dbBaseHelper.log")

#本类只提供了base操作
class DbBaseHelper(object):

    def __init__(self,sql=None,args=None,is_execute_many=False):
        self.data = DataResult()
        self.sql=sql
        self.args =args
        self.is_execute_many=is_execute_many

    #针对select操作
    def read(self, **kwargs):
        db = Connection(autocommit=False, **kwargs)
        try:
            if self.args is not None and not isinstance(self.args,dict):
                logger.error("sql params [{0}] type is error,must be dict".format(self.args))
                self.data.setMessage("sql params type is error,must be dict")
                self.data.setSuccess(False)
                return self.data
            ret = db.read(self.sql,self.args)
            self.data.setMessage(list(ret))

예제 #19

파일: ProductServiceImpl.py 프로젝트: witskeeper/shareDDD

# -*- coding: utf-8 -*-

import json
import traceback
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult
from src.main.master.dao.ProductDao import ProductDaoInterface
from src.main.master.core.AdminDecorator import AdminDecoratorServer

#set log
logger = Log('ProductServiceImpl')
logger.write_to_file(SystemConfig.logPathPrefix + "ProductServiceImpl.log")


class ProductService(object):
    def __init__(self):
        self.ProductDaoInterface = ProductDaoInterface()

    @AdminDecoratorServer.execImplDecorator()
    def addProduct(self, args):
        return self.ProductDaoInterface.addProduct(args)

    @AdminDecoratorServer.execImplDecorator()
    def deleteProduct(self, args):
        return self.ProductDaoInterface.deleteProduct(args)

    @AdminDecoratorServer.execImplDecorator()
    def getProductInfoById(self, productId):
        args = {}
        args.setdefault("id", productId)

예제 #20

# -*- coding: utf-8 -*-

import inspect
from src.main.master.util.dbUtil.dbBaseHelper import DbBaseHelper
from src.main.master.util.logUtil.log import Log
from src.main.master.common.constants import SystemConfig
from src.main.master.mapping.UserMapper import UserSQLMapper

#set log
logger = Log('UserDao')
logger.write_to_file(SystemConfig.logPathPrefix + "UserDao.log")


class UserDaoInterface:
    def addUser(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = UserSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.write()

    def getUserInfo(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = UserSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.read()

    def deleteUser(self, args):
        logger.info(inspect.stack()[0][3])
        sql = UserSQLMapper().getSQL(inspect.stack()[0][3])

예제 #21

import json
import traceback
import tornado.web
import tornado.gen
from tornado.concurrent import run_on_executor
from concurrent.futures import ThreadPoolExecutor
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult
from src.main.master.service.impl.CaseContentServiceImpl import CaseContentService
from src.main.master.util.jsonUtil.JsonUtil import CJsonEncoder
from src.main.master.core.AdminDecorator import AdminDecoratorServer

#set log
logger = Log('CaseContentController')
logger.write_to_file(SystemConfig.logPathPrefix + "CaseContentController.log")


class CaseContentHandler(tornado.web.RequestHandler):
    executor = ThreadPoolExecutor(30)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self, APIName):
        yield self.execute_get(APIName)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def post(self, APIName):
        yield self.execute_post(APIName)

예제 #22

파일: DatabaseDao.py 프로젝트: jessica-wong/engineering

# -*- coding: utf-8 -*-

import inspect
from src.main.master.util.dbUtil.dbBaseHelper import DbBaseHelper
from src.main.master.util.logUtil.log import Log
from src.main.master.common.constants import SystemConfig
from src.main.master.mapping.DatabaseMapper import DatabaseSQLMapper

#set log
logger = Log('DatabaseDao')
logger.write_to_file(SystemConfig.logPathPrefix + "DatabaseDao.log")


class DatabaseDaoInterface:
    def addDatabase(self, args):
        sql = DatabaseSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.write()

    def deleteDatabase(self, args):
        sql = DatabaseSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.write()

    def getDatabaseInfoById(self, args):
        sql = DatabaseSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.read()

    def getDatabaseAllInfoById(self, args):
        sql = DatabaseSQLMapper().getSQL(inspect.stack()[0][3])

예제 #23

파일: InterfaceController.py 프로젝트: witskeeper/shareDDD

import json
import traceback
import tornado.web
import tornado.gen
from tornado.concurrent import run_on_executor
from concurrent.futures import ThreadPoolExecutor
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult
from src.main.master.service.impl.InterfaceServiceImpl import InterfaceService
from src.main.master.util.jsonUtil.JsonUtil import CJsonEncoder
from src.main.master.core.AdminDecorator import AdminDecoratorServer

#set log
logger = Log('InterfaceController')
logger.write_to_file(SystemConfig.logPathPrefix + "InterfaceController.log")


class InterfaceHandler(tornado.web.RequestHandler):
    executor = ThreadPoolExecutor(30)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self, APIName):
        yield self.execute_get(APIName)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def post(self, APIName):
        yield self.execute_post(APIName)

예제 #24

파일: TaskMetaqInfoDao.py 프로젝트: witskeeper/shareDDD

# -*- coding: utf-8 -*-

import inspect
from src.main.master.util.dbUtil.dbBaseHelper import DbBaseHelper
from src.main.master.util.logUtil.log import Log
from src.main.master.common.constants import SystemConfig
from src.main.master.mapping.TaskMetaqInfoMapper import TaskMetaqInfoSQLMapper

#set log
logger = Log('TaskMetaqInfoDao')
logger.write_to_file(SystemConfig.logPathPrefix + "TaskMetaqInfoDao.log")


class TaskMetaqInfoDaoInterface:
    def addTaskInfo(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = TaskMetaqInfoSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.write()

    def getWaitingTaskInfos(self, args):
        #实例化
        logger.info(inspect.stack()[0][3])
        sql = TaskMetaqInfoSQLMapper().getSQL(inspect.stack()[0][3])
        daoOperate = DbBaseHelper(sql, args)
        return daoOperate.read()

    def updateTaskInfo(self, args):
        logger.info(inspect.stack()[0][3])
        sql = TaskMetaqInfoSQLMapper().getSQL(inspect.stack()[0][3])

예제 #25

파일: AssertController.py 프로젝트: witskeeper/shareDDD

import json
import traceback
import tornado.web
import tornado.gen
from tornado.concurrent import run_on_executor
from concurrent.futures import ThreadPoolExecutor
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult
from src.main.master.service.impl.AssertServiceImpl import AssertService
from src.main.master.util.jsonUtil.JsonUtil import CJsonEncoder
from src.main.master.core.AdminDecorator import AdminDecoratorServer

#set log
logger = Log('AssertController')
logger.write_to_file(SystemConfig.logPathPrefix + "AssertController.log")


class AssertHandler(tornado.web.RequestHandler):
    executor = ThreadPoolExecutor(30)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self, APIName):
        yield self.execute_get(APIName)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def post(self, APIName):
        yield self.execute_post(APIName)

예제 #26

파일: AdminDecorator.py 프로젝트: daydayhappya/shareDDD

# -*- coding: utf-8 -*-

import json
import traceback
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult

#set log
logger = Log('AdminDecorator')
logger.write_to_file(SystemConfig.logPathPrefix + "AdminDecorator.log")


class AdminDecoratorServer(object):
    def __init__(self):
        pass

    @staticmethod
    def execImplDecorator():
        def _deco(func):
            def __deco(*args, **kwargs):
                try:
                    return func(*args, **kwargs)
                except Exception, err:
                    dataResult = DataResult()
                    logger.error(traceback.format_exc())
                    dataResult.setMessage(traceback.format_exc())
                    dataResult.setSuccess(False)
                    dataResult.setStatusCode(500)
                    return dataResult

예제 #27

import json
import traceback
import tornado.web
import tornado.gen
from tornado.concurrent import run_on_executor
from concurrent.futures import ThreadPoolExecutor
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult
from src.main.master.service.impl.TestCaseInstanceServiceImpl import TestCaseInstanceService
from src.main.master.util.jsonUtil.JsonUtil import CJsonEncoder
from src.main.master.core.AdminDecorator import AdminDecoratorServer

#set log
logger = Log('TestCaseInstanceController')
logger.write_to_file(SystemConfig.logPathPrefix +
                     "TestCaseInstanceController.log")


class TestCaseInstanceHandler(tornado.web.RequestHandler):
    executor = ThreadPoolExecutor(30)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self, APIName):
        yield self.execute_get(APIName)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def post(self, APIName):

예제 #28

# -*- coding: utf-8 -*-

import json
import traceback
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult
from src.main.master.dao.WebApiDao import WebApiDaoInterface
from src.main.master.core.AdminDecorator import AdminDecoratorServer

#set log
logger = Log('WebApiServiceImpl')
logger.write_to_file(SystemConfig.logPathPrefix + "WebApiServiceImpl.log")


class WebApiService(object):
    def __init__(self):
        self.WebApiDaoInterface = WebApiDaoInterface()

    @AdminDecoratorServer.execImplDecorator()
    def addWebApi(self, args):
        if "params" not in args:
            args.setdefault("params", None)
        else:
            params = json.dumps(args.get("params"))
            args.pop("params")
            args.setdefault("params", params)
        if "failure_response" not in args:
            args.setdefault("failure_response", None)
        else:
            failure_response = json.dumps(args.get("failure_response"))

예제 #29

파일: EnvironmentController.py 프로젝트: jessica-wong/engineering

import json
import traceback
import tornado.web
import tornado.gen
from tornado.concurrent import run_on_executor
from concurrent.futures import ThreadPoolExecutor
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult
from src.main.master.service.impl.EnvironmentServiceImpl import EnvironmentService
from src.main.master.util.jsonUtil.JsonUtil import CJsonEncoder
from src.main.master.core.AdminDecorator import AdminDecoratorServer

#set log
logger = Log('EnvironmentController')
logger.write_to_file(SystemConfig.logPathPrefix+"EnvironmentController.log")

class EnvironmentHandler(tornado.web.RequestHandler):
    executor = ThreadPoolExecutor(30)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self,APIName):
        yield self.execute_get(APIName)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def post(self,APIName):
        yield self.execute_post(APIName)

예제 #30

import json
import traceback
import tornado.web
import tornado.gen
from tornado.concurrent import run_on_executor
from concurrent.futures import ThreadPoolExecutor
from src.main.master.common.constants import SystemConfig
from src.main.master.util.logUtil.log import Log
from src.main.master.entity.DataResult import DataResult
from src.main.master.service.impl.WebApiServiceImpl import WebApiService
from src.main.master.util.jsonUtil.JsonUtil import CJsonEncoder
from src.main.master.core.AdminDecorator import AdminDecoratorServer
import requests
#set log
logger = Log('WebApiController')
logger.write_to_file(SystemConfig.logPathPrefix+"WebApiController.log")

class WebApiHandler(tornado.web.RequestHandler):
    executor = ThreadPoolExecutor(30)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self,APIName):
        yield self.execute_get(APIName)

    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def post(self,APIName):
        yield self.execute_post(APIName)