python flask、flask_restful构建应用

1、bootstrap.sh  启动应用脚本

python svr.py --port 13800 --initializer initializer --decorator init_flask_restful --enable_debug

2、svr.py   主程序

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import argparse
import flask
import importlib
import traceback
from flask_cors import *
from DebugLog import debugLog
import os

def parse():
    _parser_ = argparse.ArgumentParser(description='')
    _gApp_ = _parser_.add_argument_group(description="")
    _gApp_.add_argument("-A", "--app_name", default=__name__, type=str, help=u"")
    _gApp_.add_argument("-I", "--initializer", required=True, type=str, help=u"") 
    _gApp_.add_argument("-D", "--decorator", required=True, nargs='+', type=str, help=u"")
    _gSvr_ = _parser_.add_argument_group(description="")
    _gSvr_.add_argument("-H", "--host", default="localhost", type=str, help=u"")
    _gSvr_.add_argument("-P", "--port", default=8080, type=int, help=u"")
    _gSvr_.add_argument("--enable_debug", action="store_true", default=False, help=u"")
    kwargs, attr = _parser_.parse_known_args()
    return kwargs, attr

def mainProc(kwargs):
    _app_ = flask.Flask(kwargs.app_name)
    CORS(_app_, supports_credentials=True)
    try:
        _module_ = importlib.import_module(kwargs.initializer)  #初始化flask、flask_sqlalchemy
        _module_.initialize(_app_)                              #初始化flask_restful
        for i, v in enumerate(kwargs.decorator):
            _module_ = importlib.import_module(v)
            _module_.decorate(_app_)
    except Exception as e:
        print e
        traceback.print_exc()
    else:
        _app_.run(debug = kwargs.enable_debug, host = kwargs.host, port = kwargs.port)
    finally:
        pass
 
def initLog():
    pwd = os.getcwd()
    dir = pwd + '/log'
    logfile = dir + '/pcdn_svr.log'
    if not os.path.isdir(dir):
        os.makedirs(dir)
    loglevel = 'debug'
    debugLog.init(logfile, loglevel)

if '__main__' == __name__:
    kwargs, _ = parse()
    initLog()
    debugLog.info("start server...")
    mainProc(kwargs)

3、initializer.py  初始化flask、flask_sqlalchemy

# -*- coding: UTF-8 -*-
#!/usr/bin/env python

import flask_sqlalchemy
import os
import sys
from util import Util

db = flask_sqlalchemy.SQLAlchemy()

class Config(object):
    MAINTAINER = ''
    SECRET_KEY = ''
    SITE_URL = ''
    SMART_PROXY_TOKEN = ''
    SQLALCHEMY_DATABASE_URI = Util.getSQLCONFIG("SQLconfig.conf", True)  #指定flask_sqlalchemy连接的db
    SQLALCHEMY_COMMIT_ON_TEARDOWN = True
    SQLALCHEMY_TRACK_MODIFICATIONS = False


class DevelopmentConfig(Config):
    DEBUG = True
    SQLALCHEMY_ECHO = False


class TestingConfig(Config):
    TESTING = True


class ProductionConfig(Config):
    DEBUG = False


config = {
    "development": DevelopmentConfig,
    "testing": TestingConfig,
    "production": ProductionConfig,
    "default": DevelopmentConfig
}


def initialize(flask_app, config_name="default"):
    flask_app.config.from_object(config[config_name])
    db.init_app(flask_app)

4、init_flask_restful.py   初始化flask_restful

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import flask
import flask_restful

svr_bp = flask.Blueprint("pcdn", __name__)

svr = flask_restful.Api(svr_bp)

import check_task  #将具体到uri绑定到特定类

def decorate(_flask_):
    u"""
    """
    _flask_.register_blueprint(svr_bp)
    u"""
    """
    

5、common_db.py  访问mysql的公共配置

#_*_ coding:utf8 -*- #
import MySQLdb,threading
db_lock = threading.Lock()


class DbError(Exception):
    def __init__(self, str):
        self.value = str
    def __str__(self):
        return repr(self.value)
        
class DbBase():
    def __init__(self, db_host, db_port, db_user, db_pass, db_name, charset="utf8"):
        self.db_host = db_host
        self.db_port = db_port
        self.db_user = db_user
        self.db_pass = db_pass
        self.db_name = db_name
        self.init = False
        self.charset = charset
        
    def __del__(self):  
        '''
        self.c.close()
        self.conn.close()
        '''
        pass
        
    def Connect(self):
        try:
            conn = MySQLdb.connect(self.db_host, self.db_user, self.db_pass, self.db_name, port=self.db_port, use_unicode=False, charset=self.charset)
            c = conn.cursor()
            self.init = True
            return conn, c
        except MySQLdb.Error, e:
            self.init = False
            raise DbError("Error %d:%s" %(e.args[0], e.args[1]))

    def disConnect(self, conn, c):
        pass
    
    def execute(self, sql, bget = True, bmulti = True, charset = None):
        conn = None
        c = None
        try:
            conn, c = self.Connect()    
            
            if charset != None:
                conn.set_character_set(charset)

            if not bget:
                db_lock.acquire()
            
            c.execute(sql)
            conn.commit()

            if not bget:
                conn.commit()
                c.close()
                conn.close()
                db_lock.release()
                return 0
                
            if bmulti:
                rows = c.fetchall()
                c.close()
                conn.close()
                return rows
            else:
                row = c.fetchone()
                c.close()
                conn.close()
                return row
        except MySQLdb.Error, e:
            if db_lock.locked():
                db_lock.release()
            if self.init:
                c.close()
                conn.close()
            raise DbError("Error %d:%s" %(e.args[0], e.args[1]))
    
    def submit(self):
        try:
            '''
            self.conn.commit()
            '''
            return 0
        except MySQLdb.Error, e:
            raise DbError("Error %d:%s" %(e.args[0], e.args[1]))

            

6、SQLconfig.conf    数据库配置

[Dev]
db_host=aaa
db_port=bbb
db_user=ccc
db_pass=ddd
db_name=eee
db_uri=mysql://ccc:ccc@aaa:bbb/eee?charset=utf8

7、dbclient.py  访问具体数据库

#_*_ coding:utf8 -*- #

import common_db
from util import Util

_host, _port, _user, _pass, _name = Util.getSQLCONFIG("SQLconfig.conf", False)

db_host=_host
db_port=int(_port)
db_user=_user
db_pass=_pass
db_name=_name

db_op_obj = common_db.DbBase(db_host, db_port, db_user, db_pass, db_name)

8、check_task.py   flask_restful具体应用

#!/usr/bin/env pythono
# -*- coding: UTF-8 -*-

import flask
import flask_restful
from flask_restful import reqparse
from flask_limiter import Limiter
import os
from init_flask_restful import svr as entrance
from initializer import db
import tables
from DebugLog import debugLog
import traceback
import ast
import util
from dbclient import db_op_obj

import uuid
import datetime
import re

base_parser = reqparse.RequestParser()
base_parser.add_argument('user_name', type=str, required=True, help="user_name cannot be blank or type is not right!")
base_parser.add_argument('password', type=str, required=True, help="password cannot be blank or type is not right!")

create_parser = base_parser.copy()
create_parser.add_argument('check_type', type=int, required=True, help="check_type cannot be blank or type is not right!")
create_parser.add_argument('data', type=str, required=True, action='append', help="data cannot be blank or type is not right!") #获取列表，比如[{},{}]

class v1_check_task(flask_restful.Resource):

    def post(self):
        try:
            args = create_parser.parse_args()

            db.create_all()
            dt  = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            check_task = tables.TableA.query.filter_by(check_task_id=216).first()
            if check_task:
                if check_task.check_task_status == 4:
                    return {"ret_code":-1,"ret_msg":"Task has canceled, do not cancel again"} , 401
                elif check_task.check_task_result == 1:
                    return {"ret_code":-1,"ret_msg":"Task has passed , can not cancel the task"} , 401

                dt  = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                check_task.check_task_pass_time = dt
                check_task.check_task_result = 0
                check_task.check_task_status = 4
                db.session.commit()

            db_op_obj.execute("select * from xxx")

            return {"ret_code": 0}, 200

        except Exception,e:
            debugLog.error(traceback.format_exc())
            return {"ret_code":-1,"ret_msg":str(e)} , 400


entrance.add_resource(v1_check_task,'/v1/check_tasks','/v1/check_tasks/<int:task_id>')

9、util.py  工具脚本，读取数据库信息

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import hashlib
import ConfigParser
import os


class Util(object):

    @staticmethod
    def getSQLCONFIG(filename, uri_flag):
        cf = ConfigParser.ConfigParser()
        root_path = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
        cf.read(root_path + '/' + filename)
        _host = cf.get("Dev", "db_host")
        _port = cf.get("Dev", "db_port")
        _user = cf.get("Dev", "db_user")
        _pass = cf.get("Dev", "db_pass")
        _name = cf.get("Dev", "db_name")
        _uri = cf.get("Dev", "db_uri")
        if (uri_flag):
            return _uri
        else:
            return _host, _port, _user, _pass, _name

10、tables.py  表的定义，flask_sqlalchemy

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

from oss.init import db
from sqlalchemy.dialects.postgresql import UUID

class TableA(db.Model):
    __tablename__ = 't_device_check_task'
    check_task_id           = db.Column(db.Integer, unique=True, nullable=False, primary_key=True)
    check_task_create_time  = db.Column(db.DateTime)
    check_task_start_time   = db.Column(db.DateTime)
    check_task_end_time     = db.Column(db.DateTime)
    check_task_progress     = db.Column(db.Integer)
    check_task_status       = db.Column(db.Integer)
    check_task_operator     = db.Column(db.String(32))
    check_task_provider     = db.Column(db.Integer)
    check_task_node         = db.Column(db.Integer)
    check_task_result       = db.Column(db.Integer)
    check_task_report       = db.Column(db.Text)
    check_task_detail_table = db.Column(db.String(128))
    check_task_pass_time    = db.Column(db.DateTime)
    check_task_device_type  = db.Column(db.Integer)
    operation               = db.Column(db.Text)

    def to_json(self):
        return {
                "check_task_id" : self.check_task_id,
                "check_task_create_time": str(self.check_task_create_time),
                "check_task_start_time": str(self.check_task_start_time),
                "check_task_end_time" : str(self.check_task_end_time),
                "check_task_progress" : self.check_task_progress,
                "check_task_status" : self.check_task_status,
                "check_task_operator" : self.check_task_operator,
                "check_task_provider" : self.check_task_provider,
                "check_task_node"   : self.check_task_node,
                "check_task_result"   : self.check_task_result,
                "check_task_report": self.check_task_report,
                "check_task_detail_table" : self.check_task_detail_table,
                "check_task_pass_time" : str(self.check_task_pass_time),
                "check_task_device_type" : self.check_task_device_type
                }

11、DebugLog.py  日志打印脚本

import logging
import logging.handlers 
import threading
import time
import inspect


class DebugLog:

    def init(self, logFileName, level):
        self.lock = threading.Lock()
        self.logger = logging.getLogger()
        hdlr = logging.handlers.TimedRotatingFileHandler(logFileName,when='D',interval=1,backupCount=10)
        formatter = logging.Formatter('[%(asctime)s] [%(levelname)s]  [%(filename)s:%(lineno)d] %(message)s')
        hdlr.setFormatter(formatter)	
        loglevel = logging.INFO
        if level == 'debug':
            loglevel = logging.DEBUG
        elif level == 'info':
            loglevel = logging.INFO
        elif level == 'warn':
            loglevel = logging.WARN
        elif level == 'error':
            loglevel = logging.ERROR
        elif level == 'fatal':
            loglevel = logging.FATAL

        hdlr.setLevel(loglevel)
        self.logger.setLevel(loglevel)
        self.logger.addHandler(hdlr)
        

    def debug(self, msg):
        self.lock.acquire()
        self.logger.debug("[%s:%d] %s" % (inspect.stack()[1][1], inspect.stack()[1][2], str(msg)))
        self.lock.release()

    def info(self, msg):
        self.lock.acquire()
        self.logger.info("[%s:%d] %s" % (inspect.stack()[1][1], inspect.stack()[1][2], str(msg)))
        self.lock.release()

    def warn(self, msg):
        self.lock.acquire()
        self.logger.warn("[%s:%d] %s" % (inspect.stack()[1][1], inspect.stack()[1][2], str(msg)))
        self.lock.release()

    def error(self, msg):
        self.lock.acquire()
        self.logger.error("[%s:%d] %s" % (inspect.stack()[1][1], inspect.stack()[1][2], str(msg)))
        self.lock.release()

    def fatal(self, msg):
        self.lock.acquire()
        self.logger.fatal("[%s:%d] %s" % (inspect.stack()[1][1], inspect.stack()[1][2], str(msg)))
        self.lock.release()

debugLog = DebugLog()