tinyfeng (Tiny)

ActiveStorage 死循环生成 URL 的 BUG

tinyfeng — Sat, 04 Nov 2023 01:15:04 +0800

在七牛云上传文件成功后，然后遇到死循环不断生成日志，如下

一秒钟就打了几万行日志，有没有人遇到这个问题

我只找到打日志的地方是 ActiveStorage::LogSubscriber#service_url，但是何处调用，还没有找到，毕竟 rails 实在是太魔幻了

ruby-china gem 源的问题

tinyfeng — Fri, 26 May 2023 22:56:22 +0800

把 ruby-china 当成 gem 源的时候，bundle install 报错找不到 rake 13.0.6，我特意上去看了一眼是有的

直接使用 source "https://rubygems.org"的时候没问题，但是在其他电脑上，因为网络没配置不能使用 rubygems.org，就用了 ruby-china 镜像，于是有了上述问题。

多年经验的 rubist 找个创业合伙人，也可接兼职/项目

tinyfeng — Tue, 09 May 2023 13:11:49 +0800

目前想找一个创业合伙人一起接外包（各类管理系统，网站，微信公众号，小程序），我负责技术方面，需要一个合伙人负责拉项目谈价格，长期合作。

我的优势：

毕业于西安电子科技大学（高考取分高过很多 985 的 IT 强势 211 学校），学习能力强，可以较快学习各种工具、语言、框架，加以应用
有在过外包小公司，也有大厂经验，无论前后端分离还是全栈都做过，做过教育、医疗、电商，金融行业，也有独立的游戏创业项目，经验丰富。
善于抽象和沉淀，区别于传统外包公司一单子买卖，后面接单再拿之前项目修修改改。我可以洞悉业务本质，将业务背后的通用逻辑抽象剥离，沉淀成通用技术，类似框架的工具。后续再有其他业务，可以直接应用，有利于项目维护管理，拒绝 Ctrl-C/V。
基于丰富的经验和技术沉淀，我可以很快做完一个项目，基于较为低廉的时间成本，打破市场的常规价接到项目。

举个例子，最近做的一个项目：

微信公众号那边挂号，PC 系统给诊所医生开方、药房抓药，这个系统一共写了三天（包含 vue、eleme 的学习，花了一天多）

然而这是你看到的页面背后的代码，没错，这个 Vue 前端页面是用 ruby 代码全自动生成的，CURD 后端接口也是自动生成的，前后端自动对接，专治这种 CURD 页面：

合适的有缘人，看见请不要犹豫，直接联系我！

contact:

$ echo 'MTg4MjE3Njg3MDE=\n' | base64 --decode

写了一些 rspec 的 DSL 之后，逐渐意识到元编程的强大

tinyfeng — Wed, 14 Apr 2021 12:00:51 +0800

之前写 rspec，写的不是很如意，遇到 controller 复杂的 response，甚至不如 kotlin 写的 junit 简洁。

require 'rails_helper'
RSpec.describe  UsersController, type: :controller do
    include_context 'shared context'
    # index returns {success: 1, data: [{name: 'Jay', id: 1}, {name: 'Jone', id: 2}]}
    it 'test index' do
        get :index
        res = JSON.parse(response.body).deep_symbolize_keys
        expect(res[:success]).to eq 1
        expect(res[:data].size).to eq 2
        expect(res[:data].first.name).to eq 'Jay'
        expect(res[:data].first.id).to eq 1
        expect(res[:data].second.name).to eq 'Jone'
        expect(res[:data].second.name).not_to eq 'Jay'
        expect(res[:data].second.id).to eq 1
    end
end

作为一个优雅的人，怎么能忍受呢，于是通过元编程改造：

require 'rails_helper'
RSpec.describe  UsersController, type: :controller do
    include_context 'shared context'
    # index returns {success: 1, data: [{name: 'Jay', id: 1}, {name: 'Jone', id: 2}]}
    it 'test index' do
        get :index
        expect_response do
            ex success, eq(1)
            ex data do
                ex size, eq(2)              
                item 0 do  # 也可以写成 `ex first do `
                    ex name, eq('Jay')
                    ex id, eq(1)
                end
                item 1 do
                    ex name, eq('Jone')
                    ex_not name, eq('Jay')
                    ex id, eq(2)
                end
            end
        end
    end
end

最后贴改造源代码

# shared_contest.rb
module Matchable
  extend ActiveSupport::Concern
  included do
    attr_accessor :context
    include RSpec::Matchers
  end

  def ex obj, matcher = nil, &blk
    if blk
      obj.instance_eval &blk
    else
      context.instance_eval do
        expect(obj).to matcher
      end
    end
  end

  def ex_not obj, matcher
    context.instance_eval do
      expect(obj).not_to matcher
    end
  end
end

RSpec.shared_context 'shared context', shared_context: :metadata do
  before do
    # some mock, before action mock
  end

  def res
    json = JSON.parse(response.body)
    json.is_a?(Hash) ? to_recursive_ostruct(json) : json
  end

  def to_recursive_ostruct(hash)
    obj = OpenStruct.new(hash.each_with_object({}) do |(key, val), memo|
      memo[key] = if val.is_a?(Hash)
                    to_recursive_ostruct(val)
                  elsif val.is_a?(Array)
                    result = val.map { |x| to_recursive_ostruct x }
                    result.context = self
                    result
                  else
                    val
                  end
    end)
    obj.context = self
    obj
  end

  def expect_response &blk
    ex res, &blk
  end

  def ex obj, &blk
    obj.instance_eval &blk if blk
  end

  OpenStruct.include Matchable

  class Array
    include Matchable

    def item idx, &blk
      self[idx].instance_eval &blk if blk
    end
  end
end

有办法改变 lambda 运行时的上下文吗

tinyfeng — Mon, 22 Feb 2021 13:40:20 +0800

有两段代码

a = 1
l = -> { puts a }
l.call

l = -> { puts b }
b = 1
l.call

其中第一段代码正常，而第二段代码会抛异常，因为声明 l 的时候上下文并没有 a。

原理应该类似 eval 不能在上下文中声明一个局部变量，l 运行时的上下文是声明时的上下文，不随外部上下文改变而改变，那有没有办法让第二段代码运行起来呢

写了个轻量级线程池模型，复用线程以及数据库连接

tinyfeng — Wed, 03 Jun 2020 15:15:04 +0800

想实现一个复用线程以及数据库连接的线程池，最开始通过轮询空闲线程分配任务实现，结果 cpu 上下文切换次数每秒一万次左右，实际执行下来效率也很低，直到改用队列：

class Concurrency
  SLEEP_DURATION = 0.000001
  READY_STATE = 'ready'
  PROCESSING_STATE = 'processing'

  def initialize(**options)
    @max_thread = options[:max] || 22
    pool = Rails.configuration.database_configuration[Rails.env]["pool"]
    raise PoorDbPool.new("You set max thread #@max_thread, but your database config pool is #{pool}, threads should less than pool") if pool < @max_thread

    @sleep_duration = options[:sleep_duration] || SLEEP_DURATION
    @threads = []
    @queue = Queue.new
    while @threads.length < @max_thread
      @threads << Thread.new do
        thr_start = proc do
          loop do
            Thread.current[:status] = READY_STATE
            exec_content = @queue.pop
            Thread.current[:status] = PROCESSING_STATE
            exec_content.call
          end
        end
        with_db_query = options[:with_db_query].nil? ? true : options[:with_db_query]
        if with_db_query
          ActiveRecord::Base.connection_pool.with_connection(&thr_start)
        else
          thr_start.call
        end
      end
    end
  nil
  end

  def exec(&blk)
    raise ArgumentError.new('no block given') unless blk
    @queue.push blk
  end

  # 同步等待所有任务执行完毕
  def promise
    sleep(@sleep_duration) until @queue.length.zero? && @threads.all?{ |t| t[:status] == READY_STATE }
  end

  # 同步等待任务执行完毕，立即释放线程以及数据库连接资源
  def wait
    sleep(@sleep_duration) while @queue.length > 0
    while @threads.any?{ |t| t.alive? } do
      sleep(@sleep_duration)
      @threads.select { |t| t.alive? && t[:status] == READY_STATE }.each(&:kill)
    end
  end

  class PoorDbPool < StandardError; end
end

benchmark:

co = Concurrency.new max: 10, with_db_query: false
Benchmark.bm do |x|
  x.report do
    10000000.times do |i|
      co.exec {i+1}
    end
    co.wait
  end
end

执行结果

查看 cpu 每秒上下文切换次数$ pidstat -w 1

可以看到在非 I/O 密集条件下，6 秒多的时间内，执行了 1 千万次任务，但是 cpu 每秒在 ruby 进程上的上下文切换次数只有 10-30。使用队列，在结束上一个任务，可以立马进行下一个任务，很多时候避免了切换线程，大大减少上下文切换的消耗。

cpu 切换一次线程，耗时大概是几 us，如果每次任务都切换线程，那么光系统切换 1 千万次线程的成本本身可能就是几十秒，所以对比起来，感觉效率尚可。

大家都知道，在计算密集型条件下，使用多线程，由于上下文切换，效率反而降低，下面对比不使用线程：

Benchmark.bm do |x|
  x.report do
    10000000.times do |i|
      (->{i+1}).call
    end
  end
end

结果和使用了线程池差不多，时间花销略低一点：

如果不使用 Proc 呢：

Benchmark.bm do |x|
  x.report do
    10000000.times do |i|
      i+1
    end
  end
end

结果：

可以看出，其实最大花销都在 Proc 上，不知道这里有没有优化的点。

如有不对，或者改进的地方，请指正

Parallel 并行执行任务的坑

tinyfeng — Thu, 23 Apr 2020 15:39:19 +0800

@a = 2
# =>  2

Parallel.each(1..3) do |i|
    puts @a
end
# =>  2
# =>  2
# =>  2

Parallel.each(1..3) do |i|
    @a = @a + i
end
# => 1..3

@a
# => 2

在任务里能访问到共享资源 (@a)，但无法对其修改，应该是防止共享资源竞争导致不期望的情况发生。

~~删除线欲对其进行修改，应使用 map 方法，自己手动对执行完的结果进行处理。~~

用 in_threads 可以解决这个问题，但是不确定多线程资源竞争的时候，是否安全

Parallel.each(1..3,  in_threads: 3) do |i|
    @a = @a + i
end

如何优雅地处理泛型问题

tinyfeng — Thu, 16 Apr 2020 16:57:30 +0800

把电子表格解析为对象，传入文件路径，需要解析为的类型

返回值为 interface{}，如何优雅地访问返回值的成员/方法

type Student struct {
    Name string `xlsxCol:"student name"`
    Age string `xlsxCol:"student age"`
    Grade string `xlsxCol:"student grate"`
}

type Teacher struct {
    Name string `xlsxCol:"teacher name"`
    Age string `xlsxCol:"teacher age"`
}

func parse(path string, t reflect.Type) []interface{} {
... // 已经实现
}

在用的时候

result := parse("/tmp/xxx.xslx", reflect.TypeOf(Student{}))
if len(result) > 0 {
    result[0].Name // 怎么可以访问到这个属性
}

如果是 debug 模式，在result[0].Name 这一行打断点，已经可以看到result[0] 是 {interface{} | Student}的类型，且 debug 模式可以使用 Evaluate Expression result[0].Name 访问到 Name，但是静态编译肯定过不了。

想知道通常情况应该怎么处理这一问题，我应该在每个用的地方使用类型断言吗？

我实在不想写这种代码

func parseToStudent(path string) []Student {
...
}
func parseToTeacher(path string) []Teacher {
...
}
...

此处应该祭出这个图了

Rails 5.2.3 cattr_accessor default value 的坑

tinyfeng — Wed, 25 Mar 2020 11:55:16 +0800

今天写了这么一段代码，发现只要类定义过的 cattr_accessor 的任意一个发生改变，所有都变了

后面翻了cattr_accessor源码，发现是真的坑，在send("#{sym}=", sym_default_value) 这个地方，并没有对原对象进行拷贝，导致所有的默认值是同一个对象....

<<方法其实是对最初的对象Array.new进行操作....

class module
  def mattr_accessor(*syms, instance_reader: true, instance_writer: true, instance_accessor: true, default: nil, &blk)
    mattr_reader(*syms, instance_reader: instance_reader, instance_accessor: instance_accessor, default: default, &blk)
    mattr_writer(*syms, instance_writer: instance_writer, instance_accessor: instance_accessor, default: default)
  end
  alias :cattr_accessor :mattr_accessor

  def mattr_writer(*syms, instance_writer: true, instance_accessor: true, default: nil)
    syms.each do |sym|
      raise NameError.new("invalid attribute name: #{sym}") unless /\A[_A-Za-z]\w*\z/.match?(sym)
      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
        @@#{sym} = nil unless defined? @@#{sym}

        def self.#{sym}=(obj)
          @@#{sym} = obj
        end
      EOS

      if instance_writer && instance_accessor
        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
          def #{sym}=(obj)
            @@#{sym} = obj
          end
        EOS
      end

      sym_default_value = (block_given? && default.nil?) ? yield : default
      send("#{sym}=", sym_default_value) unless sym_default_value.nil?
    end
  end
  alias :cattr_writer :mattr_writer
end

如何进入服务器上次启动的 rails console

tinyfeng — Mon, 20 Jan 2020 20:47:17 +0800

场景：上次在服务器上起了一个 irb，因为时间过长，ssh 断开连接。现在重新 ssh 连上服务器，如何在 shell 重新打开那个 irb。

我知道 tmux 可以做到这一点，但是想知道其他方式。

解决 GraphQL 与 ActiveRecord 嵌套 N + 1 SQL 问题

tinyfeng — Fri, 12 Apr 2019 23:33:40 +0800

背景

GraphQL 多级嵌套查询，如果不手动处理，会导致很严重的 N+1 问题，甚至 (N+1)^n

技术背景是 GraphQL + ActiveRecord + 关系型数据库

举个例子

您原来的 Resolver 代码可能如下所示：

class Resolvers::ProfileResolver < GraphQL::Function
  description 'User profile'

  type Types::ProfileType

  def _call(_, args, ctx)
    ctx[:current_user]
  end
end

当查询如下的时候：

query{
  profile{
    id
    works{
      comments{
        replyUser{
          name
        }
        content
      }
      name
      id
      likes{
        owner{
          name
          works{
            name
            likes{
              owner{
                name
              }
            }
          }
        }
      }
    }
    name
  }
}

它将导致多级嵌套 N + 1 问题。

如果你要解决它，你可以像这样写：

class Resolvers::ProfileResolver < OptimizedFunction
  description 'User profile'

  type Types::ProfileType

  def _call(_, args, ctx)
    User.includes([works: [comments: :reply_user, likes: [owner: [works: [likes: :owner]]]]]).find(ctx[:current_user].id)
  end
end

您将在每个 Resolver 中手动解决 N + 1 问题。更糟糕的是，即使只请求了一个字段，也不得不向数据库查询 includes 的所有表。

解决办法

graphql-batch gem
- 感觉并不特别好用
- 不容易处理多层嵌套的问题
自己动手写了个 gem

用法

Resolver从继承 GraphQL::Function 改为继承于OptimizedFunction 。
定义_call方法而不是call
使用includes_klass(your_model_name)替换 includes 语句。

class Resolvers::ProfileResolver < OptimizedFunction
  description 'User profile'

  type Types::ProfileType

  def _call(_, args, ctx)
    includes_kclass(User).find(ctx[:current_user].id)
  end
end

原理

原理是解析最开始请求的 json 多叉树，与 ActiveRecord 的模型关联关系对比，从请求 json 多叉树中过滤出嵌套的关联关系树。

希望能帮助到和我一样喜欢 rails 和 graphql 的人，欢迎提出改进意见。

Migration add_reference 多态联合索引问题

tinyfeng — Mon, 18 Mar 2019 19:58:07 +0800

基于 ActiveRecord::Migration[5.2] 生成迁移文件

add_reference :products, :user, polymorphic: true, index: true

观察到，在 products 表生成的联合索引先通过 user_type，再通过 user_id 去查

user_type 区分度是很低的（对比 user_id），我感觉不如先根据 user_id 查。

rails 生成的索引，先根据区分度很低的 type 去查是有什么原因吗？

ruby aws-sdk 搭配 minio server ，上传很慢

tinyfeng — Fri, 01 Feb 2019 01:51:32 +0800

背景

我看官方没有 ruby 的 sdk，推荐使用 aws 的 ruby 客户端，然后用了一把。

list_buckets，list_objects，以及拿 object 这些都没有问题

问题

push_object 的时候，几十比特的文件，瞬间上传成功，而 500k 文件一般 1 分钟左右，偶尔会瞬间上传成功。

一些可能有用的信息

在管理后台上传文件，很快。

查看 nginx 日志，只有在上传成功同时才会打印出日志。

查看 minio 日志，打印 requst 和 response 的日志也是在上传成功同时打印。

现在想知道，上传的时候，会慢在哪里呢。

爬 ruby-china，为什么浏览器看到的和爬到的不一样？

tinyfeng — Wed, 15 Aug 2018 11:11:29 +0800

require 'nokogiri'
require 'rest-client'
def print_title url
  begin  
    res = RestClient.get url
    doc = Nokogiri::HTML res.body
    doc.css('.title a').each do |i|
      puts i.attributes['title'].value
    end
    puts '-' * 100
  rescue
    puts "invalid url"
  end
end

puts 'Please input url, and enter "e" to exit.'
while 'e' != url = gets.chomp!
  print_title url
end

比如去爬https://ruby-china.org/topics?page=60，感觉浏览器访问的时候被过滤了一些数据....

爬到的数据应该比浏览器访问的多，导致分页页数大了以后，顶部出现了浏览器访问到的 59 页的东西

关于函数参数传递是越少越好，还是允许冗余的情况出现

tinyfeng — Fri, 03 Aug 2018 15:09:43 +0800

情况是这样，有两个方法，a 和 b，a 中调用了 b

通过 var_a 可以计算出 var_b，而 var_c 需要通过 var_a 和 var_b 计算得到

通过 var_a 和 var_b 计算得到 var_c 具备一个独立且有意义的功能，因此定义一个 b 方法

在 b 方法里，得到 var_c 有两种途径：

1.传入 var_a，通过 var_a 计算出 var_b，再通过两者计算出 var_c，这样的话，在 a 中调用 b 方法，var_a -> var_b 相当于计算了两次

2.传入 var_a 和 var_b，后者是冗余的，只是为了免去一次重复的计算，当然 var_b 可以通过设置缺省值 nil，var_b 为 nil 的时候还是通过 var_a 去计算 var_b

def a
  var_a # 假设这里计算出一个var_a
  var_b # var_b通过var_a计算得到
  var_c = b()
  # 假定这里还有一些处理var_a和var_b的逻辑
end

def b(?)
  var_a
  var_b
  var_c # var_c通过var_a和var_b计算得到
end

Rails Server 大量 CLOST_WAIT，进程卡死，服务器无响应

tinyfeng — Fri, 15 Jun 2018 10:52:19 +0800

情况是这样的，在一台 vps 上运行了rails s -p 3000 -b 0.0.0.0 &

然后运行数天或者数小时之后，突然发现大部分时候请求无响应，查看 rails log 也无请求记录，只有偶尔能够请求成功一次。

重点来了，执行lsof -i:3000后反馈如图

猜测应该是 CLOSE_WAIT 引起的，大概但是不知道具体原因，也不知道怎么防止这样的事情发生。

自己测试了一下，刚请求之后 lsof 了一下，会有这么一条记录

在请求成功后或者浏览器无响应取消请求后会变成 CLOSE_WAIT

补充：我这只是一个很简单的 http api 测试服务器，一开始并没有 CLOST_WAIT 的问题，是运行一段时间后出现的。

Grape 对比起直接在 controller 里写接口有什么优点

tinyfeng — Sun, 13 May 2018 20:14:46 +0800

如题

你们觉得最好用的点在哪里呢

我觉得可以加一个匿名功能

tinyfeng — Wed, 25 Apr 2018 10:57:25 +0800

发帖的人或者回复的人都可以选择匿名，大家觉得怎么样。

kaminari 分页，页面结构有重复

tinyfeng — Tue, 03 Apr 2018 10:06:02 +0800

页面分页组件是这样的

页面结构是这样的

在 controller 里：

@xxxs = XXX.page(params[:page] || 1).per(10)

在 view 里：

<div class="turn_page>
  <%= paginate @xxxs, window: 2 %>
</div>

为什么里的内容在 font 结束了又全部重复了一次，但是里面的 a 标签却只有链接没有 html 内容

url_helper 踩坑，url 里指定 host 自动加了本地端口

tinyfeng — Mon, 26 Mar 2018 11:46:17 +0800

这是我在 routes 里定义的一个路由：

get 'hello', to: 'hello#hello'

在 rails console 下进行如下操作：

Rails.application.routes.url_helpers.hello_hello_url host: 'http://abc.xyz'
=> "http://abc.xyz/hello"

而我在本地启动一个 server，rails s -p 3333

在 controller 里用了这个东西: hello_hello_url host: 'http://abc.xyz'

返回值是"http://abc.xyz:3333/hello",里面居然自己加了本地端口！

有没有方法能够把自动加的 3333 端口给禁掉

我知道手动添加 port 可以一定程度上解决这个问题：

hello_hello_url host: 'http://abc.xyz', port: 80 # => "http://abc.xyz/hello"

可是这时候以 https 来访问，显然会出错