theine 0.0.2 → 0.0.3

data/bin/theine_set_ruby

@@ -3,13 +3,16 @@ script = <<EOS
 #!/bin/sh
 RUBY_CMD="%RUBY_CMD%"
 
-$RUBY_CMD -e "require 'theine/client'" "$@"
+$RUBY_CMD -e "require '%CLIENT_RB_PATH%'" "$@"
 EOS
 
 if ARGV[0]
   path = %x[which theine]
+  client_rb_path = File.expand_path('../../lib/theine/client.rb', __FILE__)
   File.open(path.strip, "w") do |f|
-    f.write(script.gsub("%RUBY_CMD%", ARGV[0]))
+    script.gsub!("%CLIENT_RB_PATH%", client_rb_path)
+    script.gsub!("%RUBY_CMD%", ARGV[0])
+    f.write(script)
   end
   puts "Set theine to run using #{ARGV[0]}."
 else

data/lib/theine/client.rb

@@ -1,7 +1,6 @@
 require 'drb/drb'
 require 'readline'
-
-PRAILS_BASE_PORT = 11000
+require_relative './config'
 
 class IOUndumpedProxy
   include DRb::DRbUndumped
@@ -31,6 +30,10 @@ class IOUndumpedProxy
     end
   end
 
+  def gets(*args)
+    @obj.gets(*args)
+  end
+
   def puts(*lines)
     @obj.puts(*lines)
   end
@@ -59,32 +62,92 @@ class IOUndumpedProxy
   end
 end
 
-argv = ARGV.dup
-ARGV.clear
+module Theine
+  class Client
+    def self.start
+      new
+    end
 
-DRb.start_service
+    attr_reader :config
+
+    def initialize
+      @config = ConfigReader.new(Dir.pwd)
+      reset_argv!
+      trap_signals
+      begin
+        connect_worker
+        redirect_io
+        run_command
+      ensure
+        stop
+      end
+    end
 
-i = 1
-begin
-  balancer = DRbObject.new_with_uri("druby://localhost:#{PRAILS_BASE_PORT}")
-  sleep 0.1 until port = balancer.get_port
-  prails = DRbObject.new_with_uri("druby://localhost:#{port}")
-rescue DRb::DRbConnError
-  sleep 0.5
-  putc "."
-  i += 1
-  retry
-end
-putc "\n"
-
-trap('INT') {
-  %x[kill -2 #{prails.pid}]
-}
-
-prails.stdin = IOUndumpedProxy.new($stdin)
-prails.stdout = IOUndumpedProxy.new($stdout)
-prails.stderr = IOUndumpedProxy.new($stderr)
-begin
-  prails.command_rails(argv)
-rescue DRb::DRbConnError
+    def stop(sleep_for = 0.1)
+      begin
+        if @worker
+          %x[kill -2 #{@worker.pid}] # TODO: if client was term-ed, term worker (maybe term)
+          puts "Stopping Theine worker."
+          sleep(sleep_for) if sleep_for > 0 # to finish receiving IO
+        end
+      rescue DRb::DRbConnError
+      end
+      exit(0)
+    end
+
+  private
+    def run_command
+      @worker.command_rails(@argv)
+    rescue DRb::DRbConnError
+      $stderr.puts "\nTheine closed the connection."
+    end
+
+    def reset_argv!
+      @argv = ARGV.dup
+      ARGV.clear
+    end
+
+    def trap_signals
+      trap('INT') { exit(0) } # TODO: is this needed?
+      trap('TERM') { exit(0) }
+    end
+
+    def redirect_io
+      @worker.stdin = IOUndumpedProxy.new($stdin)
+      @worker.stdout = IOUndumpedProxy.new($stdout)
+      @worker.stderr = IOUndumpedProxy.new($stderr)
+    end
+
+    def connect_worker
+      balancer = wait_until_result("Cannot connect to theine server. Waiting") do
+        object = DRbObject.new_with_uri("druby://localhost:#{config.base_port}")
+        object.respond_to?(:get_port) # test if connected
+        object
+      end
+      port = wait_until_result("Waiting for Theine worker...") do
+        balancer.get_port
+      end
+      @worker = DRbObject.new_with_uri("druby://localhost:#{port}")
+    end
+
+    WaitResultNoResultError = Class.new(StandardError)
+    def wait_until_result(wait_message)
+      result = nil
+      dots = 0
+      begin
+        result = yield
+        raise WaitResultNoResultError unless result
+      rescue DRb::DRbConnError, WaitResultNoResultError
+        print dots == 0 ? wait_message : "."
+        dots += 1
+        sleep 0.5
+        retry
+      end
+      print "\n" if dots > 0
+      result
+    end
+  end
 end
+
+DRb.start_service
+Theine::Client.start

data/lib/theine/config.rb

@@ -0,0 +1,27 @@
+require 'yaml'
+
+module Theine
+  class ConfigReader
+    attr_reader :rails_root
+    attr_accessor :base_port, :max_port, :min_free_workers, :spawn_parallel
+    def initialize(rails_root)
+      @rails_root = rails_root
+      @base_port = 11000
+      @max_port = 11100
+      @min_free_workers = 2
+      @spawn_parallel = true
+      load_config(File.expand_path("~/.theine"))
+      load_config("#{rails_root}/.theine")
+    end
+
+    def load_config(path)
+      if File.exist?(path)
+        config = YAML.load(File.read(path))
+        config.each_pair do |k, v|
+          setter = :"#{k}="
+          send(setter, v) if respond_to?(setter)
+        end
+      end
+    end
+  end
+end

data/lib/theine/server.rb

@@ -1,75 +1,84 @@
 require 'drb/drb'
 require 'thread'
+require 'yaml'
+require_relative './config'
 
-PRAILS_BASE_PORT = 11000
-PRAILS_MAX_PORT = 11100
-MIN_FREE_INSTANCES = 2
-RAILS_APP_ROOT = Dir.pwd
+module Theine
+  class Server
+    include DRb::DRbUndumped
+    attr_reader :config
 
-class PrailsServer
-  include DRb::DRbUndumped
+    def initialize
+      @config = ConfigReader.new(Dir.pwd)
 
-  def initialize
-    @instances = []
-    @spawning = []
+      @workers = []
+      @spawning = []
 
-    @available_ports = ((PRAILS_BASE_PORT + 1)..PRAILS_MAX_PORT).to_a
-    @check_mutex = Mutex.new
-    @instances_mutex = Mutex.new
-  end
-
-  def add_instance
-    path = File.expand_path('../instance.rb', __FILE__)
-    port = @available_ports.shift
-    puts "(spawn #{port})"
-    spawn("ruby", path, PRAILS_BASE_PORT.to_s, port.to_s, RAILS_APP_ROOT)
-    @instances_mutex.synchronize { @spawning << 1 }
-  end
+      @available_ports = ((config.base_port + 1)..config.max_port).to_a
+      @check_mutex = Mutex.new
+      @workers_mutex = Mutex.new
 
-  def instance_boot(port)
-    puts "+ instance #{port}"
+      run
+    end
 
-    @instances_mutex.synchronize do
-      @spawning.pop
-      @instances << port
+    def add_worker
+      path = File.expand_path('../worker.rb', __FILE__)
+      port = @available_ports.shift
+      puts "(spawn #{port})"
+      spawn("ruby", path, config.base_port.to_s, port.to_s, config.rails_root)
+      @workers_mutex.synchronize { @spawning << 1 }
     end
-  end
 
-  def get_port
-    add_instance if all_size == 0
+    def worker_boot(port)
+      puts "+ worker #{port}"
 
-    port = nil
-    while port.nil? && all_size > 0
-      @instances_mutex.synchronize do
-        port = @instances.shift
+      @workers_mutex.synchronize do
+        @spawning.pop
+        @workers << port
       end
-      sleep 0.1 unless port
     end
 
-    Thread.new { check_min_free_instances }
+    def worker_done(port)
+      puts "- worker #{port}"
+    end
 
-    port
-  end
+    def get_port
+      add_worker if all_size == 0
 
-  def check_min_free_instances
-    if @check_mutex.try_lock
-      # TODO: mutex, and dont do it if already in progress
-      # do this in thread
-      while all_size < MIN_FREE_INSTANCES
-        sleep 0.1 until @instances_mutex.synchronize { @spawning.empty? }
-        add_instance
+      port = @workers_mutex.synchronize do
+        @workers.shift
       end
-      @check_mutex.unlock
+
+      Thread.new { check_min_free_workers }
+
+      port
     end
-  end
 
-  def all_size
-    @instances_mutex.synchronize { @instances.size + @spawning.size }
+    def check_min_free_workers
+      if @check_mutex.try_lock
+        # TODO: mutex, and dont do it if already in progress
+        # do this in thread
+        while all_size < config.min_free_workers
+          unless config.spawn_parallel
+            sleep 0.1 until @workers_mutex.synchronize { @spawning.empty? }
+          end
+          add_worker
+        end
+        @check_mutex.unlock
+      end
+    end
+
+    def all_size
+      @workers_mutex.synchronize { @workers.size + @spawning.size }
+    end
+  private
+    def run
+      DRb.start_service("druby://localhost:#{config.base_port}", self)
+      check_min_free_workers
+      DRb.thread.join
+    end
   end
 end
 
-server = PrailsServer.new
-DRb.start_service("druby://localhost:#{PRAILS_BASE_PORT}", server)
+server = Theine::Server.new
 
-server.check_min_free_instances
-DRb.thread.join

data/lib/theine/worker.rb

@@ -0,0 +1,124 @@
+root_path = ARGV[2]
+APP_PATH = "#{root_path}/config/application"
+require "#{root_path}/config/boot"
+require "#{root_path}/config/environment"
+require 'drb/drb'
+
+$real_stdout = $stdout
+$real_stderr = $stderr
+
+module Theine
+  class Worker
+    attr_reader :stdin, :stdout, :stderr
+    InputProxy = Struct.new :input do
+      # Reads a line from the input
+      def readline(prompt)
+        case readline_arity
+        when 1 then input.readline(prompt)
+        else        input.readline
+        end
+      end
+
+      def completion_proc=(val)
+        input.completion_proc = val
+      end
+
+      def readline_arity
+        input.method_missing(:method, :readline).arity
+      rescue NameError
+        0
+      end
+
+      def gets(*args)
+        input.gets(*args)
+      end
+    end
+
+    def initialize
+      @pumps = []
+    end
+
+    def command_rails(argv)
+      rails_reload!
+
+      ARGV.clear
+      ARGV.concat(argv)
+
+      require 'pry'
+      ::Rails.application.config.console = Pry
+
+      Pry.config.input = stdin
+      Pry.config.output = stdout
+
+      require 'rails/commands'
+      sleep 0.1 # allow Pumps to finish
+      DRb.stop_service
+    end
+
+    def stdin=(value)
+      @stdin = InputProxy.new(value)
+      $stdin = @stdin
+    end
+
+    def stdout=(value)
+      $orig_stdout = $stdout
+      @stdout = value
+      r, w = IO.pipe
+      $stdout = w
+      @pumps << Pump.new(r, @stdout)
+    end
+
+    def stderr=(value)
+      $orig_stderr = $stderr
+      @stderr = value
+      r, w = IO.pipe
+      $stderr = w
+      @pumps << Pump.new(r, @stderr)
+    end
+
+    def pid
+      ::Process.pid
+    end
+
+  private
+    def rails_reload!
+      ActionDispatch::Reloader.cleanup!
+      ActionDispatch::Reloader.prepare!
+    end
+
+    class Pump < Thread
+      def initialize(input, output)
+        if output
+          @input = input
+          @output = output
+          super(&method(:main))
+        else
+          close_stream(input)
+        end
+      end
+
+    private
+      def main
+        while buf = @input.sysread(1024)
+          @output.print(buf)
+          @output.flush
+        end
+      ensure
+        @output.close
+      end
+    end
+  end
+end
+
+base_port = ARGV[0]
+worker_port = ARGV[1]
+DRb.start_service("druby://localhost:#{worker_port}", Theine::Worker.new)
+
+balancer = DRbObject.new_with_uri("druby://localhost:#{base_port}")
+balancer.worker_boot(worker_port)
+
+begin
+  DRb.thread.join
+ensure
+  balancer.worker_done(worker_port)
+end

metadata

@@ -2,7 +2,7 @@
 name: theine
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Jan Berdajs
@@ -23,7 +23,8 @@ files:
 - lib/theine.rb
 - lib/theine/client.rb
 - lib/theine/server.rb
-- lib/theine/instance.rb
+- lib/theine/worker.rb
+- lib/theine/config.rb
 - bin/theine
 - bin/theine_server
 - bin/theine_set_ruby

data/lib/theine/instance.rb

@@ -1,114 +0,0 @@
-root_path = ARGV[2]
-APP_PATH = "#{root_path}/config/application"
-require "#{root_path}/config/boot"
-require "#{root_path}/config/environment"
-require 'drb/drb'
-
-$real_stdout = $stdout
-$real_stderr = $stderr
-
-class PrailsServer
-  attr_reader :stdin, :stdout, :stderr
-  InputProxy = Struct.new :input do
-    # Reads a line from the input
-    def readline(prompt)
-      case readline_arity
-      when 1 then input.readline(prompt)
-      else        input.readline
-      end
-    end
-
-    def completion_proc=(val)
-      input.completion_proc = val
-    end
-
-    def readline_arity
-      input.method_missing(:method, :readline).arity
-    rescue NameError
-      0
-    end
-  end
-
-  def initialize
-    @pumps = []
-  end
-
-  def command_rails(argv)
-    rails_reload!
-
-    ARGV.clear
-    ARGV.concat(argv)
-
-    require 'pry'
-    ::Rails.application.config.console = Pry
-
-    Pry.config.input = stdin
-    Pry.config.output = stdout
-
-    require 'rails/commands'
-    sleep 0.1 # allow Pumps to finish
-    DRb.stop_service
-  end
-
-  def stdin=(value)
-    @stdin = InputProxy.new(value)
-    $stdin = @stdin
-  end
-
-  def stdout=(value)
-    $orig_stdout = $stdout
-    @stdout = value
-    r, w = IO.pipe
-    $stdout = w
-    @pumps << Pump.new(r, @stdout)
-  end
-
-  def stderr=(value)
-    $orig_stderr = $stderr
-    @stderr = value
-    r, w = IO.pipe
-    $stderr = w
-    @pumps << Pump.new(r, @stderr)
-  end
-
-  def pid
-    ::Process.pid
-  end
-
-private
-  def rails_reload!
-    ActionDispatch::Reloader.cleanup!
-    ActionDispatch::Reloader.prepare!
-  end
-
-  class Pump < Thread
-    def initialize(input, output)
-      if output
-        @input = input
-        @output = output
-        super(&method(:main))
-      else
-        close_stream(input)
-      end
-    end
-
-  private
-    def main
-      while buf = @input.sysread(1024)
-        @output.print(buf)
-        @output.flush
-      end
-    ensure
-      @output.close
-    end
-  end
-end
-
-base_port = ARGV[0]
-instance_port = ARGV[1]
-DRb.start_service("druby://localhost:#{instance_port}", PrailsServer.new)
-
-balancer = DRbObject.new_with_uri("druby://localhost:#{base_port}")
-balancer.instance_boot(instance_port)
-
-DRb.thread.join