harker 0.5.3

data/History.txt

@@ -0,0 +1,31 @@
+=== 0.5.3 / 2009-04-21
+
+* Load app extensions on a per-instance basis.
+* Depend on hoe so Rails' test task isn't interfered with.
+
+=== 0.5.2 / 2009-03-31
+
+* Remove Hoe test task if supported.
+
+=== 0.5.1 / 2009-03-30
+
+* Fixed a problem with the Usage message.
+
+=== 0.5.0 / 2009-03-30
+
+* Use gem's config/database.yml for a base.
+* Gemifying existing apps works now.
+* Accept arguments for script/server when starting app.
+
+=== 0.0.3 / 2009-03-26
+
+* A release!
+* First pass at automating gemification of Rails apps with bin/harker.
+* Swapped order of Harker.launch args; now action then instance dir.
+* Apps don't need config/environment.rb tweaks to use harker.
+* Got some docs; yay.
+
+=== 0.0.1 / 2009-03-25
+
+ * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,66 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+bin/harker
+lib/harker.rb
+lib/harker/gemify.rb
+lib/harker/rails_configuration.rb
+lib/harker/server.rb
+lib/harker/templates/bin.erb
+lib/harker/templates/hoe.erb
+lib/harker/templates/lib.erb
+test/sample/Manifest.txt
+test/sample/README.rdoc
+test/sample/Rakefile
+test/sample/app/controllers/application_controller.rb
+test/sample/app/controllers/harks_controller.rb
+test/sample/app/helpers/application_helper.rb
+test/sample/app/helpers/harks_helper.rb
+test/sample/app/models/hark.rb
+test/sample/bin/sample_rails
+test/sample/config/boot.rb
+test/sample/config/database.yml
+test/sample/config/environment.rb
+test/sample/config/environments/development.rb
+test/sample/config/environments/production.rb
+test/sample/config/environments/test.rb
+test/sample/config/initializers/backtrace_silencers.rb
+test/sample/config/initializers/inflections.rb
+test/sample/config/initializers/mime_types.rb
+test/sample/config/initializers/new_rails_defaults.rb
+test/sample/config/initializers/session_store.rb
+test/sample/config/locales/en.yml
+test/sample/config/routes.rb
+test/sample/db/migrate/20090326050232_create_harks.rb
+test/sample/lib/sample_rails.rb
+test/sample/public/404.html
+test/sample/public/422.html
+test/sample/public/500.html
+test/sample/public/favicon.ico
+test/sample/public/images/rails.png
+test/sample/public/index.html
+test/sample/public/javascripts/application.js
+test/sample/public/javascripts/controls.js
+test/sample/public/javascripts/dragdrop.js
+test/sample/public/javascripts/effects.js
+test/sample/public/javascripts/prototype.js
+test/sample/public/robots.txt
+test/sample/script/about
+test/sample/script/console
+test/sample/script/dbconsole
+test/sample/script/destroy
+test/sample/script/generate
+test/sample/script/performance/benchmarker
+test/sample/script/performance/profiler
+test/sample/script/plugin
+test/sample/script/runner
+test/sample/script/server
+test/sample/test/fixtures/harks.yml
+test/sample/test/functional/harks_controller_test.rb
+test/sample/test/performance/browsing_test.rb
+test/sample/test/test_helper.rb
+test/sample/test/unit/hark_test.rb
+test/sample/test/unit/helpers/harks_helper_test.rb
+test/test_gemify.sh
+test/test_harker.rb

data/README.rdoc

@@ -0,0 +1,101 @@
+= Harker
+
+http://github.com/technomancy/harker
+
+== Description
+
+Harker means Rails deployments via RubyGems--because a package manager
+is a terrible thing to waste.
+
+== Motivation
+
+This will mean you can use the same infrastructure you already rely on
+for your dependencies to manage your application itself. It means
+never having to keep a checkout of your app just for deployment. It
+also becomes very easy to see what versions are installed on a given
+box and run multiple instances (of the same or different versions) at
+the same time on different ports.
+
+Your app code will live in your gem home, but all the files specific
+to a given instance will live in an instance directory.
+
+In short: you've already got a package manager. Why are you handling
+installation of your deployed apps with a one-off tool?
+
+== Setup
+
+Your Rails app will need to be modified a bit to become a gem and work
+with Harker. But don't worry, these modifications will improve your
+app and make it more awesome. Running "harker /path/to/rails/app" will
+attempt to turn it into a gem that uses Hoe. You may need to perform a
+bit of tweaking in order to get it to build cleanly since every app is
+different--see the one in test/sample/ for an example of how this
+works. In particular, be sure Manifest.txt does not include any files
+that shouldn't go in the gem, such as pid or log files.
+
+You don't have to use Hoe if you want to turn your app into a gem
+manually or using another library, but it helps.
+
+== Usage
+
+Once your app is a gem, install it locally with "rake install_gem",
+and you should be able to use the bin wrapper to generate a new
+instance:
+
+  $ your_app init ~/apps/your_app_3001
+
+Then edit ~/apps/your_app_3001/database.yml with your database
+settings. At that point you should be able to bring up your database:
+
+  $ your_app migrate ~/apps/your_app_3001
+
+Test it out by dropping into the console:
+
+  $ your_app console ~/apps/your_app_3001
+
+Then you can start and stop your application server via Rack:
+
+  $ your_app start ~/apps/your_app_3001 --daemon --port=3001
+  $ your_app stop ~/apps/your_app_3001
+
+The start command takes all the same arguments as script/server. To
+configure it in a way that doesn't require command-line arguments,
+create a config.ru file in your instance directory, and Rails will
+pick that up with Rack.
+
+If you omit the second argument, it defaults to the current directory.
+
+For deployment, simply publish your gem to a gem server (public or
+private), install it on the target server, and launch it via the bin
+wrapper as shown above.
+
+== Extensions
+
+Sometimes it becomes necessary to hot-patch a deployed app. Instead of
+editing the code inside your gem home, (which is Fraught with Peril)
+you can place .rb files inside your instance directory's extensions/
+directory. These will be loaded immediately after the application is
+required.
+
+== Requirements
+
+* rails (at least 2.3.2)
+* a Rails app to use it with
+* rubygems
+* hoe (technically optional)
+
+== Install
+
+* sudo gem install technomancy-harker --source=http://gems.github.com --source=http://gems.rubyforge.org
+
+== Todo
+
+* rake tasks for remotely installing gem
+* make it easy to "rake release" to a private gem repo
+* test, test, test. try it out with more rails apps!
+
+== License
+
+Copyright (c) 2009 Phil Hagelberg.
+
+Licensed under the same terms as Ruby.

data/Rakefile

@@ -0,0 +1,20 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/harker.rb'
+
+Hoe.new('harker', Harker::VERSION) do |p|
+  p.developer('Phil Hagelberg', 'technomancy@gmail.com')
+  p.rubyforge_name = "seattlerb"
+  p.readme_file = 'README.rdoc'
+  p.summary = "Harker: Rubygems-based deployment for Rails apps."
+
+  p.extra_deps << ["rails", "~> 2.3.2"]
+  p.extra_dev_deps << ["minitest", "~> 1.3.1"]
+  p.extra_dev_deps << ["sqlite3-ruby", "~> 1.2.4"]
+  # recommended:
+  # p.extra_dev_deps << ["mongrel", "~> 1.2.4"]
+end
+
+# vim: syntax=Ruby

data/bin/harker

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require 'harker/gemify'
+
+begin
+  gem 'hoe'
+rescue LoadError
+  abort 'Hoe not found. You can continue without hoe if you gemify
+your app yourself; see Harker documentation for details.'
+end
+
+if ARGV.include?('-h') or ARGV.include?('--help') or ARGV.size > 1
+  puts "Usage: #{File.basename($0)} [RAILS_ROOT]"
+  puts
+  puts "Attempts to turn your Rails app into a gem for deployment with harker."
+  exit
+end
+
+Harker.gemify(ARGV.shift || Dir.pwd)

data/lib/harker.rb

@@ -0,0 +1,116 @@
+require 'fileutils'
+
+# Harker lets you deploy Rails apps via RubyGems.
+#
+# These commands get invoked by the bin wrapper of the rails app gem
+# rather than by Harker itself.
+#
+module Harker
+  VERSION = '0.5.3'
+  ACTIONS = %w(start stop restart init migrate console)
+  GEM_ROOT = Gem.loaded_specs[File.basename($0)].full_gem_path rescue '.'
+
+  module_function
+
+  # Dispatch based on user's command
+  def launch(name, args)
+    action = args.shift
+
+    unless ACTIONS.include?(action)
+      abort "Usage: #{name} (#{ACTIONS.join('|')}) [INSTANCE_DIR] [START_ARGS]
+The start command takes the same arguments as script/server."
+    end
+
+    # We need to get rid of the first arg if it's the optional
+    # instance directory so script/server doesn't get confused.
+    @root = if File.directory? args.first.to_s or action == 'init'
+              File.expand_path args.shift
+            else
+              Dir.pwd
+            end
+
+    @name = name
+
+    unless action == 'init'
+      # 2.3.2 doesn't support tmp_dir config option; needs a monkeypatch.
+      require 'harker/rails_configuration'
+      require @name
+      Dir["#{@root}/extensions/*rb"].each { |f| load f }
+    end
+
+    self.send(action)
+  end
+
+  # Start and optionally daemonize the application server
+  def start
+    # http://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/2350
+    # Submitted a patch to Rails, but this lets it work with 2.3.2
+    Rails::Rack::LogTailer::EnvironmentLog.replace(Rails.configuration.log_path)
+
+    abort "Can't start; pidfile exists at #{pidfile}." if File.exist? pidfile
+    require 'harker/server'
+  end
+
+  def stop
+    abort "No pid at #{pidfile}." unless File.exist?(pidfile)
+    Process.kill('TERM', File.read(pidfile).to_i)
+  end
+
+  def restart
+    stop
+  rescue SystemExit
+    start
+  end
+
+  # Initialize a new instance of your application
+  def init
+    %w(tmp log db extensions).each do |d|
+      FileUtils.mkdir_p(File.join(@root, d))
+    end
+
+    base_db_file = File.join(GEM_ROOT, 'config', 'database.yml')
+
+    File.open("#{@root}/database.yml", 'w') do |fp|
+      # Need to make sure any sqlite3 DB paths are absolute.
+      db_config = YAML.load_file(base_db_file)
+      db_config.each do |env, hash|
+        if hash['adapter'] =~ /sqlite3?/
+          hash['database'] = File.join(@root, hash['database'])
+        end
+      end
+
+      fp.puts(db_config.to_yaml)
+    end
+
+    puts <<-END
+    Initialized #{@name} instance in #{@root}...
+    
+    Configure your database by editing #{@root}/database.yml.
+    Optionally configure your web server via rack in #{@root}/config.ru.
+    
+    Migrate your DB with: #{@name} migrate
+    Then launch with: #{@name} start --daemon
+    END
+  end
+
+  def migrate
+    puts "Migrating the #{RAILS_ENV} environment of #{@name}..."
+    ActiveRecord::Migrator.migrate(File.join(Rails.root, 'db', 'migrate'),
+                                   ENV["VERSION"] && ENV["VERSION"].to_i)
+  end
+
+  def console
+    require 'irb'
+    IRB.start
+  end
+
+  def configure(config)
+    config.database_configuration_file = File.join(@root, 'database.yml')
+    config.log_path = File.join(@root, 'log', "#{RAILS_ENV}.log")
+    config.tmp_dir = File.join(@root, 'tmp')
+  end
+
+  def pidfile
+    File.join(@root, 'tmp', 'pids', 'server.pid')
+  end
+end

data/lib/harker/gemify.rb

@@ -0,0 +1,44 @@
+require 'harker'
+require 'fileutils'
+require 'erb'
+
+module Harker
+  # Turn an existing Rails app into a gem.
+  def self.gemify(rails_root)
+    @project_name = File.basename(rails_root)
+
+    if File.exist?(rails_root + "/bin/#{@project_name}") or
+        File.exist?(rails_root + "/lib/#{@project_name}.rb")
+      abort "Can't write gem files without overwriting existing ones.
+Try manually gemifying."
+    end
+
+    File.open(File.join(rails_root, '/Rakefile'), 'a') do |fp|
+      fp.puts template('hoe')
+      puts "Added hoe block to Rakefile."
+    end
+
+    FileUtils.mkdir_p(File.join(rails_root, '/bin'))
+    File.open(File.join(rails_root, "/bin/#{@project_name}"), 'w') do |fp|
+      fp.puts template('bin')
+      puts "Wrote bin launcher."
+    end
+
+    File.open(File.join(rails_root, "/lib/#{@project_name}.rb"), 'w') do |fp|
+      fp.puts template('lib')
+      puts "Wrote lib file."
+    end
+
+    # Submitted a patch to hoe to make it ignore log files by default,
+    # but folks should still give it a once-over manually anyway.
+    system "cd #{rails_root}; touch Manifest.txt; rake check_manifest | patch"
+    puts "Wrote Manifest.txt."
+    puts "Ensure the manifest doesn't contain files you don't want in the gem."
+    puts "Then try running rake install_gem."
+  end
+
+  def self.template(name)
+    template_path = File.join File.dirname(__FILE__), 'templates', "#{name}.erb"
+    ERB.new(File.read(template_path)).result(binding)
+  end
+end

data/lib/harker/rails_configuration.rb

@@ -0,0 +1,36 @@
+# This monkeypatches Rails to allow tmp_dir to be configured.
+
+# It's been submitted upstream:
+# http://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/2379
+
+# We can remove the Configuration monkeypatch once the above patch is
+# accepted if we don't care about supporting older versions.
+
+gem 'rails'
+require 'initializer'
+
+class Rails::Configuration
+  attr_accessor :tmp_dir
+
+  def default_tmp_dir
+    File.join(root_path, 'tmp')
+  end
+
+  def default_cache_store
+    if File.exist? File.join(default_tmp_dir, 'cache')
+      [ :file_store, File.join(default_tmp_dir, 'cache') ]
+    else
+      :memory_store
+    end
+  end
+end
+
+class Rails::Initializer
+  def self.run(command = :process, configuration = Rails::Configuration.new)
+    yield configuration if block_given?
+    Harker.configure(configuration)
+    initializer = new configuration
+    initializer.send(command)
+    initializer
+  end
+end

data/lib/harker/server.rb

@@ -0,0 +1,125 @@
+# A patched copy of what Rails' script/server runs.
+
+# These changes were submitted upstream to Rails:
+# http://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/2379
+
+# We can remove this file once that patch is accepted if we don't care
+# about supporting older versions.
+
+# Only two changes were made, noted below by comments beginning with "Harker"
+
+require 'active_support'
+require 'action_controller'
+
+require 'fileutils'
+require 'optparse'
+
+begin
+  require_library_or_gem 'thin'
+rescue Exception
+  # Thin not available
+end
+
+options = {
+  :Port        => 3000,
+  :Host        => "0.0.0.0",
+  :environment => (ENV['RAILS_ENV'] || "development").dup,
+  :config      => RAILS_ROOT + "/config.ru",
+  :detach      => false,
+  :debugger    => false,
+  :path        => nil
+}
+
+ARGV.clone.options do |opts|
+  opts.on("-p", "--port=port", Integer,
+          "Runs Rails on the specified port.", "Default: 3000") { |v| options[:Port] = v }
+  opts.on("-b", "--binding=ip", String,
+          "Binds Rails to the specified ip.", "Default: 0.0.0.0") { |v| options[:Host] = v }
+  opts.on("-c", "--config=file", String,
+          "Use custom rackup configuration file") { |v| options[:config] = v }
+  opts.on("-d", "--daemon", "Make server run as a Daemon.") { options[:detach] = true }
+  opts.on("-u", "--debugger", "Enable ruby-debugging for the server.") { options[:debugger] = true }
+  opts.on("-e", "--environment=name", String,
+          "Specifies the environment to run this server under (test/development/production).",
+          "Default: development") { |v| options[:environment] = v }
+  opts.on("-P", "--path=/path", String, "Runs Rails app mounted at a specific path.", "Default: /") { |v| options[:path] = v }
+
+  opts.separator ""
+
+  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+server = Rack::Handler.get(ARGV.first) rescue nil
+unless server
+  begin
+    server = Rack::Handler::Mongrel
+  rescue LoadError => e
+    server = Rack::Handler::WEBrick
+  end
+end
+
+puts "=> Booting #{ActiveSupport::Inflector.demodulize(server)}"
+puts "=> Rails #{Rails.version} application starting on http://#{options[:Host]}:#{options[:Port]}#{options[:path]}"
+
+%w(cache pids sessions sockets).each do |dir_to_make|
+  # Harker: patched to use Rails.configuration.tmp_dir
+  FileUtils.mkdir_p(File.join(Rails.configuration.tmp_dir, dir_to_make))
+end
+
+if options[:detach]
+  Process.daemon
+  # Harker: patched to use Rails.configuration.tmp_dir
+  pid = File.join(Rails.configuration.tmp_dir, 'pids', 'server.pid')
+  File.open(pid, 'w'){ |f| f.write(Process.pid) }
+  at_exit { File.delete(pid) if File.exist?(pid) }
+end
+
+ENV["RAILS_ENV"] = options[:environment]
+RAILS_ENV.replace(options[:environment]) if defined?(RAILS_ENV)
+
+if File.exist?(options[:config])
+  config = options[:config]
+  if config =~ /\.ru$/
+    cfgfile = File.read(config)
+    if cfgfile[/^#\\(.*)/]
+      opts.parse!($1.split(/\s+/))
+    end
+    inner_app = eval("Rack::Builder.new {( " + cfgfile + "\n )}.to_app", nil, config)
+  else
+    require config
+    inner_app = Object.const_get(File.basename(config, '.rb').capitalize)
+  end
+else
+  require RAILS_ROOT + "/config/environment"
+  inner_app = ActionController::Dispatcher.new
+end
+
+if options[:path].nil?
+  map_path = "/"
+else
+  ActionController::Base.relative_url_root = options[:path]
+  map_path = options[:path]
+end
+
+app = Rack::Builder.new {
+  use Rails::Rack::LogTailer unless options[:detach]
+  use Rails::Rack::Debugger if options[:debugger]
+  map map_path do
+    use Rails::Rack::Static 
+    run inner_app
+  end
+}.to_app
+
+puts "=> Call with -d to detach"
+
+trap(:INT) { exit }
+
+puts "=> Ctrl-C to shutdown server"
+
+begin
+  server.run(app, options.merge(:AccessLog => []))
+ensure
+  puts 'Exiting'
+end