oop_rails_server 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b764225db8990e99a3727eec3d2252c3c9b857d9
+  data.tar.gz: 2ba96b68047a98c91fa77f39a050870cff565f59
+SHA512:
+  metadata.gz: 86b2cfed985bf6457e069d085bb97e00a01cc52e3ae4d4331d737ba7d982a41e668797c0c926bf174061de04d7e80ea50d7e7846639ad4ce0be6ca0b8ebb8375
+  data.tar.gz: 02c1ed8ee642d24224e90e358576fb8184922f06797a029b357052bd5856dc5ea4f4d72e25400610c414593ea12758ca5535618512226cc1a569a1ac8c4beba6

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in oop_rails_server.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Andrew Geweke
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# OopRailsServer
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'oop_rails_server'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install oop_rails_server
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/oop_rails_server/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/oop_rails_server/helpers.rb

@@ -0,0 +1,163 @@
+require 'active_support'
+require 'json'
+require 'oop_rails_server/rails_server'
+
+module OopRailsServer
+  module Helpers
+    extend ActiveSupport::Concern
+
+    attr_reader :rails_server
+
+
+    def full_path(subpath)
+      "#{rails_template_name}/#{subpath}"
+    end
+
+    def get(subpath, options = { })
+      rails_server.get(full_path(subpath), options)
+    end
+
+    def get_response(subpath, options = { })
+      rails_server.get_response(full_path(subpath), options)
+    end
+
+    def get_success(subpath, options = { })
+      data = get(subpath, options)
+      data.should match(/rails_spec_application/i) unless options[:no_layout]
+      data
+    end
+
+    def expect_match(subpath, *args)
+      options = args.extract_options!
+      regexes = args
+
+      data = get_success(subpath, options)
+      regexes.each do |regex|
+        data.should match(regex)
+      end
+
+      data
+    end
+
+    def expect_exception(subpath, class_name, message)
+      data = get(subpath)
+
+      json = begin
+        JSON.parse(data)
+      rescue => e
+        raise %{Expected a JSON response from '#{subpath}' (because we expected an exception),
+  but we couldn't parse it as JSON; when we tried, we got:
+
+  (#{e.class.name}) #{e.message}
+
+  The data is:
+
+  #{data.inspect}}
+      end
+
+      json['exception'].should be
+      json['exception']['class'].should == class_name.to_s
+      json['exception']['message'].should match(message)
+    end
+
+    def rails_template_name
+      rails_server.name
+    end
+
+    def rails_server_project_root
+      raise %{You must override #rails_server_project_root in this class (#{self.class.name}) to use OopRailsServer::Helpers;
+it should return the fully-qualified path to the root of your project (gem, application, or whatever).}
+    end
+
+    def rails_server_templates_root
+      @rails_server_templates_root ||= File.join(rails_server_project_root, "spec/rails/templates")
+    end
+
+    def rails_server_runtime_base_directory
+      @rails_server_runtime_base_directory ||= File.join(rails_server_project_root, "tmp/spec/rails")
+    end
+
+    def rails_server_additional_gemfile_lines
+      [
+        "gem 'fortitude', :path => '#{rails_server_project_root}'"
+      ]
+    end
+
+    def rails_server_default_version
+      ENV['FORTITUDE_SPECS_RAILS_VERSION']
+    end
+
+    def rails_servers
+      @rails_servers ||= { }
+    end
+
+    def rails_server
+      if rails_servers.size == 1
+        rails_servers[rails_servers.keys.first]
+      elsif rails_servers.size == 0
+        raise "No Rails servers have been started!"
+      else
+        raise "Multiple Rails servers have been started; you must specify which one you want: #{rails_servers.keys.join(", ")}"
+      end
+    end
+
+    def start_rails_server!(options = { })
+      templates = Array(options[:templates] || options[:name] || [ ])
+      raise "You must specify a template" unless templates.length >= 1
+
+      name = options[:name]
+      name ||= templates[0] if templates.length == 1
+      name = name.to_s.strip
+      raise "You must specify a name" unless name && name.to_s.strip.length > 0
+
+      server = rails_servers[name]
+      server ||= begin
+        templates = [ 'base' ] + templates unless options[:skip_base_template]
+
+        template_paths = templates.map do |t|
+          File.join(rails_server_templates_root, t.to_s)
+        end
+
+        additional_gemfile_lines = Array(rails_server_additional_gemfile_lines || [ ])
+        additional_gemfile_lines += Array(options[:additional_gemfile_lines] || [ ])
+
+        server = ::OopRailsServer::RailsServer.new(
+          :name => name, :template_paths => template_paths,
+          :runtime_base_directory => rails_server_runtime_base_directory,
+          :rails_version => (options[:rails_version] || rails_server_default_version),
+          :rails_env => options[:rails_env], :additional_gemfile_lines => additional_gemfile_lines)
+
+        rails_servers[name] = server
+
+        server
+      end
+
+      server.start!
+    end
+
+    def stop_rails_servers!
+      exceptions = [ ]
+      rails_servers.each do |name, server|
+        begin
+          server.stop!
+        rescue => e
+          exceptions << [ name, e ]
+        end
+      end
+
+      raise "Unable to stop all Rails servers! Got:\n#{exceptions.join("\n")}" if exceptions.length > 0
+    end
+
+    module ClassMethods
+      def uses_rails_with_template(template_name, options = { })
+        before :all do
+          start_rails_server!({ :templates => [ template_name ] }.merge(options))
+        end
+
+        after :all do
+          stop_rails_servers!
+        end
+      end
+    end
+  end
+end

data/lib/oop_rails_server/rails_server.rb

@@ -0,0 +1,378 @@
+require 'fileutils'
+require 'find'
+require 'net/http'
+require 'uri'
+
+module OopRailsServer
+  class RailsServer
+    attr_reader :rails_root, :rails_version, :name
+
+    def initialize(options)
+      options.assert_valid_keys(
+        :name, :template_paths, :runtime_base_directory,
+        :rails_version, :rails_env, :additional_gemfile_lines
+      )
+
+      @name = options[:name] || raise(ArgumentError, "You must specify a name for the Rails server")
+
+      @template_paths = options[:template_paths] || raise(ArgumentError, "You must specify one or more template paths")
+      @template_paths = Array(@template_paths).map { |t| File.expand_path(t) }
+
+      @runtime_base_directory = options[:runtime_base_directory] || raise(ArgumentError, "You must specify a runtime_base_directory")
+      @runtime_base_directory = File.expand_path(@runtime_base_directory)
+
+      @rails_version = options[:rails_version] || :default
+      @rails_env = (options[:rails_env] || 'production').to_s
+
+      @additional_gemfile_lines = Array(options[:additional_gemfile_lines] || [ ])
+
+
+      @rails_root = File.join(@runtime_base_directory, rails_version.to_s, name.to_s)
+      @port = 20_000 + rand(10_000)
+      @server_pid = nil
+    end
+
+    def start!
+      do_start! unless server_pid
+    end
+
+    def stop!
+      stop_server! if server_pid
+    end
+
+    def get(path, options = { })
+      get_response(path, options).body.strip
+    end
+
+    def uri_for(path)
+      uri_string = "http://localhost:#{@port}/#{path}"
+      URI.parse(uri_string)
+    end
+
+    def get_response(path, options = { })
+      uri = uri_for(path)
+      data = Net::HTTP.get_response(uri)
+      unless data.code.to_s == '200' || options[:ignore_status_code]
+        raise "'#{uri}' returned #{data.code.inspect}, not 200; body was: #{data.body.strip}"
+      end
+      data
+    end
+
+    private
+    attr_reader :template_paths, :runtime_base_directory, :rails_env, :additional_gemfile_lines, :port, :server_pid
+
+    def do_start!
+      Bundler.with_clean_env do
+        with_rails_env do
+          setup_directories!
+
+          in_rails_root_parent do
+            splat_bootstrap_gemfile!
+            rails_new!
+            update_gemfile!
+          end
+
+          in_rails_root do
+            run_bundle_install!(:primary)
+            splat_template_files!
+            start_server!
+            verify_server!
+          end
+        end
+      end
+    end
+
+    def with_rails_env
+      old_rails_env = ENV['RAILS_ENV']
+      begin
+        ENV['RAILS_ENV'] = rails_env
+        yield
+      ensure
+        ENV['RAILS_ENV'] = old_rails_env
+      end
+    end
+
+
+    def setup_directories!
+      return if @directories_setup
+
+      template_paths.each do |template_path|
+        raise Errno::ENOENT, "You must specify template paths that exist; this doesn't: '#{template_path}'" unless File.directory?(template_path)
+      end
+      FileUtils.rm_rf(rails_root) if File.exist?(rails_root)
+      FileUtils.mkdir_p(rails_root)
+
+      @directories_setup = true
+    end
+
+    def in_rails_root(&block)
+      Dir.chdir(rails_root, &block)
+    end
+
+    def in_rails_root_parent(&block)
+      Dir.chdir(File.dirname(rails_root), &block)
+    end
+
+    def splat_bootstrap_gemfile!
+      File.open("Gemfile", "w") do |f|
+        rails_version_spec = if rails_version == :default then "" else ", \"= #{rails_version}\"" end
+        f << <<-EOS
+source 'https://rubygems.org'
+
+gem 'rails'#{rails_version_spec}
+EOS
+      end
+
+      run_bundle_install!(:bootstrap)
+    end
+
+    def rails_new!
+      # This is a little trick to specify the exact version of Rails you want to create it with...
+      # http://stackoverflow.com/questions/379141/specifying-rails-version-to-use-when-creating-a-new-application
+      rails_version_spec = rails_version == :default ? "" : "_#{rails_version}_"
+      cmd = "bundle exec rails #{rails_version_spec} new #{File.basename(rails_root)} -d sqlite3 -f -B"
+      safe_system(cmd, "creating a new Rails installation for '#{name}'")
+    end
+
+    def update_gemfile!
+      gemfile = File.join(rails_root, 'Gemfile')
+      gemfile_contents = File.read(gemfile)
+
+      # Since Rails 3.0.20 was released, a new version of the I18n gem, 0.5.2, was released that moves a constant
+      # into a different namespace. (See https://github.com/mislav/will_paginate/issues/347 for more details.)
+      # So, if we're running Rails 3.0.x, we lock the 'i18n' gem to an earlier version.
+      gemfile_contents << "\ngem 'i18n', '= 0.5.0'\n" if rails_version && rails_version =~ /^3\.0\./
+
+      # Apparently execjs released a version 2.2.0 that will happily install on Ruby 1.8.7, but which contains some
+      # new-style hash syntax. As a result, we pin the version backwards in this one specific case.
+      gemfile_contents << "\ngem 'execjs', '~> 2.0.0'\n" if RUBY_VERSION =~ /^1\.8\./
+
+      gemfile_contents << additional_gemfile_lines.join("\n")
+
+      File.open(gemfile, 'w') { |f| f << gemfile_contents }
+    end
+
+    def with_env(new_env)
+      old_env = { }
+      new_env.keys.each { |k| old_env[k] = ENV[k] }
+
+      begin
+        set_env(new_env)
+        yield
+      ensure
+        set_env(old_env)
+      end
+    end
+
+    def set_env(new_env)
+      new_env.each do |k,v|
+        if v
+          ENV[k] = v
+        else
+          ENV.delete(k)
+        end
+      end
+    end
+
+    def splat_template_files!
+      @template_paths.each do |template_path|
+        Find.find(template_path) do |file|
+          next unless File.file?(file)
+
+          if file[0..(template_path.length)] == "#{template_path}/"
+            subpath = file[(template_path.length + 1)..-1]
+          else
+            raise "#{file} isn't under #{template_path}?!?"
+          end
+          dest_file = File.join(rails_root, subpath)
+
+          FileUtils.mkdir_p(File.dirname(dest_file))
+          FileUtils.cp(file, dest_file)
+        end
+      end
+    end
+
+    def start_server!
+      output = File.join(rails_root, 'log', 'rails-server.out')
+      cmd = "rails server -p #{port} > '#{output}'"
+      safe_system(cmd, "starting 'rails server' on port #{port}", :background => true)
+
+      server_pid_file = File.join(rails_root, 'tmp', 'pids', 'server.pid')
+
+      start_time = Time.now
+      while Time.now < start_time + 15
+        if File.exist?(server_pid_file)
+          server_pid = File.read(server_pid_file).strip
+          if server_pid =~ /^(\d{1,10})$/i
+            @server_pid = Integer(server_pid)
+            break
+          end
+        end
+        sleep 0.1
+      end
+    end
+
+    def verify_server!
+      server_verify_url = "http://localhost:#{port}/working/rails_is_working"
+      uri = URI.parse(server_verify_url)
+
+      data = nil
+      start_time = Time.now
+      while (! data)
+        begin
+          data = Net::HTTP.get_response(uri)
+        rescue Errno::ECONNREFUSED, EOFError
+          raise if Time.now > (start_time + 20)
+          # keep waiting
+          sleep 0.1
+        end
+      end
+
+      unless data.code.to_s == '200'
+        raise "'#{server_verify_url}' returned #{data.code.inspect}, not 200"
+      end
+      result = data.body.strip
+
+      unless result =~ /^Rails\s+version\s*:\s*(\d+\.\d+\.\d+)$/
+        raise "'#{server_verify_url}' returned: #{result.inspect}"
+      end
+      actual_version = $1
+
+      if rails_version != :default && (actual_version != rails_version)
+        raise "We seem to have spawned the wrong version of Rails; wanted: #{rails_version.inspect} but got: #{actual_version.inspect}"
+      end
+
+      say "Successfully spawned a server running Rails #{actual_version} on port #{port}."
+    end
+
+    def is_alive?(pid)
+      cmd = "ps -o pid #{pid}"
+      results = `#{cmd}`
+      results.split(/[\r\n]+/).each do |line|
+        line = line.strip.downcase
+        next if line == 'pid'
+        if line =~ /^\d+$/i
+          return true if Integer(line) == pid
+        else
+          raise "Unexpected output from '#{cmd}': #{results}"
+        end
+      end
+
+      false
+    end
+
+    def stop_server!
+      # We do this because under 1.8.7 SIGTERM doesn't seem to work, and it's actually fine to slaughter this
+      # process mercilessly -- we don't need anything it has at this point, anyway.
+      Process.kill("KILL", server_pid)
+
+      start_time = Time.now
+
+      while true
+        if is_alive?(server_pid)
+          raise "Unable to kill server at PID #{server_pid}!" if (Time.now - start_time) > 20
+          say "Waiting for server at PID #{server_pid} to die."
+          sleep 0.1
+        else
+          break
+        end
+      end
+
+      say "Successfully terminated Rails server at PID #{server_pid}."
+
+      @server_pid = nil
+    end
+
+    class CommandFailedError < StandardError
+      attr_reader :directory, :command, :result, :output
+
+      def initialize(directory, command, result, output)
+        @directory = directory
+        @command = command
+        @result = result
+        @output = output
+
+        super(%{Command failed: in directory '#{directory}', we tried to run:
+% #{command}
+but got result: #{result.inspect}
+and output:
+#{output}})
+      end
+    end
+
+    def attempt_bundle_install_cmd!(name, use_local)
+      cmd = "bundle install"
+      cmd << " --local" if use_local
+
+      description = "running 'bundle install' for #{name.inspect}"
+      description << " (with remote fetching allowed)" if (! use_local)
+
+      attempts = 0
+      while true
+        begin
+          safe_system(cmd, description)
+          break
+        rescue CommandFailedError => cfe
+          # Sigh. Travis CI sometimes fails this with the following exception:
+          #
+          # Gem::RemoteFetcher::FetchError: Errno::ETIMEDOUT: Connection timed out - connect(2)
+          #
+          # So, we catch the command failure, look to see if this is the problem, and, if so, retry
+          raise if (! is_travis_remote_fetcher_error?(cfe)) || attempts >= 5
+          attempts += 1
+        end
+      end
+    end
+
+    def is_travis_remote_fetcher_error?(command_failed_error)
+      command_failed_error.output =~ /Gem::RemoteFetcher::FetchError.*connect/i
+    end
+
+    def is_remote_flag_required_error?(command_failed_error)
+      command_failed_error.output =~ /could\s+not\s+find.*in\s+the\s+gems\s+available\s+on\s+this\s+machine/i
+    end
+
+    def do_bundle_install!(name, allow_remote)
+      begin
+        attempt_bundle_install_cmd!(name, true)
+      rescue CommandFailedError => cfe
+        if is_remote_flag_required_error?(cfe) && allow_remote
+          attempt_bundle_install_cmd!(name, false)
+        else
+          raise
+        end
+      end
+    end
+
+    def run_bundle_install!(name)
+      @bundle_installs_run ||= { }
+      do_bundle_install!(name, ! @bundle_installs_run[name])
+      @bundle_installs_run[name] ||= true
+    end
+
+    def say(s, newline = true)
+      if newline
+        $stdout.puts s
+      else
+        $stdout << s
+      end
+      $stdout.flush
+    end
+
+    def safe_system(cmd, notice = nil, options = { })
+      say("#{notice}...", false) if notice
+
+      total_cmd = if options[:background]
+        "#{cmd} 2>&1 &"
+      else
+        "#{cmd} 2>&1"
+      end
+
+      output = `#{total_cmd}`
+      raise CommandFailedError.new(Dir.pwd, total_cmd, $?, output) unless $?.success?
+      say "OK" if notice
+
+      output
+    end
+  end
+end

data/lib/oop_rails_server/version.rb

@@ -0,0 +1,3 @@
+module OopRailsServer
+  VERSION = "0.0.1"
+end

data/lib/oop_rails_server.rb

@@ -0,0 +1,3 @@
+require "oop_rails_server/version"
+require "oop_rails_server/rails_server"
+require "oop_rails_server/helpers"

data/oop_rails_server.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'oop_rails_server/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "oop_rails_server"
+  spec.version       = OopRailsServer::VERSION
+  spec.authors       = ["Andrew Geweke"]
+  spec.email         = ["andrew@geweke.org"]
+  spec.summary       = %q{Reliably runs a Rails server in a separate process, for use in tests, utilities, etc.}
+  spec.homepage      = "https://github.com/ageweke/oop_rails_server"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: oop_rails_server
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrew Geweke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- andrew@geweke.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/oop_rails_server.rb
+- lib/oop_rails_server/helpers.rb
+- lib/oop_rails_server/rails_server.rb
+- lib/oop_rails_server/version.rb
+- oop_rails_server.gemspec
+homepage: https://github.com/ageweke/oop_rails_server
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Reliably runs a Rails server in a separate process, for use in tests, utilities,
+  etc.
+test_files: []