427 Error - Site not perfect

完全吃不消 SAE 的 MySQL 各种限制了，无数次地清空数据库 -> 重新初始化 -> 导入 SQL 文件。

为什么不能在 Django 中建立好 Model 后，直接从 Django 的 View 里 syncdb 呢。

from django.http import HttpResponse

def syncdb(request):
    from django.core.management import call_command
    from cStringIO import StringIO
    import sys
    old_stdout = sys.stdout
    sys.stdout = mystdout = StringIO()
    mystdout.write('<pre>')
    call_command('syncdb')
    mystdout.write('</pre>')
    sys.stdout = old_stdout
    mystdout.seek(0)
    return HttpResponse(mystdout.read())

什么时候再把 South 整合进去就完美啦~~~ ;-)

这两天在公司的项目里用了 Long polling，了解了它的实现原理，其实不像它的名字那么玄乎，只是 Ajax 和 HTTP 的类似小妙招的办法。

先解释一下 Long polling 是什么：

首先得说到传统的 Polling，Polling 是 Ajax 隔一段时间去抓取服务器上的数据，检查数据是否更新，但这样有很大问题，首先是每次请求会实用一个  HTTP request，对应的服务器就得建一个新的线程来处理这个 HTTP request，消耗网络流量、服务器资源不说，绝大多数情况下，数据短时间内是不会更新的，也就是说绝大多数的 Ajax 请求都只能无功而返。

而 Long polling 就是用来解决这个问题的。

它的核心是：
1. 做一个超时非常长的 Ajax 请求，并且在错误捕获代码里不断执行自己。2. CGI 部分接收到请求后在限定的时间内（Ajax 超时时间内）每隔一段时间（例如一秒）对数据库进行查询，可以使用 sleep 类似的方法。
3. 如果有新的数据则返回，如果即将到 Ajax 超时的时间则返回一个错误值，比如 404，这样那个非常长的 Ajax 请求会再发一个过来，继续查询。

这个办法的最大价值是有效减少了 HTTP 请求数，对服务器而言就不用开启新的线程去处理它，旧的线程如果不是因为超时，则只会在数据已经更新的情况下返回数据。可以节约大量资源，而且实时性更高。

目前，人人网的消息提示、Web 版阿里旺旺、新浪微博的新微博提示应该都是使用这种方法做的。

但这个办法对开发有一定困扰，Django 内置的 Web service 是单线程的，一个非常长的 Ajax 请求会占用那唯一一个线程，导致别的请求无法响应。

所以最好做好两套配置，一套用于产品环境的多线程环境，一个用于开发的单线程环境。

我依然对那位在现有架构下想出这种办法的人表示钦佩。

这儿有范例代码，简单又实用：http://stackoverflow.com/questions/333664/simple-long-polling-example-code

趁着职务之便，能接触到不少手机，所以本着见啥测啥的精神，就有了此文。

目前测试软件只有 Quadrant Advanced，如果谁知道有其它测试软件，尤其针对应用程序 Load 时间的，欢迎推荐。

最后声明一下：本测试纯属个人兴趣，如果对某商品起到了促销作用纯属巧合，影响了某商品的销量也概不负责啊。

今天大年初一，祝大家新年走大运，工资节节高。

白天串了一天亲戚，晚上来想想一下去年都做了些什么比较有意义的事情，新年又应该做些什么了。

2010 旧年总结：

职业上

• Nitrate 进入稳定阶段，成功将推入公司内部，将旧的 Testopia 关掉，成为测试部唯一测试用例管理工具。
• 成功将 Nitrate 推入 Fedorahosted，正式开放源代码，并计划在 Fedora 15 的时候推广到 Fedora 社区内部测试，并计划在 Fedora 16 的时候正式使用，替代掉现有 Wiki 系统。
• 成功拿下 RHCE 和 Certified Scrum Master 认证，前者早就拿过只是刷新一下，后者让我对软件工程管理有了新的认识。
• 因感到个人技术瓶颈，离开了 Red Hat，寻找新的发展。

生活上

• 买了一套房子，正式成为房奴。
• 经过了近三年的发展，和女朋友感情进入平稳阶段，吵闹的事情减少了很多。
• 爷爷经历了84危机，好在平稳度过，目前已经无恙。

2011 新年计划：

职业上

• 寻找新的发展，并寻找转型机会，希望能将 Red Hat 先进的工作流和管理经验带入其它公司。
• 继续参加培训，提高自身水平。软件开发、管理课程、礼仪、沟通与交流、心理学/哲学方面都是不错的主题。
• 探索一些新的领域，例如互联网，移动开发，高负载下的性能优化等等。
• 启动新的项目，作为个人历练用，因为是个人项目，所以有更多“研发”的工作，用一些新的经验，新的思路，新的想法。已经有了目标，一是重写 Nitrate，二是编写一个新的项目管理工具，将 Scrum 的理念带入其中。
• 参与 Django 项目开发，适时提交补丁。

生活上

• 如果不出问题，应该会在今年结婚。
• 去考一个车本，驾驶是现在必备的技能。
• 学学喝酒。
• 阅读更多、更广泛的书籍，不再局限于软件开发方面。
• 去旅游。
• 学习一下乐器，家里的 MIDI 键盘和吉他都买了好久了，一直没动力去认真学，打算用学习编写软件的方法，跳过理论，直接实践了。
• 照顾好家人，常回家看看，尤其家里老人，可能时日无多。

希望到明年这个时候，回过头来，计划都能够完成。

好不容易搞定了火车票（当然不是通过酷讯或者黄牛），把去年写过的抓黄牛脚本重写了一下，提供给各位还在等待购买火车票的 Programmer 使用。说是抓黄牛，自然还包括普通转票者。原理还是通过轮询酷讯网站上的内容，但是增加了几个新特性：

• 用 re 提供的正则表达式替换掉了 SGMLParser 提高效率
• 可以轮询多个地址了，比如我到吉安和井冈山都可以，所以我要遍历两个地址
• 可以将转向链接直接打印在屏幕上了
• 提供了 Python 3 的 Package 级支持，但是因为 re 模块变更，正则表达式在 Python 3 里无法运行，暂时没心思更新了。

尽管酷讯推出了秒杀器，不过还是觉得不妥，一是没任何输出，谁知道它是否真的能秒到，二是不跨平台，在 Mac 和 Linux 上暂时无法使用。

Patches are welcome. :-)

#!/usr/bin/python
# encoding: utf-8
#
# Catch the yellow cattles script
#
# Author: Xuqing Kuang <xuqingkuang@gmail.com>
# New features:
# * Use regexp to instead of SGMLParser for performance
# * Polling multiple URL at one time.
# * Print out the redirect URL.
# * Basic packages compatible with Python 3
# TODO:
# * Use one regexp to split the href and text of link
# * Update re package usage to compatible with Python 3

import time
import os
import re

try:
    import urllib2 as urllib
except ImportError: # Python 3 compatible
    import urllib.request, urllib.error

urls = (
    "http://piao.kuxun.cn/beijing-jinggangshan/",
    "http://piao.kuxun.cn/beijing-jian/",

)

keyword = '3张'
sequence = 60

class TrainTicket(object):
    """
    Catch the yellow cattle
    """
    def __init__(self, urls, keyword, sequence = 60):
        self.urls = urls
        self.keyword = keyword
        self.sequence = sequence
        self.cache=[]
        self.html = ''
        self.links = []
        if hasattr(urllib, 'build_opener'):
            self.opener = urllib.build_opener()
        else: # Python 3 compatible
            self.opener = urllib.request.build_opener()
        self.result = []
        self.re_links = re.compile('<a.*?href=.*?<\/a>', re.I)
        # self.re_element = re.compile('', re.I) # Hardcode at following
        self.requests = []
        for url in urls:
            if hasattr(urllib, 'Request'):
                request = urllib.Request(url)
            else: # Python 3 compatible
                request = urllib.request.Request(url)

            request.add_header('User-Agent', 'Mozilla/5.0')
            self.requests.append(request)

    def get_page(self, request):
        """
        Open the page.
        """
        try:
            self.html = self.opener.open(request).read()
        except urllib.HTTPError:
            return False
        return self.html

    def get_links(self, html = ''):
        """
        Process the page, get all of links
        """
        if not html:
            html = self.html
        self.links = self.re_links.findall(html)
        return self.links

    def get_element(self, link = ''):
        """
        Process the link generated by self.get_links().
        Return list of the href and text
        """
        # FIXME: have no idea how to split the href and text with one regex
        # So use two regex for temporary solution
        href = re.findall('(?<=href=").*?(?=")', link) # Get the href attribute
        if not href:                                   # Process the no href attr
            href = ['']
        text = re.split('(<.*?>)', link)[2]            # Get the text of link a.
        href.append(text)                              # Append to the list.
        return href

    def get_ticket(self, request = None):
        """
        Generate the data structure of tickets for each URL.
        """
        if not request:
            request = self.requests[0]

        self.get_page(request)
        self.get_links()

        i = 0
        while i < len(self.links):
            link = self.get_element(self.links[i])
            if not link:
                continue
            url = link[0]
            name = link[1]
            if name and name.find(keyword) >= 0 and url not in self.cache:
                self.result.append((
                    i, name, url,
                ))
                self.cache.append(url)
            i += 1
        return self.result

    def print_tickets(self):
        """
        Process all of URLS and print out the tickets information.
        """
        while 1:
            self.result = []
            try:
                print('Begin retrive')
                for request in self.requests:
                    print('Begin scan %s' % request.get_full_url())
                    self.get_ticket(request)
                    print('Found %s urls.' % len(self.links))
                    for r in self.result:
                        print('Index: %s\nName: %s\nURL: %s\n' % (
                            r[0], r[1], r[2]
                        ))
                print('Scan finished, begin sleep %s seconds' % self.sequence)
                time.sleep(self.sequence)
            except KeyboardInterrupt:
                exit()
            except:
                raise

if __name__ == '__main__':
    tt = TrainTicket(urls, keyword, sequence)
    tt.print_tickets()

软件工程：

随着软件工程的不断膨胀，功能的扩展变得愈发困难，因为增加一点点小功能而导致的 Regression 可能会越来越多，同时，因为项目越来越大，参与的人越来越多，代码的结构化、模块化便成了高质量产品非常重要的特性之一。

高内聚和低耦合，其实是好的模块化编程必须具备的两项特点，高内聚，我的理解模块独立完成特定，不重复实现其他模块已经实现过的逻辑，而低耦合，即模块与模块之间的直接连接要尽量低下，耦合性高，会导致牵一发而动全身，将导致未来的代码维护和功能扩展愈发艰难。

最简单的模块化即现在 Web 开发的 MVC 架构，数据库的建模部分由 Model 完成，页面展示由  Views 完成，而之间的协调和逻辑关系由 Controller 完成，以一个 Product 项目的创建为例，它会在创建时同时创建好另外两个字段的默认值 - Version 和 Component，当 Views 接收到用户的输入后，然后将它传递给 Controller，Controller 将会判断输入的合法性并同时创建好另外两个字段的类，再通过调用 Models 提供的方法将这三个类在数据库中持久化下来。

这需要在开发前定一套统一的 API，这样各个模块才能无障碍地随意调用。

那么这样的好处在哪里？其实是非常明显的，页面显示部分不用关注数据库会提供什么养的类型，而数据库也不用关注用户会提供什么格式的数据，都会因为中间 Controller 的调度和转化被统一起来，进而达到程序的模块化，以及开发人员的专职化。

以我自身经验为例，如果要和前端配合同时完成一套功能，我们会约定好我给他什么样的 Ajax method，参数是什么，返回的是什么样的格式，这样我们两个能够同时编写不同的代码，但到功能完成之时，将两个代码放在一起，直接就能运行起来。

SOA：

那么程序与程序之间的整合，使之同时完成一项功能如何才能做到？

传统的方法有提供 RPC 接口，轮询数据库或者文件系统，但是问题在哪里？

• XML-RPC 同样会出现错误，而且缺乏 Error handler
• 数据库和文件系统的轮询有很高的风险，首先轮询文件系统就以为着这个目录里的文件要小心放置了，因为不小心就会被程序轮询到，而因为轮询造成的数据库损坏的可能性更加难以纠正。
• 很低的内聚性，很高的耦合性，为了同步两个程序间的数据，可能得克隆一份对方程序里的数据结构和逻辑方法，一旦任何一方的数据结构或逻辑改变，将导致同步失败。
• 不实时，因为轮询总是有时间间隔的，轮询频繁会导致系统负载加重，轮询频率低了又容易等待时间过长。

那么程序之间的整合如何才能更好地做到，这就需要将 SOA 的思想引入进来了，SOA - Service Orient Architechture，面向服务的架构，程序与程序之间不再是程序，而是一个个的服务，这个服务可以通过 RPC 来实现对自身方法的调用，但是还有很重要的一点，是要将自身正在做的事情告诉别的程序。

下图是 Nitrate 项目目前的结构，其实我觉得它是模块化开发的一个典范了。

Nitrate 是标准的 MVC 架构，我来解释一下它的工作流，除了基本的 Web UI 界面和 XML-RPC 界面外，我们还提供了 Global signal processor（后简称 GSP）用于监听所有 Models 的信号，目前信号有三种 - Initial，对应于数据库的 SELECT 语句，Create 对应于数据库的 Insert 语句，Update 对应于数据库的 Update 语句，所有被注册的 Models 一旦发生以上动作将会出发对应的信号，然后 GSP 将信号推入 Plugin support（后简称PS），由它以线程方式将 Signal，Models 和触发消息的 Model Instance 交由 Plugin 处理。

这里我将 Plugin 分为了两类：

一类是 Special plugin，用于整合一些特殊的程序，这些程序不带有消息队列支持，它是以传统工具整合方式工作的，接受到信号后会根据已经定义好的参数判断信号是否符合条件，如符合则通过该 Special 程序提供的 RPC 接口将 TCMS 中的改动同步进该程序中，事实上该方法危险性较高，而且需要将对方的数据库表格和参数定义在插件里。

第二类是 Messaging queue plugin，这是我最偏好的方法，目前支持的 Messaging queue（以后简称 MQ）是 QPID，它将 Models 的 Signal 转译成 MQ 的数据格式，然后直接推入 MQ，然后别的需要 Nitrate 数据的程序可以提供第三方的一个 Sync middleware，作为两个程序间的桥梁对数据进行选择性的同步，这样的好处是逻辑不用重复实现，双方共享的数据之需要存在 Sync middleware 程序中即可，不影响双方逻辑和数据库结构。而 Nitrate 本身也提供了 TCMS Messenging listener 用于监听 MQ 内的 message，例如如果 Bugzilla 新创建了一个 Product，Nitrate 将很快便能监听到并在数据库中创建一份相同的 Product 供用户使用，全程自动化，智能化，无人干预。

“能听能说”的程序才能较好地整合到其它程序中，“听” 提供了 XML-RPC 接口，别的程序可以通过它更改 Nitrate 中的数据，“说”提供了 MQ 的支持，别的程序可以监听 Nitrate 中数据的变化，并以此为依据对自身数据进行添加、更改，而且不用存储对方数据表，不用了解对方的业务逻辑，只需要写好中间的 Sync middleware 即可，好处多多，其乐无穷。

测试驱动

在之前的 Scrum 培训总结中，我说到了 CI（Continuous Integration）是 Scrum 所要求必备的，那么为什么单元测试如此重要？

下面的图可以充分说明这点：

尽管手工测试可以降低编码时间，但这也仅仅是在项目非常非常小，而且没有后期维护成本的情况下。从上图可以看出，在第一个迭代的时候，开发如果和测试的时间是一样长，这或许可以生产出一个高质量的产品，但是到第二个迭代的时候，开发人员仅仅向软件中加入了很少的 Feature，但是测试却不能减少他们的工作量，依然要进行一遍完整的测试，而且还要检查是否有因为新加入的 Feature 导致的 Regression，到第三个迭代的时候开发的时间更加少，到第五个迭代后开发已经完全没用了，尽管测试占用的时间比例很大，但是依然无法保证测试完成，产品推到生产环境下会发现问题多多，开发人员就成了救火队员，下个迭代可能要用整个迭代的时间，去修上个迭代造成的 Bug，软件将停滞不前。

那么针对不同类型的语言和软件类型，有什么 Unit Testing 的方式呢？

这要从语言的类型和特点说起了。

* HTML，CSS - 前段，结构远远大于逻辑的语言。因为浏览器的兼容性问题，它是最难进行自动化测试的语言，但是依然是有办法的，可以使用类似 Dogtail 类的自动UI点击程序，判断 Console 中的错误输出，或者使用 W3C Validator 一类的工具，对它进行错误判断。

* Python/PHP/Java - 后端，结构和逻辑并重的语言。其实它是最好编写 Unit testing 的语言，因为它只负责一件事情：提供 API 供调用，我们只需要模拟输入，判断程序是否会出现 Error 即可，Django 提供了很好的 Unit testing 框架，可以模拟客户端的提交数据，以检测 Views 和 Controller 能否正常工作，Models 能否对数据库正常读写，或者 ForeignKey 的正确性也可以通过 UT 进行验证，Java 也提供了 JUnit 等工具。

* Javascript/其它 UI 语言 - 前端，结构和逻辑并重的语言。这是最有意思的地方，很多人说 UI 类的语言的 UT 非常难以编写，因为无法验证最终的正确性，其实仔细观察就可以看出，这类语言，其实只是调用了后端提供的 API，也就是说，对于此类语言，一检查提供给后端的 API 的参数是否正确，二检查能否将后端的返回正常生成数据结构并反应在页面上即可。前者依然可以通过检查后端的出错情况，而后者可以通过更改编码方式，将逻辑层和显示层拆分解决，例如后端返回的数据需要生成一个按钮，只需要将生成按钮的代码拆分，并通过单元测试检查按钮是否正常生成并符合条件即可，因为只要能正常生成，基本上现实在页面上不会出太大问题，这是基本功能了。

另外说一句有意思的事情，前两天听说了另一种 UT 的方式，名称叫 Monkey，写一个程序在屏幕上随机乱点，只要程序能稳定跑上几个小时就算通过，这来源于让猴子敲键盘，总有一天能敲出莎士比亚全集的传说。这也算是很有创意了，只是我觉得这不能叫 UT，可能只能叫 RT(Random Testing）了，缺点很明显，一是无法针对某个功能，二难以重现（可重现的 Bug 对开发人员很重要），三难以统计。

第一个是反转字符串，前两种是我出来丢人的，请直接看第三种。

方法１：

取出最大长度并 -1，以此为索引，依次递减，并将结果加入数组。

def reverse(string):
    if not string:
        return string
    str_list = []
    i = len(string) - 1
    while(i >= 0):
        str_list.append(string[i])
        i -= 1
    return ''.join(str_list)

方法２：

类似 C 中的位移操作，使用一个中间变量 t 记录临时值，然后将前后为置换，时间主要花在将字符串转换成数组上，实际遍历只需要上面方法的一半，但比上面方法要多消耗一个临时变量 t 的内存。当然，如果用 C 就可以直接指向内存，这样最节省内存，但是 Python 可能没更好办法。

但因为对 str 操作会造成 TypeError，所以还需要组成一个临时数组并在最后合并。

def reverse2(string):
    if not string:
        return string
    
    idx = 0
    length = len(string) - 1
    h_length = length / 2 # Half of length
    # 'str' object does not support item assignment for Python
    # Use C to solve it will be better.
    # So we convert it to be a list from the string.
    str_list = [x for x in string]
    
    while(idx <= h_length):
        t_idx = length - idx
        # Use varible t to store the temporary string
        t = str_list[t_idx]
        # Start to move the bit
        str_list[t_idx] = str_list[idx]
        str_list[idx] = t
        idx += 1
    
    return ''.join(str_list)

方法３：

由 @Cotton 提供，直接用数组的方式，通过本用来做间隔数的段落进行反向遍历，我只能赞叹一句，Python 太强大了！

def reverse3(string):
    return string[::-1]

另一个是求素数，没想出什么比较好的算法，只能递归，但是因为除法（求余）非常缓慢，所以我对此算法非常不满。

方法１：

这里使用一个 range 直接生成一个数组，并用 for 递归，因为我觉得一次生成数组的速度应该比多次改写一个变量速度要快，但是自然，消耗内存稍大，如果对内存有要求，也可用 while 加递减代替。

def is_prime1(num):
    # Initial to presume it's a prime
    rt = True
    # It seems every number is possible to be the one, so it have to make a range.
    for i in range(2, num):
        if num % i == 0:
            rt = False
            break
    return rt

方法２：

由 jyf1987 提供，双数的判断一次解决（但是 3、5 的倍数如何能更快地排除呢？），剩下的是单数的递归，同时引入平方根（很好的想法，因为大于平方根后的数的计算已经没有意义，因为另一个数必然也是之前计算过的，因为 N = a*b，所以 N=M^2），降低运算量，引入 xrange 降低内存使用量，因为是原生实现，我相信应该不会比直接用 range 生成数组更慢。

from math import sqrt

def is_prime2(num):
    # Checking the Type/value
    if type(num) != int:
       raise TypeError

    if num < 2:
       raise ValueError('The number must be great than 1')

    # Inital to presume it's a prime
    rt = True
    sq_num = int(sqrt(num))

    # First we detect is it prime for 2
    if num == 2:
        return rt

    if num % 2 == 0:
        rt = False
        return rt
    
    # Now, start to detect the odd number
    # Because all of even number could division by 2, then how about 3? -_-#
    for i in xrange(3, sq_num, 2):
        if num % i == 0:
            rt = False
            break
    return rt

冰天雪地三十六度翻转跪求更好算法～嘿嘿。。。

QPID 是一种高性能 Message Bus，目前因为牵扯到工具的 SOA 架构，我的项目中将会整合它，以将自身对数据库的修改提交到 Message Bus 中, 供其它程序监听调用。

目前主流的 Message Bus 主要有以下几种：

1. RabbitMQ
2. Apache ActiveMQ
3. Apache qpid

而之所以选择 QPID 是因为它有以下几个优点（引用源)：

• Supports transactions
• Persistence using a pluggable layer — I believe the default is Apache Derby
• This like the other Java based product is HIGHLY configurable
• Management using JMX and an Eclipse Management Console application - http://www.lahiru.org/2008/08/what-qpid-management-console-can-do.html
• The management console is very feature rich
• Supports message Priorities
• Automatic client failover using configurable connection properties -
  • http://qpid.apache.org/cluster-design-note.html
  • http://qpid.apache.org/starting-a-cluster.html
  • http://qpid.apache.org/cluster-failover-modes.html
• Cluster is nothing but a set of machines have all the queues replicated
• All queue data and metadata is replicated across all nodes that make up a cluster
• All clients need to know in advance which nodes make up the cluster
• Retry logic lies in the client code
• Durable Queues/Subscriptions
• Has bindings in many languages
• For the curious: http://qpid.apache.org/current-architecture.html

而对我而言，QPID 比较有优势的地方是，一有 Python 的 bindding(Perl 的兄弟对不起了），二是源代码比较充足。

为此我写了两个基类，简单地调用了 QPID Python 中的 Receiver 和 Sender，相对于 message_transfer 方法，这种方法可以传递 Dictionary 对象，一共三个文件，其实也可以合在一起使用。

#!/usr/bin/python

import qpid
import qpid.messaging
import logging
logging.basicConfig()

class QPIDBase(object):
    def __init__(self, host='10.66.93.193', port='5672', queue_name='tmp.testing', username='guest', password='guest'):
        """
        Arguments:
            host
            port
            queue_name
            username
            password
        """
        self.host = host
        self.port = port
        self.queue_name = queue_name
        self.username = username
        self.password = password
        self.connection = None
        self.session = None
    
    def init_connect(self, mechanism='PLAIN'):
        """Initial the connection"""
        url = 'amqp://guest/guest@%s:%s' %(self.host, self.port)
        self.connection = qpid.messaging.Connection(
            url = url, sasl_mechanisms=mechanism,
            reconnect=True, reconnect_interval=60, reconnect_limit=60,
            username=self.username, password=self.password
        )
        self.connection.open()
        
    def init_session(self):
        """Initial the session"""
        if not self.connection:
            self.init_connect()
        self.session = self.connection.session()
    
    def close(self):
        """Close the connection and session"""
        self.session.close()
        self.connection.close()

#!/usr/bin/python

import qpid.messaging
from datetime import datetime
from base import QPIDBase

class QPIDSender(QPIDBase):
    def __init__(self, **kwargs):
        super(QPIDSender, self).__init__(**kwargs)
        self.sender = None
    
    def init_sender(self):
        """Initial the sender"""
        if not self.session:
            self.init_session()
        self.sender = self.session.sender(self.queue_name)
    
    def send(self, content, t = 'test'):
        """Sending the content"""
        if not self.sender:
            self.init_sender()
        props = {'type': t}
        message = qpid.messaging.Message(properties=props, content = content)
        self.sender.send(message)
    
    def typing(self):
        """Sending the contents real time with typing"""
        content = ''
        while content != 'EOF':
            content = raw_input('Start typing:')
            self.send(content)

if __name__ == '__main__':
    s = QPIDSender()
    s.send('Testing at %s' % datetime.now())
    s.close()

#!/usr/bin/python

from pprint import pprint
from base import QPIDBase

class QPIDReceiver(QPIDBase):
    def __init__(self, **kwargs):
        super(QPIDReceiver, self).__init__(**kwargs)
        self.receiver = None
    
    def init_receiver(self):
        """Initial the receiver"""
        if not self.session:
            self.init_session()
        self.receiver = self.session.receiver(self.queue_name)
        
    def receive(self):
        """Listing the messages from server"""
        if not self.receiver:
            self.init_receiver()
            
        try:
            while True:
                message = self.receiver.fetch()
                content = message.content
                pprint({'props': message.properties})
                pprint(content)
                self.session.acknowledge(message)
        except KeyboardInterrupt:
            pass
        
        self.close()

# Test code
if __name__ == '__main__':
    r = QPIDReceiver()
    r.receive()

代码非常简单，容易读懂，使用方法是在一台 Linux Server 上安装好 qpid-cpp-server, 并且启动后，在 Client 上安装 python-qpid，然后修改一下 base.py  __init__ 方法的 host 字段，或者在代码中自行指定好服务器地址，即可直接执行测试。

需要说明的是 QPID 返回的数据结构，包含可以为 Dictionary 对象的 properties 和只能为纯文本的 content 两个属性，也就是说可以将数据结构保存到 properties，而消息名称保存成 content 中，即：

        try:
            while True:
                message = self.receiver.fetch()
                content = message.content
                pprint({'props': message.properties})
                pprint(content)
                self.session.acknowledge(message)
        except KeyboardInterrupt:
            pass

一个终端执行 receiver.py 监听消息，再开一个终端执行 sender.py，将会如以下输出：

$ python ./receiver.py
{'props': {u'type': u'test', 'x-amqp-0-10.routing-key': u'tmp.testing'}}
'Testing at 2010-12-06 14:54:59.536093'

如果有兴趣试下 QPIDSender.typing() 方法，再把 Kerberos 的用户名读出来，就可以做一个 IM 啦～

问题：现在似乎 Sender 发出的消息一次只能有一个 Receiver 接收，也就是现有代码不能用于 SOA，而这理论上应该是不应该的，依然在探索。

（可以尝试打开两个 receiver.py 测试）

敏捷里最重要的事情：

人、沟通、可用的软件、适应变化。

敏捷的特点：

• Self-Organize
• Cross-Functional
• Practice
• Learning
• Transparency
• Simplicity
• Inspect & adapt
• Iterative

3355 - 敏捷开发的基本构成：

3种角色：

• CSM(Certified Scrum Master)
• Product owner
• Team

5 种特性：

• Courage 勇气
• Force 专注
• Commitment 承诺
• Openess 开放
• Respect 尊重

Invest 模型:

• Independent
• Negotiable
• Valuable
• Estimatable
• Small
• Testable

PDCA:

• Plan
• Do
• Check
• Action

燃尽图：

在一个迭代内，将 Task 一点一点完成的线性图，正常情况下应该呈开始很平缓，中期急速下降，后期继续平缓的曲线，因为初期调查代码，寻找解决方案，Task 无法按量完成，中期快速完成 Task，后期快完成时速度减缓。不过这种情况不是绝对发生。

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

敏捷我的理解是，Product Owner 将用户的需求以 User Story 的方式写出来，由 Dev Team 分解成 Task，以自愿认领、自我估算开发时间的方式，以迭代的周期（1周太短，1月太长），以最终有价值的可用的软件为目标的开发方式。

它和传统开发模式的最大区别是，不再以需求为导向，也不用再写大量的需求文档，而将重点转移到了在每个迭代的周期结束时提供可用的软件为目标，换而言之，即不再以要求在特定时间内完成所有功能，而是通过短时间的迭代开发，快速交付可用的软件给用户，并及时得到反馈以决定下一个迭代的 Task。

敏捷的要求是 Product Owner 必须在每一个迭代的开始，公布 User Story，由 Team 拆分成 Task 并估算工作量，自愿认领 Task 并给与 Product Owner 承诺可以在这个迭代内完成，而这个迭代内，Product Owner 必须给予 Team 不被打扰的环境，和不会变化的 Task，尽一切力量在迭代结束时可以交付可用的软件，并在迭代结束时开启 Review 会议总结该迭代内的收获和教训，以及向 Customer 展示这个迭代内完成的功能。

敏捷对 Team 的要求是 Self-Organize 和 Cross-Fuctional，即“自组织”与“跨职能”，因为任务都是 Team 自行申请的，即可以做到自行规划开发计划，而“跨职能”则是指 Team member 能够主动去担当一些别的职位的工作，例如设计，测试等等。

而对项目的跟踪，也是通过 Task 的完成情况进行的，而具体表现，就是燃尽图。

我认为敏捷最大的优势有以下几个：

1. 快速迭代，短期交付可用的软件给客户，可以及时得到反馈，如有问题，可以及时得到修改。
2. Feature value，特性价值，对用户需求进行评估，优先完成最具有价值的特性。
3. Task 自评估，自认领，自组织和跨职能，充分调动 Team 主人公精神，减少和 Product Manager 在认知上的矛盾，可以真正达到 6 倍速。
4. Transparency，项目进度一目了然，工程问题容易暴露。
5. Test driven 测试驱动开发，降低测试工作量，有效保证产品质量。

 这里要介绍的是，全面的 Django app 调试，从最简单的打印变量，到使用 Django 自带的 Debug Middleware 调试 SQL，最后到全面的 Django debug toolbar 的使用。

1. 使用 pprint 打印变量（简单）

2. Django debug context processor[1]（中级）

3. Django debug toolbar[2]（更简单而强大。。。 -_-#）

一、使用 pprint 打印变量。

这是最简单的办法，在启动了 django-admin runserver 后，可将变量打印到终端上，适用于临时性的排错，当然还有其它办法，只是我觉得这种办法最简单。

下面是简单范例。

from pprint import pprint
from django.http import HttpResponse
from myapp.core.models import Case
def index(request, template = 'index.html'):
    c = Case.objects.select_related('author').get(pk = 100)
    pprint(str(c.query)) # 打印 C.objects.get(pk = 100) 调用的 SQL
    pprint(dict(c)) # 打印 C.objects.get(pk = 100) 的世纪内容。
    return HttpResponse(c.__dict__)

二、Django debug context processor[1]

该 Middleware 主要用于调试 SQL 执行情况，能够将所有的数据库查询 SQL 及花费时间打印出来，但是它要求代码使用 RequestContext，普通的 Context 和 render_to_response() 便无法直接使用了，如果之前代码使用 Context 构建，可能需要重写这部分代码。

其实我推荐在开始编写代码的时候，就使用 django.views.generic.simple.direct_to_template 来渲染页面，像如下： 

from django.views.generic.simple import direct_to_template    

def index(request, template = 'index.html'):
    ...
    return direct_to_template(request, template, {
        'parameters': parameters,
        'case': c,
    })

下面说安装和使用方法：

在 settings.py 的 'TEMPLATE_CONTEXT_PROCESSORS' 段中加入 'django.core.context_processors.debug'，如下：

# RequestContext settings

TEMPLATE_CONTEXT_PROCESSORS = (
    'django.core.context_processors.auth',
    'django.core.context_processors.request',
    'django.core.context_processors.media',
    'django.core.context_processors.debug',
    'myapp.core.context_processors.processor',
    ...
)

在 settings.py 中加入 'INTERNAL_IPS'，用于识别开发机地址，内容写入本机 IP 地址即可：

# Needed by django.core.context_processors.debug:
# See http://docs.djangoproject.com/en/dev/ref/templates/api/#django-core-context-processors-debug

INTERNAL_IPS = ('127.0.0.1', )

然后，在共享模板的开头（别告诉我你一个页面一个模板文件。。。），加入生成 SQL 列表的代码：

<body id="body">
    	{% if debug %}
	<div id="debug">
		<p>
			{{ sql_queries|length }} Quer{{ sql_queries|pluralize:"y,ies" }}
			{% ifnotequal sql_queries|length 0 %}
			(<span style="cursor: pointer;" onclick="var s=document.getElementById('debugQueryTable').style;s.display=s.display=='none'?'':'none';this.innerHTML=this.innerHTML=='Show'?'Hide':'Show';">Show</span>)
			{% endifnotequal %}
		</p>
		<table id="debugQueryTable" style="display: none;">
			<tr class="odd">
				<td>#</td>
				<td>SQL</td>
				<td>Time</td>
			</tr>
			{% for query in sql_queries %}
			<tr class="{% cycle odd,even %}">
				<td>{{ forloop.counter }}</td>
				<td>{{ query.sql|escape }}</td>
				<td>{{ query.time }}</td>
			</tr>{% endfor %}
		</table>
	</div>
	{% endif %}
        ...
</body>

最终生成的效果是在页面顶部，增加了一个 XX Quueries 项，点击 (Show) 后如下：

三、Django debug toolbar[2]

Django debug toolbar 是我到目前为止见过的安装最简单，功能最强大的调试工具，它的主要特性有：

* 更加完善的 SQL 调试（比 Django debug processor 更加精准，Django debug contect processor 无法处理关系查询（Select related)）

* 记录 CPU 使用时间（可惜没有针对代码级的 profile，希望未来的版本能增加这个功能）

* 完整记录 HTTP Headers 和 Request 请求

* 完整记录模板 Context 内容，包括 RequestContext 和直接传入的变量

* 记录 Signals

* python logging 模块的日志支持

安装也比较简单，可以使用 yum 直接安装，也从上面的地址下载后，直接使用 setuptools 通用的安装方法安装即可。

$ tar zxvf robhudson-django-debug-toolbar-7ba80e0.tar.gz
$ cd robhudson-django-debug-toolbar-7ba80e0
$ python ./setup.py build
$ sudo python ./setup.py install

如需确保安装正常，从 Python shell 里看看能否 import 即可，不出错，即安装正常：

$ python
Python 2.6.1 (r261:67515, Feb 11 2010, 00:51:29) 
[GCC 4.2.1 (Apple Inc. build 5646)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import debug_toolbar
>>> 

然后是配置你的 settings.py。

我的调试 settings.py 和在产品服务器上运行的是不一样的，我也建议最好将二者分开，因为 Django app 开启 Debug 后对性能损耗非常严重。

将下面红字加入你自己的 settings.py 文件：

MIDDLEWARE_CLASSES = (
    ...
    'debug_toolbar.middleware.DebugToolbarMiddleware',
)

INSTALLED_APPS = (
    ...
    'debug_toolbar'
)

TEMPLATE_DIRS = (
    ...
    '/Library/Python/2.6/site-packages/django_debug_toolbar-0.8.3-py2.6.egg/debug_toolbar/templates/', #按需修改！指向 debug_toolbar 的模板目录。
)

DEBUG_TOOLBAR_PANELS = (
             'debug_toolbar.panels.version.VersionDebugPanel',
             'debug_toolbar.panels.timer.TimerDebugPanel',
             'debug_toolbar.panels.settings_vars.SettingsVarsDebugPanel',
             'debug_toolbar.panels.headers.HeaderDebugPanel',
             'debug_toolbar.panels.request_vars.RequestVarsDebugPanel',
             'debug_toolbar.panels.template.TemplateDebugPanel',
             'debug_toolbar.panels.sql.SQLDebugPanel',
             'debug_toolbar.panels.signals.SignalDebugPanel',
             'debug_toolbar.panels.logger.LoggingPanel'
  )

然后使用 django-admin.py runserver 启动测试服务器，下图是 Django debug toolbar 的 SQL 查询页面。

相关链接：

[1] http://www.djangosnippets.org/snippets/93/

[2] http://github.com/robhudson/django-debug-toolbar/downloads

Kerberos 这种统一用户名和密码进行登录的方式在各大公司（尤其外企）内部应该都得到广泛应用，它以其安全、高效和易于管理等特性得到了很多系统管理员的喜爱。

目前网上对于 Kerberos 登录原理的描述都过于复杂，其实它的实现非常简单，当你向一个部署了 Kerberos 的应用服务器发起登录请求的时候，服务器会去 /etc/krb5.conf 里描述的 KDC 服务器用 Kerberos 协议发起一个登录请求，如果用户名密码验证通过，将会向服务器发一个票（Ticket），否则将会引出一个错误。然后服务器可以将票发给客户端，以后客户端就可以用这张票进行其它操作。与火车票和电影票一样，Kerberos 的票，也是有使用时间限制的，如果不经过特殊设置，这张票的超时时间大约是 6 个小时。

而在 Django 里使用 Kerberos 登录，有两种办法，一种是由 Django 直接向 KDC 验证密码，另一种是在 Apache 上使用 mod_auth_kerb 模块，由浏览器来处理登录请求。

这两种办法其实都是对 Django Auth Backend 的重载，所有的 Auth Backend 都位于 django/contrib/auth/backends.py 里，这里[2]也有一个使用 Email 来进行验证的范例，我受此启发，写了这两个例子，希望也能抛砖引玉，能给你们更多启发。

第一种 － 由 Django 直接向 KDC 验证密码：

这种办法比较简单，需要在 web server 上装好 python-kerberos 包，并且配置好 /etc/krb5.conf，详细的配置方法，最好咨询 IT 部门，配置成功后在服务器上用 Kerberos 上有的普通用户运行 kinit，如果能够密码验证通过就行。

并且在 Django 的 settings.py 里写入类似下面这行，定义 Kerberos 的 Realm：

# Kerberos settings
KRB5_REALM = 'EXAMPLE.COM'

与上面的 Email 验证例子类似的是，我们需要对 authenticate 方法进行重载，加入 kerberos 认证代码，python-kerberos 已经提供了 checkPassword 方法。 

try:
    auth = kerberos.checkPassword(
        username, password, '',
        settings.KRB5_REALM
    )
except kerberos.BasicAuthError, e:
    return None

完整代码如下：

import kerberos
from django.conf import settings
from django.contrib.auth.backends import ModelBackend
from django.contrib.auth.models import User

class KerberosBackend(ModelBackend):
    """
    Kerberos authorization backend for TCMS.
    
    Required python-kerberos backend, correct /etc/krb5.conf file,
    And correct KRB5_REALM settings in settings.py.
    
    Example in settings.py:
    # Kerberos settings
    KRB5_REALM = 'EXAMPLE.COM'
    """
    def authenticate(self, username=None, password=None):
        try:
            auth = kerberos.checkPassword(
                username, password, '',
                settings.KRB5_REALM
            )
        except kerberos.BasicAuthError, e:
            return None
        
        try:
            user = User.objects.get(username=username)
        except User.DoesNotExist:
            user = User.objects.create_user(
                username = username,
                email = '%s@%s' % (username, settings.KRB5_REALM.lower())
            )
        
        user.set_unusable_password()
        user.save()
        return user

第二种：Apache 上使用 mod_auth_kerb：

这种方法略有复杂，部署它需要向 KDC 申请一个 keytab 文件，以授权该 Web Server 向  KDC 发起请求，并且需要安装和配置 mod_auth_kerb（很简单，后面有），并且 /etc/krb5.conf 一点也不能少。

但是好处也是非常明显的，上面那种依然是使用 Django Auth Contrib 的 Session Manager 来负责登录信息的维持，但是这种方法将能够完全使用 Kerberos 自身提供的 Features，包括登录维持，和 kinit 的支持，也就是说，只要在本机上使用 kinit 成功登录过一次，用 Firefox （目前似乎在 Linux 上只支持该浏览器）访问部署了 mod_auth_kerb 的网站，将都不再需要登录。

它的原理包括两种条件，一种是没有在本机执行 kinit 的，使用 Firefox 直接访问服务器，服务器将会返回一个 401 Authorization Required 错误，这时 Firefox 会弹出对话框询问你的 Kerberos 用户名和密码，并提交你的密码。另一种在本机已经执行过 kinit 的，Firefox 会去读取你客户端的 Kerberos ticket 缓存，如果没有过期的话，就会使用它。无论哪种办法，Firefox 都将在 HTTP Header 里添加一个 'Authorization' 段，并且加入 Basic Authorization 验证方式，例如我本机上的：

Authorization	Basic eGt1YW5nOkxvdmVvZnJvYWQuMTIz

使用这种部署方式，在 Django 1.1 版本以下，还没有比较好的解决办法，但好在 Django 1.1 提供了 RemoteUserBackend 后端，依然在 django/contrib/auth/backends.py 路径里，通过阅读它的代码，我们可以看到它其实依然是个 ModelBackend 的继承，而 Django 的 Request Handler 已经默认将 HTTP Meta 里的 REMOTE_USER 段给加入处理范围之内了，因此 RemoteUserBackend 的 ’authenticate‘ 与 ModelBackend 不太一样。 :-)

其实代码都已经写好，我们只需要处理一下拿到用户后的处理办法('configure_user' 方法）和处理用户名的方法（'clean_username' 方法）就可以了。

我这里在拿到用户后，出于保护密码的原则，为该用户设置了一个无效密码（'user.set_unusable_password()' 方法），并且设置了该用户的 Email。 同时，因为 RemoteUserBackend 默认返回的用户名是 ‘[username]@[KRB5_REALM]'，所以我也把后面的 REALM 给去掉，直接贴代码：

from django.conf import settings
from django.contrib.auth.backends import RemoteUserBackend

class ModAuthKerbBackend(RemoteUserBackend):
    """
    mod_auth_kerb modules authorization backend for TCMS.
    Based on DjangoRemoteUser backend.
    
    Required correct /etc/krb5.conf, /etc/krb5.keytab and
    Correct mod_auth_krb5 module settings for apache.
    
    Example apache settings:
    
    # Set a httpd config to protect krb5login page with kerberos.
    # You need to have mod_auth_kerb installed to use kerberos auth.
    # Httpd config /etc/httpd/conf.d/<project>.conf should look like this:
    
    <Location "/">

        SetHandler python-program
        PythonHandler django.core.handlers.modpython
        SetEnv DJANGO_SETTINGS_MODULE <project>.settings
        PythonDebug On
    </Location>
    
    <Location "/auth/krb5login">
        AuthType Kerberos
        AuthName "<project> Kerberos Authentication"
        KrbMethodNegotiate on
        KrbMethodK5Passwd off
        KrbServiceName HTTP
        KrbAuthRealms EXAMPLE.COM
        Krb5Keytab /etc/httpd/conf/http.<hostname>.keytab
        KrbSaveCredentials off
        Require valid-user
    </Location>

    """
    def configure_user(self, user):
        """
        Configures a user after creation and returns the updated user.
        
        By default, returns the user unmodified.
        Here, the user will changed to a unusable password
        and set the email.
        """
        user.email = user.username + '@' + settings.KRB5_REALM.lower()
        user.set_unusable_password()
        user.save()
        return user
    
    def clean_username(self, username):
        """
        Performs any cleaning on the "username" prior to using it to get or
        create the user object.  Returns the cleaned username.
        
        For more info, reference clean_username function in 
        django/auth/backends.py
        """
        return username.replace('@' + settings.KRB5_REALM, '')

Django 是一个很强大的框架，虽然缺点和优点都同样的明显，有些甚至是由于 Python 语言或者类库造成的问题，但是因为其使用的便利性，高效的开发，而且其开发小组也非常活跃，使其特性的添加非常频繁，而且网上也有大量资源，例如 Django Snippets 网站，因此依然有着非常巨大优势。而通过阅读它的代码，往往都能获得更多启发。

链接：

[1] http://trac.calendarserver.org/browser/PyKerberos/

[2] http://www.djangosnippets.org/snippets/74/

受不了了，买火车票买不到，只好盯上黄牛票了，可是没法不停地刷页面啊，刚刚就错过了一个发布了 20 分钟的黄牛票，打电话回去时已经打不通了。。。-_-#

就写了个程序来解决这个问题，粘了一堆代码（参考太多，头一次写这种东西，原作者勿怪），总算成了，可能有 bug，欢迎提交 patch 或者更好的解决办法。

可以通过修改下面的参数来修改程序执行： 

url = "http://piao.kuxun.cn/beijing-jinggangshan/" # 把火车票的搜索地址粘在这里，这里假设是北京到井冈山的
key = "2张"                                        # 搜索关键字，我得俩人啊。。。 
sequence = 60#60 * 5                               # 搜索间隔，给服务器压力别太大，每分钟一次就行了。

#!/usr/bin/python
# encoding: utf-8

import urllib2
import mailbox
import time
import os
import re
from sgmllib import SGMLParser

class URLListName(SGMLParser):
    is_a=""
    name=[]
    def start_a(self, attrs):
        self.is_a=1
    def end_a(self):
        self.is_a=""
    def handle_data(self, text):
        if self.is_a:
            self.name.append(text)

url = "http://piao.kuxun.cn/beijing-jinggangshan/"
key = "2张"
sequence = 60#60 * 5

request = urllib2.Request(url)
request.add_header('User-Agent', 'Mozilla/5.0')
opener = urllib2.build_opener()
data = opener.open(request).read()

ticket_name = URLListName()
ticket_name.feed(data)
cache=[]

while 1:
    try:
        print "beign retrive"
        data = opener.open(request).read()
        ticket_name.feed(data)
        print "beign scan"
        
        for result in ticket_name.name:
            if result and result.find(key) >= 0:
                if result in cache:
                    pass
                else:
                    print "found:" + result
                    cache.append(result)
        
        print "scan finished, begin sleep " + str(sequence) + " seconds."
        time.sleep(sequence)
    except:
        raise

很好的博客，希望能传播开，大家都能看见，希望封网的上级领导也能看见。

原文在：http://www.mindmeters.com/showlog.asp?log_id=9481

上上周末，我没有到电影院排队去看《三枪》，而是蜗居在家，抱着电脑看《海盗电台》（The Boat That Rocked）。顺便坦白一下，这是未经许可，用电驴非法下载观看的。因为我确定地知道，这种“非主流”的文艺片，是几乎不可能通过广电总局的审查而正规上映的。

Google Wave 拿到有些日子了，写写这两天对它的感觉。

这东西到底是什么？团队协作平台？Email 接替者？Wiki？BBS？它给我的感觉什么都不是，而是展示 Google 网页开发实力，和最新 Web 开发技术的一个测试产品，也有可能是因为它目前的不完善导致定位不明确吧。

打开 Wave 之后，就会看到浏览器的加载小滚轮一刻不停地滚动着，因为它需要时刻不断地连接到服务器上，获取好友以及消息的信息，在 Wave 的演示视频上我们可以看到，当 Contacts 在某个”波“里打的字，会即时显示在页面上。这是 Google 强大云计算的佐证。

奇异的滚动条，有点像 Aperture 里的风格，颠覆了传统滚动条的概念，点击直接贴伏在 Bar 上地向上按钮的时候，页面会轻轻地向上地滚动一点点，但是将 Bar 直接向下拖到底，页面不是跟着滚动着到底，而是会像开了”平滑滚动“似地划过浏览器。加上所有可以随意伸缩、最小化的面板。这是最新 Web 开发技术的佐证，而这其中有 Google 很大的功劳。

不过我依然觉得它定位不明确，缺乏 BBS 的公开，Wiki 的开放，Email 的便于查询，团队协作平台的目标性

一个 Wave 就是一个话题，用空格键在所有未读的回复间切换，对于不感兴趣的 Wave 可以 Archive 掉。用户可以很轻易地上传各种文档到自己的 Wave 中（拖拽上传对 Safari 似乎无效）。超酷的操作方式似乎才是 Wave 的全部。

我倒希望它能在未来的版本中进一步完善。

有账号的可以加我 Wave - xuqingkuang # googlewave.com

 到月末了，对这两个月做一下总结。

首先是 VirtLAB，这个从三月开始的自动化测试项目，该项目用于在 QE 团队内部替代 RHTS，由于是重新设计的 Database schema，所以我可以充分发挥 Django 自身的优势，也是因为通过 VirtLAB，使我的 Django 水平得到了极大提高，同时由于 UI 前端是自己编写的，所以对 Javascript 也远远胜过之前。现在无论是 Django 本身的 ORM，Template，Form 都很难难到我了，自定义 ORM model field、Form 的 RequestContext Processor，Field 和 Template 的 Tag、Filter 也都得心应手。

在这两个月里，VirtLAB 发展到了 2.0，主要是增加了 Queue，用于在一台机器上建立一个 Job 队列，可以同时在一台机器上排上多个 Job，一个一个重启电脑，重装系统后执行测试脚本的特性；另一个就是晚上趁着没人的时候，自动根据数据库覆盖率（在哪些机器上运行过），跑测试的功能，所以界面也换成了夜间的风格。

新版本极大地提高了自动化功能，由测试人员编写好测试脚本，白天可以由测试人员自己提交 Job 在不同的机器上执行并实时观测运行过程，晚上下班后程序也会将那些在一些机器上没有跑过的测试执行一遍，最终做到每一个测试脚本在所有的机器上都执行一遍，以检查系统是否能够在不同类型的机器上稳定运行。

另一个是用于手动测试的 TCMS（与 Testopia database schema 完全兼容的 Test Case Management  System），半年前将它撂下，现在又重新捡起来了，经过 VirtLAB 的磨砺，而且新版本里可以加表，所以我对这个代码进行了重构，使用了大量 Django 自身的特性，比如 ACL 和自带的 Admin Page。和 VirtLAB 一样，使用了 python-kerberos 做了个 Kerberos  的用户名密码验证。因为 Testopia 的数据表结构比较复杂，所以对整个 Models 进行了重构，用 ForeignKey 和 ManyToManyField 重新进行了组织，自行编写了 TimeAsTimeDeltaField 来处理 Test Case 的 Estimated Time。

UI 也经过丹青的重新设计，变得更加的方便、易用。

总之，是个脱胎换骨的版本。

明天，30 号就是正式内部使用的日子，svn 的版本号也相当吉利 2046。我们将正式用它来代替服役了很长时间的 Test Runner 和根本不成熟且有版权问题的 Testopia。

下一步计划 － 更加地自动化：

VirtLAB 将对每台机器加上 Tag，以后选机器不用去看主机名了，只要选好自己需要的配制，比如要 Intel 的处理器啊，要超过 4G 内存啊，就可以自动根据所选条件，自动选择空闲的机器，最快速地完成需要完成的 Job。

TCMS 将进一步对代码进行重构，进一步 Django app 化，同时完成 Report，以及和外部程序沟通的功能，目前只能将 Failed 的 Case 用 File a bug 链接直接提交到 Bugzilla 上，下一步将和 VirtLAB 和 ATP 整合，直接在 TCMS 里操作 VirtLAB 里的测试脚本。

BTW: 前一端时间公司内部开始使用 Redmine 进行内部项目管理，这个用 Rails 编写的工具确实有很多独到的特性，可以看看。

Palm Pre 是继 iPhone 之后唯一一个让我心动的手机，Android 虽然也让我感到很兴奋，但是因为它缺乏中心设计，也没有什么特别的创意，对它始终缺乏购买的欲望。

但是 Palm Pre 基于 Linux，全新的卡片式操作系统，实体键盘，手势操作，对云（主要是 Google）的全面支持，以及对苹果 iTunes 的支持，非常方便而且跨平台的 SDK，让我实在不能不趁着现在低价（2000+）赶紧入手一台。

大概就是这样了，办下天翼手机卡，找人去电信机房查号，刷 1.0.3 激活手机并写入 MEID/ESN，升级 1.1 写入 AKEY/HOME SID/NID 搞定童话，写入 AN/AAA 搞定 EVDO。

现在有 qinray 的 1.1 ROM，刷机写号更方便了，而且不用担心激活的问题了，但是写入 MEID/ESN 这步最好还是在 1.0.x 里做，因为 1.1 里的地址有所变化，反正我是写入后无效，重启后会自动复原。

Treo8 是个很好的 Palm 论坛，如果有兴趣可以去看一下：http://www.treo8.com/bbs/forum-33-1.html

现在还缺好用的中文输入法，无法发中文短信，但这都不是问题，因为"LInux 无限可能"。

root@castle: /var/home/root # uname -a
Linux castle 2.6.24-palm-joplin-3430 #1 175.1.23 armv71 unknown 

用苹果本子五年，头一次看见四国，兴奋ing。。。

我的主要工作是给公司内部写自动化测试工具，当然是使用 Django，这个 Web framework 越用越好用是我和我的设计师的共识。

工作配置主要是浏览器 Safari + Firefox，不过感觉还是 Webkit 比 Firefox 某种程度对开发者更加易用一些，比如 Firefox 的 form 是不能嵌在表格内部的，Safari 则可以。其它还有很多，比如 Safari 对 HTML/CSS 扩展比 Firefox 更加实用和简易，Javascript 执行速度也更快。

编辑器是 TextMate + MacVIM，TextMate 主要负责多文件的编辑，用起来还是很舒服的，MacVIM 主要是不想用鼠标的时候，全心写代码的时候用，主要用了 http://code.google.com/p/yy-vimscript/ VIM plugin 和 snippets，用 SynergyKM 共享了台式机的键盘鼠标用。

操作系统是 Snow Leopard 10.6 10A421a，我已经将它用于生产系统，系统平时还是非常稳定的，平时开一个礼拜也没问题（只待机），这次崩得很没头脑。-_-#

最新的苹果系统性能的确有极大提高，从前一篇 nbench 测试贴也能看出来，全部自带的应用程序都是 64bits，完全抛弃了 ppc 代码，体积也更小。完全重写的 Finder 打开和预览文件的性能也比之前版本高出很多，尤其是 Quake 3(32bits) 在我的本子上标准画质从 227fps 猛增到 540fps。现在就等着其它软件厂商推出64bits 的应用软件了，我目前只有 Tweetie 和 Perian 是 64 位的，其它的还是 32 位的。试着去编译过一些自由软件，但是编译始终在变量类型上会出问题，或者更加难缠的链接错误。这一版本承诺的功能也基本都已完成，不过 ZFS 去哪儿了？！-_-#

OS X 在界面上始终保持一致性和继承性，新的系统多是在细节上进行优化，而极少去颠覆之前的设计，我在设计思想上是非常赞同这一观点的。

跑题，打住。。。

这次把自己的笔记本和台式机，还有一台虚拟机服务器都跑了一下，得到了以下结果。

其中我的笔记本，Macbook Pro (2008 Early)，内置了 Intel Core 2 Duo T8300 的处理器，得到测试冠军，工作站 HP XW4600 虽然使用的处理器是 2.5Ghz E7200 的，但是比起 2.4GHz 的 T8300，性能还是有一定差距的。所以不要迷信 Intel 处理器的主频，真的有差别。

跑自己的服务器纯粹是因为我的 Web server 在上面反应真的比较慢，所以跑了一下，那个 Xen 的版本比较老了，还是 3.0.x 的，新版本能够支持 Intel VT 和 AMD-V 技术，相信性能会好不少，因为是处理器直接支持虚拟化的，只是我手头暂时没有机器测试，RHEL 5.4 里将要内置的 KVM 也很值得期待。

详情请到 http://xuqingkuang.is-programmer.com/2006/10/10/nbench.6107.html 查看，测试的详细日志那里都有。

This Is My Life, Rated
Life:	7.1
Mind:	6.5
Body:	8.9
Spirit:	8.2
Friends/Family:	4.4
Love:	6.2
Finance:	7.4
Take the Rate My Life Quiz

刚看到 TualatriX 上 Rate My Life Quiz 的链接，顺道也给自己做了下测试，结果还行，除了 Friends/Family 以外都还可以。

很奇怪我的 Body 指数居然是最高的，难道是因为没什么不良嗜好而且保持了良好睡眠？！不过北京的气候真的让人感觉很不舒服，在“你是否生活在一个有污染的环境中”的选项上，我毫不犹豫地打了一个勾，要没它估计就 10 分满分了。。。

Friends/Family 和 Love 虽然是最低，可能因为我已经有了稳定关系了，而且比较恋家，所以还是相对地高的～（^_^）

Finance 项现在在开源节流，还是颇有成效的，每个月还能有少许赢余，要点是买东西之前好好想想那个东西是否真的对你的生活有促进作用，而不仅仅是一时冲动或者 Hobby，家里有个财务顾问还是很不错的。 ^o^

别的人的测试地址在下面，请允许我把你们的地址贴出来：

Contrast: http://contrast.yo2.cn/archives/41840

TualatriX: http://imtx.cn/archives/1282.html

Chromium 官方只提供了 for 乌班兔的 deb 包，好在从 Solidot 上看到已经有好心人在 Fedora 上也编译了一份，经过试验运行起来没有问题，功能也已经比较完备了，可以满足最基本使用需求，速度却比 Firefox 要快了很多，基于对 Webkit 的好感，以后它就是我的主力浏览器了（这话前两天好像刚说过 :-p）。

我也写了个的 repo 文件，以便于用 yum 升级，内容很简单，把下面内容以文件名 chromium.repo 存放到 /etc/yum.repos.d 里就好了：

如果想偷一把小懒的话，也可以去 http://www.box.net/shared/rbyeny0bge 里下载，并放到 /etc/yum.repos.d，不过 box.net 好像被墙了，可能需要翻墙。。。

然后在终端里运行 # yum install chromium，就可以了

刚刚试了一下 Opera 10 beta 1，深深被这个界面漂亮，性能出色的浏览器吸引了，以后它就是我的主力浏览器了。

虽然之前也用过早期版本的 Opera，但是一直觉得 Opera 的界面太过于复杂，菜单太长，而且 Javascript 解释有问题，所以一直只是装完了试试就删除了。

今天装版本 10 beta 1，菜单被极度精简化了，设置选项也简单很多，简单设置一下，字体也变得和 Firefox 一样优秀，只是虽然通过了 ACID  3 测试，但是 Javascript 在 Flickr 的的上传页面依然除了些不兼容的现象 - 选择文件对话框无法打开。

不过依然是个出色的浏览器。

关于字体的设置，其实很简单，编译一下 /usr/share/opera/defaults/font.ini，禁用掉 X  Core Fonts 支持：

并且把对应语言的中文字体改掉，我这里是文泉驿的微米黑：

OK, enjoy your opera，我要去折腾我的 ibus 光标跟随了，希望能有 sci-qtimm 之类的 ibus 模块。

最后差点忘了要说一句：RnVja0dGV++8jOiuqeS9oOW7uuaIkOWFqOS4lueVjOacgOWkp+eahOWxgOWfn+e9kQo=

图片需要翻墙。

办公室有闲电脑？拿来算外星人吧。

前一段时间 SETI＠Home 项目组又发了好几封邮件，需要更多计算力量和赞助来处理大量的数据（有说是共有 15T，有说是每天 10G，一年300G ?! -_-#）。

装上服务器的 Linux（其它平台也可以），装上 Boinc，就让它自己跑吧，有 NVIDIA 显卡的可以开启 CUDA，确实可以提高运算速度。

详情可以参考：

http://zh.wikipedia.org/wiki/SETI

也有更多项目等待你的参与：

寻找引力波的 Einstein@Home: http://einstein.phys.uwm.edu/

了解了解蛋白质折叠的 Folding@home: http://folding.stanford.edu/

BTW: 现在电脑的性能确实突飞猛进，几天算的相当我之前一个月的运算量了。

端午节快乐！

今天公司人事发信，我这才知道端午节在国外叫 Dragon Boat Day，确实很贴切啊，龙舟节，所以 Happy Dragon Boat Day! :-)

BTW: is-programmer.com 的服务一直很稳定，得多谢 galeki。

多吃粽子。

移动 TD-SCDMA 测试用的话费积攒到了 4000 多元了，女朋友消化得实在太慢，怎么办呢。

刚好趁着外出，把测试的 3G USIM 卡插上 Nokia E71（因为附送的熊猫山寨机太差了。。。-_-#），拿来给笔记本 GPRS 无线上网。

首先安装好 pppd 和 wvdial，把手机的 USB 连接模式改成 PC Suite，这样才能把手机当猫用，如果使用 Connect PC to Web 的话，屏幕上会出现 Nokia Connect to Internet 的盘符。

然后在 /etc/wvdial.conf 里写下如下代码，不用对 cmnet 接入点做特别设置，直接就会连接好了。

写好后用 root 运行：

应该就可以上网了。

如果要用蓝牙的话，需要先安装 bluez，建立 /dev/rfcomm0 设备，我是在 Fedora 10 上测试的，很奇怪改好 /etc/bluetooth/rfcomm.conf 后，重启蓝牙服务无效，所以还是手工绑定那个设备吧。

用下面命令绑定设别： 

如果不知道蓝牙的 MAC 地址的话，可以用下面命令进行搜索。 

如果不知道 Internet Dialer Channel 的话，可以用下面命令查找：

然后再执行上面的 rfcomm 命令，然后用下面命令拨号。

方法应该说比较简单了，Enjoy your wireless life 吧 :-)

最近这两天恰逢315，电视上的消费者维权节目颇多，网上关于消费者维权，尤其是网上消费维权的新闻和消息也很多。其中，淘宝作为国内最大的网上购物场所，被推到了风头浪尖。其实，我相信，只要按照淘宝的流程走，在淘宝上购买商品，是非常安全的。

 今天，恰好我的头一次交易纠纷被解决了，事情如我所愿，所有货款连带邮费完全退给了我，从这件事情上，我更加信任淘宝作为国内 B2C 老大的公信力。

上个月末，想为沉睡已久的 iPod 买根数据线，但是我的 iPod 是 3 代黑白屏，必须通过 Firewire(1394) 充电和同步数据，于是在网上搜索，因为担心外地交易出问题，购买实物我一直只买本地商家的商品，问过多家店铺，但找寻未果，后来问到一家店铺，店主说可以与 iPod 同步，但价格异常便宜，只要 15 元，心想应该不是原厂的，但只要能同步数据，就豁出去了吧，于是拍下，只是邮费上有所问题，商家需要 12 元快递费，但在网上交易多次的我深知本地快递一般 5 块即可，于是让商家修改邮费，但商家只克扣了 5 元邮费，依然需要 7 元，想想算了，只要能同步数据就行，于是支付了 22 元。

第二天中午收到线，包装还可以，很小的线拿了很大的 2.5 寸硬盘盒的盒子包装，但拿出来一看，线明显不是全新，和商家描述有出入，插上 iPod，开始充电了，心里一阵激动，可是却没有启动 iTunes，启动完成之后我手工启动了 iTunes 发现没有 iPod，用 dmesg 查看内核信息，就好像 Firewire 上没有插入任何设备一样，没有任何提示，插拔试了几次，皆是如此。

于是打电话给商家要求退货，好在商家离我不远，趁着午饭时间中午就去了一趟，说明事由之后，询问店主是否还有别的线可以使用，店主回答没有，我说那我只好退货了，然后店主从钱包里拿出 15 元，扔在桌上，说只退货物的费用，运费不退，我据理力争，但店主依然不退运费，我一气之下把线和包装盒扔在店主柜台上，直接回到公司，用电脑在支付宝上申请了全额退款，经过近一个月的周折，商家期间在超时之前点击拒绝退款，最终依然到了由淘宝来判决货款走向的地步。

很高兴，支付宝依然是偏向于消费者的，下面是在支付宝上举证和留言的截图：

而得偿所愿的结果：

22 元的线真的不算什么，7 块钱的运费也不算什么，但是一分一毫都不去争取，当自己更大的利益收到侵害的时候，如何能拿得出争取的勇气？

所以我相信，自己的权益，是可以争取回来的。

然后，我想说下在淘宝上购买商品的流程，和注意事项：

1. 自然是寻找自己需要的商品
2. 找到商品后点击旺旺图标，联系商家，咨询商品情况，一定要问得非常非常详细，因为事后判定责任方的就在购买前咨询那段，如果让商家落下口实拒不退款，那支付宝也保不了你。常用的问题包括：“多长时间能到啊，物品和图片是否一致啊，我想要的功能是否都有啊，等等。。。”。我现在意识到电脑版的旺旺比网页版的旺旺更加重要，因为电脑版的旺旺有举证功能，我买这根线的时候因为只有 Mac 机，所以用的是网页版旺旺，好在所有的证据都指向我这里有利，商家也不敢举证。所以，旺旺咨询阶段非常重要。
3. 谈后之后，确认购买了，拍下之后付款，付款方式一定要选支付宝，所以开一个支付宝帐号也是必须的，即使麻烦一点。如果商家让你单独给他的帐号上汇款，那哪怕换一个商家也不要从他那里买，一般让直接汇款的人都是骗子，钱要是打过去了，基本就不用指望货物或者钱还能回来了，所以，支付宝是所有保障工作中的核心中的核心，必不可少。
4. 在支付宝支付后，物品状态会变成“买家已付款，等待卖家发货”，卖家发货后，就是等待你确认收货了，收到货物以后，第一件事情是必须仔细检查货物的外观是否完好，如果外观有问题可能是快递公司的问题，也有可能是商家那里的问题，所以不要签收，退了，让商家再寄一份，如果商家要求加邮费，除非那东西对你比较重要，而且别处买不到，否则就退钱。签收后要检查所有功能是否完好，如果功能正常，其实如果商家不着急的话，那还是可以先用两天，确定没问题了，再去确认的，如果确认没问题了，确认之后，那就到此，不用再往下看了，如果有问题，请继续读下去。
5. 如果发生问题，得和商家联系了，最好是通过旺旺，电话或者手机也可，如果商家离你不是很远，建议还是花点时间亲自去一趟，虽然这会花费一些时间，但是买东西碰到假货的机率毕竟比买到真的少很多，和商家商量一下解决办法，比如换货，退货只有到万不得已再可以使用，因为确实很伤和气，俗话说闷声发大财嘛，退款的时候要注意，如果是因为你的原因造成的问题，那可能邮费和中间发生的其它费用就得由你来承担的，谁让你一开始不说清楚，如果是商家发生的问题，尤其是对商品的描述问题，那承担责任的就非他莫属了，坚决退款，连邮费乱七八糟其它费用一起退，其实连误工车费的也可以报，确实以前有人这么干过，不过那太废周折，咱折腾不起，把属于自己的那份拿回来就行了。
6. 然后就是上淘宝上退款了，退款流程是这样的：
7. 首先是你申请退款，发起退款协议，如果商家不同意退款协议，则需要你修改协议，这时你一定要坚持立场，提交证据（留言限制 200 字），但是如果不是你出的问题，那绝对要寸步不让，可以在协议里加几句话，但是退款金额不变，提交之后又是商家确认是否同意新协议，这可能会有几个来回，但是每次提交后都会进入为期十天的超时期，所以要经常关注自己的退款流程，因为退款不会给你写信、或者旺旺上提醒你，超过十天后，如果商家没有任何反应，那会视他同意退款协议，进入你的退货阶段，这时你已经将货物快递或者亲自送到商家手里，如果已经送回，则可以直接确认，则又进入商家确认收货阶段，超时期依然是十天，这时商家仍然有机会驳回你的退款协议的，但驳回后你再次修改协议后，商家如果再次驳回，则没有超时期了，这时可以去帮助页面里给淘宝留一个言，说明你的情况，把交易号，退款页面地址都写清楚，这里限制 1000 字，说明你与商家已经没有继续协商下去的可能。淘宝会在 48 小时内给你的邮箱发一封信，说明支付宝的工作人员会在 30 天内处理交易纠纷，让你注意超时。
8. 进入到这个阶段，就可以静静地等待了，支付宝工作人员如他们所说，会在一个月内处理你的纠纷，这包括了超时期，如果证据指向你无错，那购买商品的金额最终还会回到你的手里。

最后祝所有的朋友都能淘到自己喜欢的商品，少受点退款的折腾，也希望所有的商家能向我给卖给我线的那位商家中的留言一样：

1. 提高专业知识，对自己所销售的商品有足够的了解。
2. 为客户着想，对商品的描述尽量做到详尽、真实，对不确定的事情不要轻易答应；
3. 能够负起对消费者的责任。

通常情况下，如果我们要使用一个类的方法，那我们只能将一个类实体化成一个对象，进而调用对象使用方法。

比如：

 要用 print_hello() 就得：

如果用了 @classmethod 就简单了。

其他语言中，switch语句大概是这样的

而python本身没有switch语句，解决方法有以下3种:

 从 CNBeta 的新闻上看有 Spotify 这款音乐共享软件，据说是 uTorrent 的创始人 Ludvig Strigeus 写的，Down 下来了一份，试了一下，果然不同凡响。

延时很短（几乎没有），而且都是很新的金曲，最关键的是曲子都很好听！

下载链接在： www.spotify.com/en/download/

目前只支持 Windows 和 Mac，如果想在 Linux 上用，可以使用 wine，这里有篇 Guide:

www.spotify.com/en/help/faq/wine/

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

我这里只对如何注册说一下，现在 Spotify 对英国境外的人都使用邀请方式（在英国的朋友有福了;-)），而包括我在内都是没有邀请码的。

所以按照新闻走，去 www.proxz.com/proxy_list_uk_0_ext.html 上找个英国的代理，在使用前最好 ping 一下，看看能否连上。

我用的是 212.241.180.239:81 这个地址。

然后去改代理，Mac OS X 在 System Preferences 的 Network 的 Advanced 里。

把 HTTP 和 HTTPS 的代理都选上，都改掉，然后访问：

www.spotify.com/en/get-started/

应该就是注册新帐号的页面了 ;-)

Spotify 不但是很好的音乐共享软件（其实仅限于从服务器上抓下音乐来，好像不能自己把音乐共享出去），而且还是很好的 Last.FM 客户端，在 Preferences 里填入 Last.FM 帐号后就可以自动连接 Last.FM。

最关键的是它是完整长度的试听，只是不能下载（可以 HiJack 下来，哈～）

很值得一试喔 ;-)

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

手头有五个邀请，想要的可以留邮箱。

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

这一年，我们经历了春运期的南方雪灾，经历了汶川地震，经历了经济危机，同时也经历了中国第一届奥运会，经历了神七上天。

2008 给我们带来了不可磨灭的记忆。

再见，过去了的丰富的 2008。

你好，我们将迎接你，2009。

Happy new year to everybody. :-)

前两天在逛 Wii 论坛上看到了目前市场上有很多韩版 Wii 改美版后进行销售的帖子，遂看到了居然有改区一说，于是乎想在自己的日版（已经加了 D2C 直读）的情况下尝试一下改区，没想到因为之前已经升级到 3.4J，降级后改版反而效果更好（Photo、Wii Shop Channel 都可以直接使用），后又去兔子那里改了下 D2C 直读的跳线，使原本只用 Starfall 的全区支持也更加完善。

现放出方法。

概况是：

1. 通过网络升级到 3.4J
2. 通过 这篇教程 进行降级，降级后进系统查看就应该已经是 3.2J，不过这个教程耗时稍长，但是确实完美。
3. 使用 AnyRegion Changer 改区，并且安装 3.2U 系统。
4. 找个 JS 帮你焊掉 D2C 芯片的 JP2 跳线（JP1 是美版，JP1 + JP2 是日版），或者先用 Starfall 顶着。
5. 删掉 News 和 Weather 频道，并且用美版的替换（我还没做）。
6. 用 Starfaill 开启频道全区支持并去掉光盘自动更新检查。

如果不出问题，改区之后原本系统里的 WII Shop Channel 已经是 49（美国），而且可以正常使用。

而我后来为了删帐号又改成了 1（日本），进去后也无恙，结果又改成 49 后进入报了 205958 错，改成 1 后，尝试删除帐号，输入序列号后又出现了 206651 错误，现在依然在尝试解决。所以在改区后如果 Wii Shop Channel 可以使用的话，建议不用删除帐号。

待续（晚上贴图，上传改版软件，贴具体办法）。。。

Django 的 Form 表单真的很好用，完全把以往繁琐的表单操作完全抽象出来，成了一个独立的组件。

该系统的最大特色就是与模板无关，表单元素完全在一个文件里就可以定义好，以后也可以随时扩充，修改，很方便。

为了使用富文本编辑器我还使用了 InPlaceEditor，之所以用它是因为它基于强大的 TinyMCE 编辑器，同时提供了很好的 Ajax 支持，为了使用它我还使用了 django-tinymce，这个东西理论上应该找不到编译好的包，可以用 easy_install 安装（在 Fedora 10 里的 python-setuptools-devel 包里），总之就是怎么方便怎么来啦。 :-)

OK, Let's get start it.

在 app 目录里建立一个 forms 的目录，touch 一个 __init__.py，然后在其中写下 newapp.py 文件，如下内容：

from django import forms
from tinymce.widgets import TinyMCE
 
TYPE_CHOICES = [
    [1, 'Desktop Computer'],
    [2, 'Laptop'],
]
 
class NewProduct(forms.Form):
    name = forms.CharField()
    type_id = forms.ChoiceField(choices=TYPE_CHOICES)
    description = forms.CharField(widget=TinyMCE(mce_attrs={})

添加 View 里某个方法（比如 index）填上：

def index(request):
    from testproject.app.forms.newapp import NewProduct
    new_form = NewProduct()
    return render_to_response('testform.html', { 'new_form' : new_form })

然后改模板，类似如下：

<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.01//EN">
<html lang="en">
<head>
    <title>New Product</title>
</head>
<body>
   <h1>New Product</h1>
   <form action="." method="POST">
        {{ new_form.as_table }}
　　　　 <p><input type="submit" value="Submit"></p>
    </form>
</body>
</html>

够好用吧？一个 form 定义好以后直接使用 as_table 方法就可以转换成表格。

如果需要更多自定义参数，也可以像访问数据库一样直接调用 form class 里的属性，如下：

<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.01//EN">
<html lang="en">
<head>
    <title>New Product</title>
</head>
<body>
   <h1>New Product</h1>
   <form action="." method="POST">
        {{ new_form.name }}
        {{ new_form.type_id }}
        {{ new_form.description }}
　　　　 <p><input type="submit" value="Submit"></p>
    </form>
</body>
</html>
 

在 Django 的官方教程里，设计一个 form class 的 ChoiceField 使用的是 Tuple，而我这里经过试验，List 也是可以的，而之所以使用 List，是因为这样可以通过数据库，向 ChoiceField 里添加数据，如：

from django import forms
from tinymce.widgets import TinyMCE
from testproject.app.models import ProductTypes
 
types = ProductTypes.objects.all()
TYPE_CHOICES = []
for type in types:
    TYPE_CHOICES.append([type.id, type.name])
 
class NewProduct(forms.Form):
    name = forms.CharField()
    type_id = forms.ChoiceField(choices=TYPE_CHOICES)
    description = forms.CharField(widget=TinyMCE(mce_attrs={})

嘿嘿，基本到此，还是比较简单的，附带一个我的 TinyMCE 的设置作为结尾好了。

from django import forms
from tinymce.widgets import TinyMCE
from testproject.app.models import ProductTypes
 
types = ProductTypes.objects.all()
TYPE_CHOICES = []
for type in types:
    TYPE_CHOICES.append([type.id, type.name])
 
class NewProduct(forms.Form):
    name = forms.CharField()
    type_id = forms.ChoiceField(choices=TYPE_CHOICES)
    description = forms.CharField(widget=TinyMCE(mce_attrs={'theme' : "advanced",
                                                            'skin' : "o2k7",
                                                            'skin_variant' : "silver",
                                                            'elements' : 'elm3',
                                                            'mode' : 'textareas',
                                                            'theme_advanced_toolbar_location' : "top",
                                                            'theme_advanced_toolbar_align' : "left",
                                                            'theme_advanced_resizing' : 'true',
                                                            'plugins' : "safari,pagebreak,style,layer,save,iespell,xhtmlxtras",
                                                            'theme_advanced_buttons1' : "fontselect,fontsizeselect,|,cut,copy,paste,pastetext,|,bullist,numlist,|,undo,redo,|,link,unlink",
                                                            'theme_advanced_buttons2' : "",
                                                            'theme_advanced_buttons3' : "",
                                                           })

不知道 Rails 或者其它 Web Framework 是否也有比较优秀的特色功能，希望也能有人能够介绍一下。

今天打开 System Preference 发现 OS X 10.5.6 里多了个新的 Trackpad 选项，还有视频图解如何使用 Multi-Touch，我火星了?!

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

附记：刚才在一班上看到可以在经典的铝外壳本上（最后一代非 Unibody）可以开启四指 Multi-Touch 的 kext 内核模块，

上传到了这里：http://www.box.net/shared/kp8jsregu2

经过测试，可用。

苹果净干些非能力不可为而不为之的事情。 -_-#

一下子手痒没忍住，还是搞了 ReadyNAS，很满意。

性能有点 XX，现在在用我的 Linksys WRH54G 当有线路由备份东西，每秒钟大约 3M 左右，和 Firewire 800 每秒 24M 的写入速度真的差好多。

装上 SSHToggle add-on，登上去一看，虽然早知道它是基于 Linux 的，但是一些发现还是让我吃了一惊。

nas:/bin# cat /proc/cpuinfo 
cpu          : Infrant Technologics, Inc. - neon version: 0
fpu          : Softfpu
ncpus probed    : 1
ncpus active    : 1
BogoMips        : 186.36
MMU          : version: 0
LP            : HW.FW version: 0.1
FPGA        : fpga000000-0 Configuration: 0
AHB arbitraion  : 7
CPU id    : 0
Switch    : 0
ASIC        : IT3107

再用 file 看了下 Binrary，居然是 Sparc 的。。。　-_-#

nas:/bin# file /bin/ls 
ls: ELF 32-bit MSB executable, SPARC, version 1 (SYSV), for GNU/Linux 2.2.0, dynamically linked (uses shared libs), stripped

Bash 版本有点老:

nas:~# echo $BASH_VERSION
2.05b.0(1)-release

不过还是一个基本可玩的系统，只要是基于 Linux 的，就都有搞头～

找空跑跑 benchmark ...

 给软件写个彩蛋，但是又不想随便被别人看见，于是乎给脚本加下密就成了必须的了，不是为了 Property software，而是来个 Easter egg 来取乐 :-)

找来找去，找到一个 JavaScript Compiler 还不错，经过测试可以在 Firefox 和 Safari 上正常使用（IE 就不考虑了，手头也没机器测试），普通的 Encrypt 工具可能可以支持 Safari，但是对 Firefox 的支持可真的是非常一般。

地址在：http://www.virtualpromote.com/tools/javascript-encrypt/

比如经典的 Hello World:

被加密后就成了：

看不懂了吧？ ;-)

不过使用 JavaScript Compiler 有限制，生成的代码必须以单独的文件存放，而且文件还得写上 JavaScript 的标记段，因为其实它的原理是将加密的内容，解密后直接插入 DOM 树里形成的，如果不这样做，将会在浏览器窗口中直接看到解密后的 JavaScript  代码，从这种意义上说，它就不仅仅是 JavaScript 的 Compiler 了，HTML、CSS 一类也可以用它加密。

而且为了让加密后的代码能够更加容易地调用，我们最好还能够写成 Function 的模式。

这里是可供调用的完整的代码：

加密后的代码就成了：

把它单独存成一个文件（比如 foo.js），然后引用它：

以后，只要在程序中调用 helloworld 函数就可以显示 Hello World　了。 :-)

这 Tiger 里据称就是原来的 Quartz 2D Exteme，到 Leopard 里换了个名字叫 QuartzGL 了。刚刚在 Quartz Debug 的 Tools 菜单里看见有开启它的选项，所以就开了一下，用 xbench 跑了跑测试，结果居然比不开性能还差，而且还导致一些应用程序的不兼容现象出现（QuickSliver 启动画面成一半透明白框，据说Dashboard也会有问题），所以我还是关了。

开启方法是：

$ sudo defaults write /Library/Preferences/com.apple.windowserver QuartzGLEnabled -boolean YES

恢复方法是：

$ sudo defaults write /Library/Preferences/com.apple.windowserver QuartzGLEnabled -boolean NO

注销即可，不过我为了测试结果的准确性重启了电脑。

开了后的结果：

Results	179.93	
	System Info		
		Xbench Version		1.3
		System Version		10.5.5 (9F33)
		Physical RAM		2048 MB
		Model		MacBookPro4,1
		Drive Type		FUJITSU MHY2200BH
	Quartz Graphics Test	144.47	
		Line	181.54	12.09 Klines/sec [50% alpha]
		Rectangle	145.47	43.43 Krects/sec [50% alpha]
		Circle	235.46	19.19 Kcircles/sec [50% alpha]
		Bezier	78.55	1.98 Kbeziers/sec [50% alpha]
		Text	190.48	11.92 Kchars/sec
	OpenGL Graphics Test	164.98	
		Spinning Squares	164.98	209.29 frames/sec
	User Interface Test	271.05	
		Elements	271.05	1.24 Krefresh/sec

没开的结果：

Results	206.56	
	System Info		
		Xbench Version		1.3
		System Version		10.5.5 (9F33)
		Physical RAM		2048 MB
		Model		MacBookPro4,1
		Drive Type		FUJITSU MHY2200BH
	Quartz Graphics Test	192.86	
		Line	176.63	11.76 Klines/sec [50% alpha]
		Rectangle	232.50	69.41 Krects/sec [50% alpha]
		Circle	189.12	15.42 Kcircles/sec [50% alpha]
		Bezier	189.01	4.77 Kbeziers/sec [50% alpha]
		Text	185.73	11.62 Kchars/sec
	OpenGL Graphics Test	167.72	
		Spinning Squares	167.72	212.76 frames/sec
	User Interface Test	296.17	
		Elements	296.17	1.36 Krefresh/sec

完整的测试结果在：http://db.xbench.com/merge.xhtml?doc1=327066&doc2=327063

注意：因为单独的图形结果和完整测试不是同一个时间完成，所以数据有所偏差

 昨天 Launch & Learn 的时候，做了个简单的 Django 的数据库应用，以配合 Li Li Zhang 的 ORM Course。

其实用 Django 做数据库应用真的很简单，不过比较适合用于重头设计的 Database Schema，然后用 syncdb 来同步数据库。

目前 Django 对 ForeignKey 和 One to One, One to Many, Many to Many 支持得都不错，最大的缺陷还是缺乏 Join 的支持导致多表联查的性能不好，这也是我在做开发的过程中碰到的最大问题。

其实用 Django 重头做一个数据库开发非常简单，用下面几步就可以了。

FIRST:
Create new project and a new app with django-admin.py
$ django-admin.py startproject [project_name]
$ cd [project_name]
$ django-admin.py startapp [app_name]

SECOND:
Edit the settings.py file to adjust db settings and installed apps.

THIRD:
Edit the [app_name]/models.py to modeling the database schema

FOURTH:
Edit the [prject_name]/urls.py to adjust the path of URL.

FIFTH:
Edit the [app_name]/views.py to realize your function.

SIXTH:
To run the manage.py to start the test server in the project.
$ ./manage.py runserver

THE END:
Use your browser to navigate to your http://localhost:8000 and enjoy in it. :-)

这里提供了一个范例，也是昨天在 Launch and Learn 上演示过的：www.box.net/shared/6036abumgv 中的 lnl.tar.bz2 文件，里面提供的 Steps 其实就是上面那段，只是代码中也提供了注释以方便阅读。

情况：

因为公司另有一台性能很强劲的 Linux 工作站，自己有台 mac 笔记本，在两台电脑间来回切换让人很郁闷，所以就想让一套键盘鼠标在两个系统上都能使用上，把两台电脑当成一台电脑用。

之前用过 Synergy，所以又重新打起了它的主意，唯一和以前不同的是，现在我懒了很多，都不愿意用命令行来做这种配置工作了。。。 -_-#

安装：

Mac 从 http://sourceforge.net/projects/synergykm 上下载 SynergyKM，并且安装，会在 System Preferences 里增加 SynergyKM 一项。

Fedora 9 用 yum install quicksynergy synergy 来安装 Synergy 程序，然后会在 GNOME 菜单下的 internet 项下增加 QuickSynergy 一项。

配置：

我这里是把 Fedora 工作站当成服务器，共享它的键盘鼠标，而我的笔记本放在工作站的左边，所以在 QuickSynergy 的 Share 标签页左边写上 Macbook Pro 的主机名，然后点击 Execute。

如图：

然后在 Mac OS X 的 System Preferences 里启动 SynergyKM，选择 Connect to shared keyboard and mouse，然后在 Client Configuration 里写上服务器的主机名或者 IP 地址，点上  Apply Now，然后再回到 General 标签页里，点击 Turn Synergy On，如果下面的 Status 显示了 Connected 则连接成功。

如图：

好了，现在可以试试把台式机的鼠标指针“跨过”屏幕左边，直接挪到左边的 Mac 上进行操作了。

不仅如此，Synergy 还能在两台电脑间共享剪贴板，真正是把两台电脑当成一台用。

不过好像有点 Bug，在 Fedora 机器上开着一个菜单的时候，鼠标是被局限在 Fedora 的机器上的。

 Fedora Project 提供了 Fedora 10 的发布倒计时器，只要在自己的博客边栏里加上下面的 HTML 代码，效果看我的博客旁边。

http://turnyournameintoaface.com/

这是我的：

这是超猪 SuperPig 的：

这是猪肝的：

今天对我新买的 Macbook 063 和龙芯盒子目前在做的 64 bits 版本的 everest 做了下 nbench 的性能测试。

所有测试结果放在： 这里。

简体的叫做微软雅体，繁体的叫做微软正体，让我们来看看它和 Mac OS X 下的默认字体华文黑体来对比一下。

标粗	粗体