smallfish blog feed

如何编写 Go 程序（最新版）

2012-03-14T00:00:00-07:00

官网文档（weekly）：http://weekly.golang.org/doc/code.html

中文版（旧版）：http://chenxiaoyu.org/2010/06/29/how-to-write-go.html

本想翻译下官网版本，翻译起来觉得有点麻烦和啰嗦。还是自己摘抄一些片段，适当删减。

本文文档基于 weekly.2012-03-13 版本，应该是传闻中的 Go1 RC1 版本。

鉴于新版多了 go 命令，整合了以前旧版中的不少命令，比如： 6g/6l 或者采用 Makefile 之类编译的东西。

可以自己试试下：

$ go

Go is a tool for managing Go source code.
Usage:
        go command [arguments]
The commands are:
    build       compile packages and dependencies
    clean       remove object files
    doc         run godoc on package sources
    env         print Go environment information
 … 略去若干字

言归正传，开始进入正题。 go 命令依赖一个重要的环境变量：$GOPATH

在类似 Unix 环境大概这样设置：

GOPATH=/home/user/ext:/home/user/mygo

Windows 系统请注意分隔符，是分号（非冒号）。

以上 $GOPATH 目录约定有三个子目录：

src 存放源代码（比如：.go .c .h .s等）
pkg 编译后生成的文件（比如：.a）
bin 编译后生成的可执行文件（为了方便，可以把此目录加入到 $PATH 变量中）

下面来一个实例来说明，文件和目录大概如下：

a). 设置 $GOPATH，写入 $HOME/.profile 以下内容

export GOPATH=$HOME/mygo
export PATH=$PATH:$HOME/mygo/bin

b). 建立包和目录：$GOPATH/src/example/newmath/sqrt.go（包名："example/newmath"）

$ mkdir -p $GOPATH/src/example
$ cd $GOPATH/src/example
$ mkdir newmath

// $GOPATH/src/example/newmath/sqrt.go源码如下：
package newmath

func Sqrt(x float64) float64 {
        z := 0.0
        for i := 0; i < 1000; i++ {
                z -= (z*z - x) / (2 * x)
        }
        return z
}

c). 编译 newmath/sqrt.go 包

1. 在任意目录下：
    $ go install example/newmath

2. 在源码目录下：
    cd $GOPATH/src/example/newmath
    $ go install

d). 编译独立的可执行的测试

$ cd $GOPATH/src/example
$ mkdir hello

// $GOPATH/src/example/hello/hello.go 源码：
package main

import (
        "example/newmath"
        "fmt"
)

func main() {
        fmt.Printf("Hello, world.  Sqrt(2) = %v\n", newmath.Sqrt(2))
}

$ go install example/hello # 编译 hello

这个时候可以发现在 $GOPATH/bin/hello 多了一个可执行的 hello 文件：

$ hello
Hello, world.  Sqrt(2) = 1.414213562373095

完整的目录结构如下：

bin/
    hello
pkg/
    平台名/ 如：darwin_amd64、linux_amd64
        example/
            newmath.a
src/
    example/
        hello/
            hello.go
        newmath/
            sqrt.go

简单的示例到此为止，官网文档中还有 go install 远程扩展库和测试相关，有兴趣的自己看把~~

END

Nginx GZip 压缩

2012-03-08T00:00:00-08:00

Nginx GZip 模块文档详见：http://wiki.nginx.org/HttpGzipModule

常用配置片段如下：

gzip             on;
gzip_comp_level  2;                        # 压缩比例，比例越大，压缩时间越长。默认是1
gzip_types       text/css text/javascript; # 哪些文件可以被压缩
gzip_disable     "MSIE [1-6]\.";           # 无视IE6这个笨蛋~

其中 gzip_types 选项默认只压缩 text/html，源码见：

src/http/modules/ngx_http_gzip_filter_module.c 行152：
    &ngx_http_html_default_types[0]

src/http/ngx_http.c 行77：
    ngx_str_t  ngx_http_html_default_types[] = {
        ngx_string("text/html"),

常用的静态 type 有，看自己需要压缩的情况而定：

text/html
text/plain
text/css
application/x-javascript
text/javascript
application/xml

OK，到这里基本服务端已经配置完毕，Nginx 只需要 reload 一下即可。

下面来测试一下，用 curl 来如何测试服务端已经开启 gzip（测试条件是默认gzip_types，即只压缩 text.html ，其他 type 未压缩）：

查看是否开启gzip，需要客户端加入："Accept-Encoding: gzip, deflate" 头信息。

$ curl -I -H "Accept-Encoding: gzip, deflate" "http://localhost/tag.php"

HTTP/1.1 200 OK
Server: nginx
Date: Thu, 08 Mar 2012 07:23:46 GMT
Content-Type: text/html
Connection: close
Content-Encoding: gzip

$ curl -I -H "Accept-Encoding: gzip, deflate" "http://localhost/style.css"

HTTP/1.1 200 OK
Server: nginx
Date: Thu, 08 Mar 2012 07:23:54 GMT
Content-Type: text/css
Connection: close
Last-Modified: Tue, 27 Dec 2011 10:00:51 GMT
ETag: "BC612352322D435769C4BDC03DDB2572"
Content-Length: 22834

可以看出来了把。第二个示例没有被压缩。

END

Nginx-Lua HTTP 401 认证校验

2012-02-08T00:00:00-08:00

本文示例依赖模块：

lua-nginx-module
ngx_coolkit（获取$remote_passwd 输入值）

如何编译Nginx这些扩展模块，请参考以前《Nginx 第三方模块试用记》。

基于 HTTP 401 认证其实很简单，语言或者 Web 服务器都可以在 Header 头里发送。

比如 PHP 401发送示例，或者 Apache 配置：

<Directory "/path/a">
  AuthType Basic
  AuthName "localhost"
  AuthUserFile /usr/local/apache/.htpasswd
  Require valid-user
</Directory>

这里 Apache 的认证是基于加密文件的认证，有点局限性。比如用户密码是存储在数据库中，这样的校验有点局限，当然可以通过扩展 C Apache 模块来解决（应该有类似的模块）。

本文尝试用 Nginx 来扩展一下 HTTP 401 认证，验证部分是由 lua-nginx-module 代码完成。

nginx.conf 配置片段：

location /ubuntu {
    access_by_lua '
        -- 用户和密码正确 access 则通过，并转向 proxy 部分。
        if ngx.var.remote_user == "smallfish" and ngx.var.remote_passwd == "12" then
            return
        end
        -- 返回 HTTP 401 认证输入框
        ngx.header.www_authenticate = [[Basic realm="Restricted"]]
        ngx.exit(401)
    ';
    proxy_pass http://127.0.0.1:8080/;
}

这里的校验部分只是简单的字符串匹配，当然可以扩展成数据库方式（此示例不完整）：http://forum.nginx.org/read.php?2,220692,220740

测试过程中刚好发现 ngx_coolkit 模块在处理 $remote_passwd 一个 bug，此变量在 lua 中不能直接用 ngx.var.remote_passwd 读取，原因是 remote_passwd 变量在模块设置的标志位 NGX_HTTP_VAR_NOHASH，@agentzh 已经在最新的 ngx_coolkit 中修复。

NGX_HTTP_VAR_NOHASH 完整说明参考微博：http://weibo.com/1834459124/y4xzWzV2e

老版本的 ngx_coolkit 可以通过这样来绕过：

location / {
    set $passwd $remote_passwd;
    access_by_lua '
        if ngx.var.remote_user == "smallfish" and ngx.var.passwd == "12" then
            return
        end
        ...
}

建议更新到最新版，或者直接安装 ngx-openresty 包。

END

Nginx-Lua过滤POST请求

2012-01-04T00:00:00-08:00

注：此文章会持续更新

2012 来的几天关于Hash攻击的文章不断，基本语言级别的都收到影响。

看了下 PHP 相关 patch，基本就是对 POST 的 key 数量做一个限制，其他提供的 patch 差不多也是如此。

刚好可以尝试一下 nginx-lua 模块，这里简单贴一些代码，编译步骤就略去。

本文只是根据 POST 参数个数进行简单校验的测试。

这里大概有几个步骤：

加载 conf/post-limit.lua，文件内容在下一段

access_by_lua_file 'conf/post-limit.lua';

conf/post-limit.lua 文件内容：

ngx.req.read_body()

local method   = ngx.var.request_method
local max_size = 2                               -- 参数最多个数，这里测试用，2个

if method == 'POST' then                         -- 只过滤 POST 请求
    local data = ngx.req.get_body_data()
    if data then
        local count = 0
        local i     = 0
        while true do
            if count > max_size then             -- 大于2次，重定向错误页面
                ngx.redirect('/post-max-count')
            end
            i = string.find(data, '&', i+1)      -- 查找 & 字符
            if i == nil then break end
            count = count + 1
        end
    else
        ngx.redirect('/post-error')
    end
end

原先 ngx.req.get_post_args 函数来判断，发现也收到 hash 的影响，最后采取原始的循环字符串版本。

完整 nginx 配置片段：

location /test {
    access_by_lua_file 'conf/post-limit.lua';
    root html;
}

reload nginx 即可。可以这样来访问测试：

$ curl --data "a=1&a=11&b=2" http://localhost/test/1.html
返回 405，可以正常 GET 页面内容。

$ curl --data "a=1&a=11&b=2&c=1" http://localhost/test/1.html
返回 302，重定向到 /post-max-error 错误。

想起之前用 ModPerl 重写了 Apache 的 TransHandler/AccessHandler，跟这个比较类似，加一些过滤器。

感谢 @agentzh 建议，需要注意一下，在 Nginx 配置中 client_max_body_size 和 client_body_buffer_size 需要设为相同大小。

END

The Rose

2011-12-29T00:00:00-08:00

想了很久，很难给这篇跟技术无关的博客起一个满意的标题。刚好想起以前看过的一个视频《The Rose》，姑且凑合用吧。

其实用信乐团的《海阔天空》来当标题或许更为合适，歌词依旧如此犀利和伤感：

    冷漠的人 谢谢你们曾经看轻我
    让我不低头更精彩的活
    …
    海阔天空 狂风暴雨以后
    转过头 对旧心酸一笑而过

随着时间的消逝，有些东西始终只是存在自己的回忆里，不管是美好还是伤感，始终那些都是值得。

或许，曾经有点苦涩，有点埋怨。而如今，回想起来，始终有着那么一丝丝的回味和惋惜。

清晰的记得，那是2005年的国庆前，穿越一个城市，冒着大雨，只是为了那一份为之着迷和幻想的工作。

在去南京之前，对于写程序而已，大部分时间只是在纸上模拟，代码只是流淌在自己的记忆体中。很顺利的拿到了那份工作，一呆就是四年半，接近五年的时间。

不知道五年对每个人意味着什么，得到或者失去，其实都不算什么，只是人生的一些经历而已。回忆起上上次五年，应该是自己上师范那会，十八到二十三岁，应该算是人生最年轻的阶段，得失？我不知道。而上次五年，或许算起来应该是人生中起步积累的阶段吧。

仔细想了想，印象里有很多记忆深刻的场景。比如，那个夏天，没有空调，没有风扇，几个男人，赤膊在公司加班写代码，解决线上服务器问题。那个冬天，喝完白酒，醉醺醺的去公司写了小半夜代码，早上起来检查竟然没有任何的错误。种种画面犹如电影镜头般清晰。

或许这些，都不太重要。只是我们自己在乎的太多，太把自己当回事。或许？只能是或许。

然后，一个个老员工都选择了离开。离开的原因有人会觉得是为了跳槽，是为了选择自己发展的空间，扪心自问，真是这样的吗？只是觉得那么的无奈，那么的难以言语。

聚会的时候还会经常聊起那些过去的事，过去的人。其实大家心里都清楚，为什么离开。

虽然离开这个做法，在现在看来是多么简单，多么不需要理由的事情。

但是，面对着自己陪伴成长，一步步发展起来的那份工作，谁舍得，谁愿意呢。

过去的对与错，已经不再重要。当然，我们什么都不是，真的什么都不是。

嗯，

祝福那些已经离开和即将离开的同事们，终点不是结束，只是下一个起点，一切都会好起来的。

END

JSON 美化输出

2011-11-24T00:00:00-08:00

经常会碰到一些返回 JSON 格式的应用，默认都是一大坨字一起显示，完全是虐待自己的眼睛。

比如以下JSON：

mac:~ smallfish$ curl http://127.0.0.1:8108/postgres
[{"datname":"postgres","datdba":"10","encoding":6,"datcollate":"zh_CN.UTF-8","datctype":"zh_CN.UTF-8",
"datistemplate":false,"datallowconn":true,"datconnlimit":-1,"datlastsysoid":"12172","datfrozenxid":"985",
"dattablespace":"1663","datacl":null},{"datname":"smallfish","datdba":"16384","encoding":6,
"datcollate":"zh_CN.UTF-8","datctype":"zh_CN.UTF-8","datistemplate":false,"datallowconn":true,
"datconnlimit":-1,"datlastsysoid":"12172","datfrozenxid":"985","dattablespace":"1663","datacl":null}]

顺手 Google 了下，发现了两种浏览方式：命令行查看和浏览器查看。

一、浏览器查看方式，需要安装 Chrome 插件：JSONView。

二、命令行查看，需要安装 Python。

mac:~ smallfish$ curl http://127.0.0.1:8108/postgres | python -mjson.tool

是不是美观很多了？

END

Nginx Session 模块

2011-11-09T00:00:00-08:00

上一篇《Nginx第三方模块》涉及了数据库、Memcached以及Lua的扩展，但是相对于Web开发是不是还缺点什么呢？答案是回话（Session）模块。

这里还是需要感谢一下@agentzh，已经封装好了encrypted-session模块。模块依赖ngx_devel_kit包。模块地址如下：

编译很简单，类似如下：

./configure --prefix=/opt/nginx \
    --add-module=../ngx_devel_kit \
    --add-module=../encrypted-session-nginx-module

重新编译Nginx二进制，Nginx需要quit再启动。而普通配置更新则reload即可：

1. kill -HUP `cat /path/nginx/logs/nginx.pid`
2. /path/nginx/sbin/nginx -s reload

在测试之前，需要配置encrypted_session_key（长度32位）和encrypted_session_iv（长度16位）。

encrypted_session_key "abcdefghijklmnopqrstuvwxyz123456";
encrypted_session_iv "1234567812345678";
encrypted_session_expires 5; # 默认过期时间是1d（一天）

话不到多说，直接来读写示例：

写入session，测试session名为name，值是smallfish。

location /session-write {
    set $name 'smallfish';
    set_encrypt_session $session_name $name;
    set_encode_base32 $session_name;
    add_header "Set-Cookie" "name=$session_name";
    echo "write name: $session_name";
}

读取session，Nginx读取Cookie方式为：$cookie_xxx。xxx为cookie的名称。

location /session-read {
    set_decode_base32 $session_name $cookie_name;
    set_decrypt_session $name $session_name;
    echo "read name: $name";
}

END

Nginx 第三方模块试用记

2011-10-30T00:00:00-07:00

最近试用了几个@agentzh写的第三方Nginx模块，甚为愉悦，没想到在Nginx可以玩很多技巧和扩展，分享一下。

本文尝试的几个模块大概分为：

echo
memcached
nginx
lua

详细模块地址分别为：

ngx_devel_kit https://github.com/simpl/ngx_devel_kit
set-misc-nginx-module https://github.com/agentzh/set-misc-nginx-module
memc-nginx-module https://github.com/agentzh/memc-nginx-module
echo-nginx-module https://github.com/agentzh/echo-nginx-module
lua-nginx-module https://github.com/chaoslawful/lua-nginx-module
srcache-nginx-module https://github.com/agentzh/srcache-nginx-module
drizzle-nginx-module https://github.com/chaoslawful/drizzle-nginx-module
rds-json-nginx-module https://github.com/agentzh/rds-json-nginx-module

为了省事这里一股脑把上面的module全部下载好，一起编译。PS：如果更懒惰的可以尝试下openresty项目，它帮你打包好Nginx和一堆扩展模块，得感谢@agentzh。

这里编译和drizzle和lua模块，在编译Nginx之前需要设置一下这两个库的LIB和INCLUDE文件地址：

-- lua --
export LUA_LIB=/path/to/lua/lib
export LUA_INC=/path/to/lua/include

-- drizzle --
export LIBDRIZZLE_INC=/opt/drizzle/include/libdrizzle-1.0
export LIBDRIZZLE_LIB=/opt/drizzle/lib

Nginx编译选项如下，请注意先后顺序：

./configure --prefix=/opt/nginx \
    --with-pcre=../pcre \
    --add-module=../ngx_devel_kit \
    --add-module=../set-misc-nginx-module \
    --add-module=../memc-nginx-module \
    --add-module=../echo-nginx-module \
    --add-module=../lua-nginx-module \
    --add-module=../srcache-nginx-module \
    --add-module=../drizzle-nginx-module \
    --add-module=../rds-json-nginx-module

重新编译Nginx二进制，Nginx需要quit再启动。而普通配置更新则reload即可：

1. kill -HUP `cat /path/nginx/logs/nginx.pid`
2. /path/nginx/sbin/nginx -s reload

PS：详细的模块编译可以参考各自模块的文档说明。

好吧，假设到这里已经安装和编译好Nginx以及一堆第三方扩展。下面开始尝试上面那些有趣的模块~

场景1：Helloworld

程序里helloworld很简单，nginx的hello如何实现呢？

1. 最简单的helloworld
location /hello1 {
    echo "hello 1111!";
}

2. 异步请求其他echo请求
location /hello2 {
    echo "hello 2222!";
    echo_location_async /hello1;
}

3. 输出GET请求参数，假设参数名是name，这里并对name参数进行解码
location /hello3 {
    set_unescape_uri $name $arg_name;
    set_if_empty $name "None";
    echo "hello, $name!";
}

是不是很帅气有趣。例2中的subrequest是完全non-blocking的。
echo模块还有timer扩展，页面输出加载时间也是小case了。

场景2：Memcached HTTP 接口

想当年哥为了兼容不同语言的api，自己封装了memcached操作，真是挺苦逼的，当时还非常羡慕tokyotyrant的http接口来着，现在用memc模块效果一样，还有upstream和keepalive功能哦~

location /memcached {
    set $memc_cmd $arg_cmd;
    set $memc_key $arg_key;
    set $memc_value $arg_val;
    set $memc_exptime $arg_exptime;
    memc_pass 127.0.0.1:11211;
}

URL访问类似 http://host:port/memcached?cmd=aaa&key=bbb&val=ccc

还需要自己封装么？完全的基于url编程了，不再考虑各自语言的memcached api，cluster也简化了。

场景3：数据库查询

这里用了libdrizzle模块，兼容MySQL、Drizzle、SQLite数据库。有时候为了一些查询或者接口，还需要用语言来封装一些数据库查询操作，现在直接通过drizzle模块可以很轻松的做到~~

# 添加MySQL配置
upstream mysql {
    drizzle_server 127.0.0.1:3306 dbname=test user=smallfish password=123 protocol=mysql;
}

# 通过url匹配出name，并编码防止注入，最后以json格式输出结果。
location ~ '^/mysql/(.*)' {
    set $name $1;
    set_quote_sql_str $quote_name $name;
    set $sql "SELECT * FROM users WHERE name=$quote_name";
    drizzle_query $sql;
    drizzle_pass mysql;
    rds_json on;
}

# 查看MySQL服务状态，这个很实用哦。
location /mysql-status {
    drizzle_status;
}

场景4：lua扩展

内嵌lua语言，超级牛力哦~~~想干啥都可以了，而且还可以充分发挥lua coroutine的风骚，淘宝量子统计完全是lua扩展。

location /lua1 {
    default_type 'text/plain';
    content_by_lua 'ngx.say("hello, lua")';
}

# 请求另外的url
location /lua2 {
    content_by_lua '
        local res = ngx.location.capture("/hello1")
        ngx.say("data: " .. res.body)
     ';
}

Lua支持的选项很多，具体可参考官网WIKI文档。

嗯，这里尝试玩了几个模块，详细的例子可以参考各自的模块文档，里面都有详细的说明和选项配置。

可以看出和传统编程有些微不同之处，完全是基于URL的HTTP接口，比传统的方式更为简单，更为清晰。还有non-blocking的实现，更见轻便。

END

auto-xhprof PHP自动性能测试工具

2011-09-15T00:00:00-07:00

auto-xhprof 项目地址： https://github.com/smallfish/auto-xhprof

最近需要对一些PHP应用和底层函数进行一些排错和性能方面的分析，不由得想起xhprof这个小强的利器。

当然也可以按照官方的示例来监控应用或者页面的数据，使用起来还是有点不爽。比如想监控所有访问超过2秒的页面性能情况，或者自动打开/关闭分析，请求url、响应时间等。

随手基于xhprof写了一个扩展小工具。

主要思路如下：

通过修改php.ini中的auto_prepend_file可以预加载auto-xhprof.php，自动打开xhprof功能。

;php.ini
auto_prepend_file = '/path/prepend.php'

; <?php
;    include_once '/path/auto-xhprof.php';
; ?>

主要功能点有如下：

参数配置是否自动开启xhprof。
参数配置超时的阀值，比如2秒。
保存分析后的数据到MySQL中，供集中统一分析。
数据内容含：请求的URL、相应时间。
支持gearman异步保存数据。
提供封装的xhprof_start/xhprof_end对部分程序进行手动分析。
自动记录错误信息

图一（列表显示）：

图二（部分函数显示）：

源码文件说明：

auto-xhprof.php         全局加载文件。
auto-xhprof-config.php  全局配置文件，设置MySQL数据库和参数等。
gearman-worker.php      gearman后台处理worker进程。
web/                    web显示目录，xhprof列表页面和原xhprof展示部分
xhprof_lib/             xhprof库文件。

--------- 扩展安装步骤 ---------

编译xhprof.so扩展

% cd <xhprof_source_directory>/extension/
% phpize
% ./configure --with-php-config=<path to php-config>
% make
% make install

修改php.ini中extension，以支持xhprof扩展

[xhprof]
extension=xhprof.so
xhprof.output_dir=<directory> ; 需要有写入权限，可以写/tmp，或者不设置

从github上下载auto-xhprof，并配置。

1. 非web目录拷贝到系统php include目录下，比如：/usr/include。
2. web目录拷贝到可访问的应用目录下。比如：/var/www/app1/web，前端访问为：http://app1/web/
3. 修改auto-xhprof-config.php中相应的数据库配置，超时阀值等参数。

到这里，基本安装和配置结束了，访问web目录可以看到xhprof列表信息。

另外，如果支持gearman扩展的话，需要在php.ini中启动该扩展，并在auto-xhprof-config.php中配置：

define('__XHPROF_GERAMAN_SERVERS', '127.0.0.1:4730;127.0.0.1:4730'); // gearman 服务器定义

% gearmand -vvv -q libdrizzle --libdrizzle-host=127.0.0.1\
   --libdrizzle-user=root --libdrizzle-password=123456 --libdrizzle-db=gearman\
      --libdrizzle-table=queue --libdrizzle-mysql

% php gearman-worker.php

supervisor - Python进程管理工具

2011-05-31T00:00:00-07:00

经常会碰到要写一些守护进程，简单做法放入后台：

shell> nohup python xxx.py &

偶尔这么做还可以接受，如果一堆这样的呢？

当然还有一个问题，就是各种服务，对应的命令或者路径都不太一致，比如Apache、MySQL或者其他自行编译的工具。

如果可以统一管理这些应用，是不是很哈皮？

按照惯例现Google一把，不失所望找到一个神奇的利器。supervisor！

supervisor地址：http://supervisord.org，官方标语就是：一个进程管理工具。

安装：

shell> sudo aptitude install supervisor # pip/easy_install

也可以通过其他包管理来安装，比如apt/yum等。

安装好以后，有两个可执行文件和一个配置文件（平台差异，可能路径不一致）：

/usr/bin/supervisord             --  supervisor服务守护进程
/usr/bin/supervisorctl           --  supervisor服务控制程序，比如：status/start/stop/restart xx 等
/etc/supervisor/supervisord.conf --  配置文件，定义服务名称以及接口等等

下面来一个示例，用web.py写一个hello的程序：

import web

urls = (
    '/(.*)','hello'
)

app = web.application(urls, globals())

class hello:
    def GET(self, name):
        return 'hello: ' + name

if __name__ == '__main__':
    app.run()

这个时候可以直接启动这个程序了，下面来配置supervisor，加入管理。修改supervisord.conf，加入如下片段：

[program:hello]
command=python /home/smallfish/hello.py
autorstart=true
stdout_logfile=/home/smallfish/hello.log

上面的意思应该很容易懂，program后面跟服务的名称，command是程序的执行路径，autorstart是表示自动启动，stdout_logfile是捕获标准输出。

到这里，基本搞定了，下面就是启动管理：

shell> sudo /etc/init.d/supervisor start   -- 启动supervisor服务

shell> sudo supervisorctl status hello     -- 获取hello服务的状态，因为是autorstart，这里已经启动了
hello  RUNNING    pid 1159, uptime 0:20:32

shell> sudo supervisorctl stop hello       -- 停止hello服务
hello: stopped

shell> sudo supervisorctl stop hello       -- 再次停止hello，会有错误信息
hello: ERROR (not running)

shell> sudo supervisorctl start hello      -- 启动hello服务
hello: started

OK，基本的操作就是类似这个了，仔细看supervisord.conf文件里会发现有一段[unix_http_server]的配置，默认是9001端口，可以输入用户名和密码，主要用于Basic Auth认证用的。

填写一下，然后重启supervisor服务，打开浏览器输入：http://localhost:9001，如图：

pythonbrew - Python多版本管理利器

2011-04-03T00:00:00-07:00

相信不少人在自己机器上有多个Python版本，我的机器上Python有四个版本：2.5.x、2.6.x、2.7和stackless。

测试Google App Engine时候需要切换到2.5，正式调试时候回归到2.6，自己玩的时候会选择2.7或者stackless，每次都是通过bash profile来调整，或者手动加link。真麻烦那。。。

无意间看到有一个Perl版本的brew工具：http://search.cpan.org/~gugod/App-perlbrew-0.18/bin/perlbrew！

安装：

$ easy_install pythonbrew
$ pythonbrew_install

# 或手动下载
$ curl -kLO http://github.com/utahta/pythonbrew/raw/master/pythonbrew-install
$ chmod +x pythonbrew-install
$ ./pythonbrew-install

把 source /xxx/.pythonbrew/etc/bashrc 加入到自己profile或者bashrc中去（xxx是自己的用户目录）

pythonbrew 常用命令如下：

install 安装版本：

$ pythonbrew install 2.6.6
过程可以参考安装日志：~/.pythonbrew/log/build.log
如果最后看到make error失败，应该是test过程失败。可以采取：
$ pythonbrew install --force 2.6.6

switch 选择版本：

$ pythonbrew switch 2.6.6

list 查看版本：

$ pythonbrew list       # 列出目前已安装的版本
pythonbrew list -k  # 列出可以下载和安装的版本

uninstall 卸载版本：

$ pythonbrew uninstall 2.6.6

参数还是很简单的。详见help或者http://pypi.python.org/pypi/pythonbrew/。

互联网产品与技术的那些杂事儿

2011-02-19T00:00:00-08:00

杂谈一下，我不是搞产品的也不是搞技术的，只是一个打杂的。随便扯谈一下。

作为一个产品，既然有这个名称，必定有其定位。在构思之前，就必须有明确的针对人群。比如是针对年轻人（80、90），抑或者上班族等等。模糊与笼统的定位，带来的只是无谓的“探索”。定位不是靠摸索出来的，也不是磨打出来的，是在你的脑海里，在你的产品里。即使现在模仿风气如此浓厚的时候，需要的也是定位。你的定位在哪儿，注定成就怎样的结果。

有了想法，下面就是一些调查和思考。你的这些针对人群在你的产品你会喜欢什么，会怎样的习惯？这个时候需要做的就是多和你的目标与非目标受众多去聊天，多去发觉他们的喜好与需求。或许你的改动只在某时一句话。所谓的走出去，这一步是必须的。闭门造车，最后可能出来就是一个自个儿意淫的杯具。

初期的实现与原型。很多时候喜欢在白板或者纸上写点什么，画点什么。记住！这一些都不能丢弃，或者擦掉。或许只是一些顺手涂鸦，或者解乏的简笔画。原型设计不需要一个完整的流程图，应该突出其顺序和关键点，以及部分UI的展示。这个过程中可以适当让受众面参与进来，设计出非自己主观的思路。

好吧，其实这些过程是可以修改和整合的。毕竟咱写的是互联网应用，不会给你完整的需求文档，完整的流程图，那样还叫互联网么？那是外包（无贬义，含笑）。

到现在为止应该糅合一些技术的关键字，比如哪些可以做到，哪些比较复杂。哪些技术可取，哪些可以折中。在考虑这个阶段的时候，技术人员需要的更多的是倾听，而不是纠结在某个环节，或者抵制某些习惯与思路。你可以说下自己的观点与想法，但是记住这些只是你自己的主观出发点，代表不了什么（如果正好受众面就是你，那恭喜了！）。需要做的就是记录下需求，转为脑海中虚拟的实现与流淌。一切心中有谱之后，可以适当“讨价还价”。毕竟每个人说出的都是自己的想法。

该画出流程图了。和上面原型一样，记住，别随意擦掉。用小人也可以，用箭头也可以，或者圆圈。你描述的只是过程，不是漫画和小说。当然加上这些元素会显得你的设计更加有爱。流程图的初衷在于走通整个流程，以及画出关键点。大致抽象出各个模型、结构和交互情况。适当写些文档把，这个总没有坏处的。或许这就是设计文档的初稿。

选型。有了需求，有了流程。下面当然是选择怎么去实现。说到用什么，仁者见仁，智者见智。啥好？啥不好？不是道听途说。关键在于自己。这些年来，喜欢的一句话就是：用自己熟悉的、用自己顺手的。看看外面的世界，好东西太多了，难不成有兴趣什么都来用一下？清醒吧哥们。你不是科学家，不是搞研究的。有这个时间，完全可以把你自己熟悉的搞的更透彻。这里并不是抵制新的或者好的工具，要明白一点，这些工具的作用域在哪儿，如果对自己实在可能起不到啥作用，或者只是存在你的假想中，放放把。未来再尝试也不迟。

关键点的实现与雏形。套句时髦的话，这个是不是应该算架构和设计？抽象出大致的模块，划分出结构。不必太在意其完整性和准确性，只要能走通就好。一次都给你写完了，其他人都去喝茶看报纸？雏形嘛，你懂得。当然，还得明确具体的工具，比如语言、数据库、系统等等。一个准则：用自己熟悉的，外加一条：简单就好。

是不是有了大体的架子了？可能下面就是大工作量的体力活啦。当然，分配体力活也是一个很体力的事情。没有一个好的管理者，这个产品就是大家拆东墙补西墙，互相推诿的产物。大致的职责有：传承需求和变化，分配与监察。消化和理解需求，确实是个跟天赋有关的事情，如果都是一个顺序跑下来的，那也不叫互联网了。需要很好的沟通能力，纸面或者口头的描述，随时可能千变万化，一成不变，继续去做外包把（囧）。分配这个环节就跟经验有关了，多去发觉你团队中的兴趣与擅长，用其长处，适当补短。合适的人干合适的事情，嘛效率？这就出来了。大家都在干活，进度就需要自己不断的监控与调整，适当多给自己宽裕的时间，哪怕只是那么一两小时。凡事没绝对，多想，多看，总是对的。

实现。设计数据库，写类库，写页面。详细罗列的话估计一长串。然后就是拆分逻辑，拆分页面，拆分功能点，然后就是与之对应的整合和补充。说到这边，可能就有人会说，用某某类库，或者某某框架，某某工具。这一切都建立在对其了解的基础上。不要太迷信，同样的刀在不同人手上是不一样的，用的好才是好刀，用不好连茅草都不如。折腾的滋味自己尝把。不是用了啥就牛逼，而是解决了啥，针对性的解决才是牛逼的关键。所有的一切，都只不过是实现的一种手段。条条大路，都可以。不要太迷信××，那只是一个传说。没有万能的实现，只有不断的解决与重新审视。实现细节滤过。。。

测试。不是写几个TestCase就是测试，那个只是证明你的代码看起来没啥问题，当然也不仅仅是用了啥测试框架，多专业。都只是辅助工具。除去功能性的测试，需要的是注意细节上。如果仅仅只是能用，没错没bug。这个不是产品，或许就是留言版。当然应该提供更多的可用性、流畅性以及体验。

唉，一不小心快十二点了，洗洗睡吧。未完再补充。

Python Story

2011-02-19T00:00:00-08:00

http://www.slideshare.net/nnfish/python-story

http://static.slidesharecdn.com/swf/ssplayer2.swf?doc=pythonstory-100920035248-phpapp01&stripped_title=python-story&userName=nnfish

Pylons 入门实例教程 – 发布应用

2011-02-19T00:00:00-08:00

前面几篇教程简单讲述了如何使用 Pylons 进行 WEB 方面开发的步骤，包括简单的 Hello、表单和数据库操作等内容。本篇将描述一下如何在正式环境中发布基于 Pylons 的 WEB 应用。

测试环境：Nginx 0.8.53 + FastCGI 模式（需要安装 flup 模块）

pip install flup
# easy_install -U flup

测试代码，延用前面的 Hello 示例。

mac:python smallfish$ paster create -t pylons hello
mac:python smallfish$ cd hello/
mac:hello smallfish$ paster controller hi
mac:hello smallfish$ paster serve --reload development.ini

确保以上过程无错，访问：http://127.0.0.1:5000 可以看到默认页面。

好把，开始配置发布环境。需要修改 development.ini 配置文件，找到 [server:main] 节点，修改其中的 use 方式（默认是 egg:Paste#http）。

[server:main]
use = egg:PasteScript#flup_fcgi_thread
host = 0.0.0.0
port = 5000

另外建议修改 [DEFAULT] 节点中 debug = false，以免错误会打印具体的环境和堆栈信息。

到这里 Pylons 部分以及设置好了，如果出现一下错误：

LookupError: Entry point 'flup_fcgi_thread' not found in egg 'Paste'

请注意上面的 use 部分里是 PasteScript 而不是 Paste哦。淡定淡定，别光看后面的 http 改成 flup_fcgi_thread。

下面修改 Nginx 的配置 nginx.conf，修改其中 / 部分设置。

        location / {
            fastcgi_pass   127.0.0.1:5000;
            fastcgi_index  index;
            fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
            include        fastcgi_params;
            fastcgi_intercept_errors off;
        }

其中 fastcgi_pass 中 host 和 port 对应 development.ini 中的配置。

好把，这里可以启动，看看是否正确，请注意相应的目录。

启动 Pylons 部分（启动 daemon 进程，或参考搜狐邮箱使用的 http://mailteam.blog.sohu.com/136961251.html 来管理进程）：

mac:hello smallfish$ paster serve --reload development.ini  --daemon start
# 注意，正式环境中请去除 reload 参数
# daemon 后面参数有 start | stop | restart | status，可以很方便的管理进程

启动 Nginx 部分：

mac:~ smallfish$ sudo /opt/nginx/sbin/nginx

尝试一下访问： http://localhost/ 和 http://localhost/hi/index 。是不是都可以了？OK，到这里已经整合好了。

这里是采用 FastCGI 方式发布，当然还可以用默认 http 或者本地 socket 方式，然后通过 proxy_pass 方式转发过去也是可以的。

当然，这个只是简单示例，可能正式发布时候需要注意的事项比这个复杂的多。这里只是介绍一种方式而已。

希望通过这一系列的教程，希望能对喜欢 Python 和关注 Pylons 框架的朋友能有所帮助。

前几篇链接分别如下：

PostgreSQL Key-Value 数据类型 hstore 使用教程

2011-02-19T00:00:00-08:00

现在满地都是KV数据库的文字，PostgreSQL 也有类似的结构。不过是通过其强大的扩展方式实现的。

官网文档请参考：http://www.postgresql.org/docs/current/static/hstore.html

本文测试环境在 Mac OS 下，Pg采用源码编译。

编译 hstore 扩展

mac:~ smallfish$ cd Downloads/postgresql-9.0.1/contrib/hstore/
mac:hstore smallfish$ make
... 一堆编译信息
mac:hstore smallfish$ sudo make install

导入到数据库中，注意必须以 postgres 用户，如果需要装入到指定数据库，请指明。这里采用默认数据库。

mac:hstore smallfish$ ls /opt/postgresql/share/contrib/
hstore.sql     uninstall_hstore.sql
mac:hstore smallfish$ psql -U postgres -f /opt/postgresql/share/contrib/hstore.sql
... 一堆导入命令

进入数据库，建一个测试表

postgres=# CREATE TABLE testhstore (id SERIAL, value hstore);
NOTICE:  CREATE TABLE will create implicit sequence "testhstore_id_seq" for serial column "testhstore.id"
CREATE TABLE

查看下表结构

postgres=# \d
                List of relations
 Schema |       Name        |   Type   |  Owner
--------+-------------------+----------+----------
 public | testhstore        | table    | postgres
 public | testhstore_id_seq | sequence | postgres
(2 rows)

postgres=# \d testhstore;
                         Table "public.testhstore"
 Column |  Type   |                        Modifiers
--------+---------+---------------------------------------------------------
 id     | integer | not null default nextval('testhstore_id_seq'::regclass)
 value  | hstore  |

尝试下简单 hstore类型

postgres=# select 'a=>1, b=>2'::hstore;
       hstore
--------------------
 "a"=>"1", "b"=>"2"
(1 row)

postgres=# select 'a=>1, b=>a'::hstore;
       hstore
--------------------
 "a"=>"1", "b"=>"a"
(1 row)

写几条测试数据先

postgres=# INSERT INTO testhstore (value) VALUES ('name=>smallfish, age=>29'::hstore);
INSERT 0 1
postgres=# SELECT * FROM testhstore;
 id |              value
----+----------------------------------
  1 | "age"=>"29", "name"=>"smallfish"
(1 row)

postgres=# INSERT INTO testhstore (value) VALUES ('name=>nnfish, age=>20'::hstore);
INSERT 0 1
postgres=# INSERT INTO testhstore (value) VALUES ('name=>aaa, age=>30, addr=>China'::hstore);
INSERT 0 1

查看下所有数据

postgres=# SELECT * FROM testhstore;
 id |                    value
----+---------------------------------------------
  1 | "age"=>"29", "name"=>"smallfish"
  2 | "age"=>"20", "name"=>"nnfish"
  3 | "age"=>"30", "addr"=>"China", "name"=>"aaa"
(3 rows)

查询列里面的指定 key

postgres=# SELECT id, value->'name' AS name FROM testhstore;
 id |   name
----+-----------
  1 | smallfish
  2 | nnfish
  3 | aaa
(3 rows)

postgres=# SELECT id, value->'name', value->'age' AS age FROM testhstore;
 id | ?column?  | age
----+-----------+-----
  1 | smallfish | 29
  2 | nnfish    | 20
  3 | aaa       | 30
(3 rows)

修改列某 key 值

postgres=# UPDATE testhstore SET value=value||('addr=>Shanghai') WHERE id = 2;
UPDATE 1

postgres=# SELECT * FROM testhstore;
 id |                       value
----+---------------------------------------------------
  1 | "age"=>"29", "name"=>"smallfish"
  3 | "age"=>"30", "addr"=>"China", "name"=>"aaa"
  2 | "age"=>"20", "addr"=>"Shanghai", "name"=>"nnfish"
(3 rows)

删除列里某 key

postgres=# UPDATE testhstore SET value=delete(value, 'addr') WHERE id = 3;
UPDATE 1

postgres=# SELECT * FROM testhstore;
 id |                       value
----+---------------------------------------------------
  1 | "age"=>"29", "name"=>"smallfish"
  2 | "age"=>"20", "addr"=>"Shanghai", "name"=>"nnfish"
  3 | "age"=>"30", "name"=>"aaa"
(3 rows)

按条件查询列里某 key ，注意要数据类型，CAST 强转。默认都是字符串的值。

postgres=# SELECT * FROM testhstore WHERE (value->'age')::INT > 20;
 id |              value
----+----------------------------------
  1 | "age"=>"29", "name"=>"smallfish"
  3 | "age"=>"30", "name"=>"aaa"
(2 rows)

postgres=# SELECT * FROM testhstore WHERE value->'name' = 'smallfish';
 id |              value
----+----------------------------------
  1 | "age"=>"29", "name"=>"smallfish"
(1 row)

2010 – 继续前行的路上

2011-02-19T00:00:00-08:00

每一天都在前行的路上，而这一年似乎去的特别的快，特别的短暂。

一年的时间辗转三个城市，从南京到杭州，再到上海。一切的一切似乎都是昨天，那般的清晰。

其实很早就想离开工作快五年的公司，只不过是自己一直下不了决心。性格和患得患失一直左右着自己的思绪。时间的流逝，青春不再，或许再过些时间，或许什么都不是了。

偶然的机会，很荣幸的进入淘宝工作。能够从自己的小圈子走出来，去接触外面的世界。短短的几个月中，成长的内容明显的超过了前几年的积累。这不仅仅是技术的成长，更多的是人，是视野，是想法。这一切的一切，都得感谢淘宝的师兄和主管。回想前几年，自己的世界里只有去完成一些事情，而现在更多的是应该觉得自己主动解决一些事情。当然，沟通上面来的更为明显。程序久了，思维的方式都会定死，而接触其他的岗位，去了解他们人的思路和想法，很多思绪都会豁然开朗。

杭州之行匆匆而逝，来到了大上海，这个充满魔力和摩登的都市。说真的，自己尚未体会。换了新环境，适应是必须的。在试用期内很快直接切入项目，几个月很快过去了。虽然在一些问题上自己不能决定什么，但是还是很幸运，可以从项目最初的雏形，到现在已经测试发布，自己都在其中。其实这个正是自己所擅长的。我想的就是自己能够决定更多，能够参与的更多，当然，或许这个可能性还需要自己去努力，或许现实总是那般无力，或许。

一年的流水账，想说，并不容易。希望自己一直能够如此前行，走自己的路，知道自己需要什么，能够得到什么。足矣。

零点的钟声已过，回忆这一年，许许多多的人，给了自己很多很多的帮助，感谢一下。

何伟平：很感谢何老师的推荐，才能有机会进入淘宝这样的大公司。何老师的谦虚和热心，很值得自己去学习。很遗憾，至今未有机会请何老师吃顿饭。

康伯：在淘宝时候我的主管。很感谢他跟自己多次的交流，有想法就说，就交流。给了自己很多机会。他是我至今为止唯一一个在系统方面很膜拜的人。

大舞：淘宝入职时候的师兄。试用期内给了自己很多建议和指导，一个很帅很帅的男人。@kemin_ukl

春哥：非芒果台的那位。感谢春哥推荐了自己来盛大，还混了不少饭，春哥工作和生活的太多很值得码农学习和借鉴。@mcspring

道神：灰常牛叉的DD，感谢刚来魔都时候收留了俺这个码农。回头还要多搭讪，求其在Debian方面的经验。@lidaobing

群众：鄙人群里那些哥们，你们都是神一样的男人！因为有了你们，才有了欢乐！@marchliu @xiaoxiaolu @guangfengio 等等大牛们。

话不多说，祝愿那些把帮助和关心过我的人，新年能够身体健康，幸福快乐！

去迎接新的一年，我，继续在路上。

开源网页截屏工具 CutyCapt Linux 下安装和使用

2011-02-19T00:00:00-08:00

目的是想在服务器端生成某个网页的缩略图。Google了好久，发现一个好开源东西：CutyCapt。

系统：CentOS 5.5 官网：http://cutycapt.sourceforge.net/ 依赖：QT http://www.qtsoftware.com/

首次是在Debian下测试的，很顺利。换了CentOS不是太爽。具体安装和使用步骤如下：

下载RPM包

(64位)
wget http://dl.atrpms.net/el5-x86_64/atrpms/testing/qt44-4.4.3-10_4.el5.x86_64.rpm
wget http://dl.atrpms.net/el5-x86_64/atrpms/testing/qt44-x11-4.4.3-10_4.el5.x86_64.rpm
wget http://dl.atrpms.net/el5-x86_64/atrpms/testing/qt44-devel-4.4.3-10_4.el5.x86_64.rpm

(32位)
wget http://ftp.riken.go.jp/Linux/atrpms/el5-i386/atrpms/testing/qt44-4.4.3-10_4.el5.i386.rpm
wget http://ftp.riken.go.jp/Linux/atrpms/el5-i386/atrpms/testing/qt44-x11-4.4.3-10_4.el5.i386.rpm
wget http://ftp.riken.go.jp/Linux/atrpms/el5-i386/atrpms/testing/qt44-devel-4.4.3-10_4.el5.i386.rpm

安装 qt-devel 依赖包

yum install libXi-devel
yum install libXinerama-devel

安装 qt 相关

rpm -ivh qt44-4.4.3-10*
rpm -ivh qt44-x11-4.4.3-10*
# rpm -e qt-devel --nodeps --allmatches
rpm -ivh qt44-devel-4.4.3-10*

修改 /etc/profile，最后并：source /etc/profile

export QTDIR=/usr/lib64/qt44
export QTLIB=/usr/lib64/qt44/lib
export QTINC=/usr/lib64/qt44/include
export LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH
export PATH=$QTDIR/bin:$PATH

安装 cutycapt

svn co https://cutycapt.svn.sourceforge.net/svnroot/cutycapt
mv cutycapt/CutyCapt /usr/local/CutyCapt
cd /usr/local/CutyCapt
qmake
make

安装模拟 x-server 服务端

wget http://www.flexthinker.com/wp-content/uploads/2009/11/xvfb-run.sh.txt
mv ./xvfb-run.sh.txt /usr/local/CutyCapt/xvfb-run.sh
chmod u+x /usr/local/CutyCapt/xvfb-run.sh

开始欢快的截图吧

/usr/local/CutyCapt/xvfb-run.sh --server-args="-screen 0, 1024x768x24" /usr/local/CutyCapt/CutyCapt --url=http://www.163.com --out=163.jpg

如果看不到汉字或乱码，需要安装chinese字体

yum install fonts-chinese

由于截屏的是整个网站的页面，只需要第一屏幕

convert -crop 1024x768+0+0 163.jpg 1632.jpg

缩小图片

convert -resize 40%x40% 1632.jpg 1632.jpg

Pythonic 分享

2010-08-07T00:00:00-07:00

很荣幸收到龙哥 @hoorace 邀请去参加了杭州第四期程序员圆桌会议，顺带介绍了下最近在公司内部做的关于《Pythonic》分享。喜欢Python的可以下载看看把。

Pythonic[http://static.slidesharecdn.com/swf/ssplayer2.swf?doc=pythonic-100807044344-phpapp02&stripped_title=pythonic&userName=nnfish](http://static.slidesharecdn.com/swf/ssplayer2.swf?doc=pythonic-100807044344-phpapp02&stripped_title=pythonic&userName=nnfish)

View more [http://www.slideshare.net/](http://www.slideshare.net/).

收获还是颇丰，多接触了点其他工种的朋友。

话题比较宽泛，基本我就是纯酱油飘过。感谢网新的朋友做的Vim的分享，另外威猛的升哥topic也不错，对RedHat系统安装和启动加载有了更多的了解。

另外很遗憾的就是威大师竟然没说点啥，可惜了那么好的水果茶啊。。。残念残念。。

Pylons 入门实例教程 – cookie 和 session

2010-07-03T00:00:00-07:00

本篇讲述在 Pylons 里使用 cookie 和 session。

示例还是在上篇《Pylons 入门实例教程 – cookie 和 session》的代码里继续添加。先来尝试下 cookie，添加新的 cookietest controller。

修改 index 方法，添加显示部分：

    def index(self):
        name = 'NULL'
        if request.cookies.has_key('name'):
            name = request.cookies['name']
        return 'cookie name=%s' % name

cookie 读取可以通过 request.cookies 对象，类似一个字典结构。需要注意的是读取时候用最好 has_key 判断下，这样避免抛 KeyError 异常。当然你也可以 try...catch 捕获一下。

再重新写一个方法，用来写 cookie。

    def writecookie(self):
        response.set_cookie("name", "smallfish")
        return "write cookie ok"

这里只是简单设置一个值得，set_cookie 还有其他参数，具体如下：

set_cookie(self, key, value='', max_age=None, path='/', domain=None, secure=None,
                 httponly=False, version=None, comment=None, expires=None, overwrite=False)

基本一般需要设置：max_age，path，domain，expires 这几个参数。

下面再来尝试一下 session：

smallfish@debian:~/workspace/python/hellodb$ paster controller sessiontest
Creating /home/smallfish/workspace/python/hellodb/hellodb/controllers/sessiontest.py
Creating /home/smallfish/workspace/python/hellodb/hellodb/tests/functional/test_sessiontest.py

和上面 cookie 例子类似，在 controller 里有两个方法，index 负责显示 session，writesession 负责写。

    def index(self):
        name = session.get('name', 'NULL')
        return 'session name=%s' % name

    def writesession(self):
        session['name'] = 'smallfish'
        session.save()
        return "save session ok"

index 方法里 get 后面的 NULL 是默认值。writesession 里需要注意下设置 session 之后需要 save。

删除 session 可以尝试如下：

del session['name']
# 删除所有
session.delete()

到这里，WEB 常用的一些东西在 Pylons 里基本走了一圈，包含 URL、模板、数据库和会话部分。

下一节将会涉及怎么在 Nginx 上发布 Pylons 应用。

Pylons 入门实例教程 – 数据库操作

2010-07-01T00:00:00-07:00

前面两篇入门，讲述了 Pylons 大致开发的流程、表单以及文件上传，思路大致跟传统的开发类似。本篇简单讲述下在 Pylons 如何使用数据库。

本篇侧重点是使用 ORM 框架 http://www.sqlalchemy.org/。其实本人最早是研究了一下 Storm，后来听虾哥（@marchliu）在应用里不是很爽之，遂关注了下他推荐的 SQLAlchemy。当然，你也可以对应数据库的 DB-API 库来进行操作。

示例代码的数据库是 http://www.postgresql.org。至于 Pg 配置和使用这里不再累赘，请狗之。

Debian/Ubuntu 安装很简单：

sudo aptitude install python-psycopg2

建立一个测试数据库，比如 test：

smallfish@debian:~/workspace/python/hello$ su postgres
postgres@debian:/home/smallfish/workspace/python/hello$ createdb -O smallfish test
postgres@debian:/home/smallfish/workspace/python/hello$ exit
smallfish@debian:~/workspace/python/hello$ psql -h 127.0.0.1 -p 5432 -U smallfish test
用户 smallfish 的口令：
psql (8.4.4)
SSL连接 (加密：DHE-RSA-AES256-SHA，位元：256)

输入 "help" 来获取帮助信息.

test=#

数据库的部分已经OK，下面就是来倒腾 Pylons 啦。

建立新项目，加入支持数据库部分，注意 Enter sqlalchemy那个选项，默认是 False，改成 True：

smallfish@debian:~/workspace/python$ paster create -t pylons hellodb
Selected and implied templates:
  Pylons#pylons  Pylons application template

Variables:
  egg:      hellodb
  package:  hellodb
  project:  hellodb
Enter template_engine (mako/genshi/jinja2/etc: Template language) ['mako']:
Enter sqlalchemy (True/False: Include SQLAlchemy 0.5 configuration) [False]: True
Creating template pylons
Creating directory ./hellodb

改成 True 之后在自动生成的 development.ini 里就有对应的数据库配置选项了。

再建立新的 db controller：

smallfish@debian:~/workspace/python$ cd hellodb/
smallfish@debian:~/workspace/python/hellodb$ paster controller db
Creating /home/smallfish/workspace/python/hellodb/hellodb/controllers/db.py
Creating /home/smallfish/workspace/python/hellodb/hellodb/tests/functional/test_db.py

编辑 development.ini，添加数据库配置部分。smallfish:123456 是对应的 PostgreSQL 用户名/密码，127.0.0.1:5432 是对应的主机地址/端口号，最后的test则是数据库名。

# SQLAlchemy database URL
sqlalchemy.url = postgresql://smallfish:123456@127.0.0.1:5432/test

编辑 hellodb/model/init.py，加上一个叫 msg 的表和字段的定义：

"""The application's model objects"""
from hellodb.model.meta import Session, metadata

from sqlalchemy import orm, schema, types
from datetime import datetime

def init_model(engine):
    """Call me before using any of the tables or classes in the model"""
    Session.configure(bind=engine)

def now():
    return datetime.now()

msg_table = schema.Table('msg', metadata,
    schema.Column('id', types.Integer, schema.Sequence('msg_seq_id', optional=True), primary_key=True),
    schema.Column('content', types.Text(), nullable=False),
    schema.Column('addtime', types.DateTime(), default=now),
)

class Msg(object):
    pass

orm.mapper(Msg, msg_table)

示例 Msg 表很简单，三个字段：ID、内容和时间。

上面的代码除去导入 sqlclchemy 包里几个库，基本上有一个对应表的字段定义，还有一个空的 Msg 对象。

最后一行，则是做一个 map 的动作，把 Msg 映射到 msg_table 上。

下面是不是要在数据库里建立对应的表呢？有个简单的办法可以初始化数据库：paster setup-app development.ini：

smallfish@debian:~/workspace/python/hellodb$ paster setup-app development.ini
Running setup_config() from hellodb.websetup
20:08:43,619 INFO  [sqlalchemy.engine.base.Engine.0x...854c] [MainThread] select version()
20:08:43,619 INFO  [sqlalchemy.engine.base.Engine.0x...854c] [MainThread] {}
20:08:43,625 INFO  [sqlalchemy.engine.base.Engine.0x...854c] [MainThread] select current_schema()
20:08:43,625 INFO  [sqlalchemy.engine.base.Engine.0x...854c] [MainThread] {}
20:08:43,631 INFO  [sqlalchemy.engine.base.Engine.0x...854c] [MainThread] select relname from pg_class c join pg_namespace n on n.oid=c.relnamespace where n.nspname=current_schema() and lower(relname)=%(name)s
20:08:43,631 INFO  [sqlalchemy.engine.base.Engine.0x...854c] [MainThread] {'name': u'msg'}
20:08:43,637 INFO  [sqlalchemy.engine.base.Engine.0x...854c] [MainThread]
CREATE TABLE msg (
        id SERIAL NOT NULL,
        content TEXT NOT NULL,
        addtime TIMESTAMP WITHOUT TIME ZONE,
        PRIMARY KEY (id)
)

20:08:43,637 INFO  [sqlalchemy.engine.base.Engine.0x...854c] [MainThread] {}
20:08:43,732 INFO  [sqlalchemy.engine.base.Engine.0x...854c] [MainThread] COMMIT

可以看到上面的输出日志，包括了建表的SQL语句。其中 SERIAL 对应上面 init.py 里 Column 的 Seq 定义。serial 类型在 PostgreSQL 可以看成类似 MySQL 的自增ID（auto_increment）。

现在进入 PostgreSQL 查询数据库，就可以看到表以及序列已经建立。

test=# \d
                  关联列表
 架构模式 |    名称    |  型别  |  拥有者
----------+------------+--------+-----------
 public   | msg        | 资料表 | smallfish
 public   | msg_id_seq | 序列数 | smallfish
(2 行记录)

到这里，准备工作已经完毕，包括了初始化数据库，配置文件还有示例 controller。

下面就在 controller 代码里增加读写数据库的功能吧。

首先建立一个表单模板 db.htm ，用来添加并保存到数据库表中：

<form action="/db/add" method="post">
    <input type="text" name="content" />
    <br />
    <input type="submit" value="save" />
</form>

对应 controller index 修改成，很简单。返回到模板：

class DbController(BaseController):

    def index(self):
        return render('/db.htm')

添加 add 方法，对应上面 form 中的 /db/add 路径：

    def add(self):
        content = request.POST['content']
        from hellodb import model
        msg = model.Msg()
        msg.content = content
        model.meta.Session.add(msg)
        model.meta.Session.commit()
        return "add %s ok..." % content

添加部分简单完成。获取 POST 文本框，然后初始化一个 Msg 对象（上面 model 里定义的）。

注意 add 之后，必须手动 commit，这样才会真正保存到数据库。

浏览器访问一下：http://127.0.0.1:5000/db/index，随意添加一点数据吧，这个时候你可以在 PostgreSQL 里查询已经数据已经加进来了。

下面在 index 方法传递一些值到模板，输出刚才已经添加的数据：

    def index(self):
        from hellodb import model
        c.msgs = model.meta.Session.query(model.Msg).all()
        return render('/db.htm')

c.msgs 可以理解成全局变量，关于 c 的定义在 controller前几行就应该看到了。修改模板 db.htm 显示记录：

% for msg in c.msgs:
<p>${msg.id}: ${msg.content} / ${msg.addtime}</p>
% endfor

很简单，只是一个普通 for 循环，遍历 index 方式里传递的 c.msgs。Mako模板还是很易读的吧？

继续刷新下：http://127.0.0.1:5000/db/index，可以在页面上看到已经添加的数据了。

在狂输入了几十条之后，在一页里显示是不是忒土鳖了？

下面再介绍下 Pylons 里 webhelper 里一个分页组件的用法，当然你也可以自己写分页算法。下面是示例：

    def list(self):
        from webhelpers import paginate
        from hellodb import model
        msgs = model.meta.Session.query(model.Msg)
        c.paginator = paginate.Page(
            msgs,
            page=int(request.params.get('page', 1)),
            items_per_page = 10,
        )
        return render("/list.htm")

导入 paginate，然后把查询的数据库对象当参数传递给 paginate.Page，里面的page则是页面的传递的页数参数，items_per_page 就好理解多了，就是多少条一页。这里是10条。

对应的模板 list.htm 如下：

<pre>
% if len(c.paginator):

% for msg in c.paginator:
<p>${msg.id}: ${msg.content}</p>
% endfor

<p> ${c.paginator.pager("count: $item_count $first_item to $last_item , $link_first $link_previous $link_next $link_last")} </p>
% endif

for 部分如同上面示例，下面加了一行pager。里面一些变量从名字上就可以看出功能了。包括了总条数、当前是第几到第几条，然后就是常用的首页、上页、下页和最后一页。

这里链接的文字都是<<， <， >， >>。想改成文字请查看文档吧。。如果是第一页，是不会显示首页和上一页的。这个做过分页的一般都写过类似的代码吧。

现在访问：http://127.0.0.1:5000/db/list，想看到效果当然你得多填点数据哦。10条才会显示分页的挖。

好了，这里对数据库增加和显示部分都已经有示例代码了，当然最后还有一个分页用法。至于删除和更新之类请参考 SQLAlchemy 文档吧。

Pylons 入门实例教程 – 表单和文件上传

2010-06-30T00:00:00-07:00

继续上一篇《Pylons 入门实例教程 - Hello》，现在开始讲在 Pylons 里如何提交表单和上传文件。

继续延用上篇里面的 hello 工程，在 HiController 里添加 form 方法：

    def form(self):
        return render('/form.mako')

加完以后可以访问：http://127.0.0.1:5000/hi/form，会报错。

Server Error，根据报错内容大致就知道模板文件不存在了。如果有其他错误，也可以通过这个页面查看，当然还有很强大的 Debug 个功能哦。当然正式环境一般都是关闭这个功能的。这个，你懂得。。。

好吧，写一个表单的模板，只包含一个简单的文本框和提交按钮示例。

<form action="/hi/submit" method="post">
name: <input type="text" name="name" />
<br />
<input type="submit" value="submit" />
</form>

再添加一个 submit 方法来处理表单提交，

    def submit(self):
        return "hello, name: %s" % request.params['name']

request.params 包含了表单或者URL提交的参数，建议 POST 数据参照下面的上传部分。想获取更详细的列表，可以查看文档或者自己手动 dir()查阅。

下面尝试一下文件上传，首先在 development.ini 添加一个变量，用来存放文件上传后的文件夹。

[app:main]
upload_dir = %(here)s/upload

%(here) 启动后 server 会替换到当前目录地址，上面的地址就是当前路径下的upload文件夹。

修改一下刚才的表单，加一个 file 上传，注意 multipart/form-data 这句，上传必须。

<form action="/hi/submit" method="post"  enctype= "multipart/form-data">
name: <input type="text" name="name" />
<br />
file: <input type="file" name="file" />
<br />
<input type="submit" value="submit" />
</form>

修改 submit 方法，添加文件内容：

    def submit(self):
        name   = request.POST['name']
        myfile = request.POST['file']
        import os
        import shutil
        from pylons import config
        local_name = os.path.join(config['app_conf']['upload_dir'], myfile.filename)
        local_file = open(local_name, "wb")
        shutil.copyfileobj(myfile.file, local_file)
        myfile.file.close()
        local_file.close()
        return "hello, name: %s, upload: %s" % (name, myfile.filename)

里面 import 部分这里仅仅为了示例，正式的代码请放入程序开头部分，POST 内容可以从 request.POST 获取。

config['app_conf']['upload_dir'] 就是刚才配置里 development.ini 定义的地址。这个目录需要自己手动创建哦。

smallfish@debian:~/workspace/python/hello$ mkdir upload

OK，到这里程序部分都已经修改完成。重新访问一下：http://127.0.0.1:5000/hi/form

尝试一下上传，上传后可以在 upload 文件夹下看到文件了吧。。

当然这里只是示例，还需要处理一下上传的名字，防止有特殊符号哦。

如何写 Go 代码？

2010-06-29T00:00:00-07:00

原文：http://golang.org/doc/code.html

简述

这篇文档描述了如何去写一个新的 package 和怎么去测试。本文假设你已经按照http://golang.org/doc/install.html装好Go。

在修改一个存在的 package 或者新建立一个package，确保先发一封邮件到 http://groups.google.com/group/golang-nuts，告诉大家你想做什么。这样有助于不要重复造轮子，在写代码之前最好讨论下。

社区资源

如果想获取实时帮助，可以加入 http://freenode.net/ 上 IRC 频道 #go-nuts。

Go 语言官方邮件列表是 http://groups.google.com/group/golang-nuts.

Bugs 可以参考http://code.google.com/p/go/issues/list.

对于那些想尝试开发代码的用户，这里有另外一个邮件列表 http://groups.google.com/group/golang-checkins，邮件里包含了那些刚提交到 Go 代码库的消息。

建立Go包

下面的源码假设 package 的导入路径是 x/y，约定下保存的路径是：$GOROOT/src/pkg/x/y

Makefile

这将是很好的利用 Go-specific 工具里安排源码结构，如何按照顺序和构建代码。Go 使用 GUN make。所以首先在一个新的package 文件夹里建立一个 Makefile。最简单的做法就是从 http://golang.org/src/pkg/container/vector/Makefile 源码包里拷贝一份。

include ../../../Make.$(GOARCH)

TARG=container/vector
GOFILES=\
    intvector.go\
    stringvector.go\
    vector.go\

include ../../../Make.pkg

当然在上面的源码包之外写一个新的 package ，通常的 Makefile 如下：

include $(GOROOT)/src/Make.$(GOARCH)

TARG=mypackage
GOFILES=\
    my1.go\
    my2.go\

include $(GOROOT)/src/Make.pkg

第一行 include 标准的定义和规则，package 的路径一般相对路径来代替 $(GOROOT)/src ，这样做到目的就是防止 make 时候 $(GOROOT) 含有空格，这样做很方便开发中使用Go。

TRAG 是包安装路径，这行就是其他程序导入到名字。在 Go 源码中，这个名字必须和文件夹中的 Makefile 中的一致，不需要 $GOROOT/src/pkg/ 前缀。在源码之外，你可以任意起名而不要和标准 package 的重名即可。常见的做法是独立一个 package 名：myname/tree, myname/filter，确保你的代码在 myname 里，运行 make install，将会编译后把二进制文件放入 $GOROOT/pkg，可以很方便的找到。

GOFILES 放入文件内需要编译的源码列表。多行用 \ 字符隔开。

如果想在 Go 源码树中新建包，需要添加列表到 $GOROOT/src/pkg/Makefile 中作为标准库编译，编译运行：

cd $GOROOT/src/pkg
./deps.b

更新依赖文件 Make.deps （这是每次 make all 或者 make build 都需要）

Go 源文件

在每个源码里第一行的名字应该是 Makefile 里面定义的 package 名，这里的 name 是作为默认的名字导入。（包里的每个 package 名都应该是同样的名字）Go的惯例是用路径的最后一个元素作为名字，比如 "crypto/rot13" 应该是 rot13。到目前为止，Go 是依靠 package 名字来确定一个二进制的文件，当然可能会很快的取消。

Go 是在一个包内编译源码文件，在一个文件定义常量，变量，类型或者函数，在其他文件内适用不需要再定义和声明。

想写一个干净而优美的 Go 代码不在本文范围。请参考http://golang.org/doc/effective_go.html吧。

测试

Go 有一个轻量级的测试代码框架：gotest。编写一个测试代码，只需要新建一个跟你源码名字一样，加上：_test.go 即可，测试函数一般是 func TestXXX (t *testing.T)。每次运行测试其中的函数。如果想返回错误的话一般是返回： t.Error 或 t.Fail，测试时候就会抛错。详细 gotest 测试方法请参考：http://golang.org/cmd/gotest/

*_test.go 不需要在 Makefile 中声明。

运行测试，编译时候 make test 即可，和 gotest 效果一样。如果想单独测试某一个源码，比如：one_test.go，则运行：gotest one_test.go。

如果你的修改影响性能，可以添加一个性能测试函数（参考：http://golang.org/cmd/gotest/），然后运行：gotest -benchmarks=.

当你新的代码已经通过测试，也能运行，你就可以 review 和 commit. http://golang.org/doc/contribute.html。

一个测试的例子

这是一个名字叫 numbers 测试 package ，定义了一个叫 Double 的函数，返回一个整型，结果是输入的参数乘以2。一共有三个文件。

第一个是 numbers.go

package numbers

func Double(i int) int {
    return i * 2
}

第二个是测试文件 numbers_test.go

package numbers

import (
    "testing"
)

type doubleTest struct {
    in, out int
}

var doubleTests = []doubleTest{
    doubleTest{1, 2},
    doubleTest{2, 4},
    doubleTest{-5, -10},
}

func TestDouble(t *testing.T) {
    for _, dt := range doubleTests {
        v := Double(dt.in)
        if v != dt.out {
            t.Errorf("Double(%d) = %d, want %d.", dt.in, v, dt.out)
        }
    }
}

最后是 Makefile 文件

include $(GOROOT)/src/Make.$(GOARCH)

TARG=numbers
GOFILES=\
    numbers.go\

include $(GOROOT)/src/Make.

运行 make install 将会构建和安装包到 GOROOT/pkg/ 文件夹内（他在系统的任何地方导入调用）。

运行 make test （或者 gotest）将会重新构建包，并会运行 numbers_test.go 中的 TestDouble 函数。如果输出 "PASS" 则表示测试成功通过。如果不是2到3的倍数，将会看到错误报告。

更详细的请查看http://golang.org/cmd/gotest/文档。

Pylons 入门实例教程 - Hello

2010-06-28T00:00:00-07:00

http://pylonshq.com/，当然，这些组件只是默认，你还可以根据自己喜好来选择其他组件，比如你可以采用 Jinja2 或 Genshi 模板，ORM也可以采用 SQLObject。完全是自由组合。

废话少说，现在开始安装吧。

smallfish@debian:~$ sudo aptitude install python-pylons

Debian/Ubuntu 系列系统可以直接 aptitude 安装，当然你也可以使用 easy_install 或者源码安装。

smallfish@debian:~$ sudo easy_install Pylons

更多安装文档请参考官网安装部分，http://pylonshq.com/docs/en/1.0/gettingstarted/#installing

好了，安装结束，来一个经典的Hello程序吧。

smallfish@debian:~/workspace/python$ paster create -t pylons hello
Selected and implied templates:
  Pylons#pylons  Pylons application template

Variables:
  egg:      hello
  package:  hello
  project:  hello
Enter template_engine (mako/genshi/jinja2/etc: Template language) ['mako']:
Enter sqlalchemy (True/False: Include SQLAlchemy 0.5 configuration) [False]:
Creating template pylons
Creating directory ./hello

下面输出略过，大致解说一下。Pylons 程序可以用 Paste 自动生成一些代码，包括controller。还可以运行 HTTP 服务来测试。

-t 表示自动创建的模板，可以如下来查看有哪些选项，更多就参考 help 吧。

smallfish@debian:~/workspace/python/hello$ paster create --list-templates
Available templates:
  basic_package:   A basic setuptools-enabled package
  paste_deploy:    A web application deployed through paste.deploy
  pylons:          Pylons application template
  pylons_minimal:  Pylons minimal application template

看一下hello的目录结构：

smallfish@debian:~/workspace/python/hello$ ls
development.ini  ez_setup.py  hello.egg-info  README.txt  setup.py
docs             hello        MANIFEST.in     setup.cfg   test.ini

这里具体各个文件意思就不讲解了，程序主体部分都在hello/hello目录下，development.ini 和 test.ini 分别是服务启动的配置文件，用于测试和开发环境。开始先运行一下，看效果吧。。

smallfish@debian:~/workspace/python/hello$ paster serve --reload development.ini
Starting subprocess with file monitor
Starting server in PID 1519.
serving on http://127.0.0.1:5000

在浏览器中打开：http://127.0.0.1:5000 看到页面了吧？恭喜。

继续，写一个简单的显示 hi的 controller 程序吧。

smallfish@debian:~/workspace/python/hello$ paster controller hi
Creating /home/smallfish/workspace/python/hello/hello/controllers/hi.py
Creating /home/smallfish/workspace/python/hello/hello/tests/functional/test_hi.py

自动生成程序和 test 文件。paster 启动服务不需要重启会自动加载，可以浏览器访问：http://127.0.0.1:5000/hi/index

很简单吧，打开 hi.py，基本如下：

class HiController(BaseController):

    def index(self):
        # Return a rendered template
        #return render('/hi.mako')
        # or, return a response
        return 'Hello World'

上面注释部分可以 return 一个模板文件，模板放入 templates 目录下即可。

去除上面的 return 'Hello' 返回 return render('/hi.mako')

smallfish@debian:~/workspace/python/hello$ vi hello/templates/hi.mako
% for key, value in request.environ.items():
 ${key} = ${value}
% endfor

刷新 http://127.0.0.1:5000/hi/index ，可以看到一些环境变量的输出了吧。

今天就简单的说到这里吧，下回来一个完整的例子，包括URL、模板、数据库和Session的实例。

PostgreSQL COPY 导入/导出数据

2010-06-02T00:00:00-07:00

COPY 命令可以快速的导入数据到 PostgreSQL 中，文件格式类似CVS之类。适合批量导入数据，比 \i 和恢复数据表快。

导出表数据到文件或 STDOUT ：

COPY tablename [(column [, ...])]
   TO {'filename' | STDOUT}
   [[WITH]
      [BINARY]
      [OIDS]
      [DELIMITER [AS] 'delimiter']
      [NULL [AS] 'null string']
      [CSV [HEADER]
         [QUOTE [AS] 'quote']
         [ESCAPE [AS] 'escape']
         [FORCE NOT NULL column [, ...]]

导入文件或者 STDIN 到表中：

COPY tablename [(column [, ...])]
   FROM {'filename' | STDIN}
   [[WITH]
      [BINARY]
      [OIDS]
      [DELIMITER [AS] 'delimiter']
      [NULL [AS] 'null string']
      [CSV [HEADER]
         [QUOTE [AS] 'quote']
         [ESCAPE [AS] 'escape']
         [FORCE QUOTE column [, ...]]

导出表 employee 到默认输出 STDOUT：

psql> COPY employee TO STDOUT;
1       JG100011        Jason Gilmore         jason@example.com
2       RT435234        Robert Treat          rob@example.com
3       GS998909        Greg Sabino Mullane   greg@example.com
4       MW777983        Matt Wade             matt@example.com

导出表 employee 到 sql 文件：

psql> COPY employee TO '/home/smallfish/employee.sql';

从文件导入数据：

psql> COPY employeenew FROM '/home/smallfish/employee.sql';
psql> SELECT * FROM employeenew;
employeeid  | employeecode |     name            |       email
------------+--------------+---------------------+---------------
          1 | JG100011     | Jason Gilmore       | jason@example.com
          2 | RT435234     | Robert Treat        | rob@example.com
          3 | GS998909     | Greg Sabino Mullane | greg@example.com
          4 | MW777983     | Matt Wade           | matt@example.com
(4 rows)

输出对象ID（OIDS）：

psql> COPY employee TO STDOUT OIDS;
24627  1       GM100011        Jason Gilmore         jason@example.com
24628  2       RT435234        Robert Treat          rob@example.com
24629  3       GS998909        Greg Sabino Mullane   greg@example.com
24630  4       MW777983        Matt Wade             matt@example.com

指定导出间隔符，默认是 \t ，这里为 | ：

psql>COPY employee TO STDOUT DELIMITER '|';
1|GM100011|Jason Gilmore|jason@example.com
2|RT435234|Robert Treat|rob@example.com
3|GS998909|Greg Sabino Mullane|greg@example.com
4|MW777983|Matt Wade|matt@example.com

导入文件数据，指定间隔符为 | ：

psql> COPY employeenew FROM '/home/smallfish/employee.sql' DELIMITER |;

导出指定字段的数据：

psql> COPY employee (name,email) TO STDOUT;
Jason Gilmore         jason@example.com
Robert Treat          rob@example.com
Greg Sabino Mullane   greg@example.com
Matt Wade             matt@example.com

为 NULL 字段设置默认值：

psql> COPY employee TO STDOUT NULL 'no email';
Jason Gilmore         no email
Robert Treat          rob@example.com
Greg Sabino Mullane   greg@example.com
Matt Wade             no email

导出为CVS格式：

psql> COPY employee (name, email) TO '/home/smallfish/employee.csv' CSV HEADER;

参考资料：http://apress.com/book/view/9781590595473

Go 语言模块安装工具：goinstall

2010-05-30T00:00:00-07:00

文档地址：http://golang.org/cmd/goinstall/

goinstall 主要是方便安装第三方模块，目前支持 hg(mercurial)，git，svn三种版本控制系统。

下面来举例怎么安装 web.go 模块。源地址是：http://github.com/hoisie/web.go

smallfish@debian:~$ goinstall -dashboard=true github.com/hoisie/web.go

根据网速快慢，过一段时间会结束。期间木有任何提示。（可以加上 -v=true 参数，可以显示安装过程和提示。）

查看下安装的目录和路径：

smallfish@debian:~$ ls $GOROOT/src/pkg/github.com/hoisie/web.go/
examples  _go_.8   Makefile  Readme.md   scgi.go       status.go  web_test.go
fcgi.go   LICENSE  _obj      request.go  servefile.go  web.go

代码示例：

import (web "github.com/hoisie/web.go")

另外注意点，官方文档里 -update 选项现在版本里已经缩写，改成 -u。

Cython 教程 - 调用外部C语言函数

2010-05-30T00:00:00-07:00

一般情况完全可以在 Python 里导入 from math import sin 然后调用 sin() 函数。然而，调用C里面的 sin() 函数速度会更快，尤其在复杂的循环里。在 Cython 里可以这样声明和使用：

cdef extern from "math.h":
    double sin(double)

cdef double f(double x):
    return sin(x*x)

请注意，上面的代码声明了 math.h 里的函数，提供给 Cython 使用。C编译器在编译时将会看到 math.h 的声明，但 Cython 不会去分析 math.h 和单独的定义。

当调用一个C函数时，一定要注意引入适当的链接库。这个依赖于特定的平台；下面的例子可以在Linux和Mac OS X下运行：

from distutils.core import setup
from distutils.extension import Extension
from Cython.Distutils import build_ext

ext_modules=[
    Extension("demo",
              ["demo.pyx"],
              libraries=["m"]) # Unix-like specific
]

setup(
  name = "Demos",
  cmdclass = {"build_ext": build_ext},
  ext_modules = ext_modules
)

跟从 math 库里使用 sin() 函数一样，它可以声明和导入任何C库，Cython会生成正确的共享或者静态链接库。

参考：http://docs.cython.org/src/tutorial/external.html

其实我就是个演员

2010-05-21T00:00:00-07:00

注：此文系纯水贴，正经人士请绕道。 :)

场景1 某日很HI的写着程序，凑巧做网页的美工不在，活又耽误不得，只能捋起袖子，装起了Dreamweaver+Fireworks，三下五除二搞定了前端页面。话说自从开始写程序起，就很少碰这些高级玩意了。现在只是偶尔PS修修抠抠图，享受下钢笔抠图小YY一把就足够了。其实在做程序之前，俺一直是个美工，作图做页面只不过信手拈来。

场景2 简历给某朋友看了之后，很惊讶道：原来你是做Java的？只好含泪不语+内流满面了。难道我博客只写Python或者Perl，不意味着俺就是折腾这些的哇。只好幽幽的坦然回答之：其实我的主业是Java开发者，做了六年多。其实动态语言只是我的业余爱好，顺带写了点分享的博文而已。只不过对外闭口没提Java。

场景3 有些朋友看我经常推荐PostgreSQL，就问俺：Pg和MySQL到底有哪些区别？描述种种，感觉可能他也云里雾里。遂让他自己说说需求，最后还是推荐他用MySQL。顺带讲述了一些常用优化和监控的办法。丫又惊讶的说原来你一直用的MySQL啊。好吧，只好再次内流。其实我正儿八经用数据库最长久的就是MySQL了，基本也有六年多了把。Pg只是我的业余爱好，没事研究了下，寻找下乐趣而已。

如此场景会继续重现，遂略过数字。。。

其实，我就是个演员。对系统（Linux）、语言（Java/Python/Perl）、数据库（MySQL/PostgreSQL）都略懂的角色。

不同的时间，演绎不同的角色。过去是，现在是，将来也是。

Virtualbox Nat Share

2010-05-10T00:00:00-07:00

Virtual Box 是个不错的虚拟机，小巧，功能也齐全。好像有点推销鸟。说正题，上次有个朋友就提到怎么能主机里访问虚拟机里的服务，昨晚实验了下，颇为顺利。记录下。这里利用的是默认的NAT上网，也就是共享主机上网，而不是设置独立的IP。

主机：Win XP 虚拟：Ubuntu 9.10

目的：Win里ssh进Ubuntu，能访问里面提供的服务。

主要是通过 VBoxManage setextradata 设置一些属性。

先上几个步骤图把。注意一下修改，先得关闭虚拟机，修改完事以后再启动。

查看虚拟机中的名称：ubuntu9
进入本机Vbox目录，运行VBoxManage，查看下。
添加三个项目

下面的pcnet是vbox里的网络设置，0是表示第一个网卡，后面一次类推。22是ssh端口，映射到主机的22端口。

VBoxManage setextradata "ubuntu9"  "VBoxInternal/Devices/pcnet/0/LUN#0/Config/guestssh/Protocol" TCP
VBoxManage setextradata "ubuntu9"  "VBoxInternal/Devices/pcnet/0/LUN#0/Config/guestssh/GuestPort" 22
VBoxManage setextradata "ubuntu9"  "VBoxInternal/Devices/pcnet/0/LUN#0/Config/guestssh/HostPort" 22

启动虚拟机。
设置putty登陆之。

到这里已经顺利ssh 到127.0.0.1，如果想访问虚拟机里的web服务器呢？同样很简单。

只要如下设置，web端口为81，跟上面也雷同：

VBoxManage setextradata "ubuntu9" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/web/Protocol" TCP
VBoxManage setextradata "ubuntu9" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/web/GuestPort" 81
VBoxManage setextradata "ubuntu9" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/web/HostPort" 81

另外如果想清空上面设置的选项，只要不设置后面的值即可：

VBoxManage setextradata "ubuntu9" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/web/Protocol"

【译】MongoDB 入门教程

2010-04-27T00:00:00-07:00

原文参见：http://www.mongodb.org/display/DOCS/Tutorial

启动数据库

下载 http://www.mongodb.org/display/DOCS/Downloads, 解压后并启动:

$ bin/mongod

MongoDB 默认存储数据目录为 /data/db/ (或者 c:\data\db), 当然你也可以修改成不同目录, 只需要指定 --dbpath 参数:

$ bin/mongod --dbpath /path/to/my/data/dir

获取数据库连接

现在我们就可以使用自带的shell工具来操作数据库了. (我们也可以使用各种编程语言的驱动来使用MongoDB, 自带的shell工具可以方便我们管理数据库)

启动 MongoDB JavaScript 工具:

$ bin/mongo

默认 shell 连接的是本机localhost 上面的 test库, 会看到:

MongoDB shell version: 0.9.8
url: test
connecting to: test
type "help" for help
>

"connecting to:" 这个会显示你正在使用的数据库的名称. 想换数据库的话可以:

> use mydb

可以输入 help 来查看所有的命令.

插入数据到集合

下面我们来建立一个test的集合并写入一些数据. 建立两个对象, j 和 t , 并保存到集合中去. 在例子里 '>' 来表示是 shell 输入提示符

> j = { name : "mongo" };
{"name" : "mongo"}
> t = { x : 3 };
{ "x" : 3  }
> db.things.save(j);
> db.things.save(t);
> db.things.find();
{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}
{"x" : 3 , "_id" : ObjectId("497cf61651712cf7758fbdbc")}
>

有几点需要注意下 :

不需要预先建立一个集合. 在第一次插入数据时候会自动建立.
在例子其实可以存储任何结构的数据, 当然在实际应用我们存储的还是相同元素的集合. 这个特性其实可以在应用里很灵活, 你不需要类似 alter table 来修改你的数据结构
每次插入数据时候对象都会有一个ID, 名字叫 _id.

当你运行不同的例子, 你的对象ID值都是不同的.

下面再加点数据:

> for( var i = 1; i < 10; i++ ) db.things.save( { x:4, j:i } ); > db.things.find();
{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}
{"x" : 3 , "_id" : ObjectId("497cf61651712cf7758fbdbc")}
{"x" : 4 , "j" : 1 , "_id" : ObjectId("497cf87151712cf7758fbdbd")}
{"x" : 4 , "j" : 2 , "_id" : ObjectId("497cf87151712cf7758fbdbe")}
{"x" : 4 , "j" : 3 , "_id" : ObjectId("497cf87151712cf7758fbdbf")}
{"x" : 4 , "j" : 4 , "_id" : ObjectId("497cf87151712cf7758fbdc0")}
{"x" : 4 , "j" : 5 , "_id" : ObjectId("497cf87151712cf7758fbdc1")}
{"x" : 4 , "j" : 6 , "_id" : ObjectId("497cf87151712cf7758fbdc2")}
{"x" : 4 , "j" : 7 , "_id" : ObjectId("497cf87151712cf7758fbdc3")}
{"x" : 4 , "j" : 8 , "_id" : ObjectId("497cf87151712cf7758fbdc4")}

请注意下, 这里循环次数是10, 但是只显示到8, 还有2条数据没有显示.

如果想继续查询下面的数据只需要使用 it 命令, 就会继续下面的数据:

{"x" : 4 , "j" : 7 , "_id" : ObjectId("497cf87151712cf7758fbdc3")}
{"x" : 4 , "j" : 8 , "_id" : ObjectId("497cf87151712cf7758fbdc4")}

继续

> it
{"x" : 4 , "j" : 9 , "_id" : ObjectId("497cf87151712cf7758fbdc5")}
{"x" : 4 , "j" : 10 , "_id" : ObjectId("497cf87151712cf7758fbdc6")}

从技术上讲 find() 返回一个游标对象. 但在上面的例子里, 并没有拿到一个游标的变量. 所以 shell 自动遍历游标, 返回一个初始化的set, 并允许我们继续用 it 迭代输出.

当然我们也可以直接用游标来输出, 不过这个是下一部分的内容了.

查询数据

在没有深入查询之前, 我们先看看怎么从一个查询中返回一个游标对象. 可以简单的通过 find() 来查询, 他返回一个任意结构的集合. 如果实现特定的查询稍后讲解.

实现上面同样的查询, 然后通过 while 来输出:

> var cursor = db.things.find();
> while (cursor.hasNext()) { print(tojson(cursor.next())); }
{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}
{"x" : 3 , "_id" : ObjectId("497cf61651712cf7758fbdbc")}
{"x" : 4 , "j" : 1 , "_id" : ObjectId("497cf87151712cf7758fbdbd")}
{"x" : 4 , "j" : 2 , "_id" : ObjectId("497cf87151712cf7758fbdbe")}
{"x" : 4 , "j" : 3 , "_id" : ObjectId("497cf87151712cf7758fbdbf")}
{"x" : 4 , "j" : 4 , "_id" : ObjectId("497cf87151712cf7758fbdc0")}
{"x" : 4 , "j" : 5 , "_id" : ObjectId("497cf87151712cf7758fbdc1")}
{"x" : 4 , "j" : 6 , "_id" : ObjectId("497cf87151712cf7758fbdc2")}
{"x" : 4 , "j" : 7 , "_id" : ObjectId("497cf87151712cf7758fbdc3")}
{"x" : 4 , "j" : 8 , "_id" : ObjectId("497cf87151712cf7758fbdc4")}
{"x" : 4 , "j" : 9 , "_id" : ObjectId("497cf87151712cf7758fbdc5")}
>

上面的例子显示了游标风格的迭代输出. hasNext() 函数告诉我们是否还有数据, 如果有则可以调用 next() 函数. 这里我们也用了自带的 tojson() 方法返回一个标准的 JSON 格式数据.

当我们使用的是 JavaScript shell, 可以用到JS的特性, forEach 就可以输出游标了. 下面的例子就是使用 forEach() 来循环输出:

> db.things.find().forEach( function(x) { print(tojson(x));});
{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}
{"x" : 3 , "_id" : ObjectId("497cf61651712cf7758fbdbc")}
{"x" : 4 , "j" : 1 , "_id" : ObjectId("497cf87151712cf7758fbdbd")}
{"x" : 4 , "j" : 2 , "_id" : ObjectId("497cf87151712cf7758fbdbe")}
{"x" : 4 , "j" : 3 , "_id" : ObjectId("497cf87151712cf7758fbdbf")}
{"x" : 4 , "j" : 4 , "_id" : ObjectId("497cf87151712cf7758fbdc0")}
{"x" : 4 , "j" : 5 , "_id" : ObjectId("497cf87151712cf7758fbdc1")}
{"x" : 4 , "j" : 6 , "_id" : ObjectId("497cf87151712cf7758fbdc2")}
{"x" : 4 , "j" : 7 , "_id" : ObjectId("497cf87151712cf7758fbdc3")}
{"x" : 4 , "j" : 8 , "_id" : ObjectId("497cf87151712cf7758fbdc4")}
{"x" : 4 , "j" : 9 , "_id" : ObjectId("497cf87151712cf7758fbdc5")}
>

forEach() 必须定义一个函数供每个游标元素调用.

在 mongo shell 里, 我们也可以把游标当作数组来用 :

> var cursor = db.things.find();
> print (tojson(cursor[4]));
{"x" : 4 , "j" : 3 , "_id" : ObjectId("497cf87151712cf7758fbdbf")}

使用游标时候请注意占用内存的问题, 特别是很大的游标对象, 有可能会内存溢出. 所以应该用迭代的方式来输出.

下面的示例则是把游标转换成真实的数组类型:

> var arr = db.things.find().toArray();
> arr[5];
{"x" : 4 , "j" : 4 , "_id" : ObjectId("497cf87151712cf7758fbdc0")}

请注意这些特性只是在 mongo shell 里使用, 而不是所有的其他应用程序驱动都支持.

MongoDB 游标对象不是没有快照 - 如果有其他用户在集合里第一次或者最后一次调用 next(), 你可以得不到游标里的数据. 所以要明确的锁定你要查询的游标.

指定条件的查询

到这里我们已经知道怎么从游标里实现一个查询并返回数据对象, 下面就来看看怎么根据指定的条件来查询.

下面的示例就是说明如何执行一个类似SQL的查询, 并演示了怎么在 MongoDB 里实现. 这是在 MongoDB shell 里查询, 当然你也可以用其他的应用驱动或者语言来实现:

SELECT * FROM things WHERE name="mongo"

> db.things.find({name:"mongo"}).forEach(function(x) { print(tojson(x));});
{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}
>

SELECT * FROM things WHERE x=4

> db.things.find({x:4}).forEach(function(x) { print(tojson(x));});
{"x" : 4 , "j" : 1 , "_id" : ObjectId("497cf87151712cf7758fbdbd")}
{"x" : 4 , "j" : 2 , "_id" : ObjectId("497cf87151712cf7758fbdbe")}
{"x" : 4 , "j" : 3 , "_id" : ObjectId("497cf87151712cf7758fbdbf")}
{"x" : 4 , "j" : 4 , "_id" : ObjectId("497cf87151712cf7758fbdc0")}
{"x" : 4 , "j" : 5 , "_id" : ObjectId("497cf87151712cf7758fbdc1")}
{"x" : 4 , "j" : 6 , "_id" : ObjectId("497cf87151712cf7758fbdc2")}
{"x" : 4 , "j" : 7 , "_id" : ObjectId("497cf87151712cf7758fbdc3")}
{"x" : 4 , "j" : 8 , "_id" : ObjectId("497cf87151712cf7758fbdc4")}
{"x" : 4 , "j" : 9 , "_id" : ObjectId("497cf87151712cf7758fbdc5")}
>

查询条件是 { a:A, b:B, ... } 类似 "where a==A and b==B and ...", 更多的查询方式可以参考 Mongo 开发教程部分.

上面显示的是所有的元素, 当然我们也可以返回特定的元素, 类似于返回表里某字段的值, 只需要在 find({x:4}) 里指定元素的名字, 比如 j:

SELECT j FROM things WHERE x=4

> db.things.find({x:4}, {j:true}).forEach(function(x) { print(tojson(x));});
{"j" : 1 , "_id" : ObjectId("497cf87151712cf7758fbdbd")}
{"j" : 2 , "_id" : ObjectId("497cf87151712cf7758fbdbe")}
{"j" : 3 , "_id" : ObjectId("497cf87151712cf7758fbdbf")}
{"j" : 4 , "_id" : ObjectId("497cf87151712cf7758fbdc0")}
{"j" : 5 , "_id" : ObjectId("497cf87151712cf7758fbdc1")}
{"j" : 6 , "_id" : ObjectId("497cf87151712cf7758fbdc2")}
{"j" : 7 , "_id" : ObjectId("497cf87151712cf7758fbdc3")}
{"j" : 8 , "_id" : ObjectId("497cf87151712cf7758fbdc4")}
{"j" : 9 , "_id" : ObjectId("497cf87151712cf7758fbdc5")}
>

请注意 "_id" 元素会一直被返回.

findOne() - 语法糖

为了方便, mongo shell (其他驱动) 避免游标的可能带来的开销, 提供一个findOne() 函数. 这个函数和 find() 参数一样, 不过他返回游标里第一条数据, 或者返回 null 空数据库.

作为一个例子, name=='mongo' 可以用很多方法来实现, 可以用 next() 来循环游标(需要校验是否为null), 或者当做数组返回第一个元素.

但是用 findOne() 方法则更简单和高效:

> var mongo = db.things.findOne({name:"mongo"});
> print(tojson(mongo));
{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}
>

findOne 方法更跟 find({name:"mongo"}).limit(1) 一样.

limit() 查询

你可以需要限制结果集的长度, 可以调用 limit 方法.

这是强烈推荐高性能的原因, 通过限制条数来减少网络传输, 例如:

> db.things.find().limit(3);
in cursor for : DBQuery: example.things ->
{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}
{"x" : 3 , "_id" : ObjectId("497cf61651712cf7758fbdbc")}
{"x" : 4 , "j" : 1 , "_id" : ObjectId("497cf87151712cf7758fbdbd")}
>

更多帮助

除非了一般的 help 之外, 你还可以查询 help 数据库和db.whatever 来查询具体的说明.

如果你对一个函数要做什么, 你可以不输入这些结束的括号则可以输出实现的源码, 例如:

> db.foo.insert
function (obj, _allow_dot) {
    if (!obj) {
        throw "no object passed to insert!";
    }
    if (!_allow_dot) {
        this._validateForStorage(obj);
    }
    return this._mongo.insert(this._fullName, obj);
}

mongo 是一个完整的 JavaScript shell程序, 所以在 shell 里完全可以私用JS的方法、类、语法. 此外, MongoDB 定义很多自己的类和全局变量 (比如 db). 这里可以查看完整的API说明 http://api.mongodb.org/js/.

接下来

看完这篇教程后下一步则看MongoDB更详细的文档 http://www.mongodb.org/display/DOCS/Manual

Python ConfigParser 与 ConfigObj INI 配置读写顺序

2010-04-19T00:00:00-07:00

默认的ConfigParser对于选项是按照字母顺序排列的。如下代码：

>>> from ConfigParser import ConfigParser
>>> cf = ConfigParser()
>>> cf.add_section('d')
>>> cf.set('d', 'name', 'smallfish')
>>> cf.add_section('a')
>>> cf.set('a', 'name', 'smallfish2')
>>> cf.write(open('d:/a.ini', 'w'))
>>> cf = None

生成配置如下：

[a]
name = smallfish2
[d]
name = smallfish

翻阅了官方文档似乎对ConfigParser中section的顺序没啥解说，毕竟字典本身就是无序的，如果想修改估计只能从源码入手把。不过有一个ConfigObj库还不错，可以实现顺序，当然功能不仅仅如此啦。下载地址：http://www.voidspace.org.uk/python/configobj.html

代码片段如下：

>>> from configobj import ConfigObj
>>> config = ConfigObj()
>>> config.filename = 'd:/a.ini'
>>> config['d'] = {}
>>> config['d']['name'] = 'smallfish'
>>> config['a'] = {}
>>> config['a']['name'] = 'smallfish2'
>>> config.write()

生成配置如下：

[d]
name = smallfish
[a]
name = smallfish2

梦想与坚持

2010-04-08T00:00:00-07:00

经过几天的适应总算在杭州安定下来了，回归到简单而快乐的上班生活轨道上。

夜深人静的时侯才能静下心来写点关于自己的话题，不再浮躁。

回想这毕业后的六年多的时间，自己都在做些什么？工作的内容在不停的变化，唯一不变的就是坚持了自己的梦想，一个小小的技术梦想。梦想只是目标，而坚持应该是梦想的过程。结果不一定很绚烂，但过程一定要精彩。

第一份工作真的很稚嫩，从文科啥也不懂，菜鸟起步，做起了Web设计和简单的程序编写。当然起步都是需要点时间和积累的。现在还记得为自己做出一个个简单的动画效果而激动无比的场景。随着时间的推移，发觉自己在创意方面的缺乏，两年之后就离开了生活的那个城市。

第二份工作时间很长，四年半的时间。算是一个正规军把 :) 只不过后来也变得有点山寨。收获最大的就是伴随着公司的发展对技术的不断提高要求，接触的很越来越多。最初那种土鳖式的代码工已经不符合了。逐步了解了分层模式，框架，服务器，数据库等等很多有趣的东西。而不仅仅的是把代码写完就完事了。技术上面的提高，当然也带来视野上的扩展。从开始的单一语言发展到后来的多语言结合，单一的数据库到几十台的主从结构，数据应用的分离，数据的切分，缓存系统的应用，以及服务器模块的开发。现在还记得某年的夏天没有空调一帮人赤膊写代码的场景，多hi阿。回想起过去的种种，内心真的难以平静。有时侯想想真的不是想离开，有点无奈。

最近踏上了新的起点，六年以后的第三份工作：淘宝。最初喜欢上淘宝是因为看到的网上办公环境照片，通过一些朋友的了解，里面的武侠文化很吸引自己，想想自己曾经也疯狂迷恋过武侠小说，导致正经的文学没学几篇，很是遗憾阿。经过这几天的初步接触，每天都会有着不同的收获。虽然从事的工作跟过去的内容和岗位都不太一样，但是正因为如此才有更多的好奇与向往。

一直相信只要有坚持，就会有梦想。而不是倒过来，本子电也不多了，洗洗睡吧。祝自己好运，good night！

Nginx 启动/重启脚本笔记

2010-03-27T00:00:00-07:00

Nginx本身可以通过

kill -HUP `cat /usr/local/nginx/logs/nginx.pid`

进行平滑重启的，可以通过ps进程查看一下。效果还是挺不错的。

这里介绍的是另外一种方式service，适合RHEL/CentOS系列。

kill nginx进程

kill `cat /usr/local/nginx/logs/nginx.pid`

建立 /etc/init.d/nginx 文件

#!/bin/sh
#
# nginx - this script starts and stops the nginx daemin
#
# chkconfig:   - 85 15
# description:  Nginx is an HTTP(S) server, HTTP(S) reverse \
#               proxy and IMAP/POP3 proxy server
# processname: nginx
# config:      /usr/local/nginx/conf/nginx.conf
# pidfile:     /usr/local/nginx/logs/nginx.pid

# Source function library.
. /etc/rc.d/init.d/functions

# Source networking configuration.
. /etc/sysconfig/network

# Check that networking is up.
[ "$NETWORKING" = "no" ] &amp;&amp; exit 0

nginx="/usr/local/nginx/sbin/nginx"
prog=$(basename $nginx)

NGINX_CONF_FILE="/usr/local/nginx/conf/nginx.conf"

lockfile=/var/lock/subsys/nginx

start() {
    [ -x $nginx ] || exit 5
    [ -f $NGINX_CONF_FILE ] || exit 6
    echo -n $"Starting $prog: "
    daemon $nginx -c $NGINX_CONF_FILE
    retval=$?
    echo
    [ $retval -eq 0 ] &amp;&amp; touch $lockfile
    return $retval
}

stop() {
    echo -n $"Stopping $prog: "
    killproc $prog -QUIT
    retval=$?
    echo
    [ $retval -eq 0 ] &amp;&amp; rm -f $lockfile
    return $retval
}

restart() {
    configtest || return $?
    stop
    start
}

reload() {
    configtest || return $?
    echo -n $"Reloading $prog: "
    killproc $nginx -HUP
    RETVAL=$?
    echo
}

force_reload() {
    restart
}

configtest() {
  $nginx -t -c $NGINX_CONF_FILE
}

rh_status() {
    status $prog
}

rh_status_q() {
    rh_status >/dev/null 2>&amp;1
}

case "$1" in
    start)
        rh_status_q &amp;&amp; exit 0
        $1
        ;;
    stop)
        rh_status_q || exit 0
        $1
        ;;
    restart|configtest)
        $1
        ;;
    reload)
        rh_status_q || exit 7
        $1
        ;;
    force-reload)
        force_reload
        ;;
    status)
        rh_status
        ;;
    condrestart|try-restart)
        rh_status_q || exit 0
            ;;
    *)
        echo $"Usage: $0 {start|stop|status|restart|condrestart|try-restart|reload|force-reload|configtest}"
        exit 2
esac

设置脚本为可执行

chmod +x /etc/init.d/nginx

/sbin/chkconfig nginx on

检查下

/sbin/chkconfig --list nginx
nginx           0:off   1:off   2:on    3:on    4:on    5:on    6:off

完成咯~可以尝试下面方式启动或者重启

service nginx start
service nginx stop
service nginx restart
service nginx reload

/etc/init.d/nginx start
/etc/init.d/nginx stop
/etc/init.d/nginx restart
/etc/init.d/nginx reload

web.py 数据库操作指南

2010-03-19T00:00:00-07:00

官网地址：http://webpy.org/

web.py是一个小巧灵活的框架，最新稳定版是0.33。这里不介绍web开发部分，介绍下关于数据库的相关操作。

很多Pyer一开始都喜欢自己封装数据库操作类，本人亦如此。不过后来通过观摩web.py的源码，发现其数据库操作部分相当紧凑实用。推荐懒人可以尝试一下。

废话不多，先来安装，有两种方式：

easy_install方式，如果木有此工具，可以参考：http://chenxiaoyu.org/blog/archives/23

easy_install web.py

下载源码编译。地址： http://webpy.org/static/web.py-0.33.tar.gz ，解压后执行：

python setup.py install

web.py安装算到此结束，如果想使用其中的db功能，还得借助与相应数据库操作模块，比如MySQLdb、psycopg2。如果需要尝试连接池(database pool)功能，还得装下DBUtils。这几个模块都可以通过easy_install来安装。

下面开始使用吧！

导入模块，定义数据库连接db。

import web
db = web.database(dbn='postgres', db='mydata', user='dbuser', pw='')

select 查询

# 查询表
entries = db.select('mytable')

# where 条件
myvar = dict(name="Bob")
results = db.select('mytable', myvar, where="name = $name")
results = db.select('mytable', where="id>100")

# 查询具体列
results = db.select('mytable', what="id,name")

# order by
results = db.select('mytable', order="post_date DESC")

# group
results = db.select('mytable', group="color")

# limit
results = db.select('mytable', limit=10)

# offset
results = db.select('mytable', offset=10)

更新

db.update('mytable', where="id = 10", value1 = "foo")

删除

db.delete('mytable', where="id=10")

复杂查询

# count
results = db.query("SELECT COUNT(*) AS total_users FROM users")
print results[0].total_users

# join
results = db.query("SELECT * FROM entries JOIN users WHERE entries.author_id = users.id")

# 防止SQL注入可以这么干
results = db.query("SELECT * FROM users WHERE id=$id", vars={'id':10})

6 多数据库操作 (web.py大于0.3)

db1 = web.database(dbn='mysql', db='dbname1', user='foo')
db2 = web.database(dbn='mysql', db='dbname2', user='foo')

print db1.select('foo', where='id=1')
print db2.select('bar', where='id=5')

事务

t = db.transaction()
try:
    db.insert('person', name='foo')
    db.insert('person', name='bar')
except:
    t.rollback()
    raise
else:
    t.commit()

# Python 2.5+ 可以用with
from __future__ import with_statement
with db.transaction():
    db.insert('person', name='foo')
    db.insert('person', name='bar')

Python(Stackless) + MongoDB Apache 日志(2G)分析

2010-03-04T00:00:00-08:00

为何选择Stackless？ http://www.stackless.com

Stackless可以简单的认为是Python一个增强版，最吸引眼球的非“微线程”莫属。微线程是轻量级的线程，与线程相比切换消耗的资源更小，线程内共享数据更加便捷。相比多线程代码更加简洁和可读。此项目是由EVE Online推出，在并发和性能上确实很强劲。安装和Python一样，可以考虑替换原系统Python。:)

为何选择MongoDB？ http://www.mongodb.org

可以在官网看到很多流行的应用采用MongoDB，比如sourceforge，github等。相比RDBMS有啥优势？首先在速度和性能上优势最为明显，不仅可以当作类似KeyValue数据库来使，还包含了一些数据库查询（Distinct、Group、随机、索引等特性）。再有一点特性就是：简单。不论是应用还是文档，还是第三方API，几乎略过一下就可以使用。不过有点遗憾的就是，存储的数据文件很大，超过正常数据的2-4倍之间。本文测试的Apache日志大小是2G，生产的数据文件有6G。寒...希望在新版里能有所缩身，当然这个也是明显的以空间换速度的后果。

本文除去上面提及到的两个软件，还需要安装pymongo模块。http://api.mongodb.org/python/

模块安装方式有源码编译和easy_install，这里就不再累赘。

从Apache日志中分析出需要保存的资料，比如IP，时间，GET/POST，返回状态码等。

fmt_str  = '(?P<ip>[.\d]+) - - \[(?P<time>.*?)\] "(?P<method>.*?) (?P<uri>.*?) HTTP/1.\d" (?P<status>\d+) (?P<length>.*?) "(?P<referere>.*?)" "(?P<agent>.*?)"'
fmt_name = re.findall('\?P<(.*?)>', fmt_str)
fmt_re   = re.compile(fmt_str)

定义了一个正则用于提取每行日志的内容。fmt_name就是提取尖括号中间的变量名。

定义MongoDB相关变量，包括需要存到collection名称。Connection采取的是默认Host和端口。

conn     = Connection()
apache   = conn.apache
logs     = apache.logs

保存日志行

def make_line(line):
    m = fmt_re.search(line)
    if m:
        logs.insert(dict(zip(fmt_name, m.groups())))

读取Apache日志文件

def make_log(log_path):
    with open(log_path) as fp:
        for line in fp:
            make_line(line.strip())

运行把。

if __name__ == '__main__':
    make_log('d:/apachelog.txt')

脚本大致情况如此，这里没有放上stackless部分代码，可以参考下面代码：

import stackless
def print_x(x):
    print x
stackless.tasklet(print_x)('one')
stackless.tasklet(print_x)('two')
stackless.run()

tasklet操作只是把类似操作放入队列中，run才是真正的运行。这里主要用于替换原有多线程threading并行分析多个日志的行为。

补充：

Apache日志大小是2G，671万行左右。生成的数据库有6G。

硬件：Intel(R) Core(TM)2 Duo CPU E7500 @ 2.93GHz 台式机

系统：RHEL 5.2 文件系统ext3

其他：Stackless 2.6.4 MongoDB 1.2

在保存300万左右时候，一切正常。不管是CPU还是内存，以及插入速度都很不错，大概有8-9000条/秒。和以前笔记本上测试结果基本一致。再往以后，内存消耗有点飙升，插入速度也降低。500万左右记录时候CPU达到40%，内存消耗2.1G。在生成第二个2G数据文件时候似乎速度和效率又提升上去了。最终保存的结果不是太满意。

后加用笔记本重新测试了一下1000万数据，速度比上面的671万明显提升很多。初步怀疑有两个地方可能会影响性能和速度：

文件系统的差异。笔记本是Ubuntu 9.10，ext4系统。搜了下ext3和ext4在大文件读写上会有所差距。
正则匹配上。单行操作都是匹配提取。大文件上应该还有优化的空间。

PostgreSQL UUID 函数

2010-02-26T00:00:00-08:00

测试环境：PostgreSQL 8.4

默认PostgreSQL是木有UUID函数可使用，而不像MySQL提供uuid()函数，不过在contrib里有，只需要导入一下uuid-ossp.sql即可。（PS：注意权限问题，要Pg可读改文件。）

导入很简单，下面是win下面测试，其他平台类似该操作：

D:\>psql -U postgres -h localhost -f D:\PostgreSQL\8.4\share\contrib\uuid-ossp.sql
Password for user postgres:
SET
CREATE FUNCTION
CREATE FUNCTION
CREATE FUNCTION
CREATE FUNCTION
CREATE FUNCTION
CREATE FUNCTION
CREATE FUNCTION
CREATE FUNCTION
CREATE FUNCTION
CREATE FUNCTION

进入psql，执行：

postgres=# select uuid_generate_v1();
           uuid_generate_v1
--------------------------------------
 86811bd4-22a5-11df-b00e-ebd863f5f8a7
(1 row)

postgres=# select uuid_generate_v4();
           uuid_generate_v4
--------------------------------------
 5edbfcbb-1df8-48fa-853f-7917e4e346db
(1 row)

主要就是uuid_generate_v1和uuid_generate_v4，当然还有uuid_generate_v3和uuid_generate_v5。其他使用可以参见PostgreSQL官方文档 http://www.postgresql.org/docs/8.3/static/uuid-ossp.html。

PostgreSQL RPM 安装笔记

2010-02-06T00:00:00-08:00

测试环境：REHL 5.3 PostgreSQL版本：8.4.2

首先检查下是否已经有PostgreSQL安装程序(俺的机器有pg-libs 8.1，无视之)

shell> rpm -qa | grep postgres

下载最新的8.4.2RPM安装包，这个FTP速度挺快的。:)

shell> wget http://ftp.easynet.be/postgresql/binary/v8.4.2/linux/rpms/redhat/rhel-5-x86_64/postgresql-server-8.4.2-1PGDG.rhel5.x86_64.rpm
shell> wget http://ftp.easynet.be/postgresql/binary/v8.4.2/linux/rpms/redhat/rhel-5-x86_64/postgresql-contrib-8.4.2-1PGDG.rhel5.x86_64.rpm
shell> wget http://ftp.easynet.be/postgresql/binary/v8.4.2/linux/rpms/redhat/rhel-5-x86_64/postgresql-libs-8.4.2-1PGDG.rhel5.x86_64.rpm
shell> wget http://ftp.easynet.be/postgresql/binary/v8.4.2/linux/rpms/redhat/rhel-5-x86_64/postgresql-devel-8.4.2-1PGDG.rhel5.x86_64.rpm
shell> wget http://ftp.easynet.be/postgresql/binary/v8.4.2/linux/rpms/redhat/rhel-5-x86_64/postgresql-8.4.2-1PGDG.rhel5.x86_64.rpm
shell> wget http://ftp.easynet.be/postgresql/binary/v8.4.2/linux/rpms/redhat/rhel-5-x86_64/postgresql-plpython-8.4.2-1PGDG.rhel5.x86_64.rpm

安装PostgreSQL(要注意下顺序)，首先需要更新pg-libs版本。后面几个不需要的话可以不装。主要是一些扩展功能。

shell> rpm -ivh postgresql-libs-8.4.2-1PGDG.rhel5.x86_64.rpm
shell> rpm -ivh postgresql-8.4.2-1PGDG.rhel5.x86_64.rpm
shell> rpm -ivh postgresql-server-8.4.2-1PGDG.rhel5.x86_64.rpm
shell> rpm -ivh postgresql-contrib-8.4.2-1PGDG.rhel5.x86_64.rpm
shell> rpm -ivh postgresql-devel-8.4.2-1PGDG.rhel5.x86_64.rpm
shell> rpm -ivh postgresql-plpython-8.4.2-1PGDG.rhel5.x86_64.rpm

RPM安装完后，需要初始化PostgreSQL库。service初次启动会提示。如果是源码安装这个过程就是对应的initdb -D，指定data目录。RPM默认对应目录是/var/lib/pgsql/data。

shell> service postgresql initdb

service启动PostgreSQL

shell> service postgresql start

到上面这一步基本是安装完成了。下面的是修改数据库用户密码和登陆相关。

切换到postgres用户，修改数据库密码。(注意系统用户和数据库用户密码是两个概念，虽然名字都叫postgres) 修改完需要重启数据库，这里咱不重启，等修改完认证配置再一起重启。

shell> su - postgres
shell> psql
postgres=# ALTER USER postgres WITH PASSWORD '123456';
postgres=# \q

修改认证文件/var/lib/pgsql/data/pg_hba.conf，登陆使用密码。md5格式。

shell> vi /var/lib/pgsql/data/pg_hba.conf
修改ident为md5 (local, host)

service重启PostgreSQL

shell> service postgresql restart

再次进入测试，应该会提示输入密码鸟 :)

shell>psql -U postgres

MySQL & PostgreSQL 小命令对比

2010-02-05T00:00:00-08:00

对比下一些两个数据库常用的操作。分别使用自带的client程序。

MySQL命令行：

mysql -u 用户名 -h 主机地址 -P 端口号 数据库名 -p

PostgreSQL命令行：

psql -U 用户名 -h 主机地址 -p 端口号 数据库名

操作对比：

mysql                      psql

SHOW DATABASES;           \l
USE db-name;              \c db-name
SHOW TABLES;              \d
SHOW USERS;               \du
SHOW COLUMNS;             \d table-name
SHOW PROCESSLIST;         SELECT * FROM pg_stat_activity;
SELECT now()\G            \x 可以打开和关闭类似\G功能
SOURCE /path.sql          \i /path.sql
LOAD DATA INFILE ...      \copy ...
\h                        \?

PostgreSQL tablespace 表空间

2009-12-22T00:00:00-08:00

pgsql允许管理员在文件系统里定义表空间存储位置，这样创建数据库对象时候就可以引用这个表空间了。好处就不用多说了，可以把数据库对象存储到不同的分区上，比如更好的存储之类。默认initdb之后会有两个表空间pg_global和pg_default。

查看pgsql当前表空间有哪些可以试试下面：

postgres=> SELECT spcname FROM pg_tablespace;
  spcname
------------
 pg_default
 pg_global
(2 rows)

或：

postgres=> \db
    Name    |  Owner   | Location
------------+----------+----------
 pg_default | postgres |
 pg_global  | postgres |

建立表空间需要注意的主要的是权限问题，而且要在新的空目录上建立，权限属于数据库管理员比如默认postgres。

$ mkdir /home/smallfish/pgdata
$ sudo chown -R postgres:postgres /home/smallfish/pgdata

进入psql

$ psql -U postgres -h 192.168.0.122

如果权限没设置好下面语句会报错

postgres=> CREATE TABLESPACE space1 LOCATION '/home/smallfish/pgdata';

建测试表

postgres=> CREATE TABLE foo(i int) TABLESPACE space1;

可以查看表空间目录下多了文件

postgres=> \! ls /home/smallfish/pgdata

删除表空间，需要注意的是先要删除所有该表空间里的对象

postgres=> DROP TABLESPACE space1;

ok，到这里已经建立好表空间了。当然每次建表都指定TABLESPACE也有点麻烦，来点默认的把。

postgres=> SET default_tablespace = space1;
postgres=> CREATE TABLE foo(i int);

PostgreSQL Partitioning 表分区

2009-12-22T00:00:00-08:00

测试版本：pg 8.3 (ubuntu)

在pg里表分区是通过表继承来实现的，一般都是建立一个主表，里面是空，然后每个分区都去继承它。

创建表分区步骤如下：

创建主表

CREATE TABLE users ( uid int not null primary key, name varchar(20));

创建分区表(必须继承上面的主表)

CREATE TABLE users_0 ( check (uid >= 0 and uid< 100) ) INHERITS (users);
CREATE TABLE users_1 ( check (uid >= 100)) INHERITS (users);

在分区表上建立索引，其实这步可以省略的哦

CREATE INDEX users_0_uidindex on users_0(uid);
CREATE INDEX users_1_uidindex on users_1(uid);

创建规则RULE

CREATE RULE users_insert_0 AS
    ON INSERT TO users WHERE
        (uid >= 0 and uid < 100)
    DO INSTEAD
        INSERT INTO users_0 VALUES (NEW.uid,NEW.name);

CREATE RULE users_insert_1 AS
    ON INSERT TO users WHERE
        (uid >= 100)
    DO INSTEAD
        INSERT INTO users_1 VALUES (NEW.uid,NEW.name);

下面就可以测试写入数据啦：

postgres=# INSERT INTO users VALUES (100,'smallfish');
INSERT 0 0
postgres=# INSERT INTO users VALUES (20,'aaaaa');
INSERT 0 0
postgres=# select * from users;
uid  |   name
-----+-----------
20   | aaaaa
100  | smallfish
(2 笔资料列)
postgres=# select * from users_0;
uid  | name
-----+-------
20   | aaaaa
(1 笔资料列)

postgres=# select * from users_1;
uid  |   name
-----+-----------
100  | smallfish
(1 笔资料列)

到这里表分区已经可以算完了，不过还有个地方需要修改下，先看count查询把。

postgres=# EXPLAIN SELECT count(*) FROM users where uid<100;
QUERY PLAN
------------------------------------------------
Aggregate  (cost=62.75..62.76 rows=1 width=0)
    ->  Append  (cost=6.52..60.55 rows=879 width=0)
    ->  Bitmap Heap Scan on users  (cost=6.52..20.18 rows=293 width=0)
Recheck Cond: (uid < 100)
    ->  Bitmap Index Scan on users_pkey  (cost=0.00..6.45 rows=293 width=0)
Index Cond: (uid < 100)
    ->  Bitmap Heap Scan on users_0 users  (cost=6.52..20.18 rows=293 width=0)
Recheck Cond: (uid < 100)
    ->  Bitmap Index Scan on users_0_uidindex  (cost=0.00..6.45 rows=293 width=0)
Index Cond: (uid < 100)
    ->  Bitmap Heap Scan on users_1 users  (cost=6.52..20.18 rows=293 width=0)
Recheck Cond: (uid < 100)
    ->  Bitmap Index Scan on users_1_uidindex  (cost=0.00..6.45 rows=293 width=0)
Index Cond: (uid < 100)
(14 笔资料列)

按照本来想法，uid小于100，理论上应该只是查询users_0表，通过EXPLAIN可以看到其他他扫描了所有分区的表。

postgres=# SET constraint_exclusion = on;
SET

postgres=# EXPLAIN SELECT count(*) FROM users where uid<100;
QUERY PLAN
------------------------------------------------
Aggregate  (cost=41.83..41.84 rows=1 width=0)
    ->  Append  (cost=6.52..40.37 rows=586 width=0)
    ->  Bitmap Heap Scan on users  (cost=6.52..20.18 rows=293 width=0)
Recheck Cond: (uid < 100)
    ->  Bitmap Index Scan on users_pkey  (cost=0.00..6.45 rows=293 width=0)
Index Cond: (uid < 100)
    ->  Bitmap Heap Scan on users_0 users  (cost=6.52..20.18 rows=293 width=0)
Recheck Cond: (uid < 100)
    ->  Bitmap Index Scan on users_0_uidindex  (cost=0.00..6.45 rows=293 width=0)
Index Cond: (uid < 100)
(10 笔资料列)

到这里整个过程都OK啦！

Java调用Linux SCP操作

2009-12-16T00:00:00-08:00

先来回顾下linux下scp命令的用法：

[shell $] scp -r /本地目录或文件 user@192.168.0.110:/远程目录

这条命令是把本地的目录或者文件拷贝到远程192.168.0.110一个目录下，如果是从远程拷到本地，则反一下ip和目录。-r则是递归目录。更多参见scp --help

最近在Java里调用scp，是通过一个JSP页面来触发。为了在调用系统命令时候不出现提示密码，两台机器配置好了信任关系，可以参考http://chenxiaoyu.org/blog/archives/133，大致代码如下：

Runtime.getRuntime().exec("scp /aa.txt root@192.168.0.110:/bb");

try时候也没任何异常，但是文件没拷贝过去，最后根据Process的waitFor()获取命令返回值是1。

这下可以肯定的是调用系统命令失败，在System.out.println里打印出command，linux下运行是没错的。为何呢？

后来发现原来是用户权限的问题，默认apache运行用户是nobody，根本没权限调用scp命令，配置的信任关系也是本机的root用户。

那就重新加一个user把，adduser...到配置好信任关系，在scp -i 指定一个rsa文件，并把rsa文件复制到/tmp目录下，权限为0755，继续刷新，后台可以看到提示输入密码之类的output了。

貌似还比较棘手，最后还是搜了下，发现有关Java scp的库，http://www.ganymed.ethz.ch/ssh2/。貌似比较老，先来测试一下把。

Connection conn = new Connection(“192.168.0.110”);
conn.connect();
boolean isAuthenticated = conn.authenticateWithPassword(“root”, "***********");
if (isAuthenticated == false)
    throw new IOException("Authentication failed.");
SCPClient client = new SCPClient(conn);
client.put("/aa.txt", "/bb");
conn.close();

OK！发现竟然可以一次运行了。算了就不调用系统命令了，直接使用这个库把。

client.put方法第一个参数可以是个数组，即文件名的数组。暂时没找到整个目录的方法，就自己手动获取下目录文件列表把。

SSH, SCP 不输入密码

2009-12-16T00:00:00-08:00

经常在不同linux机器之间互相scp拷文件，每次总是要输入密码才可行。

通过ssh-keygen生成公钥，在两台机器之间互相建立信任通道即可。假设本地机器client，远程机器为server。

生成rsa keygen

[winter@client winter] $ ssh-keygen -b 1024 -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/winter/.ssh/id_rsa): <Enter>
Enter passphrase (empty for no passphrase): <Enter>
Enter same passphrase again: <Enter>
Your identification has been saved in /home/winter/.ssh/id_rsa.
Your public key has been saved in /home/winter/.ssh/id_rsa.pub.
The key fingerprint is:
33:d4:7b:9c:87:04:cf:14:40:22:6d:c7:15:78:97:6a winter@client

直接上面公钥和私钥存放地址可以直接回车，私钥密码可以直接回车，也可以输入。

[winter@client winter] $ ls .ssh/
id_rsa  id_rsa.pub  known_hosts

拷贝公钥到目标机器上，并改名成authorized_keys

首次scp命令时候还是会提示输入密码，还有是否继续链接的提示，以后

测试ssh进入

[winter@client winter] $ ssh 192.168.0.110

ok，搞定！

[winter@server winter] # it's ok!

修改 ModPython 下 PYTHON_EGG_CACHE 报错

2009-12-16T00:00:00-08:00

环境：Linux Apache Python(mod_python)

换了一台新机器，没有配置Mod_Python了，在一些应用里import MySQLdb出现了下面错误：

ExtractionError: Can't extract file(s) to egg cache
The following error occurred while trying to extract file(s) to the Python egg
cache:
  [Errno 13] Permission denied: '/root/.python-eggs'
The Python egg cache directory is currently set to:
  /root/.python-eggs
Perhaps your account does not have write access to this directory?  You can
change the cache directory by setting the PYTHON_EGG_CACHE environment
variable to point to an accessible directory.

解决办法有两种：

1.设置PYTHON_EGG_CACHE环境变量

$ SetEnv PYTHON_EGG_CACHE /tmp/aaa/

目录权限注意要是apache用户，或者简单点就777

2.把egg格式转成目录

$ cd /python-path/site-packages/
$ mv MySQL_python-1.2.3c1-py2.5-linux-x86_64.egg foo.zip
$ mkdir MySQL_python-1.2.3c1-py2.5-linux-x86_64.egg
$ cd MySQL_python-1.2.3c1-py2.5-linux-x86_64.egg
$ unzip ../foo.zip
$ rm ../foo.zip

C Apache Module 开发入门

2009-12-16T00:00:00-08:00

前言：

扩展Apache模块开发网上大部分教程都是围绕Perl语言，老外的《Writing Apache Modules with Perl and C》可以算是经典之作了，可惜一直都是针对老版本开发，而且主力语言是Perl，C语言部分只是略有介绍。不过相比较而言用Perl来扩展模块功能确实比 C语言来的快速以及便捷多了，也简单容易。我自己也在工作里应用了一部分，主要是在防盗链上面写了两个简单都模块，可以参考我写的另外两篇文章：http://chenxiaoyu.org/blog/archives/120。说了那么多题外话，回到正题，这里只是用C语言实现一个简单的hello模块，模块功能是查询MySQL自带mysql数据库里都user表。

系统环境：

ArchLinux Apache2.2 MySQL 5.0

具体开发步骤：

利用Apache自带都apxs建立hello模块：

[root#localhost] apxs -g -n hello

这样就会在当前目录下新建一个hello模块的文件目录，可以看到里面有：Makefile mod_hello.c modules.mk这样的文件，具体apxs路径查询下本机apache/bin目录。

预览下mod_hello.c，可以看到里面apxs自动帮你生成一堆代码了，我们需要的只是修改里面的代码部分，先简单都介绍下里面的函数说明。

include 部分就是引入了一些必要都头文件 hello_handler 这个就是hello模块都主体部分，所有的显示、处理请求什么的都在这里。 hello_register_hooks hello_module 这俩个是需要导出的函数所必须的，先可以不管他们，按照生成的不动即可。

修改hello_handler函数，里面可以看到request_rec *r，r有很多函数和变量，具体要参见文档了。里面的ap_rputs是输出，可以简单的理解为把字符串输出到r。

static int hello_handler(request_rec *r)
{
if (strcmp(r->handler, "hello")) { // 判断apache配置文件里handler是否等于hello，不是就跳过
          return DECLINED;
     }
     r->content_type = "text/html"; // 设置content-type
     if (!r->header_only)
          ap_rputs("The sample page from mod_hello.c\n", r); // 输出一段文字
     return OK;// 返回 200 OK状态
}

增加#include "mysq.h"，查询需要用到这个头文件。具体代码参见本文结尾部分。

编译模块

[root#localhost] apxs -c -a -i -I/usr/include/mysql/ -lmysqlclient mod_hello.c

可以看到一堆编译指令，加上-I和-l是编译mysql必须的，编译完会自动在httpd.conf加上 LoadModule hello_module modules/mod_hello.so

修改httpd.conf SetHandler hello </Location
重启apache，访问http://localhost/hello，看是否成功。

=====================

完整代码：

#include "httpd.h"
#include "http_config.h"
#include "http_protocol.h"
#include "ap_config.h"
/* 头文件，本文用到了ap_rprintf函数 */
#include "apr.h"
#include "apr_lib.h"
#include "apr_strings.h"
#include "apr_want.h"
#include "mysql.h"

/* 定义mysql数据变量 */
const char *host = "localhost";
const char *user = "root";
const char *pass = "smallfish";
const char *db    = "mysql";

/* The sample content handler */
static int hello_handler(request_rec *r)
{
    if (strcmp(r->handler, "hello")) {
        return DECLINED;
    }
    r->content_type = "text/html";
    /* 定义mysql变量 */
    MYSQL mysql;
    MYSQL_RES *rs;
    MYSQL_ROW row;
    mysql_init(&amp;mysql); /* 初始化 */
    if (!mysql_real_connect(&amp;mysql, host, user, pass, db, 0, NULL, 0)) {/* 连接数据库 */
        ap_rprintf(r, "<li>Error:%d %s</li>\n", mysql_errno(&amp;mysql), mysql_error(&amp;mysql));
        return OK;
    }
    char *sql = "select host,user from user order by rand()";
    if (mysql_query(&amp;mysql, sql)!=0) { /* 查询 */
        ap_rprintf(r, "<li>Error : %d %s</li>\n", mysql_errno(&amp;mysql), mysql_error(&amp;mysql));
        return OK;
    }
    rs = mysql_store_result(&amp;mysql); /* 获取查询结果 */
    while ((row = mysql_fetch_row(rs))) { /* 获取每一行记录 */
        ap_rprintf(r, "<li>%s - %s</li>\n", row[0], row[1]);
    }
    mysql_free_result(rs); /* 释放结果集 */
    mysql_close(&amp;mysql); /* 关闭连接 */
    return OK;
}

static void hello_register_hooks(apr_pool_t *p)
{
    ap_hook_handler(hello_handler, NULL, NULL, APR_HOOK_MIDDLE);
}

/* Dispatch list for API hooks */
module AP_MODULE_DECLARE_DATA hello_module = {
    STANDARD20_MODULE_STUFF,
    NULL,                            /* create per-dir              config structures */
    NULL,                            /* merge  per-dir              config structures */
    NULL,                            /* create per-server config structures */
    NULL,                            /* merge  per-server config structures */
    NULL,                            /* table of config file commands                 */
    hello_register_hooks  /* register hooks                                */
};

Pexpect通过SSH执行远程命令

2009-12-15T00:00:00-08:00

pexpect是python一个模块，可以通过：easy_install pexpect 来安装。

这里主要是用pexpect执行ssh，查看远程uptime和df -h看硬盘状况。

#ssh_cmd.py
#coding:utf-8
import pexpect

def ssh_cmd(ip, user, passwd, cmd):
    ssh = pexpect.spawn('ssh %s@%s "%s"' % (user, ip, cmd))
    r = ''
    try:
        i = ssh.expect(['password: ', 'continue connecting (yes/no)?'])
        if i == 0 :
            ssh.sendline(passwd)
        elif i == 1:
            ssh.sendline('yes')
    except pexpect.EOF:
        ssh.close()
    else:
        r = ssh.read()
        ssh.expect(pexpect.EOF)
        ssh.close()
    return r

hosts = '''
192.168.0.12:smallfish:1234:df -h,uptime
192.168.0.13:smallfish:1234:df -h,uptime
'''

for host in hosts.split("\n"):
    if host:
        ip, user, passwd, cmds = host.split(":")
        for cmd in cmds.split(","):
            print "-- %s run:%s --" % (ip, cmd)
            print ssh_cmd(ip, user, passwd, cmd)

hosts数组格式是：主机IP:用户名:密码:命令 (多个命令用逗号, 隔开) 可以看出打印出相应的结果了，可以拼成html发送mail看起来比较美观些咯！

Perl 批量跳过 MySQL Slave 复制错误

2009-12-15T00:00:00-08:00

发现mysql slave服务器经常因为一些特殊字符或者符号产生的更新语句报错，整个同步也会因此而卡在那，最初的办法只是手动去出错的机器，执行下面三条sql语句，跳过错误即可。

slave stop;
set GLOBAL SQL_SLAVE_SKIP_COUNTER=1;
slave start;

一台slave机器用这样方法还行，多台就麻烦了，就顺手写了个简单的perl脚本，方便统一跳过错误，代码如下：

#!/usr/bin/env perl
use strict;
use warnings;

# get slave status
sub get_status {
    my ($ip, $usr, $pass) = @_;
    my $info = `mysql -u$usr -p$pass -h$ip -e 'show slave status\\G;'`;
    if (($info =~ /Slave_IO_Running: Yes/) &amp;&amp; ($info =~ /Slave_SQL_Running: No/)) {
        return 1;
    }
    return 0;
}
# mysql slave skip
sub slaveskip {
    my ($ip, $usr, $pass) = @_;
    print "slave error **\n";
    system("mysql -u$usr -p$pass -h$ip -e 'slave stop;'");
    system("mysql -u$usr -p$pass -h$ip -e 'set GLOBAL SQL_SLAVE_SKIP_COUNTER=1;'");
    system("mysql -u$usr -p$pass -h$ip -e 'slave start;'");
}

my @hosts = qw/
192.168.0.101:root:tt1234
192.168.0.102:root: tt1234
192.168.0.103:root: tt1234
/;
foreach (@hosts) {
    my ($ip, $usr, $pass) = split ':';
    print "// ----- $ip\n";
    my $count = 1;
    while ($count < 100000) {
        my $status = get_status($ip, $usr, $pass);
        print "i: $count status: $status\n";
        last if $status == 0;
        slaveskip($ip, $usr, $pass);
        select(undef, undef, undef, 0.1);
        $count++;
    }
    print "\n";
}

exit;

使用 Perl 快速解析 Apache Log

2009-12-15T00:00:00-08:00

功能简述

统计出日志里一个或多个页面总共访问的次数，比如aa.jsp, bb.jsp这样页面分别多少次。

实现简述

Apache单个日志文件800M。

最初程序使用Python编写，按行来统计，分别使用in(最慢)和index方法去查找，然后使用了正则匹配，程序运行时间从最初的1分50多秒优化到1分10秒左右，参考了http://www.dup2.org/node/1006博客中提到的gc.disable()，有了一定的提升，最终还是需要1分左右。

然后随意用了Perl写了一个，用了最土鳖的这样的按行分析，最后正则匹配，然后++，速度竟然在40-50秒之间，惊叹！后来经过http://shucho.org/blog/指点，在正则部分采用了预编译，效果那是相当惊人！800M文件只用了7秒左右。卧槽！

程序片段

# --------------------------------------------------------------------
use strict;
use Benchmark;

my $LOG_FILE = '/usr/local/apache/logs/access.log';
# 下面qr部分起了关键作用，预编译了表达式
my @EXT_LIST = map {qr/$_/} qw{
aaServlet
bbServlet
};

my $startime = new Benchmark;
my %result;
map {$result{$_} = 0} @EXT_LIST;
open LOG_FILE, $LOG_FILE;
while (<LOG_FILE>){
    foreach my $ext (@EXT_LIST){
        $result{$ext}++ if $_ =~ /$ext/;
    }
}
close LOG_FILE;

while (my ($key, $value) = each(%result)){
    $key =~ s/\(\?-xism:(.*?)\)/$1/g;
    print "$key:\t$value\n";
}

printf "** %s\n\n", timestr(timediff(new Benchmark, $startime));

mysqldumpslow 慢查询日志分析工具

2009-12-15T00:00:00-08:00

mysql自带的这个玩意挺好使的，可以对慢查询里的sql进行排序、计算等操作。

首先得配置my.cnf：

log_slow_queries = /path/slow.log # 定义log位置，注意要有写入的权限

具体的使法如下：

mysqldumpslow -s c -t 40 /path/slow.log

出来的结果是访问次数最多的40个sql，几个参数大概意思如下：

-t 显示多少条
-s 排序，默认是at。c是次数，t是时间，l是lock时间，r是返回结果。如果是ac，at，al，ar则是倒序
-g 可以用正则匹配部分语句

可以参考mysqldumpslow --help，通过这个工具可以看到哪些锁表，或者其他性能问题，还能看到某些SQL_NO_CACHE提示呢，去想办法优化把！

SSH Tunnel && Memcached

2009-12-15T00:00:00-08:00

最近一台服务器放进了移动机房，需要访问原电信机房一台Memcached服务器，Memcached服务是以内网形式启动。

依靠google大神，搜索出解决思路，在本地起一个SSH链接，通过本地一个端口实现对另外机器的映射或者叫做转发。

上周本来已经搞定，本周突发灵异事件，竟然不管了，最后百般尝试，完成结果如下：

移动机器IP：220.xxx.xxx.xxx 电信机器IP：155.xxx.xxx.xxx

在移动机器上执行：

shell > ssh -N -f -L 11211:192.168.0.xxx:11211 root@155.xxx.xxx.xxx

11211:192.168.0.xxx:11211，格式为：本地端口:memcache启动的IP:端口这里没有用RSA认证，就直接输入密码。-N 是不需要shell，-f 是程序后台执行，其他参数参见ssh --help。

shell > ps aux

可以看见进程已经在了，下面开始测试代码。

>>> import memcache
>>> mc = memcache.Client(['127.0.0.1:11211'],debug=True)
>>> print mc.get('name')

Memcached Java && Python Client API 共享

2009-12-15T00:00:00-08:00

用Python写了一个计划任务，定时更新Memcached中一个key值，写的很happy，几分钟搞定。

然后在Java Servlet测试，代码写的也很happy，编译 - 刷新，一气呵成。

然后发现值一直是null，再tail日志看看，异常不断：

com.danga.MemCached.MemCachedClient Mon Jul 20 09:37:04 CST 2009 - ++++ exception thrown while trying to get object from cache for key: test_num
 com.danga.MemCached.MemCachedClient Mon Jul 20 09:37:04 CST 2009 - 3
 com.danga.MemCached.NestedIOException: 3
 at com.danga.MemCached.MemCachedClient.get(MemCachedClient.java:1408)
 at com.danga.MemCached.MemCachedClient.get(MemCachedClient.java:1270)

晕倒，记得以前为了让两个语言实现API读写共享，手动去修改了两个的API包，实现了中文互读写。难不成今儿个还要手动去搞一把？

然后手动试了下：

shell> telnet xxxxxx 11211
get test_num
VALUE test_num 4 2
23

经查证VALUE协议返回的是 key flags len \r\n value 这样的格式，大悟：原来flags不一样啊，Java里面对int型赋值以后flags是0，而Python里则不一样，两者序列化的东西不同啊。懒得去折腾两者序列化有啥不同。来点直接的把。

然后打开Python Memcached API，大概578行_val_to_store_info方法里，可以看到flags部分，是根据变量类型进行定义的，isinstance(val, str) 如果是str则pass。

到这里就简单了，直接在py代码里：mc.set('test_num', str(num))

Java读取OK。

Apache 虚拟主机配置笔记

2009-12-15T00:00:00-08:00

环境：Linux Apache2.2 （路径 /usr/local/apache）

步骤：

修改 conf/httpd.conf，找到如下位置，去除 # 注释符

# Virtual hosts
Include conf/extra/httpd-vhosts.conf

2.修改 conf/extra/httpd-vhosts.conf

<VirtualHost *:80>
    ServerAdmin webmaster@aa.com
    DocumentRoot "/usr/aa"
    ServerName ww.aa.com
    ServerAlias ww.aa.com
    ErrorLog "logs/ww.aa.com-error_log"
    CustomLog "logs/ww.aa.com-access_log" common
</VirtualHost>

注意CustomLog这行，默认给的配置是："logs/dummy-host.example.com-access_log common"

这个其实是错误的，Apache启动时候会报错，common这个应该放在双引号外面：

Syntax error on line 32 of /usr/local/apache/conf/extra/httpd-vhosts.conf:
CustomLog takes two or three arguments, a file name, a custom log format string or format name, and an optional "env=" clause (see docs)

另外还有个问题，在Apache+Tomcat时候出现的，在配置好mod_jk之后，通过默认80端口访问jsp总会提示403禁止访问，纳闷了！后来才发现是Directory配置问题，因为每个VirtualHost配置的目录不是默认的DocumentRoot目录，在Apache2以后对于权限和安全有了更高的要求，所以必须手动配置下每个Directory属性。

<Directory "/usr/aa">
    Options Indexes FollowSymLinks
    AllowOverride None
    Order allow,deny
    Allow from all
</Directory>

OK，到这里虚拟主机部分已经配置完成！

补充一点，加上日志按天保存，避免一个巨大无比的文件！

CustomLog "|/usr/local/apache/bin/rotatelogs /usr/local/apache/logs/ww.aa.com-access-%y%m%d.log 86400 480 " combined

Apache Mod_Perl实现 URL Rewrite

2009-12-15T00:00:00-08:00

相信apache的mod_rewrite模块都很熟悉了，今天这儿换个思路，利用mod_perl来实现下，发现竟然是如此的简单！

首先得保证apache已经安装了mod_perl模块，具体安装配置可以看上一篇文章哦。

修改下http.conf配置，添加一下内容：

PerlTransHandler MyTrans # MyTrans 这个是自己添加的处理模块名

具体MyTrans.pm脚本如下：

package MyTrans;

use strict;
use Apache2::Const qw(DECLINED);

sub handler {
    my $r = shift;
    my $uri = $r->uri;
    my ($id) = ($url =~ m|^/news/(.*)\.html|);
    $r->uri("/news.php");
    $r->args("id=$id");
    return Apache2::Const::DECLINED;
}
1;

实现就是：/news/12345.html => /news.php?id=12345

Apache Mod_Perl 防盗链

2009-12-15T00:00:00-08:00

大体思路是这样的，比如有一个地址：http://www.aa.com/down/1.mp3，不幸搜索引擎或者迅雷扒到了，就无偿为他们奉献流量了。但是假如在http://www.aa.com/down/1.mp3?key=123，key参数每天变化或者几分钟变化一次，在apache服务端校验下这个参数，不正确则显示拒绝访问或者找不到的话，那样防盗链的效果就算达到了把。

modperl强大到可以任意应用apache内部API，官方地址是：http://perl.apache.org/ 。根据apache版本选择相应的modperl版本，现在大部分都apache2了，就选择modperl2把。具体安装配置可以看官方文档。

先建立/home/httpd/modperl/startup.pl(目录请自行修改)，内容如下：

use strict;

use lib qw(/home/httpd/modperl); # 把这个路径加入到perl lib路径

use Apache2::RequestRec ();
use Apache2::RequestIO ();
use Apache2::Connection ();
use Apache2::RequestUtil ();
use Apache2::ServerUtil ();
use Apache2::Log ();
use Apache2::Request ();

1;

部分本机httpd.conf配置：

LoadModule perl_module                modules/mod_perl.so
LoadModule apreq_module             modules/mod_apreq2.so
PerlPostConfigRequire /home/httpd/modperl/startup.pl
<Location /down >
    SetHandler modperl # 设置该目录交给modper处理
    PerlAccessHandler Down # Down是模块名称
    PerlSetVar key 123 # 设置校验参数值
</Location>

mod_apreq2.so这个模块需要安装Apache2::Request，具体安装：http://pyh7.spaces.live.com/blog/cns%2147D8D44208AC51E5%21128.entry

startup.pl文件一般modperl应用都有，加载一些常用库，可以在apache启动时预先载入，避免重复加载。

修改这些后可以重启下apache，看下logs/error_log里最后是否有mod_apreq和mod_perl字样，如果有就说明成功了。剩下都就是写校验的perl脚本了，/home/httpd/modperl/Down.pm，内容如下：

package Down;
use strict;
use Apache2::RequestRec ();
use Apache2::RequestIO ();
use Apache2::Connection ();
use Apache2::RequestUtil ();
use Apache2::ServerUtil ();
use Apache2::Log ();
use Apache2::Const -compile => qw(OK FORBIDDEN);
use Apache2::Request ();

sub handler {
    my $r = shift;
    my $req = Apache2::Request->new($r);
    my $ip = $r->connection->remote_ip;
    my $k = $req->param('key') || ''; # 判断访问时是否带key参数
    my $key = $r->dir_config('key') || '123'; # 加载httpd.conf配置中的key值
    if ($key eq $k) { # 相等可以正常访问
        return Apache2::Const::OK;
    } else { # 否则显示拒绝访问
        my $s = Apache2::ServerUtil->server;
        $s->log_error("[$ip--------forbidden.]");
        return Apache2::Const::FORBIDDEN;
    }
}

1;

提示一下，以上两个perl脚本文件末尾记得加上1;

重启下apache。现在可以通过http://www.aa.com/down/1.mp3和http://www.aa.com/down /1.mp3?key=123测试下。可以看见不加参数拒绝访问了把。这里只是简单的判断，实际上可以根据日期或者IP加密生成一个字符串来判断。

写这个帖子完全是无意中搜索modperl应用时候发现了，具体可以参见： http://pyh7.spaces.live.com/blog/cns%2147D8D44208AC51E5%21140.entry

上面的文档已经写都很详细了，包括怎么安装modperl、Apache2::Request等模块以及配置apache的http.conf就不在累赘都重复了。

emacs windows配置笔记

2009-12-10T00:00:00-08:00

俺最新.emcas配置地址是：http://github.com/smallfish/editor/blob/master/emacs/.emacs

最近手痒，看到不少牛x人物都是用emacs，遂在windows下装一个玩玩。

下载地址：http://ftp.gnu.org/pub/gnu/emacs/windows/emacs-23.1-bin-i386.zip

解压到：D:\emacs-23.1

可以看到bin、etc、lisp等目录。主要运行都在bin目录。

runemacs.exe 这个就是运行文件拉，可以发送到桌面快捷方式。

可以运行一下addpm.exe这个，其作用就是把emacs加入到开始程序菜单里。

试着运行一下runemacs.exe，可以发现默认光标的位置，那是一个入门教程喔，还是中文的耶~

建议都看下这个入门的教程，常用的快捷键都有说明。

接下来加点常用的功能把，比如显示行号，goto line的功能。(俺也只配置了这个两项)

配置文件主要是emacs或者.emacs，win下建议emacs，点号开头的文件需要到cmd下才行。

_emacs文件放到哪儿呢？俺是直接修改了win注册表选项。

选项是：HKEY_CURRENT_USER\Software\GNU\Emacs，注意GNU\Emacs是需要新建的。接下来在Emacs里新建一个HOME项，值是你的emacs路径，比如我的：D:\emacs-23.1\bin。

然后需要做的就是把_emacs文件在这个bin目录下。

经过几经周折，显示行号和goto功能的配置如下：

(global-linum-mode 1)
(global-set-key [(meta g)] 'goto-line)

第一行是显示行号

第二行是设置meta+g转到goto功能，meta在windows下可以用alt来操作。

其他功能以后在后续补上，快捷键挺多，用了一会手指发酸。C-x 数字(1 2 3)挺好，可以开多窗口浏览了。

使用Git维护你的网站

2009-12-08T00:00:00-08:00

简介

git是由http://en.wikipedia.org/wiki/Linus_Torvalds编写的一个开放源码的版本控制系统. 它的主要目标是高度分散, 效率超过其他竞争对手.

我就是使用git维护本网站. 我知道git不应该这样的粗重任务的使用, 即每一个开发者维护一份代码拷贝, 但是它工作的很好, 所有我使用它.

本文的目的就是说明如何在家里或者笔记本里维护一个本地拷贝, 然后让这些修改提交到互联网主机上. 下面就是介绍如何设置.

安装

# Gentoo
emerge git

# Debian/Ubuntu
apt-get install git-core

# RedHat/Fedora
yum install git

初始化

你会进入你的服务器的目录和初始化git仓库.

# 进入你的web目录
cd /$wherever/html/

# 初始化仓库
git init

# 添加所有内容
git add .

# 提交 -m备注
git commit -a -m "The Initial Import."

然后返回你的html父目录, 克隆新的git-ized web目录.

# 返回你的html目录
cd ..

# 克隆你的web目录到 html.git
git clone --bare html html.git

现在你已经初始化好了仓库, 并将整个目录(递归)到该库中, 并进行了初次提交, 为web目录建立了一个git克隆. 这个git目录(html.git)是整个过程的关键.

获取一份开发环境的拷贝

转到你的开发系统
安装git
从你的开发目录运行下面命令

git clone ssh://yoursite.com/path/to/html.git

现在已经获得一个完整的网站服务器版本的本地拷贝.

记住, 你的html.git是这里的关键, 而不是现有的html目录, 所以你要切换出来, 备份目录, 然后:

# 备份html目录, 然后克隆html.git
mv html html.backup; git clone html.git

这在当前目录获取一份html.git的拷贝, 当然名字还是html. 这就是为什么备份旧的html目录.

自动推送修改

把你的html.git目录添加到post-update钩子中

cd ../htdocs
env -i git pull

修改钩子程序为可执行

chmod +x post-update

在你的开发环境的变动

现在编辑的网站, 打开一个新的TextMate项目(你使用TextMate对吗?), 并拖动到html克隆目录. 整个结构都准备好了.

通常的变动
保存更改
运行下面的程序, 例如(QuickSearchBox, TextMate等)

# This is for an OS X box
cd /Users/daniel/Development/html/
git commit -a -m "Another update."
git push

这基本上是更新到git仓库最重要的两个命令: commit(注意:你的标记(如果想回滚的话))和push(推送到服务器).

[根据你的操作系统和git安装, 你可能需要chmod +x 钩子程序, 然后再继续]

现在你只需要激活post-update 钩子程序, 将会自动的获取web目录.

如果你在服务器端的操作基本也是相同的git commit和git push, 然后你的开发环境下git pull同步备份就可以了. 当然你还可以使用脚本, 如果你需要的话.

原文参见: http://danielmiessler.com/blog/using-git-to-maintain-your-website

tornado.database添加PooledDB连接池功能

2009-12-01T00:00:00-08:00

tornado.database模块简单包装了下对MySQL的操作，短小精悍。

无奈源码中无连接池功能，遂加上了一段DBUtils模块功能。

主要修改了reconnect()方法，大致在database.py第86行左右。(tornado 0.2 win版)

原代码如下：

    def reconnect(self):
        """Closes the existing database connection and re-opens it."""
        self.close()
        self._db = MySQLdb.connect(**self._db_args)
        self._db.autocommit(True)

修改后：

    def reconnect(self):
        """Closes the existing database connection and re-opens it."""
        self.close()
        try:
            from DBUtils import PooledDB
            pool_con = PooledDB.PooledDB(creator=MySQLdb, **self._db_args)
            self._db = pool_con.connection()
        except:
            self._db = MySQLdb.connect(**self._db_args)
            self._db.autocommit(True)

至于安装DBUtils模块可以去http://pypi.python.org/pypi/DBUtils/下载，也可以简单的用easy_install：

easy_install -U DBUtils

PooledDB有这么几个参数：

* creator
    可以生成 DB-API 2 连接的任何函数或 DB-API 2 兼容的数据库连接模块。
* mincached
    启动时开启的空连接数量(缺省值 0 意味着开始时不创建连接)
* maxcached
    连接池使用的最多连接数量(缺省值 0 代表不限制连接池大小)
* maxshared
    最大允许的共享连接数量(缺省值 0 代表所有连接都是专用的)
* maxconnections
    最大允许连接数量(缺省值 0 代表不限制)
* blocking
    设置在达到最大数量时的行为(缺省值 0 或 False)
* maxusage
    单个连接的最大允许复用次数(缺省值 0 或 False 代表不限制的复用)
* setsession:
    一个可选的SQL命令列表用于准备每个会话，如 ["set datestyle to german", ...]

creator 函数或可以生成连接的函数可以接受这里传入的其他参数，例如主机名、数据库、用户名、密码等。你还可以选择传入creator函数的其他参数，允许失败重连和负载均衡。

具体可以参照下：http://www.webwareforpython.org/DBUtils/Docs/UsersGuide.zh.html

Pysvn 程序员指南

2009-11-20T00:00:00-08:00

这是一篇关于pysvn模块的指南.

完整和详细的API请参考 http://pysvn.tigris.org/docs/pysvn_prog_ref.html.

pysvn是操作Subversion版本控制的Python接口模块. 这个API接口可以管理一个工作副本, 查询档案库, 和同步两个.

该API不能创建新的仓库; 只能作用在现有仓库上. 如果你需要创建一个仓库, 请使用Subversion的svnadmin命令.

使用这个API, 你可以check out一份工作拷贝, 添加, 编辑, 和删除工作文件, 和check in, 比较, 或者放弃更改. 仓库属性, 如关键字扩展, 行字符结束, 或者忽略的列表也可以检查和控制.

Subversion 模型

Subversion是一个更新-编辑-提交的模型. 首先在本地建立一个工作副本. 在工作副本上进行修改, 最后提交到中央仓库 (可以是本地或者远程).

这个模型允许多人偶尔会同时修改同一个文件. 大多情况下. Subversion不会干预合并这些不同修改, 如果一个提交失败, 用户或者应用则要重新检查和修改然后再次提交.

常见任务

本节给出一些使用pysvn接口的常用例子. 业务可以会递归的处理目录. 添加参数recurse=False以防止这种行为; 例如, 你可以需要添加内容没有增加一个目录.

check out一份工作副本

import pysvn
client = pysvn.Client()
#check out the current version of the pysvn project
client.checkout('http://localhost/example/trunk',
    './examples/pysvn')
#check out revision 11 of the pysvn project
client.checkout('http://localhost/example/trunk',
   './examples/pysvn-11',
   revision=pysvn.Revision(pysvn.opt_revision_kind.number, 11))

这是一个建立example测试项目的例子，目录是examples/pysvn. 这个项目是用在剩下的例子.

添加一个文件或者目录到仓库

import pysvn
# write a file foo.txt
f = file('./examples/pysvn/foo.txt', 'w')
f.write('Sample versioned file via pithon\n')
f.close()
client = pysvn.Client()
#schedule the addition;
#  the working copy will now track the file as a scheduled change
client.add('./examples/pysvn/foo.txt')
#committing the change actually adds the file to the repository
client.checkin(['./examples/pysvn/foo.txt'], 'Adding a sample file')

这个例子是在工作副本中创建了'foo.txt'文件, 然后添加到仓库. 请注意Client.import_()命令会同时增加和提交. 大多数应用, 会在许多修改后再提交.

更新工作副本

import pysvn
client = pysvn.Client()
client.update('./examples/pysvn')

从仓库中更新其他用户修改并保存到本地副本. 大多数应用应该经常这样做以防止冲突.

提交更新到仓库

import pysvn
# edit the file foo.txt
f = open('./examples/pysvn/foo.txt', 'w')
f.write('Sample versioned file via python\n')
f.close()
# checkin the change with a log message
client = pysvn.Client()
client.checkin(['./examples/pysvn'], 'Corrected spelling of python in foo.txt')

提交到Subversion是原子的. 要么所有修改都成功提交, 要么提交失败. 大部分应用会提交工作副本所有修改, 如本例所示, 或者通过个别文件或者目录, 但必须是同一单位.

放弃工作副本修改

import pysvn
# edit the file foo.txt
f = file('./examples/pysvn/foo.txt', 'w')
f.write('This change will never be seen\n')
f.close()
#discard the edits
client = pysvn.Client()
client.revert('./examples/pysvn/foo.txt')

这丢弃在工作拷贝和恢复的文件或目录的任何未提交的未经编辑的状态变化.

正在计划增加或移除留无版本或恢复到工作拷贝.

重命名或者移动文件

import pysvn
client = pysvn.Client()
#rename the file client side
client.move('./examples/pysvn/foo.txt', './examples/pysvn/foo2.txt')
#checkin the change removes the file from the repository
client.checkin(['./examples/pysvn/foo.txt', './examples/pysvn/foo2.txt'], 'Foo has become Foo2')

移动或重命名文件删除旧路径或名称的文件, 并增加了在新的位置, 同时保留以前的版本有关的信息.

在这个例子里, 我们通过文件名Client.checkin()传递父目录也将是有效的.

转移和合并可以在服务器端单步完成; 可以参见仓库任务的那节例子.

从仓库中删除文件或目录

import pysvn
client = pysvn.Client()
#schedule the removal;
#  the file will be removed from the working copy
client.remove('./examples/pysvn/foo2.txt')
#committing the change removes the file from the repository
client.checkin(['./examples/pysvn/foo2.txt'], 'Removing sample file')

有些人把删除的文件, 或是用完全清除存储库目录. 该文件仍然存在于以前的版本, 可以通过检查或以其他方式进行审查以前修订的内容检索.

确定等待变动

import pysvn
client = pysvn.Client()
changes = client.status('./examples/pysvn')
print 'files to be added:'
print [f.path for f in changes if f.text_status == pysvn.wc_status_kind.added]
print 'files to be removed:'
print [f.path for f in changes if f.text_status == pysvn.wc_status_kind.deleted]
print 'files that have changed:'
print [f.path for f in changes if f.text_status == pysvn.wc_status_kind.modified]
print 'files with merge conflicts:'
print [f.path for f in changes if f.text_status == pysvn.wc_status_kind.conflicted]
print 'unversioned files:'
print [f.path for f in changes if f.text_status == pysvn.wc_status_kind.unversioned]

生成差异或补丁

import pysvn
client = pysvn.Client()
diff_text = client.diff('./tmp-file-prefix-', '.')

获取仓库URL

import pysvn
client = pysvn.Client()
entry = client.info('.')
print 'Url:',entry.url

仓库任务

本节说明任务的例子, 操纵或检查仓库.虽然共同任务, 通过本地工作副本时间的变化, 这些任务直接影响到库获取仓库目录的清单

import pysvn
client = pysvn.Client()
entry_list = client.ls('.')

从仓库获取文件内容

import pysvn
client = pysvn.Client()
file_content = client.cat('file.txt')

创建一个标记或分支

import pysvn
client = pysvn.Client()
log_message = "reason for change"
def get_log_message():
    return True, log_message
client.callback_get_log_message = get_log_message
client.copy('http://svnrepo.com/svn/trunk', 'http://svnrepo.com/svn/tag/%s' % tag_name )

从仓库中转移或者重命名

import pysvn
client = pysvn.Client()
client.move( 'file_old.txt', 'file_new.txt' )

锁定文件

import pysvn
client = pysvn.Client()
client.lock( 'file.txt', 'reason for locking' )

锁定文件并锁定其他用户或者工作副本

import pysvn
client = pysvn.Client()
client.lock( 'file.txt', 'reason for locking', force=True )

解锁

import pysvn
client = pysvn.Client()
client.unlock( 'file.txt' )

解锁文件并锁定其他用户或工作副本

import pysvn
client = pysvn.Client()
client.unlock( 'file.txt', force=True )

测试锁定文件

Method 1:

all_entries = self.client.info2( path, recurse=False )
for path, info in all_entries:
    if info['lock']:
        if info['lock']['token'] != '':
            print '%s is locked' % path
        print info['lock']['comment']

Method 2:

all_status = self.client.status( path, recurse=False, update=True )
for status in all_status:
    if status.entry is not None:
        if status.entry.lock_token is not None:
            print '%s is locked' % status.path

Cython参考指南 - 编译

2009-11-19T00:00:00-08:00

Cython代码跟Python不一样，必须要编译。

编译经过两个阶段：

Cython编译.pyx文件为.c文件
C编译器会把.c文件编译成.so文件(Windows上是.pyd)

以下会分节介绍几种方式来建立你的扩展模块。

注意： -a 选项，如果使用该选项将会为.c文件生成一份很漂亮的HTML文件，双击高亮的章节部分会展开代码，这对理解，优化和调试模块将会非常有帮助。

命令行

从命令行执行Cython编译器，输入选项和.pyx文件列表。

$ cython -a yourmod.pyx

会生成一个yourmod.c文件（指定-a选项会生成一个HTML文件）

编译.c文件取决于你的操作系统，请参考下如何在你的系统写Python扩展模块文档。

下面是一个Linux系统的例子：

$ gcc -shared -pthread -fPIC -fwrapv -O2 -Wall -fno-strict-aliasing \
 -I/usr/include/python2.5 -o yourmod.so yourmod.c

gcc需要提供包含的文件和扩展库的链接。

在目录里会生成yourmod.so文件。

现在只需要导入你的yourmod模块就可以了。

Distutils

确保你的系统已经安装好Distutils。

下面假设需要编译的文件叫hello.pyx。

建立一个setup.py的脚本：

from distutils.core import setup
from distutils.extension import Extension
from Cython.Distutils import build_ext

ext_modules = [Extension("hello", ["hello.pyx"])]

setup(
    name = ’Hello world app’,
    cmdclass = {’build_ext’: build_ext},
    ext_modules = ext_modules
)

在命令行执行：python setup.py build_ext --inplace

现在可以在shell或者脚本里正常导入使用了。

Pyximport

在纯Python代码里调用Cython代码：

>>> import pyximport; pyximport.install()
>>> import helloworld
Hello World

这仅仅是简单调用Cython，不需要C库也不需要构建脚本。

当然也可以实验性的在Python调用。允许在Python模块中运行Cython代码在任何一个.pyx和.py模块。这包括标准库和包。如果Cython编译失败的话，pyximport会返回到加载失败的模块处。

.py安装是这样：

>>> pyximport.install(pyimport = True)

原文：http://docs.cython.org/src/reference/compilation.html

Win Python Pyrex 扩展

2009-11-17T00:00:00-08:00

在偶的ubuntu里编写pyrex程序编译成so还是挺爽的，用 timeit.Timer 测试性能提升不少，今天在windows也尝试了一番。

需要的工具有： - Pyrex http://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/ - Dev C++ http://www.bloodshed.net/devcpp.html

Pyrex 可以通过easy_install Pyrex来安装。 Dev C++ 安装完在系统环境变量Path里加上Dev C++安装目录/bin 目录。

测试扩展代码：

# file: foo.pyx
""" simple pyrex module """
cdef class Foo:
    """ foo doc ... """
    cdef char *name
    def __init__(self, name):
        self.name = name
    def __repr__(self):
        return "foo names: %s" % (self.name)

# file: setup.py
from distutils.core import setup
from distutils.extension import Extension
from Pyrex.Distutils import build_ext

setup(
    name='foo', ext_modules=[Extension("foo", ["foo.pyx"])],
    cmdclass={'build_ext':build_ext}
)

写好两个文件后，进入命令提示符：

C:\>python setup.py build_ext --inplace -c mingw32
running build_ext
pyrexc foo.pyx --> foo.c
building 'foo' extension
creating build
creating build\temp.win32-2.5
creating build\temp.win32-2.5\Release
C:\Program Files\DEV-CPP\Bin\gcc.exe -mno-cygwin -mdll -O -Wall -ID:\Python25\include -ID:\Python25\PC -c foo.c -o build\temp.win32-2.5\Release\foo.o writing build\temp.win32-2.5\Release\foo.def C:\Program Files\DEV-CPP\Bin\dllwrap.exe -mno-cygwin -mdll -static --entry _DllMain@12 --output-lib build\temp.win32-2.5\Release\libfoo.a --def build\temp.win32-2.5\Release\foo.def -s build\temp.win32-2.5\Release\foo.o -LD:\Python25\libs -L D:\Python25\PCBuild -lpython25 -lmsvcr71 -o foo.pyd

编译完毕，可以看到当前目录下多了：build目录、foo.c、foo.pyd。foo.pyd 即是编译好的二进制扩展。

C:\>python
ActivePython 2.5.0.0 (ActiveState Software Inc.) based on
Python 2.5 (r25:51908, Mar 9 2007, 17:40:28) [MSC v.1310 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import foo
<module 'foo' from 'foo.pyd'>
>>> foo.Foo("smallfish")
foo names: smallfish

MySQL Query Profile 简单使用

2009-11-16T00:00:00-08:00

MySQL Query Profile MySQL 5.0.37 以上开始支持 MySQL Query Profiler, 可以查询到此 SQL 会执行多少时间, 并看出 CPU/Memory 使用量, 执行过程中 System lock, Table lock 花多少时间等等.

详细可以参见官方文档：http://dev.mysql.com/tech-resources/articles/using-new-query-profiler.html

启动

mysql> set profiling=1;
Query OK, 0 rows affected (0.00 sec)

测试查询

mysql> select count(*) from client where broker_id=2;
+----------+
| count(*) |
+----------+
|      200 |
+----------+
1 row in set (0.00 sec)

查看profiles

mysql> show profiles;
+----------+------------+-----------------------------------------------+
| Query_ID | Duration   | Query                                         |
+----------+------------+-----------------------------------------------+
|        0 | 0.00007300 | set profiling=1                               |
|        1 | 0.00044700 | select count(*) from client where broker_id=2 |
+----------+------------+-----------------------------------------------+
2 rows in set (0.00 sec)

查看单条profile

mysql> show profile for query 1;
+--------------------+------------+
| Status             | Duration   |
+--------------------+------------+
| (initialization)   | 0.00006300 |
| Opening tables     | 0.00001400 |
| System lock        | 0.00000600 |
| Table lock         | 0.00001000 |
| init               | 0.00002200 |
| optimizing         | 0.00001100 |
| statistics         | 0.00009300 |
| preparing          | 0.00001700 |
| executing          | 0.00000700 |
| Sending data       | 0.00016800 |
| end                | 0.00000700 |
| query end          | 0.00000500 |
| freeing items      | 0.00001200 |
| closing tables     | 0.00000800 |
| logging slow query | 0.00000400 |
+--------------------+------------+
15 rows in set (0.00 sec)

mysql> alter table t engine=myisam;
Query OK, 112050 rows affected (0.64 sec)
Records: 112050  Duplicates: 0  Warnings: 0

mysql> show profiles;
+----------+------------+-----------------------------------------------+
| Query_ID | Duration   | Query                                         |
+----------+------------+-----------------------------------------------+
|        0 | 0.00007300 | set profiling=1                               |
|        1 | 0.00044700 | select count(*) from client where broker_id=2 |
|        2 | 0.00003400 | set profiling=0                               |
|        3 | 0.00007400 | set profiling=1                               |
|        4 | 0.63789700 | alter table t engine=myisam                   |
|        5 | 0.00004000 | set profiling=0                               |
+----------+------------+-----------------------------------------------+
6 rows in set (0.00 sec)

mysql> show profile for query 4;
+----------------------+------------+
| Status               | Duration   |
+----------------------+------------+
| (initialization)     | 0.00002900 |
| checking permissions | 0.00000800 |
| init                 | 0.00004000 |
| Opening table        | 0.00009400 |
| System lock          | 0.00000500 |
| Table lock           | 0.00000700 |
| setup                | 0.00004200 |
| creating table       | 0.00195800 |
| After create         | 0.00010900 |
| copy to tmp table    | 0.52264500 |
| rename result table  | 0.11289400 |
| end                  | 0.00004600 |
| query end            | 0.00000700 |
| freeing items        | 0.00001300 |
+----------------------+------------+
14 rows in set (0.00 sec)

查看cpu资源等信息

mysql> show profile cpu for query 4;
+----------------------+------------+------------+------------+
| Status               | Duration   | CPU_user   | CPU_system |
+----------------------+------------+------------+------------+
| (initialization)     | 0.00002900 | 0.00000000 | 0.00000000 |
| checking permissions | 0.00000800 | 0.00000000 | 0.00000000 |
| init                 | 0.00004000 | 0.00000000 | 0.00000000 |
| Opening table        | 0.00009400 | 0.00100000 | 0.00000000 |
| System lock          | 0.00000500 | 0.00000000 | 0.00000000 |
| Table lock           | 0.00000700 | 0.00000000 | 0.00000000 |
| setup                | 0.00004200 | 0.00000000 | 0.00000000 |
| creating table       | 0.00195800 | 0.00000000 | 0.00100000 |
| After create         | 0.00010900 | 0.00000000 | 0.00000000 |
| copy to tmp table    | 0.52264500 | 0.55591600 | 0.04199300 |
| rename result table  | 0.11289400 | 0.00199900 | 0.00000000 |
| end                  | 0.00004600 | 0.00000000 | 0.00000000 |
| query end            | 0.00000700 | 0.00000000 | 0.00000000 |
| freeing items        | 0.00001300 | 0.00000000 | 0.00000000 |
+----------------------+------------+------------+------------+
14 rows in set (0.00 sec)

其他属性列表

ALL - displays all information
BLOCK IO - displays counts for block input and output operations
CONTEXT SWITCHES - displays counts for voluntary and involuntary context switches
IPC - displays counts for messages sent and received
MEMORY - is not currently implemented
PAGE FAULTS - displays counts for major and minor page faults
SOURCE - displays the names of functions from the source code, together with the name and line number of the file in which the function occurs
SWAPS - displays swap counts

设定profiling保存size

mysql> show variables where variable_name='profiling_history_size'; # 默认15条

关闭

mysql> set profiling=0;

Python MySQLdb 查询返回字典结构

2009-11-10T00:00:00-08:00

MySQLdb默认查询结果都是返回tuple，输出时候不是很方便，必须按照0，1这样读取，无意中在网上找到简单的修改方法，就是传递一个cursors.DictCursor就行。

默认程序：

import MySQLdb
db = MySQLdb.connect(host = 'localhost', user = 'root', passwd = '123456', db = 'test')
cursor = db.cursor()
cursor.execute('select * from user')
rs = cursor.fetchall()
print rs
# 返回类似如下
# ((1000L, 0L), (2000L, 0L), (3000L, 0L))

修改后：

import MySQLdb
import MySQLdb.cursors
db = MySQLdb.connect(host = 'localhost', user = 'root', passwd = '123456', db = 'test',
                     cursorclass = MySQLdb.cursors.DictCursor)
cursor = db.cursor()
cursor.execute('select * from user')
rs = cursor.fetchall()
print rs
# 返回类似如下
# ({'age': 0L, 'num': 1000L}, {'age': 0L, 'num': 2000L}, {'age': 0L, 'num': 3000L})

或者也可以用下面替换connect和cursor部分

db = MySQLdb.connect(host = 'localhost', user = 'root', passwd = '123456', db = 'test')
cursor = conn.cursor(cursorclass = MySQLdb.cursors.DictCursor)

Python MySQL 库安装笔记

2009-11-10T00:00:00-08:00

其实MySQL-python安装很简直，以前一直也没在意，今天发觉换了1.2.3新版本，ms蹦出很多问题来了。做个记录，防止以后有问题无处可查。

一般步骤是：

安装easy_install

shell > wget http://peak.telecommunity.com/dist/ez_setup.py
shell > python ez_setup.py

会自动根据本机的py版本选择对应的egg，安装完可以看到有/usr/bin/easy_install程序了

安装MySQL-python

shell > easy_install MySQL-python

到这里安装算是完成了，不过接下来测试就郁闷了。

在import MySQLdb出现了两个错误：

a). ImportError: libmysqlclient_r.so.15: cannot open shared object file: No such file or directory

这个错误一般解决比较简单，把路径加入到LD_LIBRARY_PATH即可，不过偶的现象比较强，因为没装MySQL，哈哈

b). ImportError: /lib/tls/libc.so.6: version `GLIBC_2.4' not found

解决这个错误的办法是不用easy_install了，直接下载MySQL-python-1.2.2.tar.gz包，然后就是三步走：

shell > tar zxvf MySQL-python-1.2.2.tar.gz
shell > cd MySQL-python-1.2.2
shell > python setup.py install

Python Mako Template 学习笔记

2009-11-10T00:00:00-08:00

Mako是什么？Moko是Python写的一个模板库，Python官网http://python.org/用的就是它哦。其他废话也就不累赘了，直接来点代码，方便阅读与了解把。

(Mako官网地址：http://www.makotemplates.org/ ，可以下载安装包，推荐使用easy_install安装)

from mako.template import Template
mytemplate = Template("hello world!")
print mytemplate.render()
mytemplate = Template("hello, ${name}!")
print mytemplate.render(name="jack")

代码可以参考官方doc部分

mytemplate = Template(filename='/docs/mytmpl.txt')
print mytemplate.render()

还可以从设置模板为文件，设置filename属性

mytemplate = Template(filename='/docs/mytmpl.txt', module_directory='/tmp/mako_modules')
print mytemplate.render()

文件还可以缓存到某个目录下，下面的/docs/mytmpl.txt会产生一个py：/tmp/mako_modules/docs/mytmpl.txt.py

from mako.lookup import TemplateLookup
mylookup = TemplateLookup(directories=['/docs'])
mytemplate = Template("""<%include file="header.txt"/> hello world!""", lookup=mylookup)

查找模板，方便统一模板路径使用。

mylookup = TemplateLookup(directories=['/docs'], module_directory='/tmp/mako_modules')
def serve_template(templatename, **kwargs):
mytemplate = mylookup.get_template(templatename)
print mytemplate.render(**kwargs)

改良了上面的查找方式

mylookup = TemplateLookup(directories=['/docs'], output_encoding='utf-8',
                                       encoding_errors='replace')
mytemplate = mylookup.get_template("foo.txt")
print mytemplate.render()

设置输出编码，以及编码错误时候处理方式

Google App Engine 上试用 web.py 笔记

2009-11-10T00:00:00-08:00

看到有人在坛子里询问在GAE如何发布web.py有关问题，就尝试了一把。具体安装和使用过程如下，请对照自己本地路径相应修改：

复制本地对应web.py目录到GAE对应应用目录

比如：D:\Python25\Lib\site-packages\web 到 e:\googleapp\pynotes

写测试代码 app.yaml

application: pynotes
version: 1
runtime: python
api_version: 1

handlers:
-  url: /.*
   script: home.py

home.py

import web
render = web.template.render('templates/')
urls = (
    '/', 'index'
)
class index:
    def GET(self):
        web.header('Content-type', 'text/html')
        name = 'smallfish'
        return render.index(name)
app = web.application(urls, globals())
main = app.cgirun() # 这行是发布到GAE的关键

templates/index.html

$def with (name)
hello, $name. test by web.py

发布到GAE，测试

e:\googleapp>appcfg.py update pynotes/

到这里，一个简单web.py应用就完成了，然后刷新。GAE显示500 Error！

看后台GAE Log显示错误信息：”No module named templates“，去web.py官方溜达了一圈，发现在其cookbook里有一篇文档《http://webpy.org/cookbook/templates_on_gae》，里面说的很明白啦。

因为web.py的模板在GAE上文件系统会有所限制，所有本地得compile一下，具体命令是：python web/template.py --compile templates 最后一个参数是本地对应模板目录templates，如果有多个模板目录则一次运行一次。运行完会在templates会生成一个init.py，里面内容有兴趣可以看看，很眼熟的哦。

再次发布到GAE，可以看到OK拉！