michaeldwan-divvy 0.1.2

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Michael Dwan
+
+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.rdoc

@@ -0,0 +1,27 @@
+= Divvy
+
+Divvy is an easy to configure, easy to extend server provisioning framework written in Ruby.
+
+I created this for use on a specific project and have not yet gotten around to documenting or testing it :)
+
+Stay tuned.
+
+== Principals
+
+Divvy was created to 
+
+ - There is a difference between preparing a server and managing instances.
+ - Provisioning a server is more than just installing required software.
+ - Capistrano and Vlad are great for deployment, but are overkill for busting out SSH commands.
+ - Specific scripts should extend Divvy as necessary.
+
+== Credits
+
+Divvy was created and currently maintained by Michael Dwan.
+
+Inspiration came from Marcus Crafter's Sprinkle, Capistrano, Evan Petrie from Metromix, and 
+several other scripts and frameworks I have attempted to use over the years.
+
+== Copyright
+
+Copyright (c) 2009 Michael Dwan. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "divvy"
+    gem.summary = %Q{Divvy is an easy to configure, easy to extend server provisioning framework written in Ruby.}
+    gem.email = "mpdwan@gmail.com"
+    gem.homepage = "http://github.com/mdwan/divvy"
+    gem.authors = ["Michael Dwan"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "divvy #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.2

data/bin/divvy

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require "#{File.dirname(__FILE__)}/../lib/divvy"
+require 'optparse'
+require 'ostruct'
+
+options = OpenStruct.new
+options.verbose = false
+options.test = false
+
+parser = OptionParser.new do |opts|
+  opts.banner = <<BANNER
+Divvy
+=====
+
+Divvy is a software provisioning tool you canuse to build remote servers with. 
+
+Usage
+=====
+
+$> #{File.basename($0)} [options]
+
+Options are:
+BANNER
+  opts.separator ""
+  
+  opts.on("-s", "--script=PATH", "The divvy script to run") do |script|
+    options.script = script
+  end
+
+  opts.on("-t", "--[no-]test", "Process but do not perform actions") do |t|
+    options.test = t
+  end
+  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+    options.verbose = v
+  end
+
+  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+  opts.parse!(ARGV)
+  
+  unless options.script
+    puts "script is required"
+    puts opts
+    exit
+  end
+  
+end
+
+Divvy.init
+
+Divvy.test = options.test
+Divvy.verbose = options.verbose
+
+Divvy.run(File.read(options.script), options.script)

data/divvy.gemspec

@@ -0,0 +1,79 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{divvy}
+  s.version = "0.1.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Dwan"]
+  s.date = %q{2009-05-31}
+  s.default_executable = %q{divvy}
+  s.email = %q{mpdwan@gmail.com}
+  s.executables = ["divvy"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "bin/divvy",
+     "divvy.gemspec",
+     "examples/packages/build_essential.rb",
+     "examples/packages/databases/mysql.rb",
+     "examples/packages/databases/sqlite3.rb",
+     "examples/packages/ruby/rails.rb",
+     "examples/packages/ruby/ruby.rb",
+     "examples/packages/ruby/ruby_gems.rb",
+     "examples/packages/scm/git.rb",
+     "examples/packages/utilities/screen.rb",
+     "lib/divvy.rb",
+     "lib/divvy/duplicate_package_error.rb",
+     "lib/divvy/package.rb",
+     "lib/divvy/package_runner.rb",
+     "lib/divvy/plugins/apt.rb",
+     "lib/divvy/plugins/file_utilities.rb",
+     "lib/divvy/plugins/gem.rb",
+     "lib/divvy/plugins/rails.rb",
+     "lib/divvy/plugins/source.rb",
+     "lib/divvy/provisioner.rb",
+     "lib/divvy/server.rb",
+     "lib/divvy/verification.rb",
+     "lib/divvy/verifiers.rb",
+     "test/divvy_test.rb",
+     "test/package_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/mdwan/divvy}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.2}
+  s.summary = %q{Divvy is an easy to configure, easy to extend server provisioning framework written in Ruby.}
+  s.test_files = [
+    "test/divvy_test.rb",
+     "test/package_test.rb",
+     "test/test_helper.rb",
+     "examples/packages/build_essential.rb",
+     "examples/packages/databases/mysql.rb",
+     "examples/packages/databases/sqlite3.rb",
+     "examples/packages/ruby/rails.rb",
+     "examples/packages/ruby/ruby.rb",
+     "examples/packages/ruby/ruby_gems.rb",
+     "examples/packages/scm/git.rb",
+     "examples/packages/utilities/screen.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/examples/packages/build_essential.rb

@@ -0,0 +1,14 @@
+Divvy.package :apt_update do
+  apply do
+    run('aptitude -y update')
+    run('aptitude -y safe-upgrade')
+    run('aptitude -y full-upgrade')
+  end
+end
+
+Divvy.package :build_essential do
+  requires :apt_update
+  apply do
+    apt %w(build-essential libssl-dev libreadline5-dev zlib1g-dev)
+  end
+end

data/examples/packages/databases/mysql.rb

@@ -0,0 +1,20 @@
+Divvy.package :mysql do
+  verify do
+    has_executable 'mysql'
+  end
+
+  apply do
+    apt %q(mysql-server mysql-client libmysqlclient15-dev)
+  end
+end
+
+Divvy.package :mysql_ruby_driver do
+  requires :mysql, :ruby, :ruby_gems
+  verify do
+    ruby_can_load 'mysql'
+  end
+
+  apply do
+    ruby_gem 'mysql'
+  end
+end

data/examples/packages/databases/sqlite3.rb

@@ -0,0 +1,21 @@
+Divvy.package :sqlite3 do
+  verify do
+    has_executable 'sqlite3'
+  end
+
+  apply do
+    apt 'sqlite3'
+  end  
+end
+
+Divvy.package :sqlite3_ruby do
+  requires :sqlite3
+  
+  verify do
+    ruby_can_load 'sqlite3'
+  end
+  
+  apply do
+    apt 'libsqlite3-dev libsqlite3-ruby1.8'
+  end
+end

data/examples/packages/ruby/rails.rb

@@ -0,0 +1,11 @@
+Divvy.package :rails do
+  requires :ruby_gems
+
+  verify do
+    has_executable 'rails'
+  end
+  
+  apply do
+    ruby_gem 'rails'
+  end
+end

data/examples/packages/ruby/ruby.rb

@@ -0,0 +1,17 @@
+Divvy.package :ruby do
+  requires :build_essential
+  
+  verify { has_file '/usr/bin/ruby1.8' }
+  verify { has_file '/usr/bin/ri1.8' }
+  verify { has_file '/usr/bin/rdoc1.8' }
+  verify { has_file '/usr/bin/irb1.8' }
+
+  
+  apply do
+    apt %q(ruby1.8-dev ruby1.8 ri1.8 rdoc1.8 irb1.8 libreadline-ruby1.8 libruby1.8 libopenssl-ruby)
+    run('ln -s /usr/bin/ruby1.8 /usr/bin/ruby')
+    run('ln -s /usr/bin/ri1.8 /usr/bin/ri')
+    run('ln -s /usr/bin/rdoc1.8 /usr/bin/rdoc')
+    run('ln -s /usr/bin/irb1.8 /usr/bin/irb')
+  end  
+end

data/examples/packages/ruby/ruby_gems.rb

@@ -0,0 +1,19 @@
+Divvy.package :ruby_gems do
+  requires :build_essential, :ruby
+
+  verify do
+    has_executable 'gem'
+  end
+
+  apply do
+    source "http://rubyforge.org/frs/download.php/56227/rubygems-1.3.3.tgz" do
+      skip :configure, :build
+      stage :install do
+        run("cd #{build_dir} && ruby setup.rb")
+        run('ln -Fs /usr/bin/gem1.8 /usr/bin/gem')
+        run('gem update')
+        run('gem update --system')        
+      end
+    end
+  end
+end

data/examples/packages/scm/git.rb

@@ -0,0 +1,11 @@
+Divvy.package :git do
+  requires :build_essential
+  
+  verify do
+    has_executable 'git'
+  end
+  
+  apply do
+    apt 'git-core'
+  end
+end

data/examples/packages/utilities/screen.rb

@@ -0,0 +1,5 @@
+Divvy.package :screen do
+  apply do
+    apt 'screen'
+  end
+end

data/lib/divvy/duplicate_package_error.rb

@@ -0,0 +1,11 @@
+module Divvy
+  class DuplicatePackageError < RuntimeError
+    
+    attr_accessor :package
+    
+    def initialize(package)
+      super("The package #{package} has already been registered")
+      @package = package
+    end
+  end
+end

data/lib/divvy/package.rb

@@ -0,0 +1,33 @@
+module Divvy
+  class Package
+    
+    def initialize(name, options = {}, &block)
+      # raise ArgumentError.new('Name is required') unless name
+      @name = name.to_sym
+      @options = options
+      @dependencies = []
+      @verifications = []
+      self.instance_eval(&block)
+    end
+
+    attr_reader :name, :options, :verifications, :apply_block
+
+    def requires(*packages)
+      @dependencies << packages
+      @dependencies.flatten!
+    end
+    
+    def dependencies
+      @dependencies.each { |package| raise "Package #{package} not found!" unless Divvy.packages.key?(package) }
+      @dependencies.map { |key| Divvy.packages[key] }
+    end
+
+    def apply(&block)
+      @apply_block = block
+    end
+    
+    def verify(description = '', &block)
+      @verifications << Verification.new(self, description, &block)
+    end
+  end
+end

data/lib/divvy/package_runner.rb

@@ -0,0 +1,51 @@
+module Divvy
+  class PackageRunner
+    def initialize(server, package)
+      @server, @package = server, package
+    end
+    
+    attr_reader :server, :package
+    
+    def run(command, options = {})
+      server.remote_command(command, options)
+    end
+    
+    def scp(source, destination, options = {})
+      server.scp(source, destination, options)
+    end
+    
+    def process
+      puts "==> Processing #{package.name}"
+      
+      unless package.verifications.empty?
+        begin
+          process_verifications(true)
+          puts " --> #{package.name} already installed package: #{server.host}"
+          return
+        rescue Divvy::VerificationFailed => e
+          # Yaay package not installed yet
+        end
+      end
+      
+      self.instance_eval(&package.apply_block) unless package.apply_block.nil?
+          
+      process_verifications
+    end
+
+    private
+      def process_verifications(pre = false)
+        return if package.verifications.empty?
+        
+        if pre
+          puts " --> Checking if #{package.name} is already installed for server: #{server.host}"
+        else
+          puts " --> Verifying #{package.name} was properly installed for server: #{server.host}"
+        end
+
+        package.verifications.each do |v|
+          v.verify(server)
+        end
+        
+      end
+  end
+end

data/lib/divvy/plugins/apt.rb

@@ -0,0 +1,21 @@
+module Divvy
+  module Plugins
+    module Apt
+      def apt(*packages)
+        packages.flatten!
+        
+        options = { :dependencies_only => false }
+        options.update(packages.pop) if packages.last.is_a?(Hash)
+        
+        command = [ "DEBCONF_TERSE='yes' DEBIAN_PRIORITY='critical' DEBIAN_FRONTEND=noninteractive" ]
+        command << 'apt-get -qyu'
+        command << (options[:dependencies_only] ? 'build-dep' : 'install')
+        command << packages
+        
+        run(command.join(' '))
+      end      
+    end
+  end
+end
+
+Divvy.register_plugin(Divvy::Plugins::Apt)

data/lib/divvy/plugins/file_utilities.rb

@@ -0,0 +1,23 @@
+module Divvy
+  module Plugins
+    module FileUtilities
+      
+      # Makes a directory
+      # path is the diretory to create. This will not create the directory if it already exists
+      # mode is the file mode of the directory. If nil, no mode changes will be made
+      def mkdir(path, mode = nil)
+        run("[ -d #{path} ] || mkdir -p #{path}")
+        run("chmod #{mode} #{dir}") unless mode.nil?
+      end
+      
+      def push_text(path, text)
+        run("[ -f #{path} ] || touch #{path}")
+        run("echo '#{text}' | tee -a #{path}")
+        # "echo '#{text}' |#{'sudo' if option?(:sudo)} tee -a #{path}"
+      end
+      
+    end
+  end
+end
+
+Divvy.register_plugin(Divvy::Plugins::FileUtilities)

data/lib/divvy/plugins/gem.rb

@@ -0,0 +1,21 @@
+module Divvy
+  module Plugins
+    module RubyGems
+      def ruby_gem(gem_name, options = {})
+        options = {
+          :no_doc => true,
+        }.merge(options)
+        
+        cmd = "gem install #{gem_name}"
+        cmd << " --version '#{options[:version]}'" if options[:version]
+        cmd << " --source #{options[:source]}" if options[:source]
+        cmd << " --install-dir #{options[:install_dir]}" if options[:install_dir]
+        cmd << " --no-rdoc --no-ri" if options[:no_doc]
+        cmd << " -- #{build_flags}" if options[:build_flags]
+        run(cmd)
+      end
+    end
+  end
+end
+
+Divvy.register_plugin(Divvy::Plugins::RubyGems)

data/lib/divvy/plugins/rails.rb

@@ -0,0 +1,11 @@
+module Divvy
+  module Plugins
+    module Rails
+      def set_rails_env(env, file = '~/.profile')
+        run("grep -q \"export RAILS_ENV=production\" #{file} || echo \"export RAILS_ENV=#{env}\" >> #{file}")
+      end
+    end
+  end
+end
+
+Divvy.register_plugin(Divvy::Plugins::Rails)

data/lib/divvy/plugins/source.rb

@@ -0,0 +1,140 @@
+module Divvy
+  module Plugins
+    module Source
+      
+      def source(source, options = {}, &block)
+        SourceInstaller.new(self, source, options, &block)
+      end
+            
+      class SourceInstaller
+        def initialize(runner, source, options = {}, &block)
+          @runner = runner
+          @source = source
+          @options = {
+            :prefix => '/usr/local',
+            :archives => '/usr/local/sources',
+            :builds => '/usr/local/build'
+          }.merge(options)
+          
+          @befores = {}
+          @afters = {}
+          @stages = {
+            :prepare => Proc.new { prepare },
+            :download => Proc.new { download },
+            :extract => Proc.new { extract },
+            :configure => Proc.new { configure },
+            :build => Proc.new { build },
+            :install => Proc.new { install }
+          }
+          self.instance_eval(&block) unless block.nil?
+          
+          [:prepare, :download, :extract, :configure, :build, :install].each do |stage|
+            puts "before #{stage}" if Divvy.verbose
+            @befores[stage].call if @befores[stage]
+            puts "stage #{stage}" if Divvy.verbose
+            @stages[stage].call if @stages[stage]
+            puts "after #{stage}" if Divvy.verbose            
+            @afters[stage].call if @afters[stage]
+          end
+        end
+        
+        attr_reader :options, :source, :runner
+        
+        def before(stage, &block)
+          @befores[stage] = block
+        end
+
+        def after(stage, &block)
+          @afters[stage] = block
+        end
+
+        def stage(stage, &block)
+          @stages[stage] = block
+        end
+        
+        def skip(*stages)
+          stages.each { |stage| @stages.delete(stage) }
+        end
+        
+        def build_dir #:nodoc:
+          "#{options[:builds]}/#{options[:custom_dir] || base_dir}"
+        end
+
+        def base_dir #:nodoc:
+          if source.split('/').last =~ /(.*)\.(tar\.gz|tgz|tar\.bz2|tb2)/
+            return $1
+          end
+          raise "Unknown base path for source archive: #{ssource}, please update code knowledge"
+        end
+        
+        def archive_name
+          name = @source.split('/').last
+          raise "Unable to determine archive name for source: #{source}, please update code knowledge" unless name
+          name
+        end
+
+        private
+          def prepare
+            runner.mkdir(options[:prefix])
+            runner.mkdir(options[:archives])
+            runner.mkdir(options[:builds])
+          end
+                            
+          def download
+            run("wget -cq --directory-prefix='#{options[:archives]}' #{source}")
+          end
+                  
+          def extract
+            extract_command = case source
+              when /(tar.gz)|(tgz)$/
+                'tar xzf'
+              when /(tar.bz2)|(tb2)$/
+                'tar xjf'
+              when /tar$/
+                'tar xf'
+              when /zip$/
+                'unzip'
+              else
+                raise "Unknown source archive format: #{source}"
+            end
+            
+            run("bash -c 'cd #{options[:builds]} && #{extract_command} #{options[:archives]}/#{archive_name}'")
+          end
+                  
+          def configure
+            # command = "bash -c 'cd #{build_dir} && ./configure --prefix=#{@options[:prefix]} "            
+            command = "cd #{build_dir} && ./configure --prefix=#{@options[:prefix]} "
+            extras = {
+              :enable  => '--enable', :disable => '--disable',
+              :with    => '--with',   :without => '--without'
+            }
+            extras.inject(command) { |m, (k, v)| m << create_options(k, v) if options[k]; m }
+            
+            # command << " > #{archive_name}-configure.log 2>&1'"
+            
+            run(command)
+          end
+        
+          def build
+            # run("bash -c 'cd #{build_dir} && make > #{archive_name}-build.log 2>&1'")
+            run("cd #{build_dir} && make")
+          end
+                  
+          def install
+            # run("bash -c 'cd #{build_dir} && make install > #{archive_name}-install.log 2>&1'")
+            run("cd #{build_dir} && make install")
+          end
+          
+          def create_options(key, prefix) #:nodoc:
+            options[key].inject(' ') { |m, option| m << "#{prefix}-#{option} "; m }
+          end
+                    
+          def method_missing(symbol, *args)
+            runner.send(symbol, args)
+          end
+      end
+    end
+  end
+end
+
+Divvy.register_plugin(Divvy::Plugins::Source)

data/lib/divvy/provisioner.rb

@@ -0,0 +1,41 @@
+module Divvy
+  class Provisioner
+    def initialize(host, target_package, server_options)
+      @target_package = Divvy.packages[target_package]
+      raise "Package #{target_package} not found!" unless @target_package
+      @server = Server.new(host, server_options)
+    end
+    
+    attr_reader :target_package, :server
+    
+    def run
+      start_time = Time.now
+      print_package(target_package)
+      install_plan = normalize(target_package)
+      puts "Normalized install order: #{install_plan.map { |package| package.name }.join(', ')}"
+      install_plan.each do |package|
+        PackageRunner.new(server, package).process
+      end
+      puts "Took #{Time.now - start_time} seconds"
+    end
+    
+    private
+      # TODO: this does not prevent circular dependencies yet
+      def normalize(package)
+        packages = []
+        package.dependencies.each do |dependent|
+          packages << normalize(dependent)
+          # packages << package
+        end
+        packages << package
+        packages.flatten.uniq
+      end
+      
+      def print_package(package, depth = 1)
+        puts "#{" " * depth}#{package.name}"
+        package.dependencies.each do |dependent|
+          print_package(dependent, depth + 1)
+        end
+      end
+  end
+end

data/lib/divvy/server.rb

@@ -0,0 +1,77 @@
+require 'net/ssh'
+require 'net/scp'
+
+module Divvy
+  class Server
+    def initialize(host, options = {})
+      @host = host
+      @options = options
+    end
+
+    attr_reader :host, :options
+    
+    def remote_command(command, options = {})
+      options = {
+        :verbose => Divvy.verbose, 
+        :raise_on_exit_code => true,
+        :raise_errors => true
+      }.merge(options)
+      puts command if options[:verbose]
+      response_data = ''
+      begin
+        key_path = File.expand_path(self.options[:key]) if self.options[:key]
+        Net::SSH.start(host, self.options[:user], :password => self.options[:password], :keys => [key_path]) do |ssh|
+          ssh.open_channel do |channel|
+            channel.exec(command) do |ch, success|
+              raise "FAILED: couldn't execute command (ssh.channel.exec failure)" unless success
+
+              channel.on_data do |ch, data|  # stdout
+                print data if options[:verbose]
+                STDOUT.flush
+                response_data << data
+              end
+
+              channel.on_extended_data do |ch, type, data|
+                next unless type == 1  # only handle stderr
+                $stderr.print data
+              end
+
+              channel.on_request("exit-status") do |ch, data|
+                exit_code = data.read_long
+                raise NonZeroExitCode.new(command, exit_code) if exit_code > 0 && options[:raise_on_exit_code]
+              end
+
+              channel.on_request("exit-signal") do |ch, data|
+                puts "SIGNAL: #{data.read_long}"
+              end
+            end
+          end
+          ssh.loop
+        end
+      rescue Exception => err
+        return false unless options[:raise_errors]
+        raise
+      end
+      response_data
+    end
+
+    def scp(source, target, options = {})
+      key_path = File.expand_path(self.options[:key]) if self.options[:key]
+      Net::SCP.start(host, self.options[:user], :password => self.options[:password], :keys => [key_path]) do |scp|
+        scp.upload! source, target do |ch, name, sent, total|
+          puts "#{name}: #{sent}/#{total}"
+        end
+      end
+    end
+  end
+
+  class NonZeroExitCode < Exception
+    def initialize(command, exit_code)
+      super("Non-zero exit code: #{exit_code} for #{command}")
+      @command = command
+      @exit_code = exit_code
+    end
+    
+    attr_accessor :command, :exit_code
+  end
+end

data/lib/divvy/verification.rb

@@ -0,0 +1,37 @@
+module Divvy
+  class Verification
+
+    attr_accessor :package, :description, :commands #:nodoc:
+    
+    def initialize(package, description = '', &block) #:nodoc:
+      raise 'Verify requires a block.' unless block
+      
+      @package = package
+      @description = description.empty? ? package.name : description
+      @commands = []
+      
+      self.instance_eval(&block)
+    end
+    
+    def verify(server)
+      @commands.each do |command|
+        begin
+          server.remote_command(command)
+        rescue Divvy::NonZeroExitCode => ex  
+          raise Divvy::VerificationFailed.new(@package, description)
+        end
+      end
+    end
+  end
+  
+  class VerificationFailed < Exception #:nodoc:
+    attr_accessor :package, :description
+    
+    def initialize(package, description)
+      super("Verifying #{package.name}#{description} failed.")
+      
+      @package = package
+      @description = description
+    end
+  end
+end

data/lib/divvy/verifiers.rb

@@ -0,0 +1,62 @@
+module Divvy
+  module Verifiers
+    # Checks to make sure <tt>path</tt> is a file on the remote server.
+    def has_file(path)
+      @commands << "test -f #{path}"
+    end
+    
+    def file_contains(path, text)
+      @commands << "grep '#{text}' #{path}"
+    end
+    
+    # Tests that the directory <tt>dir</tt> exists.
+    def has_directory(dir)
+      @commands << "test -d #{dir}"
+    end
+    
+    # Checks if <tt>path</tt> is an executable script. This verifier is "smart" because
+    # if the path contains a forward slash '/' then it assumes you're checking an 
+    # absolute path to an executable. If no '/' is in the path, it assumes you're
+    # checking for a global executable that would be available anywhere on the command line.
+    def has_executable(path)
+      # Be smart: If the path includes a forward slash, we're checking
+      # an absolute path. Otherwise, we're checking a global executable
+      if path.include?('/')
+        @commands << "test -x #{path}"
+      else
+        @commands << "[ -n \"`echo \\`which #{path}\\``\" ]"
+      end
+    end
+    
+    # Checks to make sure <tt>process</tt> is a process running
+    # on the remote server.
+    def has_process(process)
+      @commands << "ps aux | grep '#{process}' | grep -v grep"
+    end
+    
+    # Checks if ruby can require the <tt>files</tt> given. <tt>rubygems</tt>
+    # is always included first.
+    def ruby_can_load(*files)
+      # Always include rubygems first
+      files = files.unshift('rubygems').collect { |x| "require '#{x}'" }
+      
+      @commands << "ruby -e \"#{files.join(';')}\""
+    end
+    
+    # Checks if a gem exists by calling "sudo gem list" and grepping against it.
+    def has_gem(name, version=nil)
+      version = version.nil? ? '' : version.gsub('.', '\.')
+      @commands << "sudo gem list | grep -e '^#{name} (.*#{version}.*)$'"
+    end
+    
+    # Checks that <tt>symlink</tt> is a symbolic link. If <tt>file</tt> is 
+    # given, it checks that <tt>symlink</tt> points to <tt>file</tt>
+    def has_symlink(symlink, file = nil)
+      if file.nil?
+        @commands << "test -L #{symlink}"
+      else
+        @commands << "test '#{file}' = `readlink #{symlink}`"
+      end
+    end
+  end
+end

data/lib/divvy.rb

@@ -0,0 +1,94 @@
+require 'rubygems'
+
+Dir["#{File.dirname(__FILE__)}/divvy/*.rb"].each { |f| require f}
+
+# class Object
+#   include Divvy::Script
+# end
+
+module Divvy
+  class << self
+    # user configurable
+    attr_accessor :test,
+                       :verbose
+                       # :port,
+                       # :allow,
+                       # :log_buffer_size,
+                       # :pid_file_directory,
+                       # :log_file,
+                       # :log_level,
+                       # :use_events
+    
+    # Internal variables
+    attr_accessor :initialized,
+                  # :running,
+                  :packages
+  end
+  
+  def self.say(message)
+    puts message
+  end
+  
+  def self.init
+    # exit if divvy is already initialized
+    return if self.initialized
+    
+    # variable init
+    self.packages = {}
+    
+    # # set defaults
+    # self.log_buffer_size ||= LOG_BUFFER_SIZE_DEFAULT
+    # self.port ||= DRB_PORT_DEFAULT
+    # self.allow ||= DRB_ALLOW_DEFAULT
+    # self.log_level ||= LOG_LEVEL_DEFAULT
+    
+    # # log level
+    # log_level_map = {:debug => Logger::DEBUG,
+    #                  :info => Logger::INFO,
+    #                  :warn => Logger::WARN,
+    #                  :error => Logger::ERROR,
+    #                  :fatal => Logger::FATAL}
+    # LOG.level = log_level_map[self.log_level]
+    
+    # flag as initialized
+    self.initialized = true
+    
+    # not yet running
+    # self.running = false
+  end
+  
+  def self.register_verifier(verifier)
+    Divvy::Verification.class_eval { include verifier }
+  end
+
+  def self.register_plugin(plugin)
+    Divvy::PackageRunner.class_eval { include plugin }
+  end
+  
+  def self.package(name, options = {}, &block)
+    package = Package.new(name, options, &block)
+    raise DuplicatePackageError.new(package.name) if packages.key?(package.name)
+    packages[package.name] = package
+  end
+
+  def self.provision(host, package, server_options)
+    provision = Provisioner.new(host, package, server_options)
+    provision.run
+  end
+  
+  def get_package(key)
+    package = PACKAGES[key]
+    raise "Package #{key} not found!" unless package
+    package
+  end
+
+  def self.run(script, filename = '__SCRIPT__')
+    Divvy.init
+    Object.new.instance_eval(script, filename)
+  end
+
+end
+
+Divvy.register_verifier(Divvy::Verifiers)
+
+Dir["#{File.dirname(__FILE__)}/divvy/plugins/*"].each { |f| require f }

data/test/divvy_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+class DivvyTest < Test::Unit::TestCase
+  
+  context 'internal_init' do
+    should 'flag itself as initialized' do
+      Divvy.init
+      assert Divvy.initialized
+    end
+    
+    should 'setup empty packages' do
+      Divvy.init
+      assert_equal Hash.new, Divvy.packages
+    end
+  end
+  
+  context 'run' do
+    should 'call initialize' do
+      Divvy.expects(:init)
+      Divvy.run('')
+    end
+    
+    should 'eval the script on Object' do
+      Object.any_instance.expects(:instance_eval).with('foobar', 'michael.rb')
+      Divvy.run('foobar', 'michael.rb')
+    end
+    
+    should 'set the filename to __SCRIPT__ if no filename specified' do
+      Object.any_instance.expects(:instance_eval).with('foobar', '__SCRIPT__')
+      Divvy.run('foobar')
+    end
+  end
+  
+  context 'packages' do
+    should 'add a package to the internal packages' do
+      code = <<-EOF
+        Divvy.package :foobar do
+        end
+      EOF
+      
+      Divvy.run(code)
+
+      assert_equal 1, Divvy.packages.size
+    end
+    
+    should 'raise DuplicatePackageError when adding duplicate package names' do
+      code = <<-EOF
+        Divvy.package :foobar do
+        end
+        Divvy.package :foobar do
+        end
+      EOF
+            
+      assert_raises Divvy::DuplicatePackageError do
+        Divvy.run(code)
+      end
+    end
+    
+  end
+
+end

data/test/package_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+class PackageTest < Test::Unit::TestCase
+  
+  context 'initialize' do
+    should 'set name to name accessor' do
+      package = Divvy::Package.new :michael do
+      end
+      assert_equal :michael, package.name
+    end
+    
+    should 'convert name strings into symbols' do
+      package = Divvy::Package.new 'michael' do
+      end
+      assert_equal :michael, package.name
+    end
+        
+    should 'set dependencies to an empty array' do
+      package = Divvy::Package.new :name do
+      end
+      assert_equal [], package.dependencies
+    end
+
+    should 'set verifications to an empty array' do
+      package = Divvy::Package.new :name do
+      end
+      assert_equal [], package.verifications
+    end
+    
+    should 'assign options to options accessor' do
+      options = { :peanut => 'butter jelly time' }
+      package = Divvy::Package.new :name, options do
+      end
+      assert_equal options, package.options
+    end
+
+    should 'assign options an empty hash if no options present' do
+      package = Divvy::Package.new :name do
+      end
+      assert_equal Hash.new, package.options
+    end
+    
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'divvy'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: michaeldwan-divvy
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Michael Dwan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-31 00:00:00 -07:00
+default_executable: divvy
+dependencies: []
+
+description: 
+email: mpdwan@gmail.com
+executables: 
+- divvy
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/divvy
+- divvy.gemspec
+- examples/packages/build_essential.rb
+- examples/packages/databases/mysql.rb
+- examples/packages/databases/sqlite3.rb
+- examples/packages/ruby/rails.rb
+- examples/packages/ruby/ruby.rb
+- examples/packages/ruby/ruby_gems.rb
+- examples/packages/scm/git.rb
+- examples/packages/utilities/screen.rb
+- lib/divvy.rb
+- lib/divvy/duplicate_package_error.rb
+- lib/divvy/package.rb
+- lib/divvy/package_runner.rb
+- lib/divvy/plugins/apt.rb
+- lib/divvy/plugins/file_utilities.rb
+- lib/divvy/plugins/gem.rb
+- lib/divvy/plugins/rails.rb
+- lib/divvy/plugins/source.rb
+- lib/divvy/provisioner.rb
+- lib/divvy/server.rb
+- lib/divvy/verification.rb
+- lib/divvy/verifiers.rb
+- test/divvy_test.rb
+- test/package_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/mdwan/divvy
+post_install_message: 
+rdoc_options: 
+- --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: 3
+summary: Divvy is an easy to configure, easy to extend server provisioning framework written in Ruby.
+test_files: 
+- test/divvy_test.rb
+- test/package_test.rb
+- test/test_helper.rb
+- examples/packages/build_essential.rb
+- examples/packages/databases/mysql.rb
+- examples/packages/databases/sqlite3.rb
+- examples/packages/ruby/rails.rb
+- examples/packages/ruby/ruby.rb
+- examples/packages/ruby/ruby_gems.rb
+- examples/packages/scm/git.rb
+- examples/packages/utilities/screen.rb