而今迈步从头越 - Home

自己移植了一个比较喜欢的wordpress主题用用

2009-01-02T18:36:00Z

一直垂涎于Wordpress有很多好看的theme可以用，mephisto这两年的更新与发展也太慢了，看来rails的blog系统，相对于PHP来说还真的有一些小众的感觉。

等着别人port我看基本是没戏，自己动手吧，虽然不难，但是有一点啰嗦，加上我的CSS知识也很一般，好在做port这种事其实与CSS基本无关，对于mephisto来说，其实要了解的主要是liquid与mephisto自己的一点变量而已。

截了以前的样子，留个记录吧

新年新气象

2009-01-01T13:27:00Z

2008年混杂着奥运的狂喜与自然灾害及金融危机呼啸而过，时间真的是过的越来越快，果然是：”我觉察他去的匆匆了，伸出手遮挽时，他又从遮挽着的手边过去“。

此去经年是我最爱在元旦时留下的标题，而今又是“流光容易把人抛，红了樱桃，绿了芭蕉“了、、、然掩而叹息亦不能改变我又老去了一岁，在过去的一年中我又一事无成的事实。

看来历史总是重复的基本上也是对的吧，不过人总会不满足于现状，在回首看看逝去的一年，心中不由的生出的恐惧与懊恼，追悔不及自然是有的，但是后悔是不能解决问题的，真的问题是需要解决问题，让自己成长，能在自己曾经的时光废墟中立起来，也算是新年新气象吧。

特此立酸文志之，只需要在明年的元旦再看时不再心中有悔，此愿足矣！

太酷的广告了

2008-11-19T16:08:00Z

从Textmate到Emacs

2008-11-10T15:48:00Z

虽然Textmate一直是俺的最爱，但是出了ruby及os x之外，使用Textmate有时成了一种奢望，就说rubinius吧，这个*nix only的项目，现在也没有办法在cgywin上编译通过，在我打过多处补丁之后，发现这几乎对我来说是一项不可能完成的任务。不太懂*nix下的线程与信号的说，这个以后俺再补补，争取出个windows上原生线程的port。

为了在*nix（ubuntu与mac os x)下读读它，并跟踪一下它的运行，我只好祭出emacs了，好在它可以整合emacs code browser及cscope，而且还能同时使用图形化的gdb界面。看来Ｃ++还是用emacs好了。

其实我也一直很叶公好龙滴，虽然早就耳闻emacs的好，但是在ubuntu下俺就用gedit来偷懒，dreamhost上用不太熟的vi来混混，windows上还是主要依赖于VS、notepad++，有时也拿intype来找一下textmate的感觉。

最近又因为公司里不许安装Ｄ版，而且VS公司又不肯买，在这点的Jole测试上公司应该是零分的:( 还说是因为印度那边用VC++ Express一直都很好，而且因为金融危机的问题，公司不肯再在软件上投入更多的预算，真是服了公司的目光短浅及印度人的忍耐力、、、、

不过我是被Visual Assist X给宠坏了，不让我使用alt+o, alt+shift+s, alt+shift+o我是没有办法习惯了,而且我曾经花美金买到绝版的ref++及现在refactor!等等的插件都再也办法用了:( 不能装插件的vc express是一个让我无法适应的IDE。

好在emacs还有一个windows的版本，在配完cedet之后，与VAX相同的功能也都回来了，只是emacs下的重构功能我还没有试过，而且那个是要收费滴

经过了几天与emacs的搏斗之后，才发现emacs的难学只是听起来吓人的，慢慢的，还不等你记住，你的手指也开始记住了它的习惯了。而且使用它与*nix下的工具合作起来真的是很爽的，而且这样你在三个平台之下都有了一个统一的IDE感觉真的很爽，不过不知为什么，我居然没有想过用eclipse与netbean呢？我也不知道，可能我天生爱受虐，或者喜欢虐键盘，总对用quicksilver与launchy调出一个emacs疯狂打上一些古怪组合键感觉良好。不知你是否有同好？呵呵

Rubinius与LLVM

2008-10-05T07:25:00Z

一直对Rubinius所宣称的“Ruby In Ruby”很以为然，而且龙书中之也提到一个语言成熟的标志之一就是能“自举”--即使用自已来实现自己。以此为标准，Fortran、Basic、Javascript、Perl、PHP之类应该都算是不举，而LISP、C/C++、Smalltalk早就是很举的，Python、Java与Ruby现在是半举，并在让自己摆脱ED的印象之中，而Rubinius自然是Rubyist的春药罗

这两天读到Simple VM JIT with LLVM 觉得很是有趣，不过奇怪的是居然这个网站也被盾了，如果你从来没有tor过，或者gladder过，建议你赶紧找一个翻过墙去看看。不过顺便也谈谈我的读后感吧，算是学习笔记了。

Rubinius与YARV一样是一个虚拟机(VM)，它如同Python一样，先将源代码编译成Bytecode文件，在执行时优先执行Bytecode。这样能提高ruby的执行效率。说到VM自然不能不说它的bc了，一个VM无非就是拿一些bc来执行了事而已，其实PC也是这样的，只是一个实一个虚而已。

Evan为了举例说明，首先杜撰了一个足够tiny的VM：

只操作整数
被编号的寄存器
只有三条指令
1. 0 - set(reg, val)　将第reg号寄存器设为整数值val
2. 1 - add(result, reg, val) 将第reg寄存器与val相加，并将结果放入result寄存器
3. 2 - show(reg) 将寄存器reg中的内容打印出来

因此下面这字节

  [ 0, 0, 3,
    1, 0, 0, 4,
    2, 0 ]

就表明将3与4相加并打印出来这样一个简单的功能，结果嘛如果不出意思自然是7

用C实现这个VM最平铺直叙的方法就是直接写就好了，如下

void add(int* ops, int* registers) {
  registers[ops[1]] = registers[ops[2]] + ops[3];
}

void set(int* ops, int* registers) {
  registers[ops[1]] = ops[2];
}

void show(int* ops, int* registers) {
  printf("=> %d\n", registers[ops[1]]);
}

void run(int* ops, int* registers) {
  switch(*ops) {
  case 0:
	set(ops, registers);
	ops += 3;
    break;
  case 1:
	add(ops, registers);
	ops += 4;
    break;
  case 2:
	show(ops, registers);
    return;
  }
}

随后Evan还另给出一个去除switch的直接的不能再直接的版本：

void my_program() {
  int registers[2] = {0, 0};
  int program[10] = [ 0, 0, 3,
                      1, 0, 0, 4,
                      2, 0 ]

  int* ops = (int*)program;

  set(ops, registers);
  ops += 3;
  add(ops, registers);
  ops += 4;
  show(ops, registers);
  ops += 2;
}

其实两者的功能是一样的，唯一的区别是前者更通用一点，可以在运行时执行，而后者比较象使用Bytecode直接翻译过来的样子。

而且的确是这样，处理这样将Bytecode执行的一种最最静态的方法，就是写一个bc的C代码生成器(C code emitter)，将bc一次解析并产生一个类似第二段代码后几句的c代码文件，然后编译执行即可。

不过这种方法最大的缺点就是太静态了，所以的东西已经在编译时就定了，这当然不是Rubinius可以使用的方式，至于如第一段代码那样，一个更动态一点的方法，就是写一个解释器，在运行时解析代码并动态执行。其实这就有点类似YARV的方式。
除此之外有没有别的什么方法还执行bc呢？自然是有的，而且早就有很多人使用过了，那就是JIT(Just-in-time compilation)嘛:　JIT是一个不那么纯编译也不那么纯解释的方法，bc在被执行前，先被转成目标机器上的原生指令，然后再执行，因为这一过程是即时的生成的，因此可以在其中增加一个优化的环节。而且因为代码是即时生成的，因此它可以对生成的代码做一些caching，所以它要比一句一句“忠实”执行的解释器快，而且因为JIT能获得更多的运行时信息，如CPU的架构及代码执行统计信息，因此能够生成一些CPU“特化”的代码及运行时的优化工作，所以JIT也是很有可能比静态编译要快的。

其实说了这么多也不过是为了引入今天所要谈的主角-----LLVM: LLVM并不是一个编译器，而仅仅只是一个编译器的基础设施(infrastructure)，这个比较绕，其实它最有趣是提供了一套语言无关的中间层的优化与分析工具集。晕，其实这样说依然很绕:( 不过如果看一看Evan的例子之后可能会明白一些

首先就算是JIT也是需要将Bytecode的语义，即set/add/show指令提供给LLVM滴，先将这三个函数放入一个ops.c文件中，再用到llvm-gcc工具了，它利用gcc的前端，将C代码转换成LLVM的bc文件

命令如下

llvm-gcc -emit-llvm -O3 -c ops.c

这会生成一个ops.o的bc文件

使用llvm-dis < ops.o　命令查看，会看到与bc文件相对应的LLVM汇编指令

@.str = internal constant [7 x i8] c"=> %dA0"		;  [#uses=1]

define void @add(i32* %ops, i32* %registers) nounwind  {
entry:
	%tmp1 = getelementptr i32* %ops, i32 1		;  [#uses=1]
	%tmp2 = load i32* %tmp1, align 4		;  [#uses=1]
	%tmp4 = getelementptr i32* %ops, i32 2		;  [#uses=1]
	%tmp5 = load i32* %tmp4, align 4		;  [#uses=1]
	%tmp7 = getelementptr i32* %registers, i32 %tmp5		;  [#uses=1]
	%tmp8 = load i32* %tmp7, align 4		;  [#uses=1]
	%tmp10 = getelementptr i32* %ops, i32 3		;  [#uses=1]
	%tmp11 = load i32* %tmp10, align 4		;  [#uses=1]
	%tmp12 = add i32 %tmp11, %tmp8		;  [#uses=1]
	%tmp14 = getelementptr i32* %registers, i32 %tmp2		;  [#uses=1]
	store i32 %tmp12, i32* %tmp14, align 4
	ret void
}

define void @set(i32* %ops, i32* %registers) nounwind  {
entry:
	%tmp1 = getelementptr i32* %ops, i32 1		;  [#uses=1]
	%tmp2 = load i32* %tmp1, align 4		;  [#uses=1]
	%tmp4 = getelementptr i32* %ops, i32 2		;  [#uses=1]
	%tmp5 = load i32* %tmp4, align 4		;  [#uses=1]
	%tmp7 = getelementptr i32* %registers, i32 %tmp2		;  [#uses=1]
	store i32 %tmp5, i32* %tmp7, align 4
	ret void
}

declare i32 @printf(i8*, ...) nounwind 

define void @show(i32* %ops, i32* %registers) nounwind  {
entry:
	%tmp1 = getelementptr i32* %ops, i32 1		;  [#uses=1]
	%tmp2 = load i32* %tmp1, align 4		;  [#uses=1]
	%tmp4 = getelementptr i32* %registers, i32 %tmp2		;  [#uses=1]
	%tmp5 = load i32* %tmp4, align 4		;  [#uses=1]
	%tmp7 = tail call i32 (i8*, ...)* @printf( i8* getelementptr ([7 x i8]* @.str, i32 0, i32 0), i32 %tmp5 ) nounwind 		;  [#uses=0]
	ret void
}

无它，这个ops.o主要是拿来给LLVM使用的，在运行时生成相应的语义调用

然后使用LLVM的C++ API来生成一段与第二段代码相应的LLVM代码

Function* create(Module** out) {
  std::string error;
  Module* jit;

  // Load in the bitcode file containing the functions for each
  // bytecode operation.
  if(MemoryBuffer* buffer = MemoryBuffer::getFile("ops.o", &error)) {
    jit = ParseBitcodeFile(buffer, &error);
    delete buffer;
  }

  // Pull out references to them.
  Function* set =  jit->getFunction(std::string("set"));
  Function* add =  jit->getFunction(std::string("add"));
  Function* show = jit->getFunction(std::string("show"));

  // Now, begin building our new function, which calls the
  // above functions.
  Function* body = cast<Function>(jit->getOrInsertFunction("body",
        Type::VoidTy,
        PointerType::getUnqual(Type::Int32Ty),
        PointerType::getUnqual(Type::Int32Ty), (Type*)0));

  // Our function will be passed the ops pointer and the
  // registers pointer, just like before.
  Function::arg_iterator args = body->arg_begin();
  Value* ops = args++;
  ops->setName("ops");
  Value* registers = args++;
  registers->setName("registers");

  BasicBlock *bb = BasicBlock::Create("entry", body);

  // Set up our arguments to be passed to set.
  std::vector<Value*> params;
  params.push_back(ops);
  params.push_back(registers);

  // Call out to set, passing ops and registers down
  CallInst* call = CallInst::Create(set, params.begin(), params.end(), "", bb);
  ConstantInt* const_3 = ConstantInt::get(APInt(32,  "3", 10));
  ConstantInt* const_4 = ConstantInt::get(APInt(32,  "4", 10));

  // add 3 to the ops pointer.
  GetElementPtrInst* ptr1 = GetElementPtrInst::Create(ops, const_3, "tmp3", bb);

  // Setup and call add, notice we pass down the updated ops pointer
  // rather than the original, so that we've moved down.
  std::vector<Value*> params2;
  params2.push_back(ptr1);
  params2.push_back(registers);
  CallInst* call2 = CallInst::Create(add, params2.begin(), params2.end(), "", bb);

  // Push the ops pointer down another 4.
  GetElementPtrInst* ptr2 = GetElementPtrInst::Create(ops, const_4, "tmp3", bb);

  // Setup and call show.
  std::vector<Value*> params3;
  params3.push_back(ptr2);
  params3.push_back(registers);
  CallInst* call3 = CallInst::Create(show, params3.begin(), params3.end(), "", bb);

  // And we're done!
  ReturnInst::Create(bb);

  *out = jit;
  return body;
}

然后调用之

int main() {
  // The registers.
  int registers[2] = {0, 0};

  // Our program.
  int program[20] = {0, 0, 3,
                     1, 0, 0, 4,
                     2, 0};

  int* ops = (int*)program;

  // Create our function and give us the Module and Function back.
  Module* jit;
  Function* func = create(&jit);

  // Add in optimizations. These were taken from a list that 'opt', LLVMs optimization tool, uses.
  PassManager p;

  /* Comment out optimize
  p.add(new TargetData(jit));
  p.add(createVerifierPass());
  p.add(createLowerSetJmpPass());
  p.add(createRaiseAllocationsPass());
  p.add(createCFGSimplificationPass());
  p.add(createPromoteMemoryToRegisterPass());
  p.add(createGlobalOptimizerPass());
  p.add(createGlobalDCEPass());
  p.add(createFunctionInliningPass());
  */

  // Run these optimizations on our Module
  p.run(*jit);

  // Setup for JIT
  ExistingModuleProvider* mp = new ExistingModuleProvider(jit);
  ExecutionEngine* engine = ExecutionEngine::create(mp);

  // Show us what we've created!
  std::cout << "Created
" << *jit;

  // Have our function JIT'd into machine code and return. We cast it to a particular C function pointer signature so we can call in nicely.
  void (*fp)(int*, int*) = (void (*)(int*, int*))engine->getPointerToFunction(func);

  // Call what we've created!
  fp(ops, registers);
}

最后的结果会是这样

<snip same LLVM as before>

define void @body(i32* %ops, i32* %registers) {
entry:
call void @set( i32* %ops, i32* %registers )
%tmp3 = getelementptr i32* %ops, i32 3 ;  [#uses=1]
call void @add( i32* %tmp3, i32* %registers )
%tmp31 = getelementptr i32* %ops, i32 4 ;  [#uses=1]
call void @show( i32* %tmp31, i32* %registers )
ret void
}
=> 7

bc被执行了，不是吗？而且上面的那个boby就如同是my_program最后几行代码最直白的翻译，不同这处只是它是用API来产生的而已。

不过等等，最有趣的在后面，如果将LLVM的优化功能全部打开了之后，我们能得到什么？

define void @body(i32* %ops, i32* %registers) {
entry:
	%tmp1.i = getelementptr i32* %ops, i32 1		;  [#uses=1]
	%tmp2.i = load i32* %tmp1.i, align 4		;  [#uses=1]
	%tmp4.i = getelementptr i32* %ops, i32 2		;  [#uses=1]
	%tmp5.i = load i32* %tmp4.i, align 4		;  [#uses=1]
	%tmp7.i = getelementptr i32* %registers, i32 %tmp2.i		;  [#uses=1]
	store i32 %tmp5.i, i32* %tmp7.i, align 4
	%tmp3 = getelementptr i32* %ops, i32 3		;  [#uses=3]
	%tmp1.i7 = getelementptr i32* %tmp3, i32 1		;  [#uses=1]
	%tmp2.i8 = load i32* %tmp1.i7, align 4		;  [#uses=1]
	%tmp4.i9 = getelementptr i32* %tmp3, i32 2		;  [#uses=1]
	%tmp5.i10 = load i32* %tmp4.i9, align 4		;  [#uses=1]
	%tmp7.i11 = getelementptr i32* %registers, i32 %tmp5.i10		;  [#uses=1]
	%tmp8.i = load i32* %tmp7.i11, align 4		;  [#uses=1]
	%tmp10.i = getelementptr i32* %tmp3, i32 3		;  [#uses=1]
	%tmp11.i = load i32* %tmp10.i, align 4		;  [#uses=1]
	%tmp12.i = add i32 %tmp11.i, %tmp8.i		;  [#uses=1]
	%tmp14.i = getelementptr i32* %registers, i32 %tmp2.i8		;  [#uses=1]
	store i32 %tmp12.i, i32* %tmp14.i, align 4
	%tmp31 = getelementptr i32* %ops, i32 4		;  [#uses=1]
	%tmp1.i2 = getelementptr i32* %tmp31, i32 1		;  [#uses=1]
	%tmp2.i3 = load i32* %tmp1.i2, align 4		;  [#uses=1]
	%tmp4.i4 = getelementptr i32* %registers, i32 %tmp2.i3		;  [#uses=1]
	%tmp5.i5 = load i32* %tmp4.i4, align 4		;  [#uses=1]
	%tmp7.i6 = call i32 (i8*, ...)* @printf( i8* getelementptr ([7 x i8]* @.str, i32 0, i32 0), i32 %tmp5.i5 ) nounwind 		;  [#uses=0]
	ret void
}
=> 7

对，函数被LLVM给Inline化了，强吧！Evan称之为使用核能做饭，呵呵。

嗯，的确是很趣，那么我们从中又能学到什么呢？使用LLVM强大的中间层基础设施，可以为rubinius的bc执行带来强大的JIT功能。至于rubinius真的是怎样做到，让我读读rubinius的代码之后再接着谈吧:)

做下广告吧Promo Code: LEESEON

2008-09-06T18:50:00Z

无意间发现DreamHost 最近在搞优惠活动，凡是在9月10号之前注册的用户，都能享受无限的(之前是500G)磁盘空间与无限的带宽(之前是5T)。呵呵，其实这当然是有一点噱头的成份在里面，毕竟500G与5T(每周都会涨的)我是根本没有用完过，不过如果你认为你一定能用完，或者你梦想远大，或者只为了YY，那你可以赶紧注册一个噢!

当然当然最重要的就是，呵呵，使用我的PROMO CODE：LEESEON 噢，这个是能打折滴，以前是$97，现在也就只有$50了，看来老外滑头起来也是不差的

自然自然无利不起早嘛，听说使用我的Promo Code我是能赚钱滴—俺从来没有拿到过:(,不过还是要佩服一下这种有点象传销一般的病毒式商业运作方式

mephisto0.8出错了:(

2008-09-06T15:28:00Z

好久没有写blog了，最近才发现游戏公司忙起来还真的不是一般的忙，现在对那著名的“对EA的血泪控诉”也开始是感同身受了啊，唉!

好在最近闲下来了一点，而且发现自己的gmail里面堆满了从dreamhost发过来的Cron Daemon的错误提示，提示我mephisto的/admin出错了。

本来没有当回事，估计是因为dreamhost的rails升级到2.1.0引起的，当时我使用mephisto0.8，因为正好系统中有rails 2.0.2一时偷懒没有将rails freeze起来，心想应该freeze一下就没有问题了。二话不说，开工，运行


rake rails:freeze:gems VERSION=2.0.2

本以为重启一下服务就能好了，谁知出了一堆错，提示我 “undefined method ‘install_gem_spec_stubs’”

查了一下文档，不对啊，install_gem_spec_stubs可是rails2.1.0中的函数啊，怎么会出现在mephisto 0.8之中，怪啊，不过即然如此，拿2.0.2试试便知，运行


rails _2.0.2_ testrails

打开config/boot.rb看了看，根本不用比较工具就能发现mephisto0.8的文件中的确是多出一行，注掉即可

  class VendorBoot < Boot
    def load_initializer
      require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer"
      #Rails::Initializer.run(:install_gem_spec_stubs)
    end
  end

想想，可能是因为使用edge rails来生成的mephisto 0.8的原始文件的吧

Capistrano配置及版本控制实践

2008-07-06T18:24:00Z

以前一直都将Capistrano 的deploy.rb的文件放在SVN中，最近需要将代码共享给别人一同开发，这才发现了有一个问题，就是我的空间帐号与数据库的密码是不希望让人知道，毕竟知道的人越少越好嘛。

而且最近做了一件傻事，就是以前我都是将


ENV["GEM_HOME"]="/home/yourusername/.gems" 
ENV["GEM_PATH"]="/home/yourusername/.gems:/usr/lib/ruby/gems/1.8"

这样的配置放在dispatch.fcgi中，现在因为使用了Phusion Passenger (mod_rails)之后，这一段的内容放在了config/enviroment.rb之中，所以在windows上运行rake test时，出现了找不到gems的错误，一时没有想到了这样的问题，还费了半天的功夫:(

于是鉴于这些问题，deploy.rb原则上不需要放在版本控制中的，而且database.yml与enviroment.rb也不需要放在版本控制之中，这些文件可以另外保存，与rails代码分开，放在另一个版本控制之中，并且放在share_dir中，在部署时拷贝到相应的目录之中。

想做到这样，只需要在deploy.rb中增加一个任务

before "deploy:restart", 'deploy:copy_config'
desc "Copy the configuration file " 
task :copy_config, :roles => :app, :except => { :no_release =>  true  }   do
  run "cp -f #{shared_dir}/environment.rb #{current_path}/config/environment.rb" 
  run "cp -f #{shared_dir}/database.yml #{current_path}/config/database.yml" 
end

即可

更新了一下脚本

2008-07-06T15:35:00Z

自从上回之后，ruby、rails与gems也都开始更新了，于是也更新了一下安装脚本，如下：

mkdir ~/.gems
echo ‘export GEM_HOME=”$HOME/.gems”’ >> .bash_profile
echo ‘export GEM_PATH=”$GEM_HOME:/usr/lib/ruby/gems/1.8”’ >> .bash_profile
echo ‘export PATH=”$HOME/.gems/bin:$PATH”’ >> .bash_profile
echo ‘export PATH=”$HOME/local/bin:$PATH”’ >> .bash_profile
. ~/.bash_profile
echo $PATH
touch ~/.gemrc
echo gemhome:/home/$(whoami)/.gems >> ~/.gemrc
echo gempath: >> ~/.gemrc
echo -/home/$(whoami)/.gems >> ~/.gemrc
echo -/usr/lib/ruby/gems/1.8 >> ~/.gemrc
# setup directories
mkdir -p ~/local/usr/src/ruby
cd ~/local/usr/src/ruby
# Install readline
wget ftp://ftp.cwru.edu/pub/bash/readline-5.2.tar.gz
tar zxvf readline-5.2.tar.gz
cd readline-5.2
./configure—prefix=$HOME/local
make
make install
cd ..
# install ruby
wget ftp://ftp.ruby-lang.org/pub/ruby/1.8/ruby-1.8.7-p22.tar.bz2
tar jxvf ruby-1.8.7-p22.tar.bz2
cd ruby-1.8.7-p22
./configure—prefix=$HOME/local—with-readline-dir=$HOME/local/
make
make install
cd ..
# fix path
export PATH=$HOME/local/bin:$PATH
# get rubygems
wget http://rubyforge.org/frs/download.php/38646/rubygems-1.2.0.tgz
tar zxvf rubygems-1.2.0.tgz
cd rubygems-1.2.0
$HOME/local/bin/ruby setup.rb config—prefix=$HOME/local
$HOME/local/bin/ruby setup.rb setup
$HOME/local/bin/ruby setup.rb install
cd ..
# Install RAILS
gem install rails
# Install FastCGI
curl -O http://www.fastcgi.com/dist/fcgi-2.4.0.tar.gz
tar xzvf fcgi-2.4.0.tar.gz
cd fcgi-2.4.0
./configure—prefix=$HOME/local
make
make install
cd ..
# Install FastCGI & MySQL gem packages
gem install fcgi——with-fcgi-dir=$HOME/local
gem install mysql——with-mysql-config
# gem update

关于脚本的解释可以看以前的说明，这次仅仅只是版本上的更新而已，不再多做说明

文件依然放在http://leeseon.com/private/allinstall.sh 处

也同样可以使用


curl http://leeseon.com/private/allinstall.sh | sh

来执行，无它、、、

Rails/Ruby社区越来越快了

2008-06-22T17:19:00Z

Rails在6.1号就已经发布2.1了，这个号称参与人数最多，代码更改行数最多的版本，就这么漫不经心地来了。最近gems也发布1.2了，而且中文版本的《what’s new in rails 2.1》也基本上在网络上翻译好了，rails的社区参与度与活跃度也最来最高了，这样的rails/ruby社区怎能不越来越快？

最近依然在忙碌中度过，上来写写博文只能算是应个景儿，有点对不起自己了:(

running on rails-----在铁轨上奔跑速度自然就会快:P

2008-06-05T15:53:00Z

最近一直忙于工作，居然有两周没有写blog了，不过也不是完全没有时间写，只是因为实在是没有什么时间来实践rails上的一些新东东，觉得言之无物:(

不过ruby/rails社区最近却是如大事连连：先是rails 2.1的发布，还有就是ironruby在rubinius之后也宣布可以运行rails了，这个所有ruby实现都视之为重要目标的里程碑。

一旦运行上了轨道，后面自然是一发而不可收拾噢，虽然我对ironruby的兴趣缺缺的说

只是偶然发现ruby on rails的这个名字真的很有趣，以至于我自己能生造出Running On Rails这样古怪的半通不通的双关来，算是玩笑吧:P

Rubinius开始支持rails了

2008-05-19T16:28:00Z

不是我不明白，只是这个世界变得快!

最近因为地震的原因，在网上看新闻的时侯比较多，对于ruby的新进展的了解要慢了几拍：

昨天才知道dreamhost已经开始支持mod_rails了，还写下了一篇酸溜溜的blog

今天也是通过从InfoQ订阅的新闻中得知Rubinius开始支持rails了，好消息啊，这是续它支持gems与merb之后又一重大的里程碑啊，贺之！看来以后新的rails的基于rubinius的host主机很可能会出现了，最有可能的自然是engineyard 了，只是不希望太贵噢，这样我还能试试，不过想来可能性不大:(

使用Capistrano在Dreamhost上部署mod_rails

2008-05-19T14:44:00Z

虽然以前Capistrno 在windows下不能使用，但是自从2.0以后，其实就是可以使用的了。而且现在的2.3还加入了对git的支持。

而且从InfoQ 上得知Tom Copeland 已经使用Capistrano来更新mod_rails了,的确如它所说，只是给这个应用程序建立了一个“restart.txt”文件，就会导致Passenger Phusion/mod_rails重启这个应用程序。的确很简单明了不是吗？

最终的deploy.rb文件看起来会象下面这样

set :scm, :subversion
set :repository, "http://yoursvn/trunk"
set :svn_username, "svnuser"
set :svn_password, "svnpassword"
role :app, "www.yourdomain.com"
role :web, "www.yourdomain.com"
role :db, "www.yourdomain.com" , :primary => true
set :deploy_to, "/home/yourusername/"
set :user, "yourusername"
set :password, "yourpassword"
set :use_sudo, false
namespace :deploy do
desc "restarting mod_rails with restart.txt"
task :restart, :roles => :app, :except => { :no_release => true } do
run "touch #{current_path}/tmp/restart.txt"
end
[:start, :stop].each do |t|
desc "#{t} task is a no-op with mod_rails"
task t, :roles => :app do ; end
end
end

dreamhost真的开始支持mod_rails了

2008-05-18T09:27:00Z

呵呵，这个当然是好事，只可惜我一语成谶，正好在DreamHost 支持mod_rails的两天之前写了两篇关于怎样在dreamhost上安装ruby、rails与gems的blog, 当然现在这些东东已经过期了，不再有用了，看来以后有什么心得就需要立刻记下来，第一为了免得稍纵即逝错过了最想记录下来的冲动时刻，第二也许我早点写出来，可能会对大家更有用，起码能让后来者少起点弯路（有点自以为的是地想）。当然做我们这么行，知识的过期是再正常不过的了，不过当年在那儿探索的苦恼与成功之后的喜悦是不可能忘却的，而且从中学到的一些东西也并不是全无用处，比如虽然有了mod_rails但是当你需要自己的gems时，还是可以自己装一份来用的嘛，只是不会再遇到我所遇到的那些莫名的 FastCGI: comm with (dynamic) server ”/home/u/domain/public/dispatch.fcgi” aborted: (first read) idle timeout (60 sec) 的挫折了，这自然是好事噢，有点不甘心地说:P

嗯，如dreamhost所说一般以domain的控制面板上多了一个Ruby on Rails Passenger的选项，勾上就好了，简单得不行了吧，不过有一点要注意，dispatch.fcgi中的代码将会永远用不到了，所以如果如我一般自己安装了gems的并有dispatch.fcgi中配置了gems的路径的话，就需要将


ENV["GEM_HOME"]="/home/yourusername/.gems" 
ENV["GEM_PATH"]="/home/yourusername/.gems:/usr/lib/ruby/gems/1.8"

移到config/enviroment.rb中的ENV[‘RAILS_ENV’] ||= ‘production’之后就好了，否则可能会看到一个mod_rails提示的出错页面，无它，很简单的，不错

在DreamHost上安装Ruby、Gems与Rails的最简单方法之续

2008-05-10T18:03:00Z

昨天只是泛泛谈了一下在DreamHost上安装Ruby、Gems与Rails的最简单方法似乎有点意犹未尽，决定写个续集，呵呵:)

好吧从哪儿说起呢？嗯，看我注释过的脚本吧，注释应该已经算是说得比较明白了，无它!

#修改.bash_profile，设置环境变量GEM_HOME与GEM_PATH
#并将~/.gems/bin与~/local/bin加入到查找路径的前端
echo 'export GEM_HOME="$HOME/.gems"' >> .bash_profile
echo 'export GEM_PATH="$GEM_HOME:/usr/lib/ruby/gems/1.8"' >> .bash_profile
echo 'export PATH="$HOME/.gems/bin:$PATH"' >> .bash_profile
echo 'export PATH="$HOME/local/bin:$PATH"' >> .bash_profile
#执行.bash_profile使变量生效
. ~/.bash_profile
#显示PATH变量，仅仅只是为了测试
echo $PATH
#生成gems所需的目录及.gemrc文件，并填充相应内容
mkdir ~/.gems
touch ~/.gemrc
echo gemhome:/home/$(whoami)/.gems >> ~/.gemrc
echo gempath: >> ~/.gemrc
echo -/home/$(whoami)/.gems >> ~/.gemrc
echo -/usr/lib/ruby/gems/1.8 >> ~/.gemrc
# setup directories
mkdir -p ~/local/usr/src/ruby
cd ~/local/usr/src/ruby
# Install readline
wget ftp://ftp.cwru.edu/pub/bash/readline-5.2.tar.gz
tar zxvf readline-5.2.tar.gz
cd readline-5.2
./configure --prefix=$HOME/local
make
make install
cd ..
# install ruby
wget ftp://ftp.ruby-lang.org/pub/ruby/1.8/ruby-1.8.6-p114.tar.gz
tar zxvf ruby-1.8.6-p114.tar.gz
cd ruby-1.8.6-p114
./configure --prefix=$HOME/local --with-readline-dir=$HOME/local/
make
make install
cd ..
# fix path
export PATH=$HOME/local/bin:$PATH
# get rubygems
wget http://rubyforge.org/frs/download.php/35283/rubygems-1.1.1.tgz
tar zxvf rubygems- 1.1.1.tgz
cd rubygems-1.1.1
$HOME/local/bin/ruby setup.rb config --prefix=$HOME/local
$HOME/local/bin/ruby setup.rb setup
$HOME/local/bin/ruby setup.rb install
cd ..
# Install RAILS
gem install rails
# Install FastCGI
curl -O http://www.fastcgi.com/dist/fcgi-2.4.0.tar.gz
tar xzvf fcgi-2.4.0.tar.gz
cd fcgi-2.4.0
./configure --prefix=$HOME/local
make
make install
cd ..
# Install FastCGI & MySQL gem packages
gem install fcgi -- --with-fcgi-dir=$HOME/local
gem install mysql -- --with-mysql-config