def get_url(self, routename, **kargs):
    """ Return a string that matches a named route """
    scriptname = request.environ.get('SCRIPT_NAME', '').strip('/') + '/'
    location = self.router.build(routename, **kargs).lstrip('/')
    return urljoin(urljoin('/', scriptname), location)

def route(self, path=None, method='GET', callback=None, name=None,
          apply=None, skip=None, **config):

for name in '''route get post put delete error mount
               hook install uninstall'''.split():
    globals()[name] = make_default_app_wrapper(name)
url = make_default_app_wrapper('get_url')
del name

from bottle import default_app
 
import x
 
local.x_app = x.app
 
app.mount('/x', x.app)

{{ local.x_app.get_url('hello', name='ai', x=1) }}

from bottle import BaseTemplate
 
BaseTemplate.defaults.update(dict(
    request=request,
    local=local,
    )
)

from bottle import BaseTemplate
 
if 'filters' not in BaseTemplate.settings:
    BaseTemplate.settings['filters'] = {}
 
filters = BaseTemplate.settings['filters']
 
def urlencode_filter(params):
    '''
    urlencode
    '''
    from urllib import urlencode
 
    return urlencode(params)
 
filters.update(dict(
    urlencode=urlencode_filter,
    )
)

function str_format(str, obj) {
    return str.replace(/\{\s*(\w+)\s*\}/g, function(_i, _1) {
        return obj[_1] != null ? obj[_1] : '';
    });
};

9825#0: *745262 readv() failed (104: Connection reset by peer) while reading upstream, client: 121.14.96.125

--pep333-input
--post-buffering 4096

server {
    listen       8080;
    server_name  localhost;
 
    location / {
        proxy_pass http://localhost:8888;
 
        error_page 433 = @433;
        error_page 434 = @434;
    }
    location @433 {
        proxy_pass http://localhost:6788;
    }
    location @434 {
        proxy_pass http://localhost:6789;
    }
 
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   html;
    }
 
}

void ngx_http_foo_post_handler(ngx_http_request_t *r){
    // 请求全部读完后从这里入口, 可以产生响应
    ngx_http_request_body_t* rb = r->request_body;
 
    char* body = NULL;
    int body_size = 0;
 
    if (rb && rb->buf)
    {
        body = (char*)rb->buf->pos;
        body_size = rb->buf->last - rb->buf->pos;
    }
 
    int result = get_route_id(r->connection->log, 
                              (int)r->method,
                              (char*)r->uri.data,
                              (char*)r->args.data,
                              body,
                              body_size
                              );
    if (result < 0)
    {
        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "get_route_id fail, result:%d", result);
        result = DFT_ROUTE_ID;
    }
    ngx_http_finalize_request(r, result);
 
}
 
static ngx_int_t ngx_http_req_route_handler(ngx_http_request_t *r)
{
    ngx_http_read_client_request_body(r, ngx_http_foo_post_handler);
    return NGX_DONE; // 主handler结束
}

extern int get_route_id(ngx_log_t *log, int method, char* uri, char* args, char* body, int body_size);

extern int get_route_id(ngx_http_request_t *r, int method, char* uri, char* args, char* body, int body_size);

r->connection->log

int get_route_id(ngx_log_t *log, int method, char* uri, char* args, char* body, int body_size)
{
    const char lua_funcname[] = "get_route_id";
 
    lua_State *L = luaL_newstate();
 
    luaL_openlibs(L);
 
    if (luaL_loadfile(L, LUA_FILENAME) || lua_pcall(L, 0, 0, 0))
    {
        ngx_log_error(NGX_LOG_ERR, log, 0, "cannot run configuration file: %s", lua_tostring(L, -1));
        lua_close(L);
        return -1;
    }
 
    lua_getglobal(L, lua_funcname); /* function to be called */
    lua_pushnumber(L, method);
    lua_pushstring(L, uri);
    lua_pushstring(L, args);
    lua_pushlstring(L, body, body_size);
 
    /* do the call (1 arguments, 1 result) */
    if (lua_pcall(L, 4, 1, 0) != 0)
    {
        ngx_log_error(NGX_LOG_ERR, log, 0, "error running function %s: %s", lua_funcname, lua_tostring(L, -1));
        lua_close(L);
        return -2;
    }
 
    /* retrieve result */
    if (!lua_isnumber(L, -1))
    {
        ngx_log_error(NGX_LOG_ERR, log, 0, "function %s must return a number", lua_funcname);
        lua_close(L);
        return -3;
    }
 
    int result = (int)lua_tonumber(L, -1);
 
    lua_pop(L, 1); /* pop returned value */
 
    lua_close(L);
    return result;
}

function get_route_id(method, uri, args, body)
 
    loc, pf ,appid = get_need_vals(method, uri, args, body)
 
    if loc == nil or pf == nil or appid == nil then
        return OUT_CODE
    end
 
    --到这里位置，就把所有的数据都拿到了
    --print (loc, pf, appid)
 
 
    -- 找是否在对应的url, loc中
    if not is_match_pf_and_loc(pf, loc) then
        return OUT_CODE
    end
 
    -- 找是否在对应的appid中
    if not is_match_appid(appid) then
        return OUT_CODE
    end
 
    return IN_CODE
end

server {
    listen       8080;
    server_name  localhost;
 
    location /req_route {
        req_route;
        error_page 433 = @433;
        error_page 434 = @434;
    }
    location @433 {
        proxy_pass http://localhost:6788;
    }
    location @434 {
        proxy_pass http://localhost:6789;
    }
 
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   html;
    }
 
}

#ADD-BEGIN by dantezhu in 2012-02-10 02:30:57
from threading import local
 
local_data = local()
#ADD-END
 
class Database(object):
    placeholder = '?'
 
    def connect(self, dbtype, *args, **kwargs):
#Add-Begin by dantezhu in 2011-12-16 01:56:34
        self.dbtype = dbtype
#Add-End
        if dbtype == 'sqlite3':
            import sqlite3
            self.connection = sqlite3.connect(*args)
        elif dbtype == 'mysql':
            import MySQLdb
            self.connection = MySQLdb.connect(**kwargs)
            self.placeholder = '%s'
 
#ADD-BEGIN by dantezhu in 2012-02-10 02:30:40
    def __getattr__(self, key):
        if key == 'connection':
            if not hasattr(local_data, key):
                raise AttributeError, 'the object has no attr: ' + key
                return None
 
            cmd = 'local_data.' + str(key)
            return eval(cmd)
        else:
            return object.__getattr__(self, key)
 
    def __setattr__(self, key, value):
        if key == 'connection':
            cmd = 'local_data.' + str(key) + '=value'
            exec cmd
        else:
            object.__setattr__(self, key, value)
#ADD-END

netsh wlan set hostednetwork mode=allow ssid=dantezhu_wifi key=00000000

netsh wlan start hostednetwork

curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, (int)(timeout_sec*1000));                                                        
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS, (int)(timeout_sec*1000));

def get_image_type(pd, is_path=True):
    '''
    获取图片的类型，支持传入路径和文件内容
    '''
    if is_path:
        f = file(pd, 'rb')
        data = f.read(10).encode('hex')
    else:
        data = pd.encode('hex')
 
    ftype = None
 
    if data.startswith('ffd8'):
        ftype = 'jpeg'
    if data.startswith('424d'):
        ftype = 'bmp'
    if data.startswith('474946'):
        ftype = 'gif'
    elif data.startswith('89504e470d0a1a0a'):
        ftype = 'png'
 
    return ftype

stringstream ss;
int x;
 
ss << "190";
ss >> x;
 
cout << x;

stringstream ss;
string x;
 
ss << "190";
ss >> x;
 
cout << x;

stringstream ss;
string x;
 
ss << "x y z";
ss >> x;
 
cout << x;

stringstream ss;
int x;
ss << "";
ss >> x;
cout << x;

SELECT * FROM(
SELECT * FROM db_app_right0.tb_app_right0
UNION
SELECT * FROM db_app_right0.tb_app_right1
)AS t  INTO OUTFILE '/tmp/mx';

CREATE backup.tablename AS SELECT * FROM dbname.tablename  WHERE id = 90000;
DELETE FROM dbname.tablename  WHERE id = 90000;

insert into dbname.tablename select * from backup.tablename;

bottle_site_tpl/
|~conf/
|~depend/
| |+autumn/
| |+jinja2/
| |+wtforms/
| |-__init__.py
| `-bottle.py
|~log/
| `-site.log
|~module/
| |-__init__.py
| |-forms.py
| |-models.py
| |-mysession.py
| `-web_func.py
|+static/
|~views/
| `-test.html
|~web/
| |-__init__.py
| `-test.py
|-myapp.py
`-setting.py

import setting
 
from bottle import debug, run
 
from web import app
 
if __name__ == '__main__':
    debug(True)
    run(app, host="0.0.0.0", port=80, reloader=True)

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
from bottle import Bottle
from bottle import debug, run
from bottle import redirect, abort, static_file
from bottle import jinja2_template as template
from bottle import request, response, local
from bottle import TEMPLATE_PATH
 
from mysession import get_session_info, set_session_info
from mysession import deco_session_check
 
from setting import CUSTOM_TPL_PATH
TEMPLATE_PATH.insert(0, CUSTOM_TPL_PATH)
 
app = Bottle()
 
app.mount('/test', __import__('test').app)
 
if __name__ == '__main__':
    debug(True)
    run(app, host="0.0.0.0",reloader=True)