sprinkle 0.1.4

data/examples/rails/rails.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env sprinkle -s
+
+# Annotated Example Sprinkle Rails deployment script
+#
+# This is an example Sprinkle script configured to install Rails from gems, Apache, Ruby and
+# Sphinx from source, and mysql from apt on an Ubuntu system.
+#
+# Installation is configured to run via capistrano (and an accompanying deploy.rb recipe script).
+# Source based packages are downloaded and built into /usr/local on the remote system.
+#
+# A sprinkle script is separated into 3 different sections. Packages, policies and deployment:
+
+
+# Packages (separate files for brevity)
+#
+#  Defines the world of packages as we know it. Each package has a name and
+#  set of metadata including its installer type (eg. apt, source, gem, etc). Packages can have
+#  relationships to each other via dependencies.
+
+require 'packages/essential'
+require 'packages/rails'
+require 'packages/database'
+require 'packages/server'
+require 'packages/search'
+
+
+# Policies
+#
+#  Names a group of packages (optionally with versions) that apply to a particular set of roles:
+#
+#   Associates the rails policy to the application servers. Contains rails, and surrounding
+#   packages. Note, appserver, database, webserver and search are all virtual packages defined above.
+#   If there's only one implementation of a virtual package, it's selected automatically, otherwise
+#   the user is requested to select which one to use.
+
+policy :rails, :roles => :app do
+  requires :rails, :version => '2.1.0'
+  requires :appserver
+  requires :database
+  requires :webserver
+  requires :search
+end
+
+
+# Deployment
+#
+#  Defines script wide settings such as a delivery mechanism for executing commands on the target
+#  system (eg. capistrano), and installer defaults (eg. build locations, etc):
+#
+#   Configures spinkle to use capistrano for delivery of commands to the remote machines (via
+#   the named 'deploy' recipe). Also configures 'source' installer defaults to put package gear
+#   in /usr/local
+
+deployment do
+
+  # mechanism for deployment
+  delivery :capistrano do
+    recipes 'deploy'
+  end
+
+  # source based package installer defaults
+  source do
+    prefix   '/usr/local'
+    archives '/usr/local/sources'
+    builds   '/usr/local/build'
+  end
+
+end
+
+# End of script, given the above information, Spinkle will apply the defined policy on all roles using the
+# deployment settings specified.

data/examples/sprinkle/sprinkle.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env sprinkle -c -s
+
+# Example of the simplest Sprinkle script to install a single gem on a remote host. This
+# particular script assumes that rubygems (and ruby, etc) are already installed on the remote
+# host. To see a larger example of installing an entire ruby, rubygems, gem stack from source,
+# please see the rails example.
+
+# Packages, only sprinkle is defined in this world
+
+package :sprinkle do
+  description 'Sprinkle Provisioning Tool'
+  gem 'crafterm-sprinkle' do
+    source 'http://gems.github.com' # use alternate gem server
+    #repository '/opt/local/gems'   # specify an alternate local gem repository
+  end
+end
+
+
+# Policies, sprinkle policy requires only the sprinkle gem
+
+policy :sprinkle, :roles => :app do
+  requires :sprinkle
+end
+
+
+# Deployment settings
+
+deployment do
+
+  # use vlad for deployment
+  delivery :vlad do
+    role :app, 'yourhost.com'
+  end
+
+end
+
+# End of script, given the above information, Spinkle will apply the defined policy on all roles using the
+# deployment settings specified.

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/actors/vlad.rb

@@ -0,0 +1,30 @@
+module Sprinkle
+  module Actors
+    class Vlad
+      require 'vlad'
+      attr_accessor :loaded_recipes
+
+      def initialize(&block)
+        self.instance_eval &block if block
+      end
+
+      def script(name)
+        @loaded_recipes ||= []
+        self.load name
+        @loaded_recipes << script
+      end
+
+      def process(name, commands, roles)
+        commands = commands.join ' && ' if commands.is_a? Array
+        t = remote_task(task_sym(name), :roles => roles) { run commands }
+        t.invoke
+      end
+
+      private
+
+        def task_sym(name)
+          "install_#{name.to_task_name}".to_sym
+        end
+    end
+  end
+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_commands
+          "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,33 @@
+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_commands
+          cmd = "gem install #{gem}"
+          cmd << " --version '#{version}'" if version
+          cmd << " --source #{source}" if source
+          cmd << " --install-dir #{repository}" if repository
+          cmd
+        end
+
+    end
+  end
+end

data/lib/sprinkle/installers/installer.rb

@@ -0,0 +1,85 @@
+module Sprinkle
+  module Installers
+    class Installer
+      attr_accessor :delivery, :package, :options, :pre, :post
+
+      def initialize(package, options = {}, &block)
+        @package = package
+        @options = options
+        @pre = {}; @post = {}
+        self.instance_eval(&block) if block
+      end
+
+      def pre(stage, *commands)
+        @pre[stage] ||= []
+        @pre[stage] += commands
+      end
+
+      def post(stage, *commands)
+        @post[stage] ||= []
+        @post[stage] += commands
+      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
+
+        # Installation is separated into two styles that concrete derivative installer classes
+        # can implement.
+        #
+        # Simple installers that issue a single or set of commands can overwride
+        # install_commands (eg. apt, gem, rpm). Pre/post install commands are included in this
+        # style for free.
+        #
+        # More complicated installers that have different stages, and require pre/post commands
+        # within stages can override install_sequence and take complete control of the install
+        # command sequence construction (eg. source based installer).
+
+        def install_sequence
+          commands = pre_commands(:install) + [ install_commands ] + post_commands(:install)
+          commands.flatten
+        end
+
+        def install_commands
+          raise 'Concrete installers implement this to specify commands to run to install their respective packages'
+        end
+
+        def pre_commands(stage)
+          dress @pre[stage] || [], :pre
+        end
+
+        def post_commands(stage)
+          dress @post[stage] || [], :post
+        end
+
+        def dress(commands, stage); commands; end
+
+    end
+  end
+end

data/lib/sprinkle/installers/rake.rb

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

data/lib/sprinkle/installers/rpm.rb

@@ -0,0 +1,20 @@
+module Sprinkle
+  module Installers
+    class Rpm < 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_commands
+          "rpm -Uvh #{@packages.join(' ')}"
+        end
+
+    end
+  end
+end

data/lib/sprinkle/installers/source.rb

@@ -0,0 +1,120 @@
+module Sprinkle
+  module Installers
+    class Source < Installer
+      attr_accessor :source
+
+      def initialize(parent, source, options = {}, &block)
+        @source = source
+        super parent, options, &block
+      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 --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
+
+      protected
+
+        def dress(commands, stage)
+          commands.collect { |command| "bash -c 'cd #{build_dir} && #{command} >> #{@package.name}-#{stage}.log 2>&1'" }
+        end
+
+      private
+
+        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