sbfaulkner-astrovan 0.5.0

data/README.rdoc

@@ -0,0 +1,46 @@
+= astrovan
+
+simple, lightweight deployment tasks
+
+== WHY?
+
+First, I want to say that I'm *not* doing this because I don't like
+capistrano.
+
+I do like (ok, love) capistrano, but think that it can maybe be done
+a bit more simply.
+
+This is my attempt.
+
+== Installation
+
+    $ script/plugin install git://github.com/sbfaulkner/astrovan.git
+
+== Sample recipes
+
+=== Update only
+
+    require 'astrovan'
+
+    using 'www.example.com' do
+      deploy 'git://github.com/sbfaulkner/scanty.git'
+    end
+
+== NOTES
+
+- no block for deploy implies mkdir && update
+
+== TODO
+
+- stdin handling for exec
+- stdout/stderr handling for exec
+- other commands (all using exec)
+  - share (smart wrapper arouncd symlink?)
+  - cp ?
+  - mv ?
+- documentation
+
+== Legal
+
+*Author*:: S. Brent Faulkner <brentf@unwwwired.net>
+*License*:: Copyright (c) 2009 unwwwired.net, released under the MIT license

data/VERSION.yml

@@ -0,0 +1,4 @@
+---
+:major: 0
+:minor: 5
+:patch: 0

data/lib/astrovan.rb

@@ -0,0 +1,17 @@
+require 'astrovan/session'
+
+module Astrovan
+  # Create a deployment session for the specified remote hosts.
+  #
+  # The provided block will execute within the context of the newly created session.
+  def using(*hosts, &block)
+    raise ArgumentError, "Missing block" unless block_given?
+    env = hosts.last.is_a?(Hash) ? hosts.pop : {}
+    raise ArgumentError, "Missing host" unless hosts.any?
+    session = Session.new(hosts.flatten, env)
+    session.instance_eval(&block)
+    session.close
+  end
+end
+
+include Astrovan

data/lib/astrovan/deploy.rb

@@ -0,0 +1,53 @@
+module Astrovan
+  module Deploy
+    # Deploy an application to the remote servers.
+    #
+    # Options:
+    # * +application+ - a name for the application. If not provided, the application name is taken from the last component of the path to the source repository.
+    # * +deploy_to+ - the path of the directory for application deployment. Defaults to '/u/apps/:application'
+    #
+    # If a block is provided, the block is run to deploy the application in the specified environment.
+    #
+    # If no block is provided, a default deployment recipe is applied. The default recipe is:
+    # * create the deployment, release and shared directories
+    # * update the application from the repository into the release directory
+    # * symlink to the current application
+    #
+    # Due to differences in application environments, no provision is made to restart the application in the default
+    # recipe.
+    def deploy(repository, options = {})
+      original_environment = self.environment.dup
+
+      self.repository = repository
+      self.application = application = options[:application] || self.application || File.basename(URI.parse(repository).path.split('/').last,".git")
+      self.deploy_to = deploy_to = options[:deploy_to] || self.deploy_to || "/u/apps/#{application}"
+      self.shared_path = shared_path = File.join(deploy_to, 'shared')
+      self.shared_repository = shared_repository = File.join(shared_path, "#{application}.git")
+      self.release_name = release_name = Time.now.utc.strftime("%Y%m%d%H%M%S")
+      self.releases_path = releases_path = File.join(deploy_to, 'releases')
+      self.release_path = release_path = File.join(releases_path, release_name)
+      self.env = options[:env] || self.env
+      self.rakefile = options[:rakefile] || self.rakefile
+
+      if block_given?
+        yield
+      else
+        # TODO: consider moving directory setup outside of update
+        dirs = [deploy_to, releases_path, shared_path]
+        # TODO: these shared children are rails specific... come up with another plan
+        # shared_children = %w(system log pids)
+        # dirs += shared_children.map { |d| File.join(shared_path, d) }
+        mkdir(dirs, options)
+
+        update options
+
+      end
+    rescue => e
+      # TODO: rollback
+      # rollback
+      raise
+    ensure
+      self.environment.replace original_environment
+    end
+  end
+end

data/lib/astrovan/exec.rb

@@ -0,0 +1,37 @@
+require 'net/ssh/multi'
+
+module Astrovan
+  module Exec
+    # Executes a command on the remote servers.
+    #
+    # Options:
+    # * +on+ - specifies a subset of servers to run the command on.
+    def exec(command, options = {})
+      session = session_for(options.delete(:on))
+      begin
+        command = command.gsub(/[\$\\"`]/) { |m| "\\#{m}" }
+        command = %Q(sh -c "#{command}")
+        if env = options[:env] || self.env
+          env = env.collect { |var,value| %Q(#{var}=#{value.gsub(/[ "]/) { |m| "\\#{m}" }}) }.join(' ') unless env.is_a?(String)
+          command = "env #{env} #{command}"
+        end
+        channel = session.exec command do |ch, stream, data|
+          STDERR.puts "[#{ch[:host]}] #{stream}: #{data}"
+        end
+        channel.wait
+        errors = 0
+        channel.each do |c|
+          if c[:exit_status] != 0
+            STDERR.puts "[#{c[:host]}] ERROR: terminated with non-zero exit status (#{c[:exit_status]})"
+            errors += 1
+          else
+            STDERR.puts "[#{c[:host]}] terminated with exit status of zero"
+          end
+        end
+        raise "#{errors} remote command(s) failed" if errors > 0
+      ensure
+        session.close if session != self.session
+      end
+    end
+  end
+end

data/lib/astrovan/rake.rb

@@ -0,0 +1,24 @@
+module Astrovan
+  module Rake
+    # Execute a rake task on the remote servers.
+    #
+    # Options:
+    # * +rakefile+ - specify the path to a rakefile (if not in the default location)
+    def rake(*tasks)
+      options = tasks.last.is_a?(Hash) ? tasks.pop : {}
+      rake = 'rake'
+      rakefile = options.delete(:rakefile) || self.rakefile
+      rake << ' -f ' << rakefile if rakefile
+      exec "#{rake} #{tasks.join(' ')}", options
+    end
+
+    # Map one or more rake tasks to deployment methods.
+    def surrogate(map)
+      map.each do |method,task|
+        raise ArgumentError, "Method <#{method}> already defined" if methods.include?(method.to_s)
+        instance_eval "def #{method}; rake '#{task}'; end"
+      end
+    end
+    alias_method :surrogates, :surrogate
+  end
+end

data/lib/astrovan/session.rb

@@ -0,0 +1,87 @@
+require 'astrovan/deploy'
+require 'astrovan/exec'
+require 'astrovan/util'
+require 'astrovan/rake'
+require 'astrovan/update'
+
+module Astrovan
+  # Created by the using method, this is the context within which all other deployment methods run.
+  class Session
+    include Astrovan::Deploy
+    include Astrovan::Exec
+    include Astrovan::Util
+    include Astrovan::Rake
+    include Astrovan::Update
+
+    #:stopdoc:
+    DEFAULTS = {
+      :application => nil,
+      :deploy_to => nil,
+      :env => nil,
+      :password => nil,
+      :rakefile => nil,
+      :username => nil
+    }
+    #:startdoc:
+
+    # array of names of the hosts for the deployment session
+    attr_reader :hosts
+
+    def initialize(hosts, environment = {}) #:nodoc:
+      surrogates  :disable => 'web:disable',
+                  :enable => 'web:enable',
+                  :migrate => 'db:migrate'
+
+      @hosts = hosts
+      @environment = DEFAULTS.merge environment
+      
+      options = {}
+      options[:username] = environment[:username] if environment[:username]
+      options[:password] = environment[:password] if environment[:password]
+
+      @session = Net::SSH::Multi.start
+      @servers = hosts.inject({}) { |servers,host| servers[host] = @session.use(host, options); servers }
+    end
+
+    def close #:nodoc:
+      @session, session = nil, @session
+      session.close if session
+    end
+
+  protected
+    def environment # :nodoc:
+      @environment
+    end
+
+    def session # :nodoc:
+      @session
+    end
+
+    def servers # :nodoc:
+      @servers
+    end
+
+    def session_for(hosts) # :nodoc:
+      if hosts
+        @session.on(servers_for(hosts))
+      else
+        @session
+      end
+    end
+
+    def servers_for(hosts) # :nodoc:
+      @servers.values_at(*hosts)
+    end
+
+  private
+    def method_missing(symbol, *args)
+      if @environment.include?(symbol)
+        @environment[symbol]
+      elsif symbol.to_s =~ /^(.+)=$/ && !methods.include?($1)
+        @environment[$1.to_sym] = args.first
+      else
+        super
+      end
+    end
+  end
+end

data/lib/astrovan/update.rb

@@ -0,0 +1,29 @@
+require 'uri'
+
+module Astrovan
+  module Update
+    def update(options = {})
+      shared_repository = self.shared_repository
+      repository = self.repository
+      release_path = self.release_path
+
+      # TODO: do we need branch support, submodule config, etc?
+      exec <<-END, options
+        if [ -d '#{shared_repository}' ]
+        then
+          cd #{shared_repository} &&
+          git fetch #{repository}
+        else
+          git clone --bare #{repository} #{shared_repository}
+        fi &&
+        git clone #{shared_repository} #{release_path}
+      END
+
+      yield if block_given?
+    rescue => e
+      # TODO: rollback
+      # rollback
+      raise
+    end
+  end
+end

data/lib/astrovan/util.rb

@@ -0,0 +1,40 @@
+module Astrovan
+  module Util
+    # Create one or more directories on the remote servers. Intermediate directories will be created
+    # as required.
+    def mkdir(*paths)
+      options = paths.last.is_a?(Hash) ? paths.pop : {}
+      # flatten, so that arrays of paths can be passed as arguments
+      paths = paths.flatten.join(' ')
+      # TODO: consider using sudo?
+      exec "mkdir -p #{paths} && chmod g+w #{paths}", options
+    end
+
+    # Remove files or directories on the remote servers.
+    #
+    # Options:
+    # * +recursive+ - set to true to attempt to recursively remove a directory
+    def rm(*paths)
+      options = paths.last.is_a?(Hash) ? paths.pop : {}
+      # flatten, so that arrays of paths can be passed as arguments
+      paths = paths.flatten.join(' ')
+      # TODO: consider using sudo?
+      rm = 'rm'
+      rm << ' -r' if options.delete(:recursive)
+      exec "#{rm} #{paths}", options
+    end
+
+    # Create a sylink on the remote servers. Any existing symlink will be removed first.
+    #
+    # Options:
+    # * +to+ - the path to the new symlink
+    def symlink(*paths)
+      options = paths.last.is_a?(Hash) ? paths.pop : {}
+      raise ArgumentError, "You must provide a target using the :to option" unless to = options.delete(:to)
+      # flatten, so that arrays of paths can be passed as arguments
+      paths = paths.flatten.join(' ')
+      # TODO: consider using sudo?
+      exec "ln -sf #{path} #{to}", options
+    end
+  end
+end

data/test/astrovan_test.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class AstrovanTest < Test::Unit::TestCase
+  def test_using_should_require_block
+    assert_raise ArgumentError do
+      using 'one.astrovan.local'
+    end
+  end
+
+  def test_using_should_require_at_least_one_host
+    assert_raise ArgumentError do
+      using do
+      end
+    end
+  end
+
+  def test_using_should_setup_session_for_specified_host
+    assert_nothing_raised do
+      using 'one.astrovan.local' do
+        raise StandardError if hosts != %w(one.astrovan.local)
+      end
+    end
+  end
+
+  def test_using_should_setup_session_for_multiple_hosts
+    assert_nothing_raised do
+      using 'one.astrovan.local', 'two.astrovan.local', 'three.astrovan.local' do
+        raise StandardError if hosts != %w(one.astrovan.local two.astrovan.local three.astrovan.local)
+      end
+    end
+  end
+
+  def test_using_should_setup_session_for_array_of_hosts
+    assert_nothing_raised do
+      using %w(one.astrovan.local two.astrovan.local three.astrovan.local) do
+        raise StandardError if hosts != %w(one.astrovan.local two.astrovan.local three.astrovan.local)
+      end
+    end
+  end
+
+  def test_using_should_setup_session_for_mixed_host_arguments
+    assert_nothing_raised do
+      using %w(one.astrovan.local two.astrovan.local), 'three.astrovan.local' do
+        raise StandardError if hosts != %w(one.astrovan.local two.astrovan.local three.astrovan.local)
+      end
+    end
+  end
+
+  def test_using_should_create_session
+    assert_nothing_raised do
+      using %w(one.astrovan.local two.astrovan.local) do
+        raise TypeError unless session.is_a?(Net::SSH::Multi::Session)
+        raise StandardError if servers.size != hosts.size
+      end
+    end
+  end
+
+  def test_using_should_create_subsession
+    assert_nothing_raised do
+      using %w(one.astrovan.local two.astrovan.local) do
+        session = session_for(%w(one.astrovan.local))
+        raise TypeError unless session.is_a?(Net::SSH::Multi::Subsession)
+        raise StandardError if servers.size != hosts.size
+      end
+    end
+  end
+end

data/test/deploy_test.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class DeployTest < Test::Unit::TestCase
+  def test_should_deploy
+    using 'astrovan.local', :password => ENV['PASSWORD'] do
+      deploy 'git://github.com/adamwiggins/scanty.git', :env => { :PATH => '$PATH:/usr/local/git/bin' }
+    end
+  end
+
+  def test_should_deploy_static_site
+    flunk
+  end
+
+  def test_should_deploy_rails_application
+    flunk
+  end
+
+  def test_should_deploy_sinatra_application
+    flunk
+  end
+
+  def test_should_deploy_heroku_application
+    flunk
+  end
+
+  def test_should_deploy_github_application
+    flunk
+  end
+
+  def test_should_deploy_jekyll_site
+    flunk
+  end
+end

data/test/exec_test.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SessionTest < Test::Unit::TestCase
+  def test_should_exec
+    using 'astrovan.local', :password => ENV['PASSWORD'] do
+      exec 'hostname'
+    end
+  end
+
+  def test_should_fail_to_exec
+    assert_raise RuntimeError do
+      using 'astrovan.local', :password => ENV['PASSWORD'] do
+        exec 'kjasdhfkjahsdf'
+      end
+    end
+  end
+end

data/test/rake_test.rake

@@ -0,0 +1,6 @@
+task :succeed do
+end
+
+task :fail do
+  raise "failed"
+end

data/test/rake_test.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RakeTest < Test::Unit::TestCase
+  def setup
+    @rakefile = File.expand_path(File.join(File.dirname(__FILE__),'rake_test.rake'))
+  end
+
+  def test_should_run_rake_task
+    using 'astrovan.local', :password => ENV['PASSWORD'], :rakefile => @rakefile do
+      rake 'succeed'
+    end
+  end
+
+  def test_should_fail_when_rake_task_fails
+    assert_raise(RuntimeError) do
+      using 'astrovan.local', :password => ENV['PASSWORD'], :rakefile => @rakefile do
+        rake 'fail'
+      end
+    end
+  end
+
+  def test_should_fail_when_rake_task_not_defined
+    assert_raise(RuntimeError) do
+      using 'astrovan.local', :password => ENV['PASSWORD'], :rakefile => @rakefile do
+        rake 'undefined'
+      end
+    end
+  end
+
+  def test_should_define_methods_to_run_rake_task
+    using 'astrovan.local', :password => ENV['PASSWORD'] do
+      raise "succeed method should not be defined" if methods.include?('succeed')
+      raise "fail method should not be defined" if methods.include?('fail')
+      surrogates :succeed => 'success', :fail => 'failure'
+      raise "succeed method should be defined" unless methods.include?('succeed')
+      raise "fail method should be defined" unless methods.include?('fail')
+    end
+  end
+
+  def test_should_fail_to_define_method_if_already_defined
+    assert_raise(ArgumentError) do
+      using 'astrovan.local', :password => ENV['PASSWORD'] do
+        surrogate :freeze => 'rails:freeze:edge'
+      end
+    end
+  end
+end

data/test/session_test.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class SessionTest < Test::Unit::TestCase
+  def setup
+    @session = Session.new(%w(one.astrovan.local), :user => 'admin')
+    super
+  end
+  
+  def test_should_initialize_hosts
+    assert_equal %w(one.astrovan.local), @session.hosts
+  end
+  
+  def test_hosts_should_be_readonly
+    assert_raise(NoMethodError) { @session.hosts = %w(two.astrovan.local) }
+  end
+
+  def test_should_fail_for_undefined_value
+    assert_raise(NoMethodError) { @session.unknown }
+  end
+  
+  def test_should_initialize_value
+    assert_equal 'admin', @session.user
+  end
+  
+  def test_should_set_value
+    @session.password = 'Passw0rd'
+    assert_equal 'Passw0rd', @session.password
+  end
+  
+  def test_should_overwrite_value
+    @session.user = 'marc.garneau'
+    assert_equal 'marc.garneau', @session.user
+  end
+  
+  def test_should_have_predefined_methods_to_run_standard_rake_tasks
+    assert_method :migrate, @session
+    assert_method :enable, @session
+    assert_method :disable, @session
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'astrovan'
+
+require 'socket'
+require 'resolv-replace'
+
+class IPSocket
+  class << self
+    def getaddress_with_trace(name)
+      return getaddress_without_trace('127.0.0.1') if name =~ /^(.*\.)?astrovan\.local$/
+      getaddress_without_trace(name)
+    end
+    alias_method :getaddress_without_trace, :getaddress
+    alias_method :getaddress, :getaddress_with_trace
+  end
+end
+
+class Test::Unit::TestCase
+  def self.ask_for(text)
+    STDOUT.print text
+    STDIN.gets.chomp
+  end
+
+  ENV['PASSWORD'] ||= ask_for('Password: ')
+protected
+  def assert_method(name, object = nil)
+    object ||= self
+    assert object.methods.include?(name.to_s), "Expected <#{name}> method to be defined"
+  end
+
+  def assert_no_method(name, object = nil)
+    object ||= self
+    assert ! object.methods.include?(name.to_s), "Expected <#{name}> method to be undefined"
+  end
+end

data/test/update_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class UpdateTest < Test::Unit::TestCase
+  def test_should_update
+    using 'astrovan.local', :password => ENV['PASSWORD'] do
+      deploy 'git://github.com/adamwiggins/scanty.git', :env => { :PATH => '$PATH:/usr/local/git/bin' } do
+        update
+      end
+    end
+  end
+end

data/test/util_test.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class UtilTest < Test::Unit::TestCase
+  include
+  def setup
+    @path = "/tmp/astrovan.#{Time.now.to_i}"
+    super
+  end
+
+  def teardown
+    system "rm -rf #{@path} #{@path}.lnk"
+    super
+  end
+
+  def test_should_mkdir
+    assert !File.exist?(@path)
+    using 'astrovan.local', :password => ENV['PASSWORD'], :path => @path do
+      mkdir path
+    end
+    assert File.exist?(@path)
+    assert File.directory?(@path)
+  end
+
+  def test_should_rm_file
+    create_file
+    using 'astrovan.local', :password => ENV['PASSWORD'], :path => @path do
+      rm path
+    end
+    assert !File.exist?(@path)
+  end
+
+  def test_should_not_rm_directory
+    system "mkdir -p #{@path}"
+    assert File.exist?(@path)
+    assert File.directory?(@path)
+    assert_raise(RuntimeError) do
+      using 'astrovan.local', :password => ENV['PASSWORD'], :path => @path do
+        rm path
+      end
+    end
+    assert File.exist?(@path)
+    assert File.directory?(@path)
+  end
+
+  def test_should_rm_directory_with_recursive_option
+    system "mkdir -p #{@path}"
+    assert File.exist?(@path)
+    assert File.directory?(@path)
+    using 'astrovan.local', :password => ENV['PASSWORD'], :path => @path do
+      rm path, :recursive => true
+    end
+    assert !File.exist?(@path)
+  end
+
+  def test_should_symlink
+    data = create_file
+    target = @path + ".lnk"
+    using 'astrovan.local', :password => ENV['PASSWORD'], :path => @path, :target => target do
+      symlink path, :to => target
+    end
+    assert_equal data, File.open(target) { |f| f.gets.chomp }
+  end
+
+protected
+  def create_file
+    data = Time.now.utc.to_s
+    File.open(@path,'w') { |f| f.puts data }
+    assert File.exist?(@path)
+    assert !File.directory?(@path)
+    data
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: sbfaulkner-astrovan
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- S. Brent Faulkner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-21 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: simple, lightweight deployment tasks
+email: brentf@unwwwired.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- VERSION.yml
+- lib/astrovan
+- lib/astrovan/deploy.rb
+- lib/astrovan/exec.rb
+- lib/astrovan/rake.rb
+- lib/astrovan/session.rb
+- lib/astrovan/update.rb
+- lib/astrovan/util.rb
+- lib/astrovan.rb
+- test/astrovan_test.rb
+- test/deploy_test.rb
+- test/deployment
+- test/deployment/github
+- test/deployment/github/TODO
+- test/deployment/heroku
+- test/deployment/heroku/TODO
+- test/deployment/jekyll
+- test/deployment/jekyll/TODO
+- test/deployment/rails
+- test/deployment/rails/TODO
+- test/deployment/sinatra
+- test/deployment/sinatra/TODO
+- test/deployment/static
+- test/deployment/static/TODO
+- test/exec_test.rb
+- test/rake_test.rake
+- test/rake_test.rb
+- test/session_test.rb
+- test/test_helper.rb
+- test/update_test.rb
+- test/util_test.rb
+has_rdoc: true
+homepage: http://sbfaulkner.github.com/astrovan
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: simple, lightweight deployment tasks
+test_files: []
+