十年踪迹 http://www.silverna.org/blog 专注于前端开发 Thu, 05 Apr 2012 02:27:40 +0000 http://wordpress.org/?v=2.7.1 en hourly 1 用sublime构建phonegap项目 http://www.silverna.org/blog/?p=256 http://www.silverna.org/blog/?p=256#comments Thu, 05 Apr 2012 02:21:21 +0000 月影 http://www.silverna.org/blog/?p=256 Tools > Build System > New Build System 编辑打开的文件： {     "cmd": ["$project_path/sim-run.sh", "$project_name", "$project_name"] } 保存到 $Packages/User目录下 保存后，将sublime的project文件放在sim-run所在的目录下： 菜单 Project > Save Project As （目录选择当前编辑的项目的目录，并将前面download的sim-run.sh文件也放在这个目录） 接下来选择Build System > 之前保存的sublime-build文件， 之后command+B就可以看到模拟器中的运行结果了。 （注意上面的配置要求project的名字和build的app的名字要一样，如果xcode中改了target，那么将第二个$project_name替换成实际target的名字就行了） 参考文章：http://shazronatadobe.wordpress.com/2011/02/23/running-your-iphone-app-in-the-simulator-without-xcode/ ]]> 有了sublime，利用xcode的命令行，可以在不启动xcode的情况下正确build出phonegap的app并在模拟器中运行。
具体步骤如下：

首先安装最新的 ios-sim
(OSX 使用命令 rake install prefix=/usr/bin/)

之后使用xcode命令的build脚本（保存到 sim-run.sh）就可以编译和载入模拟器运行

接下来要做的事情是将build脚本加入到sublime的Build System中
具体方法如下：

Sublime菜单 > Tools > Build System > New Build System
编辑打开的文件：

  1. {
  2.     "cmd": ["$project_path/sim-run.sh", "$project_name", "$project_name"]
  3. }

保存到 $Packages/User目录下

保存后，将sublime的project文件放在sim-run所在的目录下：
菜单 Project > Save Project As （目录选择当前编辑的项目的目录，并将前面download的sim-run.sh文件也放在这个目录）

接下来选择Build System > 之前保存的sublime-build文件， 之后command+B就可以看到模拟器中的运行结果了。
（注意上面的配置要求project的名字和build的app的名字要一样，如果xcode中改了target，那么将第二个$project_name替换成实际target的名字就行了）

参考文章：http://shazronatadobe.wordpress.com/2011/02/23/running-your-iphone-app-in-the-simulator-without-xcode/

]]> http://www.silverna.org/blog/?feed=rss2&p=256 使用PyV8解析HTML文档 http://www.silverna.org/blog/?p=252 http://www.silverna.org/blog/?p=252#comments Thu, 23 Feb 2012 03:05:36 +0000 月影 http://www.silverna.org/blog/?p=252 什么是PyV8?

PyV8是一个Python封装V8引擎的壳。它提供了简单可用的API，能够利用python来构建出JavaScript的运行时环境。

PyV8能用来干什么？

在nodejs火热流行的时代，或许很少人关注这个基于python简单封装的v8引擎。在某些方面，它比nodejs简洁，而它们拥有同样的本质基础，使得它具有和nodejs相似的潜力。

既然是基于v8的，那么利用它来解析dom和执行javascript是理所当然的。试想一下，如果我们能够建立一个系统把html文档结构解析成w3c dom树，那么我们就可以在上面运行任何javascript，使得这个系统事实上成为一个浏览器（尽管缺少渲染和显示的部分）。

不过，pyv8提供的是纯js运行环境，因此，要解析html文档，还需要为它构建出w3c dom以及浏览器的环境。实现dom和浏览器接口毫无疑问是件力气活，幸运的是，pyv8的官方demo中为我们做了80%以上的工作，提供了w3c.py和browser.py的支持！我们所要做的是在这基础上做一些基本的修改。

好吧，让我们来实践一下：

首先我们构建一个基本的js运行环境，参考commonjs的api实现js基础的模块加载和执行。这一部分还不涉及dom和浏览器，基本上是js原生环境。

  1. import os, re, platform
  2. from PyV8 import JSContext, JSError
  3.  
  4. from logger import logger
  5.  
  6. class CommonJS():
  7.     _js_path = [os.path.dirname(__file__), os.path.join(os.path.dirname(__file__),'core')]
  8.     _js_logger = logger().instance()
  9.  
  10.     def __init__(self):
  11.         self._js_threadlock = False
  12.         self._js_ctx = JSContext(self)
  13.         self._js_modules = {}
  14.         self._loaded_modules = {}
  15.  
  16.         for jsroot in CommonJS._js_path:
  17.             for (root, dirs, files) in os.walk(jsroot):
  18.                 for _file in files:
  19.                     m = re.compile('(.*)\.js$').match(_file)
  20.                     relpath = os.path.relpath(root, jsroot)
  21.                     namespace = re.sub(r'^\.', '', relpath)
  22.                     namespace = re.sub(r'^\\', '/', namespace)
  23.                     if(namespace):
  24.                         namespace = namespace + '/'
  25.                     if(m):
  26.                         self._js_modules.update({namespace + m.group(1) : os.path.join(root,_file)})
  27.  
  28.         self.execute("var exports;");               
  29.    
  30.     @classmethod
  31.     def append(path):
  32.         if(path not in CommonJS._js_path):
  33.             CommonJS._js_path.append(path)
  34.  
  35.     def require(self, module):
  36.         if(not self._js_modules.has_key(module)):
  37.             raise Exception, "unknown module `" + module + "`"
  38.         path = self._js_modules[module]
  39.  
  40.         if(not self._loaded_modules.has_key(path)):
  41.             self._js_logger.info("loading module <%s>...", module)
  42.             code = file(path).read()
  43.             try:
  44.                 code = code.decode('utf-8')
  45.                 if(platform.system() == 'Windows'):
  46.                     code = code.encode('utf-8')
  47.                 self._js_ctx.eval(code)
  48.             except JSError, ex:
  49.                 self._js_logger.error(ex)
  50.                 self._js_logger.debug(ex.stackTrace)
  51.                 raise Exception, ex
  52.             self._loaded_modules[path] = self._js_ctx.locals.exports
  53.             return self._loaded_modules[path]
  54.         else:
  55.             return self._loaded_modules[path]
  56.  
  57.     def execute(self, code, args = []):
  58.         self._js_ctx.enter()
  59.        
  60.         # use lock while jscode executing to make mutil-thread work
  61.         while self._js_threadlock:
  62.             pass
  63.         self._js_threadlock = True
  64.         try:
  65.             if(isinstance(code, basestring)):
  66.                 code = code.decode('utf-8')
  67.                 if(platform.system() == 'Windows'):
  68.                     code = code.encode('utf-8')
  69.                 r = self._js_ctx.eval(code)
  70.             else:
  71.                 r = apply(code, args)
  72.             return r
  73.         except JSError, ex:
  74.             self._js_logger.error(ex)
  75.             self._js_logger.debug(ex.stackTrace)
  76.             raise Exception, ex
  77.         finally:
  78.             self._js_threadlock = False
  79.             self._js_ctx.leave()

好了，我们可以测试一下：

  1. from commonjs import CommonJS
  2. ctx = CommonJS()
  3. ctx.append('/my/js/path')
  4. print ctx.execute('require("base"); QW.provide("Test",{}); exports = QW.Test');

结果是
[JSObject]

在这基础上，我们进一步实现整个运行时环境和一些内置方法：

  1. #JavaScript HTML Context for PyV8
  2.  
  3. from PyV8 import JSClass
  4. from logger import logger
  5. import re, threading, hashlib
  6.  
  7. import urllib,urllib2
  8.  
  9. from w3c import parseString, Document, HTMLElement
  10. from commonjs import CommonJS
  11.  
  12. import browser
  13.  
  14. from StringIO import StringIO
  15. import gzip
  16.  
  17. class JSR(CommonJS, browser.HtmlWindow):
  18.     def __init__(self, url_or_dom, charset=None, headers={}, body={}, timeout=2):
  19.         urllib2.socket.setdefaulttimeout(timeout)
  20.         jsonp = False
  21.  
  22.         if(isinstance(url_or_dom, Document)):
  23.             url = "localhost:document"
  24.             dom = url_or_dom
  25.  
  26.         elif(url_or_dom.startswith('<')):
  27.             url = "localhost:string"
  28.             dom = parseString(url_or_dom)
  29.  
  30.         else: #url
  31.             url = url_or_dom
  32.             if(not re.match(r'\w+\:\/\/', url)):
  33.                 url = "http://" + url
  34.  
  35.             request = urllib2.Request(url, urllib.urlencode(body), headers=headers) 
  36.             response = urllib2.urlopen(url)
  37.            
  38.             contentType = response.headers.get('Content-Type')
  39.  
  40.             if(contentType):
  41.                 #print contentType
  42.                 t = re.search(r'x-javascript|json', contentType)
  43.                 if(t):
  44.                     jsonp = True
  45.                 m = re.match(r'^.*;\s*charset=(.*)$', contentType)
  46.                 if(m):
  47.                     charset = m.group(1) 
  48.                 #print charset
  49.  
  50.             if(not charset):
  51.                 charset = 'utf-8' #default charset
  52.                 # guess charset from httpheader
  53.  
  54.             html = response.read()
  55.             encoding = response.headers.get('Content-Encoding')
  56.  
  57.             if(encoding and encoding == 'gzip'):
  58.                 buf = StringIO(html)
  59.                 f = gzip.GzipFile(fileobj=buf)
  60.                 html = f.read()   
  61.                            
  62.             self.__html__ = html
  63.             html = unicode(html, encoding=charset, errors='ignore')
  64.             dom = parseString(html)   
  65.  
  66.         navigator = browser.matchNavigator(headers.get('User-Agent') or '')
  67.            
  68.         browser.HtmlWindow.__init__(self, url, dom, navigator)
  69.         CommonJS.__init__(self)
  70.        
  71.         self.console = JSConsole(self._js_logger)
  72.        
  73.         for module in "base, array.h, function.h, helper.h, object.h, string.h, date.h, custevent, selector, dom_retouch".split(","):
  74.             self.execute(self.require, [module.strip()])
  75.        
  76.         if(jsonp):
  77.             code = "window.data=" + html.encode('utf-8')
  78.             self.execute(code)
  79.             #print code
  80.  
  81.         self._js_logger.info('JavaScript runtime ready.')
  82.  
  83.     _js_timer_map = {}
  84.  
  85.     def _js_execTimer(self, id, callback, delay, repeat = False):
  86.         code = '(function f(){ _js_timers[' + str(id) + '][1].code();'
  87.         if(repeat):
  88.             code = code + '_js_execTimer(' + str(id) + ', f, ' + str(delay) + ', true);'
  89.         code = code + '})();'
  90.  
  91.         #thread locking
  92.         self._js_timer_map[id] = threading.Timer(delay / 1000.0, lambda: self.execute(code))
  93.         self._js_timer_map[id].start()
  94.  
  95.     def setTimeout(self, callback, delay):
  96.         timerId = super(JSR, self).setTimeout(callback, delay)
  97.         self._js_execTimer(timerId, callback, delay, False)
  98.         return timerId
  99.  
  100.     def clearTimeout(self, timerId):
  101.         if(timerId in self._js_timer_map):
  102.             self._js_timer_map[timerId].cancel()
  103.             self._js_timer_map[timerId] = None
  104.             super(JSR, self).clearTimeout(timerId)
  105.  
  106.     def setInterval(self, callback, delay):
  107.         timerId = super(JSR, self).setInterval(callback, delay)
  108.         self._js_execTimer(timerId, callback, delay, True)
  109.         return timerId       
  110.    
  111.     def clearInterval(self, timerId):
  112.         if(timerId in self._js_timer_map):
  113.             self._js_timer_map[timerId].cancel()
  114.             self._js_timer_map[timerId] = None
  115.             super(JSR, self).clearTimeout(timerId)
  116.  
  117.     def md5(self, str):
  118.         return hashlib.md5(str).hexdigest()
  119.  
  120. class JSConsole(JSClass):
  121.     def __init__(self, logger):
  122.         self._js_logger = logger
  123.     def log(self, msg):
  124.         self._js_logger.info(str(msg).decode('utf-8'))

到此为止，一个简单的运行时环境就实现了。

使用方法：

  1. from jsruntime import JSR
  2.  
  3. rt = JSR('www.baidu.com')
  4. rt.execute('alert(document.title)') #结果是“百度一下，你就知道”
  5. rt.execute('document.querySelector("body div")') #获得body下匹配的第一个div
  6. ...

利用它，你就可以用js来处理抓取的页面元素，甚至通过运行页面上的js来获取动态加载的内容，只要继续扩展，可以用它来实现一个相当不错的页面内容采集服务，而采集规则，不再只能是简单的正则，而是可以用js像处理任何动态网页那样来处理抓取的页面。

有兴趣滴童鞋可以研究下，pyv8的潜力还是很大的，大家一起期待一下~

]]> http://www.silverna.org/blog/?feed=rss2&p=252 让Kohana直接支持python——client篇 http://www.silverna.org/blog/?p=244 http://www.silverna.org/blog/?p=244#comments Mon, 12 Dec 2011 06:45:07 +0000 月影 http://www.silverna.org/blog/?p=244 最后，是让php和python”对接“起来
我们在php的auto_load的时候也让python加载对应的模块

  1. <?php defined('SYSPATH') or die('No direct script access.');
  2.  
  3. Socket_Instance::$client = new Socket_Client('127.0.0.1', 1990);
  4.  
  5. class Python_Env_Init extends Kohana{
  6.     /**
  7.      * add auto_load to create php local classes associate to remote python classes
  8.      */
  9.     public static function auto_load($class){
  10.         try{
  11.                 $data = Socket_Instance::find_class($class, self::$_paths);
  12.                 $code =
  13.                     'class '.$class.' extends Socket_Instance
  14.                         {
  15.                             protected static $_class="'.$class.'";
  16.                             function __construct(){
  17.                                 $args = func_get_args();
  18.                                 parent::__construct(self::$_class,$args);
  19.                             }
  20.                             static function __callStatic($func, $args){
  21.                                 return self::_rpc_call(self::$client,
  22.                                     array(
  23.                                             "class" => self::$_class,
  24.                                             "func" => $func,
  25.                                             "args" => $args, )
  26.                                 );                                                   
  27.                             }
  28.                     }';
  29.                 eval($code);
  30.                 return true;
  31.         }catch(Exception $ex){
  32.                 return false;
  33.         }
  34.     }
  35. }
  36.  
  37. spl_autoload_register(array('Python_Env_Init', 'auto_load'));


注意到，auto_load的时候动态定义一个class，这个class是一个叫做Socket_Instance的类的实例，这个类是这样的——

  1. <?php defined('SYSPATH') or die('No direct script access.');
  2.  
  3. /**
  4. * the socket instanc handle an unique object instance from the socket server
  5. *
  6. * @package    Python
  7. * @category   Socket
  8. * @author     akira.cn@gmail.com
  9. * @copyright (c) 2011 WED Team
  10. * @license    http://kohanaframework.org/license
  11. */
  12. class Socket_Instance{
  13.     /**
  14.      * unique identifier to hold the instance
  15.      */
  16.     protected $_id;
  17.  
  18.     /**
  19.      * constructor
  20.      */
  21.     protected $_constructor;
  22.     /**
  23.      * constructor arguments
  24.      */
  25.     protected $_args;
  26.    
  27.     /**
  28.      * socket client
  29.      */
  30.     public static $client = null;
  31.    
  32.     /**
  33.      * create a new socket instance to operate an object instance from the socket server
  34.      *
  35.      * @param    String            $class    class name
  36.      * @param    Array            $args    construct arguments
  37.      * @param    Socket_Client    $client
  38.      */
  39.     public function __construct($class, $args = array(), $id = null){
  40.         if(!isset($id)){
  41.             $id = uniqid('i',true);
  42.         }
  43.         $this->_constructor = $class;
  44.         $this->_args = $args;
  45.         $this->_id = $id;
  46.  
  47.         self::$client->instances[$this->_id] = $this;
  48.     }
  49.    
  50.     /**
  51.      * call a function from remote server
  52.      *
  53.      * @param    String    $func    method name
  54.      * @param    Array    $args    method arguments
  55.      * @return    mixed
  56.      */
  57.     public function __call($func, $args){
  58.         return self::_rpc_call(self::$client,
  59.             array(   
  60.                     "class"        => $this->_constructor,
  61.                     "init"        => $this->_args,
  62.                     "func"        => $func,
  63.                     "args"        => $args,
  64.                     "id"        => $this->_id)
  65.         );                                                   
  66.     }
  67.    
  68.     /**
  69.      * make a rpc_call, send data to server
  70.      *
  71.      * @param    Socket_Client    $client
  72.      * @param    Array            $data
  73.      * @return    mixed   
  74.      */
  75.     protected static function _rpc_call($client, $data){
  76.         $data = json_encode($data);
  77.         $socket = $client->socket();
  78.  
  79.         $res = socket_write($socket, $data, strlen($data));
  80.  
  81.         if($res===false){
  82.             return $client->_error('error socket_write'.socket_strerror(socket_last_error()));
  83.         }
  84.         $res = socket_read($socket, 1024, PHP_BINARY_READ);
  85.         $size = intval(substr($res, 0, 8));
  86.         while($size + 8 > strlen($res)){
  87.             $res .= socket_read($socket, 1024, PHP_BINARY_READ);
  88.         }
  89.         while($size + 8 < strlen($res)){
  90.             $res = substr($res, $size + 8);
  91.             $size = intval(substr($res, 0, 8));
  92.         }
  93.         $res = substr($res, 8, $size);
  94.  
  95.         $ret = json_decode($res, true);
  96.        
  97.         if($ret['err'] == 'sys.socket.error'){
  98.             throw new Socket_Exception($res);
  99.         }
  100.        
  101.         $data = $ret['data'];
  102.        
  103.         //if python func returns a python object, create this object via php
  104.         if(is_array($data) && isset($data['@class']) && isset($data['@init']) && isset($data['@id'])){
  105.             $data = new Socket_Instance($data['@class'], $data['@init'], $data['@id']);
  106.         }
  107.  
  108.         return $data;
  109.     }
  110.  
  111.     /**
  112.      * find a class from remote server
  113.      *
  114.      * @param    String    $class    class name
  115.      * @param    Array    $paths    root paths
  116.      * @return    boolean
  117.      */
  118.     public static function find_class($class, $paths = array()){
  119.         return self::_rpc_call(self::$client,array('class' => $class, 'paths' => $paths));   
  120.     }
  121. }

Socket_Instance及其派生类当实例化的时候生成一个唯一的id，用来标识这个实例，并利用魔术方法来处理静态方法和对象方法
注意到实例化Sockiet_Instance的时候并不会连接python，因此python端的对应实例是延迟初始化的，只有当第一个对象方法被调用的时候，id被第一次传入python处理程序（见上一篇），python端的对象实例才被创建（调用static方法因为不传id，所以并不会导致python端的对象构造）。这样的话如果用户new了一个class但一次都没使用过，那么python那头就不会连接和构造，从而优化了效率。

最后为socket_instance封装一个socet client对象

  1. <?php defined('SYSPATH') or die('No direct script access.');
  2.  
  3. /**
  4. * Creating socket handles connected to the socket server
  5. *
  6. * @package    Python
  7. * @category   Socket
  8. * @author     akira.cn@gmail.com
  9. * @copyright (c) 2011 WED Team
  10. * @license    http://kohanaframework.org/license
  11. */
  12. class Socket_Client{
  13.     /**
  14.      * socket server ip address
  15.      */
  16.     private $_host;
  17.     /**
  18.      * socket server port
  19.      */
  20.     private $_port;
  21.     /**
  22.      * socket connection
  23.      */
  24.     private $_socket;
  25.     /**
  26.      * error reports
  27.      */
  28.     private $_error;
  29.    
  30.     /**
  31.      * the object instances handled
  32.      */
  33.     public $instances = array();
  34.    
  35.     /**
  36.      * create a new socket client object
  37.      *
  38.      * @param    String    $host
  39.      * @param    Int        $port
  40.      */
  41.     function __construct($host = '127.0.0.1', $port = 1990) {
  42.         $this->_host = $host;
  43.         $this->_port = $port;
  44.         $this->_connect();
  45.     }
  46.    
  47.     /**
  48.      * create the connection
  49.      *
  50.      * @return    Socket
  51.      */
  52.     private function _connect() {
  53.         $sock = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
  54.         if($sock === false){
  55.             return $this->_error('error socket_create'.socket_strerror(socket_last_error()));
  56.         }
  57.  
  58.         $ret = socket_connect($sock, $this->_host, $this->_port);
  59.         if($ret === false){
  60.             return $this->_error('error socket_connect'.socket_strerror(socket_last_error()));
  61.         }
  62.  
  63.         $this->_socket = $sock;
  64.     }
  65.  
  66.     /**
  67.      * get the socket handle
  68.      *
  69.      * @return Socket
  70.      */ 
  71.     public function socket(){
  72.         return $this->_socket;
  73.     }
  74.    
  75.     /**
  76.      * remove the instances handled from the socket server
  77.      */
  78.     public function __destruct() {
  79.         $socket = $this->_socket;
  80.         socket_write($socket, '', 0);
  81.         socket_close($socket);
  82.     }
  83.    
  84.     /**
  85.      * provide errors
  86.      *
  87.      * @throws Socket_Exception
  88.      */
  89.     private function _error($errMsg = '') {
  90.         $this->_error = array(
  91.             'err' => 'sys.socket.error',
  92.             'msg' => $errMsg,
  93.         );
  94.         throw new Socket_Exception($errMsg);
  95.     }
  96. }

至此，kohana下python和php直连的机制基本上完成了，用户只需要像写php普通类的方法用python写那些类，在kohana中就可以像是用php写的那些类一样的调用，是不是非常简单呢？

最后，放上这个项目的开源地址——
https://github.com/akira-cn/Kohana-python

]]> http://www.silverna.org/blog/?feed=rss2&p=244 让Kohana直接支持python——RPC篇 http://www.silverna.org/blog/?p=240 http://www.silverna.org/blog/?p=240#comments Mon, 12 Dec 2011 06:31:17 +0000 月影 http://www.silverna.org/blog/?p=240 上一篇中，我们实现了基础的TCP Server，数据通过json协议进行传输

接下来，我们需要处理RPC请求的核心部分。
我们来看，在PHP代码中写：

  1. $myObj = new Foo_Bar();
  2. $myObj->test();

我们要python端做哪些事情


首先，我们要让python找到对应的模块加载（按kohana规则，这个模块叫 classes/foo/bar.py）
其次，我们用php new了一个python对象，对象名为Foo_Bar，接着，调用了test方法
在RPC请求中，我们先要通知python去new这个对象，并且将这个实例保存下来
再次，当我们调用test()方法时，python要知道调用这个方法的对象实例是我们刚才保存下来的那个Foo_Bar实例。所以这里，我们必须要维持一个唯一的id，作为这个实例的标识。
id有两个作用，一是避免对象的重复构造，二是让python知道该用哪个对象去调用方法。

对于让python找到对应的模块加载，这个可以放在php的autoload中进行，只要在autoload的过程中，将对应的路径classes加入到python的sys.path中，并且写好classes/foo/__init__.py，那么在python中通过import或__import__就能将正确的模块加载进来了。

至于new正确的python对象，只需要将Foo_Bar解析成foo.bar.Foo_Bar，应该不难。这只是简单的正则替换而已。

有了class，我们根据guid构造出实例，并且将这个实例保存在对应的guid的字典字段中。

完整的代码并不复杂：

  1. # coding=utf-8
  2.  
  3. import sys
  4. import uuid
  5. from types import *
  6.  
  7. class Handler():
  8.     def __init__(self):
  9.         self.rpc_instances = {}
  10.     def execute(self, data):
  11.         rpc_instances = self.rpc_instances;
  12.  
  13.         if('paths' in data): #set auto loading paths
  14.             data['paths'].reverse()
  15.             for i in range(len(data['paths'])):
  16.                 path = data['paths'][i] + 'classes'
  17.                 if(path not in sys.path):
  18.                     sys.path.insert(1, path)
  19.        
  20.         #call the object instance func - {id, func, args[class, init]}
  21.         if('id' in data):
  22.             if(data['id'] in rpc_instances):    #the object has been created
  23.                 o = rpc_instances[data['id']]
  24.             else:                               #create new object instance
  25.                 c = self.find_class(data['class'])
  26.                 o = apply(c, data['init'])
  27.                 rpc_instances[data['id']] = o 
  28.             res =  apply(getattr(o, data['func']), data['args']) or '' 
  29.  
  30.         #call class func - {class, [func, args]}
  31.         else:
  32.             c = self.find_class(data['class'])
  33.             #if not 'func', only to test wether the class exists or not
  34.             if(not ('func' in data)): #TODO: get the detail info of the class?
  35.                 res = True
  36.             else:
  37.                 res = apply(getattr(c, data['func']), data['args']) or ''
  38.        
  39.         if(type(res) is InstanceType):
  40.             uid = str(uuid.uuid4())
  41.             rpc_instances[uid] = res
  42.             res = {'@id':uid, '@class':res.__class__.__name__, '@init':[]}  
  43.        
  44.         return {'err':'ok', 'data':res}
  45.  
  46.     def find_class(self, class_name):
  47.         #resolve the path from class name like 'Model_Logic_Test'
  48.         path = map(lambda s: s.lower(), class_name.split('_'))
  49.         p = __import__(".".join(path))
  50.  
  51.         for i in range(len(path)):
  52.             if(i > 0):
  53.                 p = getattr(p, path[i])
  54.    
  55.         return getattr(p, class_name)
]]> http://www.silverna.org/blog/?feed=rss2&p=240 让Kohana直接支持python——Server篇 http://www.silverna.org/blog/?p=236 http://www.silverna.org/blog/?p=236#comments Fri, 09 Dec 2011 06:46:19 +0000 月影 http://www.silverna.org/blog/?p=236 最近写php用的是Kohana(http://kohanaframework.org/) MVC框架。这个框架用的人不是很多，不过确实是一个相当不错的轻量级PHP MVC框架。
php用于web开发还是很方便的，这门语言专注于web开发，作为前端工程师，非常喜欢这种简单的脚本语言。
不过有些后端的服务，如一些对异步要求较高的服务，用php写就稍稍有点费劲，而用python则是不错的选择。
因此，我自然开始考虑是否能将kohana和python结合起来。
我的设想是：在kohana中能直接new python写的class，就像php的原生方法那样简单

例如：
在koahan中，如果要直接加载一个php的类clas Foo_Bar，那么要求这个类定义放在 classes/foo/bar.php 文件中
现在如果我定义在classes/foo文件夹下的是一个python文件 bar.py，里面定义了一个python的类Foo_Bar
我希望也能用kohana调用这个类
即——

  1. $myObj = new Foo_Bar(); //不论这个类是php还是python写的

首先的问题是python和php之间的通信问题，思考之后，我决定用tcp socketserver来解决它，数据协议就用json
python自带了一个socketserver，那是可以支持多线程的异步socket，试着拿它写了一个server——

  1. # coding=utf-8
  2.  
  3. import sys
  4. import json
  5. import traceback
  6. import socket
  7. from SocketServer import BaseRequestHandler, ThreadingTCPServer
  8. from daemon import Daemon
  9.  
  10. from handler import Handler
  11.  
  12. from logger import logger
  13. logger = logger().instance()
  14.  
  15. class RequestHandler(BaseRequestHandler, Handler):
  16.     def setup(self):
  17.         logger.debug('setup')
  18.         self.request.settimeout(60)
  19.         self.rpc_instances = {}
  20.     def handle(self):
  21.         while True:
  22.             try:
  23.                 data = self.request.recv(2*1024*1024)
  24.                 if not data:
  25.                     break  #end
  26.                 data = json.loads(data)
  27.  
  28.                 res = self.execute(data)
  29.                
  30.                 logger.debug('instance count:' + str(len(self.rpc_instances.keys())))
  31.  
  32.                 res = json.dumps(res) 
  33.                 res = str(len(res)).rjust(8, '0') + res 
  34.                 self.request.send(res)
  35.             except socket.timeout as err:
  36.                 res = ('error in RequestHandler :%s, res:%s' % (traceback.format_exc(), data))
  37.                 logger.debug(res)
  38.                 res = json.dumps({'err':'sys.socket.error', 'msg':format(err)})
  39.                 res = str(len(res)).rjust(8, '0') + res 
  40.                 self.request.send(res)
  41.                 self.request.close()
  42.                 break
  43.             except Exception as err:
  44.                 res = ('error in RequestHandler :%s, res:%s' % (traceback.format_exc(), data))
  45.                 logger.debug(res)
  46.                 res = json.dumps({'err':'sys.socket.error', 'msg': format(err)})
  47.                 res = str(len(res)).rjust(8, '0') + res 
  48.                 self.request.send(res)
  49.  
  50.     def finish(self):
  51.         logger.debug('finish')
  52.         self.request.close()
  53.  
  54.     def response(self, data):
  55.         res = json.dumps(data)
  56.         res = str(len(res)).rjust(8, '0') + res 
  57.         self.transport.write(res)
  58.  
  59. class Server(Daemon):       
  60.     def conf(self, host, port):
  61.         self.host = host
  62.         self.port = port
  63.         ThreadingTCPServer.allow_reuse_address = True
  64.     def run(self):
  65.         server = ThreadingTCPServer((self.host, self.port), RequestHandler)
  66.         try:
  67.             server.serve_forever()
  68.         except Exception as err:
  69.             logger.debug(traceback.format_exc())
  70.    
  71. if __name__ == '__main__':
  72.     server = Server('/tmp/daemon-tortoise.pid')
  73.     port = 1990
  74.     if len(sys.argv) >= 3:
  75.         port = sys.argv[2]
  76.     server.conf('0.0.0.0', port) #change ip address if you want to call remotely
  77.     if len(sys.argv) >= 2:
  78.         if 'start' == sys.argv[1]:
  79.             server.start()
  80.         elif 'stop' == sys.argv[1]:
  81.             server.stop()
  82.         elif 'restart' == sys.argv[1]:
  83.             server.restart()
  84.         else:
  85.             print("Unknown command")
  86.             sys.exit(2)
  87.         sys.exit(0)
  88.     else:
  89.         print("usage: %s start|stop|restart" % sys.argv[0])
  90.         sys.exit(2)

继承自Daemon的Server是让操作系统管理进程的，关键的是——

  1. server = ThreadingTCPServer((self.host, self.port), RequestHandler)
  2.         try:
  3.             server.serve_forever()

这一步启动了一个tcp server，接下来在RequestHandler中处理逻辑

  1. res = self.execute(data)

这一句将json数据解析成python类和方法来执行，具体的代码我们在后续的RPC篇中详细介绍

如果处理过程中有错误，记录日志，并把错误信息发送回php，以方便捕获异常进行调试

在这个模型下，python的整个过程是一个多线程的请求，每个php请求单独建立一个线程连接，处理完成之后或者请求超时之后，连接将被关闭，所有的资源得到释放。

上面用原生的SocketServer实现了简单的php和python通信的机制，它确实能稳定地跑起来，而且效率不差
不过由于存在GIL机制的限制，python多线程模型不能完全占有CPU资源，因此考虑到进一步提高并发请求的效率，改用异步非阻塞单线程机制是一个合理的想法。
对于异步非阻塞连接，php的twisted框架提供了一个相当不错的实现，因此安装twisted之后，利用这个框架写了一个新的server——
server-twisted.py

  1. # coding=utf-8
  2.  
  3. import sys
  4. import traceback
  5. from daemon import Daemon
  6.  
  7. from twisted.internet import reactor
  8. from twisted.internet.protocol import Protocol, Factory
  9. from twisted.protocols.policies import TimeoutMixin
  10.  
  11. from handler import Handler
  12.  
  13. from logger import logger
  14. logger = logger().instance()
  15.  
  16. import json
  17.  
  18. class PHPRequest(Protocol, TimeoutMixin, Handler):   
  19.     def connectionMade(self):
  20.         logger.debug('connection opened')
  21.         self.setTimeout(self.factory.conn_timeout)
  22.         self.clients = str(self.transport.getPeer().host)
  23.         self.factory.connections = self.factory.connections + 1
  24.         logger.debug('connections:' + str(self.factory.connections))
  25.    
  26.     def connectionLost(self,reason):
  27.         self.setTimeout(None)
  28.         self.factory.connections = self.factory.connections - 1
  29.         logger.debug('connection closed:' + reason)
  30.    
  31.     def timeoutConnection(self):
  32.         res = {'err' : 'sys.socket.error', 'msg':"timed out: %s" % self.clients}
  33.         logger.debug("timed out: %s" % self.clients)
  34.         self.response(res)
  35.         self.transport.unregisterProducer()
  36.         self.transport.loseConnection()
  37.  
  38.     def dataReceived(self,data):
  39.         try:
  40.             data = json.loads(data)
  41.             res = self.execute(data)
  42.             logger.debug('instance count:' + str(len(self.rpc_instances.keys())))
  43.         except Exception as err:
  44.             res = ('error in RequestHandler :%s, res:%s' % (traceback.format_exc(), data))
  45.             logger.debug(res)
  46.             res = {'err':'sys.socket.error', 'msg':format(err)}
  47.         finally:
  48.             self.response(res)
  49.    
  50.     def response(self, data):
  51.         res = json.dumps(data)
  52.         res = str(len(res)).rjust(8, '0') + res 
  53.         self.transport.write(res)
  54.  
  55. class PHPRequestFactory(Factory):
  56.     protocol = PHPRequest
  57.     connections = 0
  58.     def __init__(self, conn_timeout):
  59.         self.conn_timeout = conn_timeout
  60.  
  61. class Server(Daemon):       
  62.     def conf(self, host, port):
  63.         self.host = host
  64.         self.port = port 
  65.     def run(self):
  66.         try:
  67.             logger.debug('run')
  68.             factory = PHPRequestFactory(60)
  69.             reactor.listenTCP(self.port, factory)
  70.             reactor.run()
  71.         except:
  72.             logger.debug(traceback.format_exc())
  73.    
  74. if __name__ == '__main__':
  75.     server = Server('/tmp/daemon-tortoise.pid')
  76.     port = 1990
  77.     if len(sys.argv) >= 3:
  78.         port = sys.argv[2]
  79.     server.conf('0.0.0.0', port) #change ip address if you want to call remotely
  80.     if len(sys.argv) >= 2:
  81.         if 'start' == sys.argv[1]:
  82.             server.start()
  83.         elif 'stop' == sys.argv[1]:
  84.             server.stop()
  85.         elif 'restart' == sys.argv[1]:
  86.             server.restart()
  87.         else:
  88.             print("Unknown command")
  89.             sys.exit(2)
  90.         sys.exit(0)
  91.     else:
  92.         print("usage: %s start|stop|restart" % sys.argv[0])
  93.         sys.exit(2)

twisted是异步事件回调的模型，逻辑比之前的socketserver更简单，分别处理好connectionMade、connectionLost、dataRecevied和timeoutConnection几个事件就好了。
到此为止，简单的server写好了，它可以和php的client之间相互通信。现在我们要做的事情是将php发送给python的json格式的数据解析成python的命令执行，并且组织好返回给php的数据格式。

关于php的client，将在下一篇文章中详细说明。

]]> http://www.silverna.org/blog/?feed=rss2&p=236 show一段用Lafe写的代码 http://www.silverna.org/blog/?p=233 http://www.silverna.org/blog/?p=233#comments Mon, 18 Jul 2011 07:45:37 +0000 月影 http://www.silverna.org/blog/?p=233
  1. class Layout_My_Layout extends Base_Layout{
  2.     function build(){
  3.         if($ua->isPc) $this->pc->display();
  4.         else if($ua->isPad) $this->pad->display();
  5.         else if($ua->isPhone) $this->phone->display();
  6.     }
  7.     public function layout_pc(){
  8.         $main_body = "left_2_right_3_5.Right";
  9.         $side_bar = "left_2_right_3_5.Left";
  10.  
  11.         if($ua->userReverse){
  12.             $main_body = "left_3_right_2_5.Left"; //用户选择把side_bar放在右边的设置
  13.             $side_bar = "left_3_right_2_5.Right";
  14.         }
  15.  
  16.         $this->{'Header common_header'} = $headder_data;
  17.         $this->{"Body $main_body main_panel"} = $side_data;
  18.         $this->{"Body $side_bar side_panel"} = $right_data;
  19.         $this->{'Footer common_footer'} = $footer_data;
  20.     }
  21.     public function layout_pad(){
  22.         ......
  23.     }
  24.     public function layout_phone(){
  25.         ......
  26.     }
  27. }
]]> http://www.silverna.org/blog/?feed=rss2&p=233 LAFE——基于Layout的前端开发方式简介 http://www.silverna.org/blog/?p=228 http://www.silverna.org/blog/?p=228#comments Sun, 17 Jul 2011 18:22:36 +0000 月影 http://www.silverna.org/blog/?p=228 LAFE是个神马东东呢？听起来像个新鲜玩艺儿吧？
要解释这个还蛮费劲的。而我这个人又比较懒，不喜欢长篇大论。（看我前一篇文章是啥时候更新的就知道我有多懒了=.=）
为什么我不经常更新呢，一是我比较懒，二是我一般不喜欢经常码字的，特别是比较忙的时候，如果废话就会被老大发现我工作不饱和，然后说不定就有更多的活要做了……

额……
还是言归正传，谈谈LAFE吧
好吧，我们天天说模块化模块化，但是没有人真正说清楚，一般的开发过程中，如果我们要把前端设计成模块化开发，究竟应该肿么写代码才比较爽。如果只是简单把页面分成一块块的，然后把这些模块一一载入进来，拼成页面，那再简单也不过了。

但是现实没这么理想化，如果一个页面足够复杂，那么可能包含一个头部、一个底部、中间包含一个边拦，一个主栏，主栏里边可能又嵌套包含一个有头、身子、底的复杂结构，然后这种结构还能多重嵌套，这时候你就知道有多烦了。

模块化不仅仅只是拆，更烦的是拼装，如何把一个复杂页面很快速拼装出来呢，好吧，我们看看传统的方式是如何工作滴——

最初的办法是全部写在views下的模板中，例如php有include和require，smarty有include，假如一个a模板要引入b和c，那么就在a中直接写

  1. <?php include('b.php')?>
  2. <?php include('c.php')?>

这种做法当然可以，但是在页面复杂的时候不可取，理由首先是不够灵活，现在我的a页面要套b和c，但是随着需求改变，如果我要新增一个把c换成d的页面，那么得重新写一个模板，写多了很难管理。另外页面模块加载会非常散乱，假如a引入b、c，b引入d、c引入e、f，一个维护网站的开发人员，如果不熟悉这个模块，他要改的东西在e中，得从页面开始找到a，从a找到b、c，从c找到e，才能定位到模板所在，在模块非常多的情况下，这会让维护人员抓狂。另外，联调的时候让写php的工程师拼页面本来就是一件繁琐的工作，而这种简单粗暴的模块拆分方式，无疑加重了他们的麻烦，拼接页面的时候找来找去，相信会让非常多工程师受不了。

那么有没有聪明的做法？当然有，例如，可以事先把模块规划成对象，然后利用php封装，采用搭积木的方式在统一的地方进行拼接，例如——
（以下代码参考某框架，感谢曾经有幸一起共事的几位开发者，感谢某优秀前端开发团队，我以曾经是团队中一员为荣!）

  1. $page = new Page($data);               
  2.     $page->add('header',new xHeader($hd));
  3.     $page->add('search',new xBase($b3search, 'search'));
  4.     $page->add('list',new xBase($show_list, 'list'));
  5.     $page->add('pager',new xBase($pager, 'pager'));
  6.     $page->add('footer',new xFooter());
  7.         $page->extJs('piao/ext/switchcity.js');

我们会看到，这种方式下，有了页面、层和模块的概念，而这些布局、模块和内容，可以在一段php代码中build出来，易于统一管理和维护。而且这种代码方式，对php程序员来说更亲切（这样，在忙的时候，我们就更容易骗他们为我们干活），页面像搭积木一样，这多简单~

不过这也有一些不足之处，首先你必须先约定Header、Footer和其他容器的命名和相互关系，其次，你必须封装和扩展对应的类，第三，在页面比较复杂的时候，比如层嵌套的时候，这种描述也不那么直观，你很难直接看出数据与结构模块之间的关联关系。最后，它并没有想象中的那么灵活，在不额外开发的情况下，你不能随意配置和使用各种Layout结构和模块。

那么，我们有什么解决方案呢？先看下面一段代码——

  1. $layout->{'Header hd'} = $hd;
  2. $layout->{'Header search'} = $b3search;
  3. $layout->{'Body list'} = $showlist;
  4. $layout->{'Body pager'} = $pager;
  5. $layout->{'Footer footer'} = $footer;
  6. $layout->{'Footer extJs'} = $extJs;

这段代码结构简单，它把页面分成Layout容器和模块两个层级，{}之间是结构和模块的描述，模块是可以对应到views下面的module目录的文件，可以设定一个查找目录的规则，例如先找模板当前目录下的module目录，找不到，再去找views下面的module目录，这样就建立起模板管理的层级依赖关系来。=右边是赋给模板的变量，在module中可以用到。这种写法和上面一种写法的不同在于，它不用事先准备对象，所有的模块一律同样对待。它形式上只做简单直观的赋值操作，但定义了一套描述模块位置的语法。它足够灵活，不限制你构建任何模块，它只负责将这些模块找到，拼接到页面中去。它能做到足够灵活，看下面的代码：

  1. $layout->{'Header hd'} = $hd;
  2. $layout->{'Header search'} = $b3search;
  3. $layout->{'Body layer_gride_3_5.Left list'} = $showlist;
  4. $layout->{'Body layer_gride_3_5.Left pager'} = $pager;
  5. $layout->{'Body layer_gride_3_5.Right list'} = $rightside;
  6. $layout->{'Footer footer'} = $footer;
  7. $layout->{'Footer extJs'} = $extJs;

在这里，我们在模板中嵌套了另一层Layout，也就是layer_gride_3_5，它至少有Left和Right两个结构，这样我们就做到了Layout的层级嵌套。
用这套东西还能写出很多好玩的代码来，比如我可以在{}里面用变量，等等等等，还有很多可以想象的事情，这些在下一篇文章里我在详细介绍吧（=.=不过不知道下一篇啥时候更新）

最后，无码无真相，放上代码—— https://github.com/akira-cn/lafe

谢谢观赏~

]]> http://www.silverna.org/blog/?feed=rss2&p=228 [偷懒]本地web开发的一体化解决方案 http://www.silverna.org/blog/?p=223 http://www.silverna.org/blog/?p=223#comments Thu, 09 Jun 2011 09:37:55 +0000 月影 http://www.silverna.org/blog/?p=223 最近在新公司研究PHP开发的前端方案，考虑用CodeIgniter+Smarty3的方案。研究了一下nginx+PHP+CI+Smarty的配置。

感谢明城(@gracecode)同学提供的Farseer，真是个方便实用的好东东~

整合的Farseer-QWDIY，windows下解压到任意目录就可以直接使用，集成CI和Smarty3，脚本库集成QWrap，无需修改配置，直接访问
http://localhost
就可以看到欢迎界面啦~

]]> http://www.silverna.org/blog/?feed=rss2&p=223 【广告】《程序员成长的烦恼》 http://www.silverna.org/blog/?p=219 http://www.silverna.org/blog/?p=219#comments Tue, 22 Mar 2011 09:11:40 +0000 月影 http://www.silverna.org/blog/?p=219 低调滴做个广告。。。
http://book.douban.com/subject/6024321/

程序员成长的烦恼

]]> http://www.silverna.org/blog/?feed=rss2&p=219 【小技巧】QWrap核心中的几个不起眼小方法使用技巧（一） http://www.silverna.org/blog/?p=211 http://www.silverna.org/blog/?p=211#comments Wed, 16 Mar 2011 09:28:37 +0000 月影 http://www.silverna.org/blog/?p=211 http://www.qwrap.com/

1. ObjectH.dump

用ObjectH.dump 方法可以将非枚举类型的方法从原生对象中“提取”出来

  1. QW.ObjectH.mix(window, QW);
  2.  
  3. var ah = ObjectH.dump(Array, ["join","reverse","push","pop","concat","slice","splice"]); //提出Array的以上方法
  4. ah.toString = function(arr){
  5.     return arr.toString();
  6. }
  7.  
  8. var List = function(arr){
  9.     this.items = arr;
  10. }
  11.  
  12. ah = HelperH.methodize(ah, "items");
  13. ObjectH.mix(List.prototype, ah, true);
  14.  
  15. var myList = new List([1,2,3,4]);
  16. myList.push(5);
  17. alert(myList); //[1,2,3,4,5]

2.ObjectH.create

ObjectH.create方法可以利用对象的原型快速创建一个新对象，例如：

  1. function Foo(x, y){
  2.     this.x = x;
  3.     this.y = y;
  4. }
  5. var f1 = new Foo(1,2);
  6. var f2 = ObjectH.create(f1,{x:3,y:4}); //相当于 f2 = new Foo(3,4);

这个用在需要copy匿名类的对象或者多态类的设计模式里边的对象复制特别有效（例如在装饰器里，你在复制对象进行操作之前不必关心具体的装饰器类型是哪一个，因为你只要保证复制出来的那个对象的类型和原始对象的类型相同就好了，而create确实保证了这个）

3. FunctionH.bind

实际上在ECMA v5的标准里，bind除了绑定this，还有固化参数的作用的，所以它能起到的作用类似于currying

  1. function Foo(x, y){
  2.     return x+y;
  3. }
  4. var Foo5 = FunctionH.bind(Foo, null, 5);
  5. alert(Foo5(10)); //5+10

4. FunctionH.lazyApply

懒惰执行是一个不起眼的方法，但是它有时候很有用。

  1. function deal(x){
  2.     var y = 0;
  3.     for(var i = 0; i <= 10; i++){
  4.         y += Math.pow(i, x);
  5.     }
  6.     alert(y);
  7. }
  8.  
  9. FunctionH.lazyApply(deal,null,[2],0,function(){return Math.random()>0.5?1:-1;});  //只有一半的机会执行deal方法
]]> http://www.silverna.org/blog/?feed=rss2&p=211