sprinkle 0.1.4

data/lib/sprinkle/package.rb

@@ -0,0 +1,94 @@
+module Sprinkle
+  module Package
+    PACKAGES = {}
+
+    def package(name, metadata = {}, &block)
+      package = Package.new(name, metadata, &block)
+      PACKAGES[name] = package
+
+      if package.provides
+        (PACKAGES[package.provides] ||= []) << package
+      end
+
+      package
+    end
+
+    class Package
+      include ArbitraryOptions
+      attr_accessor :name, :provides, :installer, :dependencies, :recommends
+
+      def initialize(name, metadata = {}, &block)
+        raise 'No package name supplied' unless name
+
+        @name = name
+        @provides = metadata[:provides]
+        @dependencies = []
+        @recommends = []
+        self.instance_eval &block
+      end
+
+      def apt(*names)
+        @installer = Sprinkle::Installers::Apt.new(self, *names)
+      end
+
+      def rpm(*names)
+        @installer = Sprinkle::Installers::Rpm.new(self, *names)
+      end
+
+      def gem(name, options = {}, &block)
+        @recommends << :rubygems
+        @installer = Sprinkle::Installers::Gem.new(self, name, options, &block)
+      end
+
+      def source(source, options = {}, &block)
+        @recommends << :build_essential # Ubuntu/Debian
+        @installer = Sprinkle::Installers::Source.new(self, source, options, &block)
+      end
+
+      def process(deployment, roles)
+        return if meta_package?
+
+        @installer.defaults(deployment)
+        @installer.process(roles)
+      end
+
+      def requires(*packages)
+        @dependencies << packages
+        @dependencies.flatten!
+      end
+
+      def recommends(*packages)
+        @recommends << packages
+        @recommends.flatten!
+      end
+
+      def tree(depth = 1, &block)
+        packages = []
+
+        @recommends.each do |dep|
+          package = PACKAGES[dep]
+          next unless package # skip missing recommended packages as they can be optional
+          block.call(self, package, depth) if block
+          packages << package.tree(depth + 1, &block)
+        end
+
+        @dependencies.each do |dep|
+          package = PACKAGES[dep]
+          raise "Package definition not found for key: #{dep}" unless package
+          block.call(self, package, depth) if block
+          packages << package.tree(depth + 1, &block)
+        end
+
+        packages << self
+      end
+
+      def to_s; @name; end
+
+      private
+
+        def meta_package?
+          @installer == nil
+        end
+    end
+  end
+end

data/lib/sprinkle/policy.rb

@@ -0,0 +1,85 @@
+require 'highline/import'
+
+module Sprinkle
+  module Policy
+    POLICIES = []
+
+    def policy(name, options = {}, &block)
+      p = Policy.new(name, options, &block)
+      POLICIES << p
+      p
+    end
+
+    class Policy
+      attr_reader :name, :packages
+
+      def initialize(name, metadata = {}, &block)
+        raise 'No name provided' unless name
+        raise 'No roles provided' unless metadata[:roles]
+
+        @name = name
+        @roles = metadata[:roles]
+        @packages = []
+        self.instance_eval(&block)
+      end
+
+      def requires(package, options = {})
+        @packages << package
+      end
+
+      def to_s; name; end
+
+      def process(deployment)
+        all = []
+
+        cloud_info "--> Cloud hierarchy for policy #{@name}"
+
+        @packages.each do |p|
+          cloud_info "\nPolicy #{@name} requires package #{p}"
+
+          package = Sprinkle::Package::PACKAGES[p]
+          raise "Package definition not found for key: #{p}" unless package
+          package = select_package(p, package) if package.is_a? Array # handle virtual package selection
+
+          tree = package.tree do |parent, child, depth|
+            indent = "\t" * depth; cloud_info "#{indent}Package #{parent.name} requires #{child.name}"
+          end
+
+          all << tree
+        end
+
+        normalize(all) do |package|
+          package.process(deployment, @roles)
+        end
+      end
+
+      private
+
+        def cloud_info(message)
+          logger.info(message) if Sprinkle::OPTIONS[:cloud] or logger.debug?
+        end
+
+        def select_package(name, packages)
+          if packages.size <= 1
+            package = packages.first
+          else
+            package = choose do |menu|
+              menu.prompt = "Multiple choices exist for virtual package #{name}"
+              menu.choices *packages.collect(&:to_s)
+            end
+            package = Sprinkle::Package::PACKAGES[package]
+          end
+
+          cloud_info "Selecting #{package.to_s} for virtual package #{name}"
+
+          package
+        end
+
+        def normalize(all, &block)
+          all = all.flatten.uniq
+          cloud_info "\n--> Normalized installation order for all packages: #{all.collect(&:name).join(', ')}"
+          all.each &block
+        end
+    end
+  end
+end

data/lib/sprinkle/script.rb

@@ -0,0 +1,13 @@
+module Sprinkle
+  class Script
+    def self.sprinkle(script, filename = '__SCRIPT__')
+      powder = new
+      powder.instance_eval script, filename
+      powder.sprinkle
+    end
+
+    def sprinkle
+      @deployment.process if @deployment
+    end
+  end
+end

data/lib/sprinkle/sequence.rb

@@ -0,0 +1,21 @@
+module Sprinkle
+  class Sequence
+    attr_accessor :stages
+
+    def initialize(&block)
+      self.instance_eval &block if block
+    end
+
+    def method_missing(sym, *args, &block)
+      @stages ||= ActiveSupport::OrderedHash.new
+      @stages[sym] = block
+    end
+
+    def each(&block)
+      @stages.each do |section, commands|
+        block.call section, commands.call
+      end
+    end
+
+  end
+end

data/lib/sprinkle/version.rb

@@ -0,0 +1,9 @@
+module Sprinkle #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 4
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/sprinkle.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'active_support'
+
+# Use active supports auto load mechanism
+Dependencies.load_paths << File.dirname(__FILE__)
+
+# Configure active support to log auto-loading of dependencies
+#Dependencies::RAILS_DEFAULT_LOGGER = Logger.new($stdout)
+#Dependencies.log_activity = true
+
+# Load up extensions to existing classes
+Dir[File.dirname(__FILE__) + '/sprinkle/extensions/*.rb'].each { |e| require e }
+
+# Configuration options
+module Sprinkle
+  OPTIONS = { :testing => false, :verbose => false }
+end
+
+# Define a logging target and understand packages, policies and deployment DSL
+class Object
+  include Sprinkle::Package, Sprinkle::Policy, Sprinkle::Deployment
+
+  def logger
+    @@__log__ ||= ActiveSupport::BufferedLogger.new($stdout, ActiveSupport::BufferedLogger::Severity::INFO)
+  end
+end

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'sprinkle'
+
+module Kernel
+  def logger
+    @@__log_file__ ||= StringIO.new
+    @@__log__ = ActiveSupport::BufferedLogger.new @@__log_file__
+  end
+end

data/spec/sprinkle/actors/capistrano_spec.rb

@@ -0,0 +1,150 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Sprinkle::Actors::Capistrano do
+
+  before do
+    @recipes = 'deploy'
+    @cap = ::Capistrano::Configuration.new
+    ::Capistrano::Configuration.stub!(:new).and_return(@cap)
+    @cap.stub!(:load).and_return
+  end
+
+  def create_cap(&block)
+    Sprinkle::Actors::Capistrano.new &block
+  end
+
+  describe 'when created' do
+
+    it 'should create a new capistrano object' do
+      ::Capistrano::Configuration.should_receive(:new).and_return(@cap)
+      create_cap
+    end
+
+    describe 'when verbose' do
+
+      before do
+        Sprinkle::OPTIONS[:verbose] = true
+      end
+
+      it 'should set verbose logging on the capistrano object' do
+        @cap = create_cap
+        @cap.config.logger.level.should == ::Capistrano::Logger::INFO
+      end
+
+    end
+
+    describe 'when not verbose' do
+
+      before do
+        Sprinkle::OPTIONS[:verbose] = false
+      end
+
+      it 'should set quiet logging on the capistrano object' do
+        @cap = create_cap
+        @cap.config.logger.level.should == ::Capistrano::Logger::IMPORTANT
+      end
+
+    end
+
+    describe 'with a block' do
+
+      before do
+        @actor = create_cap do
+          recipes 'cool gear' # default is deploy
+        end
+      end
+
+      it 'should evaluate the block against the actor instance' do
+        @actor.loaded_recipes.should include('cool gear')
+      end
+
+    end
+
+    describe 'without a block' do
+
+      it 'should automatically load the default capistrano configuration' do
+        @cap.should_receive(:load).with('deploy').and_return
+      end
+
+      after do
+        @actor = create_cap
+      end
+
+    end
+
+  end
+
+  describe 'recipes' do
+
+    it 'should add the recipe location to an internal store' do
+      @cap = create_cap do
+        recipes 'deploy'
+      end
+      @cap.loaded_recipes.should == [ @recipes ]
+    end
+
+    it 'should load the given recipe' do
+      @cap.should_receive(:load).with(@recipes).and_return
+      create_cap
+    end
+
+  end
+
+  describe 'processing commands' do
+
+    before do
+      @commands = %w( op1 op2 )
+      @roles    = %w( app )
+      @name     = 'name'
+
+      @cap = create_cap do; recipes 'deploy'; end
+      @cap.stub!(:run).and_return
+    end
+
+    it 'should dynamically create a capistrano task containing the commands' do
+      @cap.config.should_receive(:task).and_return
+    end
+
+    it 'should invoke capistrano task after creation' do
+      @cap.should_receive(:run).with(@name).and_return
+    end
+
+    after do
+      @cap.process @name, @commands, @roles
+    end
+
+  end
+
+  describe 'generated task' do
+
+    before do
+      @commands = %w( op1 op2 )
+      @roles    = %w( app )
+      @name     = 'name'
+
+      @cap = create_cap do; recipes 'deploy'; end
+      @cap.config.stub!(:fetch).and_return(:sudo)
+      @cap.config.stub!(:invoke_command).and_return
+    end
+
+    it 'should use sudo to invoke commands when so configured' do
+      @cap.config.should_receive(:fetch).with(:run_method, :sudo).and_return(:sudo)
+    end
+
+    it 'should run the supplied commands' do
+      @cap.config.should_receive(:invoke_command).with('op1', :via => :sudo).ordered.and_return
+      @cap.config.should_receive(:invoke_command).with('op2', :via => :sudo).ordered.and_return
+    end
+
+    it 'should be applicable for the supplied roles' do
+      @cap.stub!(:run).and_return
+      @cap.config.should_receive(:task).with(:install_name, :roles => @roles).and_return
+    end
+
+    after do
+      @cap.process @name, @commands, @roles
+    end
+
+  end
+
+end

data/spec/sprinkle/deployment_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Sprinkle::Deployment do
+  include Sprinkle::Deployment
+  
+  def create_deployment(&block)
+    deployment do
+      delivery :capistrano, &block
+      
+      source do
+        prefix '/usr/local'
+      end
+    end
+  end
+
+  describe 'when created' do
+
+    it 'should be invalid without a block descriptor' do
+      lambda { deployment }.should raise_error
+    end
+
+    it 'should be invalid without a delivery method' do
+      lambda { @deployment = deployment do; end }.should raise_error
+    end
+
+    it 'should optionally accept installer defaults' do 
+      @deployment = create_deployment
+      @deployment.should respond_to(:source)
+    end
+    
+    it 'should provide installer defaults as a proc when requested' do 
+      @deployment = create_deployment
+      @deployment.defaults[:source].class.should == Proc
+    end
+    
+  end 
+  
+  describe 'delivery specification' do
+    
+    before do
+      @actor = mock(Sprinkle::Actors::Capistrano)
+      Sprinkle::Actors::Capistrano.stub!(:new).and_return(@actor)
+    end
+
+    it 'should automatically instantiate the delivery type' do 
+      @deployment = create_deployment
+      @deployment.style.should == @actor
+    end
+
+    it 'should optionally accept a block to pass to the actor' do
+      lambda { @deployment = create_deployment }.should_not raise_error
+    end
+
+    describe 'with a block' do
+
+      it 'should pass the block to the actor for configuration' do
+        @deployment = create_deployment do; recipes 'deploy'; end
+      end
+
+    end
+  end
+  
+  describe 'when processing policies' do 
+    
+    before do 
+      @policy = mock(Policy, :process => true)
+      POLICIES = [ @policy ]
+      @deployment = create_deployment
+    end
+    
+    it 'should apply all policies, passing itself as the deployment context' do
+      @policy.should_receive(:process).with(@deployment).and_return
+    end
+    
+    after do
+      @deployment.process
+    end
+  end
+
+end

data/spec/sprinkle/extensions/array_spec.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Array, 'task name conversions' do
+  
+  it 'should be able to deliver a task name' do
+    ['build_essential'].to_task_name.should == 'build_essential'
+  end
+  
+  it 'should join multiple elements together with a _ char' do
+    ['gdb', 'gcc', 'g++'].to_task_name.should == 'gdb_gcc_g++'
+  end
+  
+  it 'should use the task name of the underlying array element' do
+    string = 'build-essential'
+    string.should_receive(:to_task_name).and_return('build_essential')
+    [string].to_task_name.should == 'build_essential'
+  end
+    
+end

data/spec/sprinkle/extensions/string_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe String, 'task name conversions' do
+  
+  it 'should be able to deliver a task name' do
+    'build_essential'.to_task_name.should == 'build_essential'
+  end
+  
+  it 'should convert all - chars to _ in the task name' do
+    'build-essential'.to_task_name.should == 'build_essential'
+  end
+  
+  it 'should convert multiple - chars to _ chars in the task name' do
+    'build--essential'.to_task_name.should == 'build__essential'
+  end
+  
+  it 'should lowercase the task name' do
+    'BUILD-ESSENTIAL'.to_task_name.should == 'build_essential'
+  end
+  
+end

data/spec/sprinkle/installers/apt_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Sprinkle::Installers::Apt do
+
+  before do
+    @package = mock(Sprinkle::Package, :name => 'package')
+  end
+
+  def create_apt(debs, &block)
+    Sprinkle::Installers::Apt.new(@package, debs, &block)
+  end
+
+  describe 'when created' do
+
+    it 'should accept a single package to install' do
+      @installer = create_apt 'ruby'
+      @installer.packages.should == [ 'ruby' ]
+    end
+
+    it 'should accept an array of packages to install' do
+      @installer = create_apt %w( gcc gdb g++ )
+      @installer.packages.should == ['gcc', 'gdb', 'g++']
+    end
+
+  end
+
+  describe 'during installation' do
+
+    before do
+      @installer = create_apt 'ruby' do
+        pre :install, 'op1'
+        post :install, 'op2'
+      end
+      @install_commands = @installer.send :install_commands
+    end
+
+    it 'should invoke the apt installer for all specified packages' do
+      @install_commands.should =~ /apt-get -qyu install ruby/
+    end
+
+    it 'should specify a non interactive mode to the apt installer' do
+      @install_commands.should =~ /DEBIAN_FRONTEND=noninteractive/
+    end
+
+    it 'should automatically insert pre/post commands for the specified package' do
+      @installer.send(:install_sequence).should == [ 'op1', %(DEBCONF_TERSE='yes' DEBIAN_PRIORITY='critical' DEBIAN_FRONTEND=noninteractive apt-get -qyu install ruby), 'op2' ]
+    end
+
+    it 'should install a specific version if defined'
+
+  end
+
+end