crafterm-sprinkle 0.1.0

data/lib/sprinkle/actors/capistrano.rb

@@ -0,0 +1,80 @@
+require 'capistrano/cli'
+
+module Sprinkle
+  module Actors
+    class Capistrano
+      attr_accessor :config, :loaded_recipes
+
+      def initialize(&block)
+        @config = ::Capistrano::Configuration.new
+        @config.logger.level = Sprinkle::OPTIONS[:verbose] ? ::Capistrano::Logger::INFO : ::Capistrano::Logger::IMPORTANT
+        @config.set(:password) { ::Capistrano::CLI.password_prompt }
+        if block
+          self.instance_eval &block
+        else
+          @config.load 'deploy' # normally in the config directory for rails
+        end
+      end
+
+      def recipes(script)
+        @loaded_recipes ||= []
+        @config.load script
+        @loaded_recipes << script
+      end
+
+      def process(name, commands, roles)
+        define_task(name, roles) do
+          via = fetch(:run_method, :sudo)
+          commands.each do |command|
+            invoke_command command, :via => via
+          end
+        end
+        run(name)
+      end
+
+      private
+
+        # REVISIT: can we set the description somehow?
+        def define_task(name, roles, &block)
+          @config.task task_sym(name), :roles => roles, &block
+        end
+
+        def run(task)
+          @config.send task_sym(task)
+        end
+
+        def task_sym(name)
+          "install_#{name.to_task_name}".to_sym
+        end
+    end
+  end
+end
+
+
+=begin
+
+# channel: the SSH channel object used for this response
+# stream: either :err or :out, for stderr or stdout responses
+# output: the text that the server is sending, might be in chunks
+run "apt-get update" do |channel, stream, output|
+   if output =~ /Are you sure?/
+     answer = Capistrano::CLI.ui.ask("Are you sure: ")
+     channel.send_data(answer + "\n")
+   else
+     # allow the default callback to be processed
+     Capistrano::Configuration.default_io_proc.call[channel, stream, output]
+   end
+ end
+
+
+
+ You can tell subversion to use a different username+password by
+ setting a couple variables:
+    set :svn_username, "my svn username"
+    set :svn_password, "my svn password"
+ If you don't want to set the password explicitly in your recipe like
+ that, you can make capistrano prompt you for it like this:
+    set(:svn_password) { Capistrano::CLI.password_prompt("Subversion
+ password: ") }
+ - Jamis
+=end

data/lib/sprinkle/deployment.rb

@@ -0,0 +1,33 @@
+module Sprinkle
+  module Deployment
+    def deployment(&block)
+      @deployment = Deployment.new(&block)
+    end
+
+    class Deployment
+      attr_accessor :style, :defaults
+
+      def initialize(&block)
+        @defaults = {}
+        self.instance_eval(&block)
+        raise 'No delivery mechanism defined' unless @style
+      end
+
+      def delivery(type, &block)
+        @style = Actors.const_get(type.to_s.titleize).new &block
+      end
+
+      def method_missing(sym, *args, &block)
+        @defaults[sym] = block
+      end
+
+      def respond_to?(sym); !!@defaults[sym]; end
+
+      def process
+        POLICIES.each do |policy|
+          policy.process(self)
+        end
+      end
+    end
+  end
+end

data/lib/sprinkle/extensions/arbitrary_options.rb

@@ -0,0 +1,10 @@
+module ArbitraryOptions
+  def self.included(base)
+    base.alias_method_chain :method_missing, :arbitrary_options
+  end
+  
+  def method_missing_with_arbitrary_options(sym, *args, &block)
+    self.class.dsl_accessor sym
+    send(sym, *args, &block)
+  end
+end

data/lib/sprinkle/extensions/array.rb

@@ -0,0 +1,7 @@
+class Array
+  
+  def to_task_name
+    collect(&:to_task_name).join('_')
+  end
+  
+end

data/lib/sprinkle/extensions/blank_slate.rb

@@ -0,0 +1,5 @@
+class BlankSlate
+  instance_methods.each do |m| 
+    undef_method(m) unless %w( __send__ __id__ send class inspect instance_eval instance_variables ).include?(m)
+  end
+end

data/lib/sprinkle/extensions/dsl_accessor.rb

@@ -0,0 +1,15 @@
+class Module
+  def dsl_accessor(*symbols)
+    symbols.each do |sym|
+      class_eval %{
+        def #{sym}(*val)
+          if val.empty?
+            @#{sym}
+          else
+            @#{sym} = val.size == 1 ? val[0] : val
+          end
+        end
+      }
+    end
+  end
+end

data/lib/sprinkle/extensions/string.rb

@@ -0,0 +1,10 @@
+class String
+  
+  # REVISIT: what chars shall we allow in task names?
+  def to_task_name
+    s = downcase
+    s.gsub!(/-/, '_') # all - to _ chars
+    s
+  end
+  
+end

data/lib/sprinkle/extensions/symbol.rb

@@ -0,0 +1,7 @@
+class Symbol
+  
+  def to_task_name
+    to_s.to_task_name
+  end
+  
+end

data/lib/sprinkle/installers/apt.rb

@@ -0,0 +1,20 @@
+module Sprinkle
+  module Installers
+    class Apt < Installer
+      attr_accessor :packages
+
+      def initialize(parent, packages, &block)
+        super parent, &block
+        packages = [packages] unless packages.is_a? Array
+        @packages = packages
+      end
+
+      protected
+
+        def install_sequence
+          "DEBCONF_TERSE='yes' DEBIAN_PRIORITY='critical' DEBIAN_FRONTEND=noninteractive apt-get -qyu install #{@packages.join(' ')}"
+        end
+
+    end
+  end
+end

data/lib/sprinkle/installers/gem.rb

@@ -0,0 +1,31 @@
+module Sprinkle
+  module Installers
+    class Gem < Installer
+      attr_accessor :gem
+
+      def initialize(parent, gem, options = {}, &block)
+        super parent, options, &block
+        @gem = gem
+      end
+
+      def source(location = nil)
+        # package defines an installer called source so here we specify a method directly
+        # rather than rely on the automatic options processing since packages' method missing
+        # won't be run
+        return @options[:source] unless location
+        @options[:source] = location
+      end
+
+      protected
+
+        # rubygems 0.9.5+ installs dependencies by default, and does platform selection
+
+        def install_sequence
+          cmd = "gem install #{gem}"
+          cmd << " --version '#{version}'" if version
+          cmd << " --source #{source}" if source
+          cmd
+        end
+    end
+  end
+end

data/lib/sprinkle/installers/installer.rb

@@ -0,0 +1,47 @@
+module Sprinkle
+  module Installers
+    class Installer
+      attr_accessor :delivery, :package, :options
+
+      def initialize(package, options = {}, &block)
+        @package = package
+        @options = options
+        self.instance_eval(&block) if block
+      end
+
+      def defaults(deployment)
+        defaults = deployment.defaults[self.class.name.split(/::/).last.downcase.to_sym]
+        self.instance_eval(&defaults) if defaults
+        @delivery = deployment.style
+      end
+
+      def process(roles)
+        raise 'Unknown command delivery target' unless @delivery
+
+        if logger.debug?
+          sequence = install_sequence; sequence = sequence.join('; ') if sequence.is_a? Array
+          logger.debug "#{@package.name} install sequence: #{sequence} for roles: #{roles}\n"
+        end
+
+        unless Sprinkle::OPTIONS[:testing]
+          logger.info "--> Installing #{package.name} for roles: #{roles}"
+          @delivery.process(@package.name, install_sequence, roles)
+        end
+      end
+
+      def method_missing(sym, *args, &block)
+        unless args.empty? # mutate if not set
+          @options[sym] = *args unless @options[sym]
+        end
+
+        @options[sym] || @package.send(sym, *args, &block) # try the parents options if unknown
+      end
+
+      protected
+
+        def install_sequence
+          raise 'Concrete installers implement this to specify commands to run to install their respective packages'
+        end
+    end
+  end
+end

data/lib/sprinkle/installers/rake.rb

@@ -0,0 +1,16 @@
+module Sprinkle
+  module Installers
+    class Rake < Installer
+      def initialize(parent, commands = [], &block)
+        super parent, &block
+        @commands = commands
+      end
+
+      protected
+
+        def install_sequence
+          "rake #{@commands.join(' ')}"
+        end
+    end
+  end
+end

data/lib/sprinkle/installers/source.rb

@@ -0,0 +1,137 @@
+module Sprinkle
+  module Installers
+    class Source < Installer
+      attr_accessor :source, :pre, :post
+
+      def initialize(parent, source, options = {}, &block)
+        @pre = {}; @post = {}
+        @source = source
+        super parent, options, &block
+      end
+
+      def pre(stage, *commands)
+        @pre[stage] ||= []
+        @pre[stage] += commands
+      end
+
+      def post(stage, *commands)
+        @post[stage] ||= []
+        @post[stage] += commands
+      end
+
+      protected
+
+        def install_sequence
+          prepare + download + extract + configure + build + install
+        end
+
+        %w( prepare download extract configure build install ).each do |stage|
+          define_method stage do
+            pre_commands(stage.to_sym) + self.send("#{stage}_commands") + post_commands(stage.to_sym)
+          end
+        end
+
+        def prepare_commands
+          raise 'No installation area defined' unless @options[:prefix]
+          raise 'No build area defined' unless @options[:builds]
+          raise 'No source download area defined' unless @options[:archives]
+
+          [ "mkdir -p #{@options[:prefix]}",
+            "mkdir -p #{@options[:builds]}",
+            "mkdir -p #{@options[:archives]}" ]
+        end
+
+        def download_commands
+          [ "wget -cq --directory-prefix='#{@options[:archives]}' #{@source}" ]
+        end
+
+        def extract_commands
+          [ "bash -c 'cd #{@options[:builds]} && #{extract_command} #{@options[:archives]}/#{archive_name}'" ]
+        end
+
+        def configure_commands
+          return [] if custom_install?
+
+          command = "bash -c 'cd #{build_dir} && ./configure --silent --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 << " > #{@package.name}-configure.log 2>&1'" ]
+        end
+
+        def build_commands
+          return [] if custom_install?
+          [ "bash -c 'cd #{build_dir} && make > #{@package.name}-build.log 2>&1'" ]
+        end
+
+        def install_commands
+          return custom_install_commands if custom_install?
+          [ "bash -c 'cd #{build_dir} && make install > #{@package.name}-install.log 2>&1'" ]
+        end
+
+        def custom_install?
+          !! @options[:custom_install]
+        end
+
+        # REVISIT: must be better processing of custom install commands somehow? use splat operator?
+        def custom_install_commands
+          dress @options[:custom_install], :install
+        end
+
+      private
+
+        def pre_commands(stage)
+          dress @pre[stage] || [], :pre
+        end
+
+        def post_commands(stage)
+          dress @post[stage] || [], :post
+        end
+
+        def dress(commands, stage)
+          commands.collect { |command| "bash -c 'cd #{build_dir} && #{command} >> #{@package.name}-#{stage}.log 2>&1'" }
+        end
+
+        def create_options(key, prefix)
+          @options[key].inject(' ') { |m, option| m << "#{prefix}-#{option} "; m }
+        end
+
+        def 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: #{archive_name}"
+          end
+        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
+
+        def build_dir
+          "#{@options[:builds]}/#{base_dir}"
+        end
+
+        def base_dir
+          if @source.split('/').last =~ /(.*)\.(tar\.gz|tgz|tar\.bz2|tb2)/
+            return $1
+          end
+          raise "Unknown base path for source archive: #{@source}, please update code knowledge"
+        end
+    end
+  end
+end

data/lib/sprinkle/package.rb

@@ -0,0 +1,76 @@
+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
+    
+      def initialize(name, metadata = {}, &block)
+        raise 'No package name supplied' unless name
+
+        @name = name
+        @provides = metadata[:provides]
+        @dependencies = []
+        self.instance_eval &block
+      end
+    
+      def apt(*names)
+        @installer = Sprinkle::Installers::Apt.new(self, *names)
+      end
+    
+      def gem(name)
+        @dependencies << :rubygems
+        @installer = Sprinkle::Installers::Gem.new(self, name)
+      end
+    
+      def source(source, &block)
+        @dependencies << :build_essential # REVISIT: should only be for Ubuntu/Debian, need platform specific bits here
+        @installer = Sprinkle::Installers::Source.new(self, source, &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 tree(depth = 1, &block)
+        packages = []
+      
+        @dependencies.each do |dep|
+          package = PACKAGES[dep]
+          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,84 @@
+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]
+          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/version.rb

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

data/lib/sprinkle.rb

@@ -0,0 +1,29 @@
+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
+
+# Understand packages, policies and deployment DSL
+class Object
+  include Sprinkle::Package, Sprinkle::Policy, Sprinkle::Deployment
+end
+
+# Define a logging target
+class Object
+  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