chalvern (Jingwei)

在 Rails 里使用了 Parellel (多进程) 后出现的奇葩问题

chalvern — Thu, 14 Sep 2017 20:33:45 +0800

最近开发中出现一个奇葩场景。

场景

Redmine 中，目前有几十个 issue，每个 issue 都需要修改状态，因为每个 issue 都是数据独立的，所以想把修改这件事放到多个进程中去做，充分利用一下硬件资源嘛。

使用了 Gem Parallel

Parallel.each(@issues, in_processes: 4) do |issue|
  do-something, including mails delivering
ene

ps: 每个 issue 修改并保存成功，会发出一封邮件。

遇到的两个问题

相应的单元测试中，监控不到发送邮件的正确数目，目前 ActionMailer::Base.deliveries.count 的值恒为 0，推测：测试进程里的 ActionMailer::Base.deliveries 和业务逻辑里的 ActionMailer::Base.deliveries 是独立的……手工验证确实是这样的，，那么问题来了： 这种情况应该怎么写测试用例呢？
单元测试，理论上每运行完都会运行相应的 rollback ,保证数据库的纯正。目前发现，上面的数据是会保留的，从而干扰了一些正常的测试。。。 这种情况是不是有方法解决呢？

本地跑 homeland-docker 总是出现 nginx 欢迎页面

chalvern — Sat, 20 May 2017 22:08:49 +0800

本地跑 homeland-docker，发现总是跳到 nginx 欢迎页面

研究了半天，发现是因为在 nginx.conf 中的 include 是这样写的：

# DO NOT CHANGE THIS
include /etc/nginx/conf.d/*.conf;

但是，经过

sudo docker-compose run app ls /etc/nginx/conf.d/

=> default.conf  homeland   homeland.conf

发现了这个文件夹中有个 default.conf……

把 nginx.conf 中对应的语句修改成

include /etc/nginx/conf.d/homeland.conf;

就可以了=。=

想问，这个问题是不是 docker image 在配置的时候忘了删这个 default.conf 了，，，纠结中……

Ruby 中的衔尾蛇——对象和类之间的循环关系

chalvern — Wed, 12 Apr 2017 22:09:31 +0800

Ruby 中的 ∞

在 Ruby 中，Object 是所有类的超类 (Superclass) , "Class"是所有对象的类 (class) 。即，对任何类取有限次 superclass ，最后都能得到 Object (其实是 BasicObject); 对任何的对象 (类也是一种对象) 取有限次 class 最后都能得到 Class。

相对于其他的编程语言，Ruby 这里存在一个比较绕的逻辑，这里先画出基本的关系图如下：

Object 与 Class 中的方法

由于对象与类之间特殊的关系，那么在方法的角度来分析，能得出什么样好玩的结论呢？

1. Object 中的类方法 (methods) 与 Class 中的实例方法 (instance_methods) 相同

Object.methods == Class.instance_methods
# => true

2. Class 中的实例方法 (instance_methods) 一部分继承于 Object 的实例方法 (instance_methods), 另一部分应该 Mixin 于独立的模块。

Object.instance_methods.length
# => 56 

(Class.instance_methods-Object.instance_methods).length
# => 44

3. Class 中的类方法 (methods) 主要继承于 Object 的类方法 (methods)

Class.methods-(Object.methods&Class.methods)
# => [:nesting]

从输出的结果来看，Class 的类方法主要继承与 Object, 但是在此之外添加了一个 :nesting 方法。

4. [基于前两个结论]Class 中的类方法与实例方法具有很高的重合性

Class.methods-(Object.methods&Class.instance_methods)
# => [:nesting]

根据个人的理解，Ruby 的元编程能力的最本质表现，是 Ruby 可以像对待对象 (Object) 那样动态地对类 (Class) 进行运行时编辑。在代码层面的表达，则是类 (Class) 能够同时进行两次 new ("Class#new"和"Class#new#new") 分别创建类和对象 .

根据上面的结论，可以认为 Ruby 在设计之初主要问题之一便是统一对象 (Object) 与类 (Class) 之间的关系。而为了赋予 Ruby 元编程的能力，设计上无法避免对象和类在方法定义上的冗余问题 (比如一些方法同时是 Class 的类函数和实例函数 ), 为了解决这个问题，就自然而然地引入了模块 (module) 的概念。

Ruby 中方法的调询

在 Ruby 中，最简单的方法调询路径，是当某个对象调用某个方法时，Ruby 会首先到对象所对应的类中查找是否有这个方法。但是因为继承以及混入 (mixin) 的存在，Ruby 中存在更为复杂的方法调询路径。

与 Java 等语言类似，为了调用方法，Ruby 会首先查找对象的类，然后依次查找类的超类 (superclass) ，直到找到这个方法为止（当然如果已经找到了 Object 还找不到一般就会报错了）。比如下面的代码：

class MyClass:
  def my_method;
    'my_mythod()'
  end
end

class MySubclass < MyClass
end

obj = MySubclass.new
obj.my_method()     # => "my_method()"

Ruby 中的类与对象

chalvern — Sun, 26 Mar 2017 10:50:33 +0800

Ruby 中的类

打开类 (Open Class)

在 Ruby 中，类和其他代码（对象、函数等）没有本质的区别。可以在类的定义中放任何代码：

3.times do
  class C
    puts "hel"
  end
end
#输出
#hello
#hello
#hello

Ruby 会在类中运行任何可以运行的代码。但是需要重点的说明的是，上面的代码并不意味着定义了三个 C 类，比如下面的代码：

class D
  def x; 'x'; end
end

class D
  def y; 'y'; end
end

obj = D.new
obj.x   # => "x"
obj.y   # => "y"

从代码可以知道，上面的两个类 D 包含了两个地方定义的方法。也就是说，在第二次定义 D 类时，Ruby 能够找到第一次定义的 D 类并把新的方法（y）添加到 D 类中。在 Ruby 术语中，这叫做“打开类”(Open class)。

换句话说，可以在任何时候打开一个已经存在的类，并向里面添加新的方法——包括 String 和 Array 这样的标准类。

【注意】 Ruby 的这种特性是完全不同于其他常见语言，比如 Java、Python 等。可能未接触过 Ruby 的人会觉得这样太乱了，比如可能（而且很有可能，尤其当不同人做开发时）在不同的时间在同一个类中引入同样的一个方法，那么就容易引起混乱（一般称这种在类中全局引入方法的方式叫做猴子补丁 [Monkeypatch]）。但是，还是要补充一句，对于有自制力并且时刻记得“能力越大，责任越大”的人来说，Ruby 的这种特性能带来很牛 x 的体验。

Ruby 中的对象

实例变量 (instance variables)

Ruby 中的对象也是一个比较有意思的东西，与 Java、Python 等也具有很大的不同。比如下面的代码：

class MyClass
  def my_method
    @v = 1
  end
end

obj = MyClass.new
obj.class   # => MyClass

obj.instance_variables  # => []

obj.my_method
obj.instance_variables  # => [:@v]

在 Ruby 中，对象中存在实例变量 (instance variables) ，可以通过方法 instance_variables 进行查看当前对象中的 实例变量。

不过这里有意思的一点是，Ruby 中的实例变量和类是完全不搭嘎的。也就是说，Ruby 中对象中有哪些实例变量并不受类定义的影响。比如上面代码，在调用 obj.my_method前后，obj 中的实例变量是不一样的。或者可以这么认为：Ruby 中同一个类的不同实例对象可以具有不同的实例变量。（对于 javaer 或者 pythoner 来说，简直又一个喜闻乐见的特性）

方法 (Methods)

Ruby 中的方法和其他语言中的方法类似，对于每个实例化对象，它只保存自己的实例变量，而方法都保存在对应的类中。

obj(OBJECT)		MyClass (CLASS)
@v = 1	(class) ——>	my_method()
(instance variables)		(Methods)

这里需要注意的是，Ruby 中的方法同样分类方法和实例方法，其中实例方法只能对象被调用，而类方法则只能被类调用。

总结一下就是，类似于 Java 等语言，对象的实例变量在对象本地存在，而对象的方法在对象所对应的类中存在。但是和 Java 等编程语言不同的是，Ruby 中的类其实也是一种对象。那么 Ruby 基于这个前提又能引起哪些不可思议的特性呢，后面会一一道来。

Ruby 中类的真实面目

是的， Ruby 中的类其实是一种对象。

因为类也是一种对象，因此所有对象的特性也是类具有的特性。比如，(Class) 有自己的类，这个类就是——Class，举个例子，假如一个字符串可以通过 str#class 获得它的类 String，那么 String 作为一个对象也可以通过 String#class 获知它自己的类。比如下面的代码：

"hello".class   # => String
String.class    # => Class
Class.class     # => Class

这是一个完全不同于 Java 等开发语言的特性。可以这么认为，在 Java 中，类的实例对象只是一个可读的类，运行时可以随意生成某类的对象，却不能随意修改类的结构；但是在 Ruby 中，类的限制规范更少，可以像对象那样在运行时定义动态的类（通过 Class.new ）。或者更简单地说：在运行时，其他语言只允许读类的信息，但是 Ruby 还允许编辑类的信息。