3

假设我在几个开放的交互式 Rails 控制台之一中运行一个很长的工作脚本。

该脚本正在更新一个非常非常大的记录表中​​的列。我已将 ActiveRecord 记录器静音以加快该过程，并指示脚本输出一些进度记录，以便我知道该过程需要多长时间。这就是我目前正在做的事情，它看起来像这样：

ModelName.all.each_with_index do |r, i|
  puts i if i % 250
  ...runs some process...
  r.save
end

有时它的两个嵌套数组正在运行，这样就会有多个迭代器和其他东西同时运行。

有没有办法我可以做这样的事情并从单独的 Rails 控制台访问该变量？（这样每次进程运行时变量都会被覆盖而不会减慢）

records = ModelName.all
$total = records.count
records.each_with_index do |r, i|
  $i = i
  ...runs some process...
  r.save
end

同时在其他控制台中进行

puts "#{($i/$total * 100).round(2)}% complete"
#=> 67.43% complete

我知道将全局变量从一个单独的 ruby​​ 实例传递到下一个是行不通的。我也只是试过这个没有效果

Unix 控制台 1

 $X=5
 echo {$X}
 #=> 5

Unix控制台2

echo {$X}
#=> ""

最后，我也知道使用像这样的全局变量是一个主要的软件设计模式。我认为这是合理的，但如果我愿意，我仍然想知道如何打破这条规则。

写入文本文件显然会起作用。所以会写入一个单独的数据库表或其他东西。这不是一个坏主意。但真正酷的技巧是在两个实例之间共享一个变量，而不写入文本文件或数据库列。

无论如何这会叫什么？隧道？我不太清楚如何标记这个问题。也许坏主意就是其中之一。但老实说设计模式不是这个问题的意义所在。

我使用答案制定了一些解决方案：

这是我设置的一个似乎有效的快速实现：

该系统通常需要三个单独的类（在我的情况下，我使用所有类，因为我在 Rails 中并且更容易）

计数器类：这被传递给 DRb，然后它的所有方法都可以通过客户端访问。因此，这个对象可能非常复杂。

class Counter
  attr_accessor :i
  def initialize
    @i = 0
  end
  def report(total)
    "#{(@i.to_f / total.to_f * 100).round(2)}%"
  end
end

柜台服务器。计数器被传递到这个。在我的情况下，该进程挂起，因此不返回任何内容并且无法访问。我还没有弄清楚如何将它作为可通过对象访问的守护进程运行，因此最好传入 uri 并控制它，因此不需要返回任何内容。这样做的好处是你可以让它运行很长时间，然后重写通过 attr_accessor 调用的访问器方法访问的变量。Ruby 让它变得超级简单。

require 'drb'
class CounterServer
  def initialize(uri="druby://:9000")
    DRb.start_service(uri, Counter.new)
    puts "server running on #{DRb.uri}"
    trap("INT") {DRb.stop_service}
    DRb.thread.join
  end
end

客户端。允许您访问服务器。

require 'drb'
class CounterClient
  attr_reader :client, :total
  def initialize(uri="druby://:9000", records)
    @client = DRbObject.new nil, uri
    @total = records.count
  end
  def incremement
    @client.i += 1
  end
  def monitor_and_report
    values = []
    puts "you must first set the @total value! This should be done in the ruby script being monitored by passing in the records as a first variable for initialize" if @client.total.nil?
    5/0 if @client.total.nil?
    while ((@client.i) < (@client.total))
      values << pctg_complete
      puts "#{pctg_complete}%"
      last_index = (values.count - 1)
      percentage_per_second = get_slope(values[last_index], values[last_index - 1])
      puts get_eta(percentage_per_second, values[last_index]) unless values.count == 1
      sleep 10
    end
  end

  def get_slope(latest, second_latest)
    run  = 10.0# seconds
    rise = (latest - second_latest)
    slope = (rise/run)
    slope
  end

  def get_eta(velocity, current)
    puts "velocity: #{velocity}"
    puts "current: #{current}"
    pctg_left_to_complete = (100.0 - current)
    puts "pctg_left: #{pctg_left_to_complete}"
    estimated_seconds_remaining = pctg_left_to_complete / velocity
    minutes_left = (estimated_seconds_remaining / 60.0).round(0)
    "estimated #{minutes_left} minutes until completion"
  end

因此，在我的问题示例中：

控制台 1

CounterServer.new
#=> hangs while server runs

控制台（红宝石脚本）2

records = ModelName.all
c = CounterClient.new(nil, records)
records.each_with_index do |r, i|
  c.increment
  ...runs code...
  r.save
 end

控制台 3

c = CounterClient.new
c.monitor_and_report

请注意几周后再次查看此代码： 此代码可能要简单得多。一方面， Counter 类不需要报告任何内容。它所需要的只是 attr_accessor 方法。服务器和客户端也可以精简到只有几行。

但是，这里的脚本有更多的主题元素。自从我编写它以来，我还没有使用过一次，但在我看来，学习如何在不同的 ruby​​ 控制台之间进行通信似乎是一项非常强大的技能。

更新 这款手表的“较小功能”不起作用。即eta函数。这是一块****

4

2 回答 2

3

你需要 Drb。它通过创建分布式 ruby​​ 服务（服务器）来工作，然后客户端连接到它并能够从中获取 Ruby 对象。

http://www.ruby-doc.org/stdlib-1.9.3/libdoc/drb/rdoc/DRb.html

于 2013-10-12T20:38:20.623 回答
0

让 ruby​​ 在 unix 通道上发出数据，例如 STDERR 或 STDOUT。然后将该输出通过管道传输到另一个基于 ruby​​ 的接收器。

该辅助进程只会空闲并检查其 STDIN 中的数据——找到任何数据，它将打印到屏幕上。

您还可以让长时间运行的脚本在捕获给定信号时发出数据来执行此操作。因此，日志记录操作只会在您发出信号时发生。

memcached_client = get_memcashed_singleton

begin
  if record_count % 250 == 0
    Signal.trap("USR1") do
      memcached_client.store('lrp1_percent_done', batch_position )
    end
    Signal.trap("TERM") do
      puts "Terminating..."
      stop_processing_at_next_logical_block
    end
  end
  # . . . do some work . . .
while records_left_in_giant_processing_table?

但总的来说，从技术上讲，一个更好的架构策略是，您的长时间运行的进程为您的网络中的另一个预先存在的服务打开一个到 memcached 的客户端连接 - 并将日志数据写入其中。

您需要为此支付的唯一费用是用于连接的内存，以及用于与基于内存的服务器进行通信的极少时间。

您必须考虑写入一条信息以便另一个进程可以读取它意味着什么，以及这样做需要多长时间。原则上讲，你要么写到磁盘，要么写到内存中注册。

磁盘上的文件类似于套接字。

内存中的寄存器类似于报告

于 2013-10-12T21:02:11.263 回答