theine2 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 615c630c33ec9fd5f782deea81fddd51bcbdc52c974e99af20f445367c76b09f
+  data.tar.gz: 486d8591356ff29c79b6156391ff17758e27046886427c6281c78bd814661b7f
+SHA512:
+  metadata.gz: 72db5c2e5ae02fceb6d279dcabc21c13cdd11bc7c4357c2e585456e23a1fc47eef0fcffec7c0d9e853bd6696942f95b1d8fc3e4793b4d22924f68456f27b7c8f
+  data.tar.gz: 6287b46b78472aadb565160588c53352cd37be889caf642bd116338ec31b2f5721a1a8b080fe604aed9e429a7d1747a8ef06c31f8d22d949dbe8a8e60b2379db

data/bin/theine

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'theine/client'

data/bin/theine_current_ruby

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'theine/client'

data/bin/theine_server

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'theine/server'

data/bin/theine_set_ruby

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+script = <<EOS
+#!/bin/sh
+RUBY_CMD="%RUBY_CMD%"
+
+$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|
+    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
+  puts "Usage: theine_set_ruby /path/to/ruby_executable"
+end

data/lib/theine/client.rb

@@ -0,0 +1,84 @@
+require 'drb/drb'
+require 'readline'
+require_relative './config'
+
+module Theine
+  class Client
+    def self.start
+      new
+    end
+
+    attr_reader :config
+
+    def initialize
+      @config = ConfigReader.new(Dir.pwd)
+      @argv = ARGV.dup
+      begin
+        connect_worker
+        run_command
+        attach_screen
+        exit_prompt
+      end
+    end
+
+  private
+    def attach_screen
+      # Using vt100 because it does not have smcup/rmcup support,
+      # which means the output of the screen will stay shown after
+      # screen closes.
+      set_vt_100 = "export TERM=vt100; tset"
+      erase_screen_message = "echo '\\033[2A\\033[K'"
+      exec("#{set_vt_100}; screen -r theine#{@port}; #{erase_screen_message}")
+    end
+
+    def run_command
+      argv = @argv.dup
+      command = argv.shift
+
+      case command
+      when "rake"
+        @worker.command_rake(argv)
+      when "rspec"
+        @worker.command_rspec(argv)
+      when 'cucumber'
+        @worker.command_cucumber(argv)
+      else
+        @worker.command_rails([command] + argv)
+      end
+    rescue DRb::DRbConnError
+      $stderr.puts "\nTheine closed the connection."
+    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

@@ -0,0 +1,137 @@
+require 'drb/drb'
+require 'thread'
+require 'yaml'
+require_relative './config'
+
+module Theine
+  class Server
+    include DRb::DRbUndumped
+    attr_reader :config
+
+    def initialize
+      @config = ConfigReader.new(Dir.pwd)
+
+      @workers = []
+      @workers_in_use = []
+      @worker_pids = {}
+      @spawning_workers = []
+
+      @available_ports = ((config.base_port + 1)..config.max_port).to_a
+      @check_mutex = Mutex.new
+      @workers_mutex = Mutex.new
+
+      run
+    end
+
+    def add_worker
+      path = File.expand_path('../worker.rb', __FILE__)
+      port = @workers_mutex.synchronize { @available_ports.shift }
+      puts "(spawn #{"#{port} #{debug}".strip})"
+      spawn("screen", "-d", "-m", "-S", worker_session_name(port),
+        "sh", "-c",
+        "jruby #{debug} #{path} #{config.base_port.to_s} #{port.to_s} #{config.rails_root}")
+      @workers_mutex.synchronize { @spawning_workers << port }
+    end
+
+    def worker_session_name(port)
+      "theine#{port}"
+    end
+
+    def set_worker_pid(port, pid)
+      @workers_mutex.synchronize do
+        @worker_pids[port] = pid
+      end
+    end
+
+    def worker_boot(port)
+      puts "+ worker #{port}"
+
+      @workers_mutex.synchronize do
+        @spawning_workers.delete(port)
+        @workers << port
+      end
+    end
+
+    def worker_done(port)
+      puts "- worker #{port}"
+      @workers_mutex.synchronize do
+        @workers_in_use.delete(port)
+        @available_ports << port
+      end
+    end
+
+    def get_port(spawn_new = true)
+      add_worker if spawn_new && all_size == 0
+
+      port = @workers_mutex.synchronize { @workers.shift }
+      @workers_mutex.synchronize { @workers_in_use << port } if port
+
+      Thread.new { check_min_free_workers } if spawn_new
+
+      port
+    end
+
+    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_workers.empty? }
+          end
+          add_worker
+        end
+        @check_mutex.unlock
+      end
+    end
+
+    def all_size
+      @workers_mutex.synchronize { @workers.size + @spawning_workers.size }
+    end
+
+    def stop!
+      if spawning_worker_pids.include?(nil)
+        puts "Waiting for workers to quit..."
+        sleep 0.1 while spawning_worker_pids.include?(nil)
+      end
+
+      @workers_mutex.synchronize do
+        (@spawning_workers + @workers_in_use + @workers).each do |port|
+          kill_worker(port)
+        end
+      end
+      exit(0)
+    end
+  private
+    def kill_worker(port)
+      print "- worker #{port}"
+      worker_pid = @worker_pids[port]
+      worker_pid ||= DRbObject.new_with_uri("druby://localhost:#{port}").pid
+      system("kill -9 #{worker_pid} > /dev/null 2>&1")
+      session_name = worker_session_name(port)
+      system("screen -S #{session_name} -X quit > /dev/null 2>&1")
+      puts "."
+    rescue
+    end
+
+    def spawning_worker_pids
+      @spawning_workers.map { |port| @worker_pids[port] }
+    end
+
+    def run
+      trap("INT") { stop! }
+      trap("TERM") { stop! }
+      system("screen -wipe > /dev/null 2>&1")
+
+      DRb.start_service("druby://localhost:#{config.base_port}", self)
+      check_min_free_workers
+      DRb.thread.join
+    end
+
+    def debug
+      "--debug" if ARGV.any? {|a| a.to_s.strip == "--debug" }
+    end
+  end
+end
+
+Theine::Server.new

data/lib/theine/worker.rb

@@ -0,0 +1,170 @@
+RAILS_ROOT_PATH = ARGV[2]
+APP_PATH = "#{RAILS_ROOT_PATH}/config/application"
+require 'drb/drb'
+
+module Theine
+  class Worker
+    attr_reader :port, :balancer
+
+    COMMANDS = {
+      rails: proc {
+        require 'rails/commands'
+      },
+      rake: proc {
+        require 'rake'
+        ::Rails.application.load_tasks if defined? ::Rails
+
+        tasks = []
+        ARGV.each do |arg|
+          if arg =~ /^(\w+)=(.*)$/m
+            ENV[$1] = $2
+          else
+            tasks << arg
+          end
+        end
+
+        tasks.each do |task|
+          is_test_task = task =~ /^(spec|test)$/
+          if is_test_task
+            previous_env = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+            change_rails_env_to("test")
+          end
+
+          ::Rake::Task[task].invoke
+
+          change_rails_env_to(previous_env) if is_test_task
+        end
+      },
+      rspec: proc {
+        change_rails_env_to("test")
+
+        require 'rspec/core'
+        RSpec::Core::Runner.autorun
+      },
+      cucumber: proc {
+        change_rails_env_to("test")
+        require 'active_support/descendants_tracker'
+        require 'cucumber/rspec/disable_option_parser'
+        require 'cucumber/cli/main'
+        cucumber_runtime = Cucumber::Runtime.new
+        cucumber_main = Cucumber::Cli::Main.new(ARGV.dup)
+        cucumber_main.execute!(cucumber_runtime)
+      }
+    }
+
+    def initialize(port, balancer)
+      @port = port
+      @balancer = balancer
+      @command_proc = proc { }
+    end
+
+    def run
+      boot
+      begin
+        DRb.thread.join
+        screen_move_to_bottom
+        sleep 0.1 while !screen_attached?
+
+        puts "command: #{@command_name} #{argv_to_s}"
+        instance_exec(&@command_proc)
+      ensure
+        balancer.worker_done(port)
+      end
+    end
+
+    COMMANDS.each_pair do |command_name, command|
+      define_method("command_#{command_name}") do |argv|
+        set_argv(argv)
+        set_command(command_name, &command)
+      end
+    end
+
+    def pid
+      ::Process.pid
+    end
+
+    def stop!
+      exit(1)
+    end
+
+    def screen_attached?
+      !system("screen -ls | grep theine#{@port} | grep Detached > /dev/null")
+    end
+
+    def screen_move_to_bottom
+      puts "\033[22B"
+    end
+
+  private
+    def set_command(command_name, &block)
+      rails_reload!
+      @command_name = command_name
+      @command_proc = block
+      DRb.stop_service
+    end
+
+    def change_rails_env_to(env)
+      ENV['RAILS_ENV'] = env
+      ENV['RACK_ENV'] = env
+      if defined? ::Rails
+        ::Rails.env = env
+
+        # load config/environments/test.rb
+        test_env_rb = ::Rails.root.join("config/environments/#{env}.rb")
+        load(test_env_rb) if File.exist?(test_env_rb)
+
+        if defined? ActiveRecord
+          ActiveRecord::Base.establish_connection rescue nil
+        end
+
+        if defined? SequelRails
+          Sequel::Model.db = SequelRails.setup env
+        end
+      end
+    end
+
+    def argv_to_s
+      ARGV.map { |arg|
+        if !arg.nil? && arg.include?(" ")
+          "\"#{arg}\""
+        else
+          arg
+        end
+      }.join(' ')
+    end
+
+    def set_argv(argv)
+      ARGV.clear
+      ARGV.concat(argv)
+    end
+
+    def rails_reload!
+      if Rails.version.to_f >= 5.1
+        Rails.application.reloader.reload!
+        Rails.application.reloader.prepare!
+      else
+        ActionDispatch::Reloader.cleanup!
+        ActionDispatch::Reloader.prepare!
+      end  
+    end
+
+    def start_service
+      DRb.start_service("druby://localhost:#{@port}", self)
+    end
+
+    def boot
+      balancer.set_worker_pid(port, pid)
+
+      require "#{RAILS_ROOT_PATH}/config/boot"
+      require "#{RAILS_ROOT_PATH}/config/environment"
+      start_service
+
+      balancer.worker_boot(port)
+    end
+  end
+end
+
+balancer = DRbObject.new_with_uri("druby://localhost:#{ARGV[0]}")
+worker = Theine::Worker.new(ARGV[1].to_i, balancer)
+
+worker.run

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: theine2
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jan Berdajs
+- Ron Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-26 00:00:00.000000000 Z
+dependencies: []
+description: A Rails preloader for JRuby
+email: ron.a.williams@gmail.com
+executables:
+- theine
+- theine_current_ruby
+- theine_server
+- theine_set_ruby
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/theine
+- bin/theine_current_ruby
+- bin/theine_server
+- bin/theine_set_ruby
+- lib/theine.rb
+- lib/theine/client.rb
+- lib/theine/config.rb
+- lib/theine/server.rb
+- lib/theine/worker.rb
+homepage: https://github.com/rwilliams/theine2
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Theine2
+test_files: []