Deploy RoR on local machine

Like deploying other website, the static file is served via nginx, and the Ruby logic will be handled via some middle-wares, here is the list:

Thin

1. Install the thin via homebrew

    gem install thin
   

2. Start the thin server. Since this is a testing deploy, I just execute thin in the project directory.

    thin start
   

   After the command executed, you can find some information printed via thin command. The default port of the server is 3000, which should be used to fill the nginx configuration file.

3. Update the configuration file for nginx. The upstream section should be put in http block.

    upstream todo_app {
        server http://127.0.0.1:3000
    }
   

   The location section should be put in server block.

    location / {
        proxy_set_header  X-Real-IP  $remote_addr;
        proxy_set_header  X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header  Host $http_host;
        proxy_redirect    off;
   
        try_files $uri $uri/index.html $uri.html @ruby;
    }
   
    location @ruby {
        proxy_pass http://todo_app
    }
   

   The proxy_pass will pass all ruby request to the upstream server. Unix socket can also be used in the upstream section.

4. Restart the nginx server, the RoR project can be shown in the web browser now.

Passenger

1. Install passenger via gem

    gem install passenger
   

2. Install passenger module for nginx

    passenger-install-nginx-module
   

   Or you can install nginx and passenger module with brew like this

    brew install nginx --with-passenger
   

   If nginx still report the error that can not find the PassengerLoggingAgent, try to use passenger package-runtime and then get the agent from package passenger-standalone/XXX/support.tar.gz

   In the http section, you should specify the value of passenger_root and passenger_ruby. Here is the configuration in my laptop:

    passenger_root /usr/local/lib/ruby/gems/1.9.1/gems/passenger-3.0.12;
    passenger_ruby /usr/local/bin/ruby;
   

   NOTICE: Make sure to set rails_env variable is set to the same stage with development, seems the default value is production. Here is my configuration section in nginx:

    passenger_root /usr/local/lib/ruby/gems/1.9.1/gems/passenger-3.0.12;
    passenger_ruby /usr/local/bin/ruby;
   
    server {
        listen       8080;
        server_name  localhost;
        root /Users/ziming/tmp/learn_rb/rails/todo_app/public;
        passenger_enabled on;
        rails_env development;
    }
   

Unicorn

1. Install unicorn via gem

    gem install unicorn
   

2. Get the sample configuration file from unicorn website

    curl -o config/unicorn.rb https://raw.github.com/defunkt/unicorn/master/examples/unicorn.conf.rb
   

   And update the working_directory, pid, stderr_path and stdout_path in the sample configuration file.
   NOTICE: Need absolute path here.

3. The left step is the same with Thin, a upstream section should be added to nginx.conf, and redirection should be added to location section.

Deploy remotely via Capistrano

Capistrano is a useful tool for deploying RoR application to remote server(s). The Capistrany package provides several tasks for simplfying the deploying jobs.

1. Prepare the RoR application

   Before deploying, we should prepare the application. Since this only show how to deploy, so we just use the generated project. I have create a repository on bitbucket, and the scm used for this application is mercurial.

   First I create the repository DailyCheckIn on butbucket, then I clone the project to local directory dailycheckin. The directory is an empty directory except some mercurial information. After directory ready, I create RoR application via rails new
   command. Before doing the initialization commit, I should create a .hgignore file based on the .gitignore (Just add syntax: glob at the first line, remove the leader slash in the path, and rename .gitignore to .hgignore). After all things done, commit the new added file and push to the server, then we have a RoR application.

2. Capify the RoR project

   The project should be ‘capified’ before deplying via Captistrano, which can be done via command capify . easily. This command will create Capfile and config/deploy.rb file in current directory. The Capfile is the wrapper, and the tasks is written in file deploy.rb

3. Configure the Capistrano

   Here are the information should be checked before deploying:

   • Application name
   • Server information
     • Application layer
     • Wer server
     • Database
   • SCM information
     • Repository location
     • SCM type
   • Directory the project should be deployed to

   Here is a sample configuration file for the project

   set :application, "DailyCheckIn"
   set :repository,  
   set :scm, :mercurial
   server , :web, :app, :db, :primary => true
   set :deploy_to, 
   set :use_sudo, false
   

   The detailed information of configuration can be found in Capistrano document.

4. Deploy the application

   Next step is deploy the application. The first step is setting up the server, Capistrano provide task cap deploy:setup to do this. This task will do a series of mkdir calls. Make sure the permission of directory.

   After setting up completed, it is recommended to check the dependencies via cap deploy:check command. Re-run this command after any change to the environment to make sure all check passed.

   The next step should be done manually, you should login to the server and make sure the database can meet the requirement configured in the config/database.yml file.

   After environment ready, task deploy:update can be used to clone the code to server. The clone operation will create a new snapshot in the releases directory, and link it with symbol link current in top level of depoly directory. Then cap deploy:start can be used to start the services.

Here is to RoR learning log (1)

According to the requirements, the length of ToDo account should less than 100 characters and the status of ToDo can only be chosen from 0 or 1, so some validator should be added to the model. With the validator, the model code should be looked like:

STATUS_OPTION = [0, 1]

class ToDo < ActiveRecord::Base
  attr_accessible :content, :status
  validates :content, :presence => true,
                      :length => { maximum: 100 }
  validates :status, :presence => true,
                     :numericality => { :only_integer => true },
                     :inclusion => { :in => STATUS_OPTION }
end

Statements started with `validates` keyword are validator. The available condition list can be checked at this page. If the value passed in break the rule, the error message will be shown in the page.

With the validators, the value saved can be guaranteed to be correct. But seems radio box or drop down box is better than the text field, so we plan to modify the template page. The template is placed under `app/views/to_dos` directory, which is a HTML file with some template control commands. By default, when viewing the URL http://[address]/index, the template with the same name, index.html.erb, will be rendered. The generated form is saved in file `_form.html.erb`, the default type of status is `number_field`, which should be updated to `select`. The document for `select` is here, according the document, the option list should be provided, and here we can use the constant `STATUS_OPTION` defined in model file. Here is the updated `status` field in the form object:

  <%= f.label :status %>
  <%= f.select :status, ToDo::STATUS_OPTION %>

The form type will change from text field to drop down menu after updating the form.

Congratulations, a simple ToDo application has been worked out. It is a very simple application, which do not contain the static files, user authentication, unit test and so on. In next step, I plan to re-write the linuxfb website with more better structure, hope can touch more features in RoR.

Build development environment

The whole process is tested on Mac OS, and I think this may have little difference with Linux.

Ruby should be installed before trying Rails. To separate with the Ruby used by system, it is recommended to use RVM (Ruby version manager) to build the local Ruby environment (seems like the virtualenv in Python). Here is the install script from RVM installing page

$ curl -L get.rvm.io | bash -s stable
$ source ~/.rvm/scripts/rvm
$ rvm requirements
$ rvm install 1.9.3

After installing, the command rvm use can be used to select the version of Ruby.

Next per-requisite is gem, which can be get from this page

Then we can use gem to install rails

gem install rails

A simple TODO list

This section will implement a todo list application, which is copied from bottle tutorial page. Here is the goal copied from that page:

At the end of this tutorial, we will have a simple, web-based ToDo list. The list contains a text (with max 100 characters) and a status (0 for closed, 1 for open) for each item. Through the web-based user interface, open items can be view and edited and new items can be added.

This log only create the default controller, and some other thing such as adding validator and modifying template will be shown in next log.

First, we have to create the directory for application. We named the application to `todo_app`, and we run this command to do the initialization:

$ rails new todo_app

After plenty of output message, we have a new directory named todo_app, and the directory structure has been initialized in it. After running `rails server` in the directory, we can access the default website via http://127.0.0.1:3000

Next step is generate database schema for this application. As mentioned above, the schema contains two fields, one is record content, the other is status of record. Rails provide a generator script to simplify the operation.

$ rails generate scaffold ToDo content:string status:integer

Then use rake command to migrate the database

$ rake db:migrate

This script will generate URL mapping, model and default view for the ToDo table. You can use http://127.0.0.1:3000/to_dos to access the new added things (You can check the config/routes.rb to find the correct mapping). There is no data currently, but there is a link to add new record, which is linked to http://127.0.0.1:3000/to_dos/new. And after record added, there will be show, edit and destroy action to each record.

The controller, view and model is saved in app directory. The file app/controllers/to_dos_controller.rb will handle the request sent from browser, the file app/models/to_do.rb is the model of ToDo record, and the files under app/views/to_dos/ will show the returned record. In this demo project, we need add some validation while adding ToDo record, and modify the list page for updating the ToDo record.

For now, there is a simple web application, can use generated view/controller/model to manager ToDo list. In the next log, this application will have a validator and new template.

General

• Ruby is free format and case sensitive.
• Besides commenting one line code with leading #, Ruby can use `=being` and `=end` to define a comment block.
• Everything in Ruby is object. Which means 1.5 means a float number but 1.times can generate a enumerator.
• Ruby use `nil` to indicate a NULL object
• Only `false` and `nil` is false. Be careful, you have to face the fact that `if 0` will do not enter else branch in Ruby, which is different with other language I have learned.
• There is no `++` and `–` in Ruby, you can work around with `+=1` and `-=1` sometimes.
• Constant name must start with capital letter, and local variable must start with lowercase letter or underscore(`_`). Program can not be executed if name do not obey this rule (hmm… Python use force indent, while Ruby use force name type).
• In Ruby, constant, class and module are all treated as constant, so must follow the constant name rule.
• Parentheses are optional while defining or calling function, so all the code following is legal:

foobar
foobar()

foobar(a, b, c)
foobar a, b, c

def foo bar
    puts bar
end

def foo(bar)
    puts bar
end

• `.to_i`, `.to_f` and `.to_s` are used to convert object to integer, float and string.
• You can insert underscore(_) in integer number to make it more readable.

Variable and method

• Global, local, instance and class variable are defined in different way
• Variable with prefix `$` means global variable
• Variable with prefix `@` means instant variable in class, like `self.var` in Python
• Variable with prefix `@@` means the class variable, like static variable in C++
• Ruby also include some built in variable:
• `$0` means the filename.
• `$:` means search path, which is a list, like the `sys.path` in Python.
• `$$` means the process id.
• Usually, a variable can be assigned default value with this syntax: `var ||= `
• Only `?`, `!` and `=` can be used as suffix to the method
• method name ends with `?` means this method will return boolean value.
• method name ends with `!` means this method will do changes on original object instead of creating new copy.
• method name ends with `=` can used to define operator.
• If no `return` at last of function, the value of last expression will be returned as return value.
• Argument of method can be defined as `*args`, which means the method can accept uncertain number of argument.
• Seems there is no `**args` in Ruby, arguments passed with `*args` will lost information of argument name. The `**args` used in Python method can accept argument with name.
• `alias` can be used to define a alias for a method/operator/global var/regular expression back-ref, but not local var/class var/constant. The object pointed by new name will NOT updated after updating old one.

String

• Ruby use `puts` to print string to screen, and `gets` to receive string from standard input.
• `puts` is used like a keyword, but actually it is a method defined in Ruby kernel
• `puts` method will invoke `to_s` method of an object
• Strings fetched with `gets` will usually be tidied by `chomp` method
• You can use `+` to connect string. Like Python, it will create a new string object, so the performance may downgrade if connecting too may string with `+`
• String defined by single quota and double quota are different. A string defined by single quota only convert `\\` to `\`, which means `’a\\n’` == `’a\n’`, and all the three character will be printed out with `puts`. While the double quota will convert all escape string, further more, it will also handle the expression interpolation `#{}`.
• There are three methods to compare string, `==`, `eql?` and `equal?`. The first two methods compare string content while the last one compares object id.
• A magic keyword `%w` can be used to build string array, like this: %w{ab cd ef gh \n} == ["ab", "cd", "ef", "gh", "\\n"].

Flow control and code block

• `if..else..end`, and the else if is written as `elsif` in Ruby. (hmm… we have `else if`, `elseif` and `elif` yet, and now we have `elsif`, seems we only need elf now).
• There is reverse if, named `unless`, help to write complex logic?
• There is `cond ? a : b` operator in Ruby.
• There is a switch-case model in Ruby, `case..when..else..end`
• Code blocks are defined in `{ }` (single line) or `do..end` (multiple line). The `{ }` has higher precedence than `do..end`.
• Code block followed by function will be executed after `yield` called in the function.
• Can pass argument to block by passing argument to `yield`.
• Method `block_given?` can be used in function to check whether this function has block followed.

Array, range and hash

• Seems there is no index error in Ruby, you will get `nil` if try to access element out of array size.
• `ARGV` means command line arguments, which is an array.
• Range can be generated via `a..b` or `a…b`, the list generated with three dots do not contain `b`.
• `.to_a` method can convert a range object to array.
• There is a `===` operator in range object, check whether the element is included in range.
• Name start with `:` is a symbol, which is unique in global.
• There is a symbol table in Ruby, which contains function, class variable (variable start with `@`) and user defined symbol. `Symbol.all_symbols` can be used to get all symbol name, w/o colon.
• Symbol can not be used as a left value. It is just a symbol, can be used as right value.
• For string comparison and hash index, a temp string will create a new object each time, which may reduce the performance.
• There is a `to_s` method for symbol, and a `to_sym` method for string.
• Save information in string if take more concern on content, and symbol for object id.
• Hash (dict in python) can use any object as key, which is different with Python.
• It is recommended to use symbol to replace the string index
• Hash can be defined via `{key: val}` or `{key => val}`. If using the first method, the `key` can not be a string, but a name obey the variable rule, and Ruby will convert it to symbol. That is: {a: 2} == {:a => 2}

File

• Usual way for using File: `File.open() do |f| .. end`
• Can define file encoding and internal encoding in the open command, which is better than built-in `open` of Python
• `Find.find()` will traverse the directory, include sub directory.
• `File.new()` can open a random access file, which can response to `.seek` method.

Regular expression

• Pattern enclosed by slash is an regular expression object, `/foobar/`
• Both string and regular expression has match method. RE use `match` while string use `=~`.
• `.match` in RE will return `MatchData` object of matched, or `nil` for not found.
• `=~` in string will return index if found, or `nil` for not found.

Class

• class is a first-class object in Ruby, which is an object of Class.
• As mentioned before, the class name must has first character uppercased.
• Create a new object with `ClassName.new`, which will invoke `allocate` method to allocate space and `initalize` method for initialization.
• Variable with prefix `@` is class variable, which can be used in the whole object, seems like the `self.` variable in Python, but in Ruby, name with `self.` must function, then, the first character must be uppercased.
• `methods` method can be used to printed out all methods in class, like the `dir` in Python.
• `responsed_to?` method can be used to check whether the method exists in the object. If not, Ruby first will check whether there is `method_mission` method first, and then throw exception of not found.
• Every class in Ruby is open, which means you can update any class, include built-in class like string, at anytime. But make sure you will not bring the conflict into exist class.
• A more safer way is define a sub-class, and override the needed method.
• In Ruby, one class can only be inherit from a single class. However, module can be used as multi inherit, seems like the interface in Java.
• If calling `super` in one class, the method in parent class will be executed, but different syntax can cause different result:
• Calling `super` with no parentheses, then the argument in sub method will be passed to parent method.
• Calling `super` with empty parentheses, then the default value of parent method will be used, and error will be reported if no default value defined.
• Calling `super` with value, then pass this value to parent method.
• Abstract class, seems more like syntax sugar. Calling undefined method in parent class, and implement the method in subclass.
• The default access rule for method in class is public, can add protect/private before def if needed.
• Those access type can be only applied to method, the instance/class variable is private by default.

Proc

• Like lambda in Python, but named Proc in Ruby.
• Each code block created by `lambda` is a object of `Proc` class, which can be executed by calling `.call` method.
• Here is a example for lambda with argument: `lambda {|x| “Hello #{x}”}`.call “Hell”`

Load and require

• `load` and `require` are methods defined in `Object`, but more like a keyword during usage.
• File included by `load` will be loaded every time program executed, while `require` only once.
• Pass filename w/o suffix to `require`, and `require` will find the file in the path. If the suffix is rb, then imported as source file. For library suffix, like .so, .dll, `require` will import them as Ruby extension.
• `require` will return `true` or `false` after execution complete.

Exception

• A special class, user can throw it via `raise`.
• Default exception type is `RuntimeError`, but can be changed by passing class name to `raise`
• Use `rescue` to handle the exception.

无锡

30号晚上就冲上了去无锡的动车，本来买的坐票，上车后惊喜的发现是软卧改的座，然后更惊喜的是旁边那俩是一对，最后的结果就是两张铺三个人好好的睡了一觉。除了没有床单被套枕巾，和普通的软卧没啥区别。早上打着哈欠推开包厢门，看到走道边坐着的昏昏欲睡的人们，心里暗道好运气~

再一次站在无锡的火车站，与上次不同的是这次是在老站，也就是南广场下的车，不需要走那条坑爹的地道-过马路-地道线路（不过后来去上海的时候发现地道已经修通了，所以只需要抱怨地道长就好了，不用抱怨过马路了）。去无锡就是冲着小笼和馄饨的（当然明面上的主要任务是去慰问新进升级为娃他爹的某朋友），本想继续去出崇安寺上次吃的那一家王兴记，结果对着手机地图才发现想去的熙盛源是另有其地（上次去的时候还没有新手机，这次去的时候新手机已经被偷了，~~~>.<~~~）。作为一只吃货，我决定去那家没吃到的店。

顺着路走了好久，中间问了N个人路，但是悲催的是最多的一个听懂了一半，印象中上次来听他们说话没那么难懂的啊。路过赫赫有名的三凤桥老店（里面熟食部的人是里三层外三层，参考逢年过节的稻香村吧，而另一半卖真空包装的就没人，欺负外地人啊~），就给它家的招牌按了一张，嗯。话说，圈啊，你念念不忘的排骨就它家的哈~

顺路继续再走个十来分钟就到了目的地，坐下要了个荠菜馄饨还有个小笼就开吃。当时也没想着拿相机出来拍，就随手用手机摁了一张，意思意思吧，嘿嘿~

无锡的，差不多就这些了吧，这次纯路过，也没怎么玩，除了吃就是去朋友家坐着了，还玩了一下午的Wii。好吧，我承认我很无聊，娃他爹不知道……

魔都

1号下午的动车去魔都，40分钟左右就已经站在虹桥火车站的地面上了，长三角的动车真方便……去酒店住下收拾好的时候天已经黑了，想了想还是决定去被本地人鄙视的南京路外滩放放风，谁让咱是硬盘人呢~

嗯，我承认我十分的没创意，所以直接去的是第一食品，为小杨生煎啊。南京路上的人不比上次厦门中山路上的人少，还好没像上次那样碰到一堆售完的店。小杨生煎在第一食品二楼，里面还有好几家别的店，在入口处统一付钱。当时要了小杨生煎和它家的贡丸粉丝吧，一份别家的煎饺，还有一份第三家的老鸭粉丝汤。说实在的，味道一般，就算是生煎也没有什么太出彩的地方，好像还没有印象中小时候外婆家旁边早点摊上1块钱7个的生煎好吃，而且有意思的是，它家的生煎前的是有褶子的那一面，不知道是不是就是这样，反正就小奇怪就是啦。点的其它的东西完全没可以说道的地方，只上图不说话~

在第一食品楼下还找到了别人推荐的凯司令，买了它家的粟子蛋糕，细细的粟子馅上铺一层奶油，很香，也很好吃。

吃完就晃去了江边，天冷的缘故吧，江边没有太多的，于是很从容的找到了个桥桩子摆上相机，拍下了本次唯为数不多除了吃的东西以外的照片（其实总共就俩……）

第二天中午和猫总俩口子吃的鹭鹭，本帮菜，发现有些地方和家里面的菜还是有些相似的，嗯。

第三天因为有事没走成，所以抓住最后一个晚上摸去了七叶和茶，号称是从隔壁某个岛上开过来的抹茶店。店里面的装修有种素雅的感觉，点的东西上来后有一股茶的清香，相比之前吃的抹茶，茶味和苦位更重一些吧。出门的时候没背相机，所以只好放几张打包的泡芙和提拉米苏照片上来了。

先放盒子，三个小小的盒子，看着很好看。拍照片的时候想玩焦外，可惜套头的焦外实在是……凑合看吧，LOL。

然后是提拉米苏，上面是一层很香的抹茶粉，然后下面的奶油中嵌着一块块的抹茶蛋糕。不过话说，我还是比较喜欢吃饼干做的那种，这个，有点腻……

然后是泡芙。买了俩，一个抹茶，一个焙茶。颜色上一个绿一个黑，口感上也是一个轻一个重，不过，都好香的……话说，今天整理照片的时候才发现把抹茶的那一只拍的和隔壁岛国的天狗一样，当时咋没发现呢……

最后，4号下午高铁回帝都，一路上没碰上雷雨停车追尾躲猫猫等事故，所以也就没啥写的了，丢张虹桥的照片吧~

PS：时间仓促，加上晚上太冷，所以，银行街啊，南京路啊，外滩啥的照片，等下次吧，上海帮还有好多人没见着呢。作为一个硬盘人，表示对上海帮众的不屑表示没看见，嗯。
PS2：在老城区里面乱转的时候，满喜欢那些两三层的房子的感觉的，不知道那边晚上会不会像天津那些风情区一样也有景观灯。
PSP：这次带了个小的八爪鱼架子去，没背大架子，结果发现，偷懒是不行滴，小架子是不靠谱滴……
PS3：上海的地铁感觉比北京方便，4号上午上班点出门也没感觉太挤，不过，票价啊，贵啊，更郁闷的是到了虹桥准备滚蛋的时候才发现原来可以有一日票卖，冤大头啊~
PSV：上海的路，咋都那么长呢，第一天下地铁去住的地方，上来先看到的门牌号就是22XX，那叫一个汗啊。本来以为是个例，咨询了上海帮众后发现是正常情况，唔，好吧，硬盘人啊硬盘人~

脚本的原理就是检查一个working directory中所有文件的status，然后把输出的内容去重。脚本运行需要设置好CVSROOT环境变量，而且需要提供一个CVS的工作目录作为参数。

#!/usr/bin/python

import re
import os
import sys
import subprocess as sp

def get_all_tags(cvs_wdir):
    is_tag_line = False
    cvs_cmd = 'cvs -Q status -R -v'
    cvs_tag_pattern = re.compile(r'(\w+)\s+')
    tmp_tags = []

    os.chdir(cvs_wdir)
    cmd_pipe = sp.Popen(cvs_cmd, shell=True, stdout=sp.PIPE)

    for line in cmd_pipe.stdout.readlines():
        if 'Existing Tags' in line:
            is_tag_line = True
            continue

        if not is_tag_line:
            continue

        if '============' in line and is_tag_line == True:
            is_tag_line = 0
            continue

        line = line.strip()
        if line != '':
            try:
                tag = cvs_tag_pattern.findall(line.strip())[0]
            except IndexError:
                print line
                raise
            tmp_tags.append(tag)

    return set(tmp_tags)

if __name__ == '__main__':
    print '\n'.join(sorted(get_all_tags(sys.argv[1])))

话说，有人能提供更好的办法吗？然后，有人可以告诉我，这个东西取出来的东西是全部的tag吗？没用过CVS……

下面是Life Game，wiki链接在此。这是一个零玩家游戏，其实它就是一个简单的状态机。在一个点阵中，每个点都有0, 1两种状态，分别表示这个点的死与生。某个点的下一步的状态由它周围的8个点决定。周围的点数过多或者过少都会造成此点的死亡（生命是多么的不容易啊~）。规则很简单，只有4条，但是由这4条规则可以演化出许多好玩的东西，据说如果时间够长的话，可以看到从混沌到有序这一神奇的过程，唔，我是还没看到大规模有序的出现，以后再说吧~

至于算法…..就是拿JS写了个最简单的，把所有状态存放在一个二维数组中，每一步去遍历这个数组，然后根据周边点的状态决定被遍历点下一步该是生还是灭。很暴力的直接循环了，三年前的小破本T61还是能跑的起来的，嗯~

目前程序的初始状态是随机生成5e4个点放在Canvas中，以后如果有空的话，会考虑从本地文件中载入点的座标以及存储点到本地文件中，可以以后接着算，据说HTML5有对本地存储据做支持，就当继续学吧。

网页的地址在 http://www.hzmangel.info/html5/life/life.html ，start开始跑，stop停止，每刷新一次会重新生成一堆随机点。size表示点的边长，最小值是2吧，其实算是在程序里面hard code的了，下面那个speed是每一步的时间，如果有更改记得改完后点update。程序是用HTML5(Canvas+FormWidget)+CSS3(圆角框)+WebFonts(G家的服务)弄的，所以请自行选择靠谱的浏览器和网络环境~

首先是上次版聚的片子，做的一般，凑合看吧，呵呵。有些片子里面列出来的东西就不细说了，主要说的可能还是版聚完后查的AIO相关的一些东西。

讲到异步IO这块的时候讨论比较激烈，主要就是在异步IO和非阻塞IO之间的区别。课后做了些功课，于是有了下面这些玩意，如有走过路过发现不对的，敬请指正，在此先行谢过，呵呵。

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

ASYNC/SYNC 和 Blocking/Non-Blocking其实可以说是不相干的两个东西，但是由于使用的时候会有特定的组合，所以有时也就混为一谈了。分别在Internet和大中华局域网转了转，找到两篇文章[1][3]，比着上次的幻灯小总结一下吧。

先从 Dai Jun 后来临时找的幻灯说起，那个片子把IO的时间分成了两个阶段，第一阶段是从应用程序发起请求开始到数据准备完毕结束，第二阶段是把数据从内核态拷贝到用户态。对于应用程序而言，当第二阶段结束后，就表示数据可以使用了，也就是这次IO操作完成。

首先说Blocking/Non-Blocking，阻塞和非阻塞的区别其实很简单，就是应用程序在等待数据的过程中，是否可以做其它的事情。例如最简单的SYN Blocking操作，程序调了个read()就后就把自己拍晕然后等着被返回的数据砸醒，晕了程序当然不能干活，所以它就是阻塞的。在文章[1]中，有几个很形象的示意图，可以很方便的看出区别。

再说说ASYN/SYN。同步和异步，主要描述的是消息通知的机制([3])，同步是指内核在处理完请求后，不会告诉程序数据已经准备好了，而需要程序自己去检查；而异步的情况下，请求处理完成后内核会发给程序一个通知。所以，对于悲催的Non-Blocking SYN的模式，程序需要一遍又一遍的去检查数据是不是好了，效率可能还没有Blocking SYN的高。而IO复用，即select()/epoll()的方案，虽然也有阻塞，但是终归它是由系统告知某个fd可用的，所以是异步的IO。至于AIO，把等待数据这个过程也省去了，直接发完请求该干嘛干嘛，等着被叫号就好了。

所以那天片子里面说的AIO，应该就是指Non-Blocking ASYN的情况，此文中下面写的AIO，都是指这种情况，即非阻塞异步IO。

说完了区别，再来给AIO补一点东西。

在Linux中，AIO有两种接口，一种是glibc提供的POSIX异步IO接口，即aio_*函数系；另一种是Linux的原生异步IO接口，是由libaio提供的。POSIX AIO是在用户空间通过线程+阻塞模拟并发操作来实现的，所以性能上没有太多出彩的地方，但是libaio是原生的AIO实现，性能上会好很多[2][4]。这个库好像最早是Oracle弄出来的，在Oracle/DB2中有应用。它使用不同于read()/write()的一套接口，具体的程序我也没看，不过应该是可以用在网络环境中的。

至于为什么现在还是用epoll撑起大半边天，可能是因为还没有到需要大规模考虑C1000K问题的时候吧，还有就是AIO的编程模型和传统模型的差别不是一点半点，基本上整个架构都需要推倒重来，相比于这个带来的风险，还是直接加服务器比较保险。不过TB已经有童鞋在折腾这些东西了，在slideshare上找到一个片子，有兴趣的可以去围观一下：

http://www.slideshare.net/mryufeng/c1000k 。话说，这个是不是丢给 Bergwolf 就好？

差不多就这些了，不知道有没有理解错的地方。最后是参考文献

[1] Boost application performance using asynchronous I/O, M. Tim Jones, http://www.ibm.com/developerworks/linux/library/l-async/

[2] Linux Asynchronous I/O Design: Evolution & Challenge, Suparna Bhattacharya, http://www.kernel.org/pub/linux/kernel/people/suparna/aio-linux.pdf

[3] 同步/异步与阻塞/非阻塞的区别, http://www.cppblog.com/converse/archive/2009/05/13/82879.html

[4] High Performance Solid State Storage Under Linux, Eric Seppanen, Matthew T. O’Keefe, David J. Lilja, http://storageconference.org/2010/Papers/MSST/Seppanen.pdf

金莲

这次出门转一圈最大的收获可能就是看到金莲了吧。这几年一直怨念没有时间去小五看金莲，这次算是看了个够。尤其是第三天在乌兰布统，绵延到远处山脚下的草原上，灿烂的金莲像满天星斗一样点缀期其中。可能没有小五那么好看，但是也已经心满意足鸟~

晚霞

第一天下了两场雨，所以天上的云格外的多。晚饭后照例拿起相机出门乱逛，不经意间就发现了天边的一抹红云，于是不顾旁边狂吠不止的大黄狗，开始一阵狂拍。前后也就十分钟的时间，当我喂饱了相机卡开始慢悠悠的往回走的时候，才看到匆匆赶来的同事们，唔，好像他们就没拍到啥了~

日出

虽然之前去内蒙和泰山已经看过了日出，但是还是没有禁的住他们的撺掇，决定了再去看一次日出。虽然周六喝了点酒，依然在周日清晨3点半把自己给从床上拽了起来。和他们坐上包的小面，开到某个土坡脚下开始爬山。绕过一丛又一丛树，终于在东方微亮的时候找到了个视野开阔的地方。支上架子摆好相机，在等待日出的同时和头上大群的蚊子做着不屈不挠的斗争……

遗珠

还有些片子不好归类，就都丢这吧~

吐槽

照片发放完毕，下面进入本文最后一个环节：吐槽~~~

• 食：这次是我吃过的最难吃的农家饭，没有之一。先不说味道，以前吃的饭好歹能有一个硬点的菜，这次到好，除了那个烤全羊（这个后面专门吐槽），就没见到过能当作肉块的东西。那家的豆腐和南瓜味道倒是不错，不过我估计是个农家乐都能做出来这玩意，而且还比TA家的好吃。
• 住：住过的最没有性价比的农家，同样没有之一。据说100一间一晚的标间，窗户直接通到院子还锁不上，屋里没有空调（第二天听到隔壁有一家几口晚上睡觉被冻的嗞哇乱叫在那和老板掐），热水器基本没出来过热水，水龙头的水是用来滴水穿石的。嗯，住的地方叫金塞山庄，好像还是跟车导游家老姨开的，可以直接拉黑了（后面还要拉黑一个），嗯。
• 黑：那边真TMD的黑啊：
  草地摩托100一小时，想去年去丰宁的时候也就40。CPI再涨也不带这么玩的。
  第一天晚上在外面找了家店吃烤全羊，店里面（还不是超市）18一瓶的酒能卖到70。
  住的地方给的烤全羊居然TMD是挂炉烤的，一点烟火味都没有，真不如白煮，羊杂做汤还要单独收钱。上烤全羊那天晚上先上一堆米饭馒头
  晚上说有篝火，随便拿了十来根树枝往竖的铁棍子上一靠，浇点汽油，那火是大，不到20分钟就点的连火都烤不成了。
  第三天早上包的小面看日出，给带到的地方烂不说，还开口要350，那点路在北京顶多60出头。
  景点骑马50一小时还是人牵着遛的，关键是那人还是走着牵着马，这哪是骑马啊，是明明是遛人有木有。
  跟车的那个导游啥事不干就会跟着车跑，然后到地方说一声到哪了留多少时间就不见影子了，最多会介绍一下这边哪家店是他哪个亲戚开的，然后后面此地无银的加上一句不鼓励大家乱购物哈….
• 景：最想吐槽的就是这个，去之前听人说的天花乱坠地涌金莲说那有多么好看，号称风景最美的坝上，结果到了那边大失所望。这TM哪是草原啊，之前去丰宁那次我还以为我没看到那边所谓的京北第一草原，结果到了这号称风景最好的坝上才发现，坝上和草原放一起说的时候，人们省略了两个定语和一个连词，其实它的全称是河北的坝上和内蒙的草原……最不能忍的是那边晚上居然看不见星星，本来带着架子是想去拍银河的，结果连找个北斗都要维持45度仰望天空的姿势10秒以上才能看见，帝都大风天的晚上看到的星星也比这多啊。还有那些神马还珠格格康熙王朝外景地，到了那边直接吐槽无力了。

差不多就这些了吧，该说的都说了，反正归到最后一句话就是如果没去过草原千万不要把第一次给坝上啊。以后想骑马骑摩托的直接去丰宁，离北京也近。想看景色的再多跑点至少去锡盟吧，300多公里都开出来了也不再多这100来公里，况且到赤峰还有火车，当然呼伦贝尔或青海或西藏会更好。对于我来说，估计以后会把坝上直接拉黑了吧（第二个被拉黑的登场），因为相比于骑马，我还是更愿意看风景吧，而坝上的风景，唔，吐槽无力了~~

$ python setup.py install --record foo.txt
$ cat foo.txt | xargs rm -f

没找到怎么让它输出到stdout，只好用临时文件弄了。