baptize 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZGRmM2Y4ZGE4YWM1NTNjNWFjYWY1Y2Q3YjBiZGQ5ZDczOTIxMGZlOA==
+  data.tar.gz: !binary |-
+    NWZhZGI1NDQ1YjdmZjg5NDY3N2M4OGE5ODY0M2NmYmRjYmY5M2EzNg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MzRhMTc5NzI1ODA5MWJkOGFmZmE4YjJhZTQzMWUzODM1OTdiYmE3OTk1ZTFh
+    MTRmYjE0OTRmOTY2Mjc2YjBjZDhkMmYyODcxNzMzYjE5ZTdjZGM1MzdkZmQ0
+    NWIwNzViNGIwM2E3MTZhOGEyMDBlN2I5Yjc2NWE3OGEzYTQ5ZmM=
+  data.tar.gz: !binary |-
+    MDU4NTc0ZmE3NDhjODY4YTk0ODU1MGZkYzIwZTQ4Yjc5OTM2Y2U4ZWE2ZWZh
+    MTNmODVjYjNiMzA1ZDIxNWM5YWE2ZWRlZDI1NDdjZTg3YzZiYzVlZTQ5ZWJl
+    NTQ4MTFhYzE1YTU1MzNmOWE4YzFiOTExNjNlYmM0Y2E1YmU3MWY=

data/README.markdown

@@ -0,0 +1,26 @@
+Baptize
+---
+
+Entirely undocumented for the time being.
+
+To install, run:
+
+    rake install
+
+A sample `Capfile` to get you started:
+
+    require 'bundler'
+    require 'capistrano'
+    require 'baptize'
+    set :capistrano_path, "#{root_path}/capistrano"
+    set :assets_path, "#{capistrano_path}/assets"
+    load_configuration :roles
+
+    Dir.glob("#{capistrano_path}/packages/**/*.rb").each do |package|
+      load(package)
+    end
+
+    Dir.glob("#{capistrano_path}/recipes/**/*.rb").each do |recipe|
+      load(recipe)
+    end
+

data/lib/baptize/dsl.rb

@@ -0,0 +1,189 @@
+module Capistrano
+  module Baptize
+
+    # Raised by verifiers, if conditions aren't met
+    class VerificationFailure < RuntimeError
+    end
+
+    class PolicyDefinition
+      attr_reader :role, :dependencies
+
+      def initialize(role, parent)
+        @role = role
+        @dependencies = []
+        @parent = parent
+      end
+
+      def respond_to?(sym, include_priv = false)
+        super || @parent.respond_to?(sym, include_priv)
+      end
+
+      def method_missing(sym, *args, &block)
+        if @parent.respond_to?(sym)
+          @parent.send(sym, *args, &block)
+        else
+          super
+        end
+      end
+
+      def full_name
+        "baptize:policies:#{role}"
+      end
+
+      def requires(*tasks)
+        Array(tasks).flatten.each do |name|
+          @dependencies << (name.kind_of?(Symbol) ? "baptize:packages:#{name}" : name.to_s)
+        end
+      end
+    end
+
+    class PackageDefinition
+      attr_reader :name, :description, :dependencies, :install_block, :verify_block, :before_block, :after_block
+
+      def initialize(name, parent)
+        @name = name
+        @parent = parent
+        @dependencies = []
+        @install_block = nil
+        @verify_block = nil
+        @before_block = nil
+        @after_block = nil
+      end
+
+      def respond_to?(sym, include_priv = false)
+        super || @parent.respond_to?(sym, include_priv)
+      end
+
+      def method_missing(sym, *args, &block)
+        if @parent.respond_to?(sym)
+          @parent.send(sym, *args, &block)
+        else
+          super
+        end
+      end
+
+      def full_name
+        "baptize:packages:#{name}"
+      end
+
+      def description(desc = nil)
+        @description = desc unless desc.nil?
+        @description
+      end
+      alias_method :desc, :description
+
+      def requires(*tasks)
+        Array(tasks).flatten.each do |name|
+          @dependencies << "baptize:packages:#{name}"
+        end
+      end
+
+      def before(&block)
+        @before_block = block
+      end
+
+      def after(&block)
+        @after_block = block
+      end
+
+      def install(&block)
+        @install_block = block
+      end
+
+      def verify(&block)
+        @verify_block = block
+      end
+    end
+
+    module DSL
+
+      def self.packages_installed
+        @packages_installed ||= []
+      end
+
+      def self.packages_installed=(value)
+        @packages_installed = value
+      end
+
+      def self.policies
+        @policies ||= {}
+      end
+
+      def policy(role_names, &block)
+        Array(role_names).flatten.each do |role_name|
+          if Capistrano::Baptize::DSL.policies[role_name]
+            policy = Capistrano::Baptize::DSL.policies[role_name]
+            policy.instance_eval &block
+          else
+            Capistrano::Baptize::DSL.policies[role_name] = PolicyDefinition.new(role_name, self)
+            policy = Capistrano::Baptize::DSL.policies[role_name]
+            policy.instance_eval &block
+            namespace :baptize do
+              namespace :policies do
+                task policy.role do
+                  logger.info "Applying policy #{policy.role}"
+                  old_env_roles = ENV['ROLES']
+                  # TODO: This is maybe not ideal, as multiple roles would be applied in sequence, not parallel.
+                  # Also, I'm not sure if they would be skipped for later roles, if already run for an earlier one
+                  Capistrano::Baptize::DSL.packages_installed = []
+                  ENV['ROLES'] = policy.role.to_s
+                  policy.dependencies.each do |task_name|
+                    find_and_execute_task(task_name)
+                  end
+                  ENV['ROLES'] = old_env_roles
+                end
+              end
+            end
+            after "baptize:install", policy.full_name
+          end
+        end
+      end
+
+      def package(package_name, &block)
+        package = PackageDefinition.new(package_name, self)
+        package.instance_eval &block
+        namespace :baptize do
+          namespace :packages do
+            desc "[package] #{package.description}" if package.description
+            task package.name do
+              # Cap doesn't track if a task has already been applied - we need to do this
+              unless Capistrano::Baptize::DSL.packages_installed.include? package.name
+                Capistrano::Baptize::DSL.packages_installed << package.name
+                instance_eval(&package.before_block) if package.before_block
+                if package.verify_block
+                  logger.debug "Verifying package #{package.name}"
+                  already_installed = begin
+                                        instance_eval(&package.verify_block)
+                                        true
+                                      rescue VerificationFailure => err
+                                        false
+                                      end
+                  if already_installed
+                    logger.info "Skipping previously installed package #{package.name}"
+                  else
+                    logger.info "Installing package #{package.name}"
+                    instance_eval(&package.install_block)
+                    instance_eval(&package.verify_block)
+                  end
+                elsif package.install_block
+                  # logger.important "WARNING: `verify` block not implemented for package #{package.name}."
+                  logger.info "Installing package #{package.name}"
+                  instance_eval(&package.install_block)
+                else
+                  # logger.important "WARNING: `install` block not implemented for package #{package.name}."
+                  logger.info "Nothing to do for package #{package.name}"
+                end
+                instance_eval(&package.after_block) if package.after_block
+              end
+            end
+          end
+        end
+        package.dependencies.each do |task_name|
+          before package.full_name, task_name
+        end
+      end
+    end
+
+  end
+end
+

data/lib/baptize/helpers.rb

@@ -0,0 +1,78 @@
+module Capistrano
+  module Baptize
+
+    module Helpers
+      def asset_path(asset)
+        File.join(fetch(:assets_path), asset)
+      end
+
+      def remote_assert(command)
+        results = []
+        pipeline = Array(command).flatten.map {|c| "#{c} > /dev/null 2> /dev/null ; if [ $? -eq 0 ] ; then echo -n 'true' ; else echo -n 'false' ; fi" }.join(" ; ")
+        invoke_command(pipeline) do |ch, stream, out|
+          results << (out == 'true')
+        end
+        results.all?
+      end
+
+      # logs the command then executes it locally.
+      # returns the command output as a string
+      def run_locally(cmd)
+        if dry_run
+          return logger.debug "executing locally: #{cmd.inspect}"
+        end
+        logger.trace "executing locally: #{cmd.inspect}" if logger
+        output_on_stdout = nil
+        elapsed = Benchmark.realtime do
+          output_on_stdout = `#{cmd}`
+        end
+        if $?.to_i > 0 # $? is command exit code (posix style)
+          raise Capistrano::LocalArgumentError, "Command #{cmd} returned status code #{$?}"
+        end
+        logger.trace "command finished in #{(elapsed * 1000).round}ms" if logger
+        output_on_stdout
+      end
+
+      def current_role
+        ENV['ROLES'].to_sym
+      end
+
+      def load_configuration(environment)
+        top.instance_eval do
+          if environment == :all
+            Dir.glob("#{capistrano_path}/config/**/*.rb").each do |conf|
+              load(conf)
+            end
+          else
+            Dir.glob("#{capistrano_path}/config/#{environment}.rb").each do |conf|
+              load(conf)
+            end
+            Dir.glob("#{capistrano_path}/config/#{environment}/**/*.rb").each do |conf|
+              load(conf)
+            end
+          end
+        end
+      end
+
+      def md5_of_file(path, md5)
+        remote_assert "test $(md5sum #{path.shellescape} | cut -f1 -d' ') = #{md5.shellescape}"
+      end
+
+      def escape_sed_arg(s)
+        s.gsub("'", "'\\\\''").gsub("\n", '\n').gsub("/", "\\\\/").gsub('&', '\\\&')
+      end
+
+      def replace_text(pattern, replacement, path)
+        run "sed -i 's/#{escape_sed_arg(pattern)}/#{escape_sed_arg(replacement)}/g' #{path.shellescape}"
+      end
+
+      def render(path, locals = {})
+        require 'erb'
+        require 'ostruct'
+        ERB.new(File.read(path)).result(OpenStruct.new(locals).instance_eval { binding })
+      end
+
+    end
+
+  end
+end

data/lib/baptize/install.rb

@@ -0,0 +1,61 @@
+module Capistrano
+  module Baptize
+
+    # Defines all baptize top-level tasks
+    def self.install(scope)
+      scope.instance_eval do
+        set :root_path, File.expand_path(Dir.pwd)
+        set :capistrano_path, "#{root_path}/capistrano"
+        # Can't run this here, since Capfile might want to redefine
+        # load_configuration :roles
+
+        namespace :baptize do
+
+          desc "Loads baptize configuration files"
+          task :load_configuration do
+            top.instance_eval do
+              top.load_configuration :baptize
+              default_run_options[:shell] = 'sudo bash' if fetch(:use_sudo, true)
+            end
+          end
+
+          task :default do
+            load_configuration
+            install
+          end
+
+          desc "Configures all available roles"
+          task :install do ; end
+
+          desc "List configured roles"
+          task :roles do
+            load_configuration
+            result = []
+            logger.info "Configured roles:"
+            top.roles.each do |name,r|
+              logger.info "#{name} [" + r.servers.join(", ") + "]"
+            end
+          end
+
+          namespace :policies do
+            desc "List configured policies"
+            task :default do
+              load_configuration
+              logger.info "Configured policies:"
+              tasks.flatten.each do |x|
+                if x.kind_of?(Capistrano::TaskDefinition) && x.fully_qualified_name != "baptize:policies"
+                  name = x.fully_qualified_name.gsub(/^baptize:policies:/, "")
+                  policy = Capistrano::Baptize::DSL.policies[name.to_sym]
+                  logger.info "#{name} [" + policy.dependencies.join(", ") + "]"
+                end
+              end
+              # logger.info "Policies have been defined for roles: " + policies.join(", ")
+            end
+          end
+
+        end
+      end
+    end
+
+  end
+end

data/lib/baptize/plugins/apt.rb

@@ -0,0 +1,22 @@
+module Capistrano
+  module Baptize
+    module Plugins
+      module Apt
+
+        def apt(packages, options = {})
+          command = options[:dependencies_only] ? 'build-dep' : 'install'
+          noninteractive = "env DEBCONF_TERSE='yes' DEBIAN_PRIORITY='critical' DEBIAN_FRONTEND=noninteractive"
+          packages = Array(packages).flatten.map{|p| p.to_s.shellescape }.join(" ")
+          invoke_command "#{noninteractive} apt-get --assume-yes --force-yes --show-upgraded --quiet #{command} #{packages}"
+        end
+
+        def has_apt(packages)
+          Array(packages).flatten.each do |p|
+            raise VerificationFailure, "apt package #{p} not installed" unless remote_assert("dpkg --status #{p.to_s.shellescape} | grep 'ok installed'")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/baptize/plugins/base.rb

@@ -0,0 +1,43 @@
+module Capistrano
+  module Baptize
+    module Plugins
+      module Base
+
+        def has_file(path)
+          raise VerificationFailure, "Remote file #{path} does not exist" unless remote_assert("test -e #{path.shellescape}")
+        end
+
+        def has_directory(path)
+          raise VerificationFailure, "Remote directory #{path} does not exist" unless remote_assert("test -d #{path.shellescape}")
+        end
+
+        def matches_local(local_path, remote_path)
+          raise VerificationFailure, "Couldn't find local file #{local_path}" unless ::File.exists?(local_path)
+          require 'digest/md5'
+          local_md5 = Digest::MD5.hexdigest(::File.read(local_path))
+          raise VerificationFailure, "Remote file #{remote_path} doesn't match local file #{local_path}" unless md5_of_file(remote_path, local_md5)
+        end
+
+        def file_contains(path, text, options = {})
+          options = {:mode => :text}.merge(options)
+          if options[:mode] == :text
+            command = Array(text.strip.split("\n")).flatten.map {|line| "grep --fixed-strings #{line.shellescape} #{path.shellescape}" }.join(" && ")
+          elsif options[:mode] == :perl
+            command = "grep --perl-regexp #{text.shellescape} #{path.shellescape}"
+          else
+            command = "grep --basic-regexp #{text.shellescape} #{path.shellescape}"
+          end
+          remote_assert command
+        end
+
+        def has_executable(path)
+          raise VerificationFailure, "No executable #{path} found" unless remote_assert "which #{path.shellescape}"
+        end
+
+        def has_user(name)
+          raise VerificationFailure, "No user #{name}" unless remote_assert "id -u #{name.to_s.shellescape}"
+        end
+      end
+    end
+  end
+end

data/lib/baptize/plugins/pecl.rb

@@ -0,0 +1,43 @@
+module Capistrano
+  module Baptize
+    module Plugins
+      module Pecl
+
+        def pecl(package_name, options = {})
+          package_version = options[:version]
+          if package_version
+            run "TERM= pecl install --alldeps #{package_name.shellescape}-#{package_version.shellescape}"
+          else
+            run "TERM= pecl install --alldeps #{package_name.shellescape}"
+          end
+          ini_file = ! options[:ini_file].nil?
+          if ini_file
+            if ini_file.is_a?(String)
+              text = ini_file
+            elsif ini_file.is_a?(Hash) && ini_file[:content]
+              text = ini_file[:content]
+            else
+              text = "extension=#{package_name}.so"
+            end
+            if ini_file.is_a?(Hash) && ini_file[:path]
+              path = ini_file[:path]
+            else
+              path = "/etc/php5/conf.d/#{package_name}.ini"
+            end
+            put(text, path)
+          end
+        end
+
+        def has_pecl(package_name, options = {})
+          package_version = options[:version]
+          if package_version
+            raise VerificationFailure, "PECL package #{package_name}-#{package_version} not installed" unless remote_assert "TERM= pecl list | grep \"^#{package_name.shellescape}\\\\s*#{package_version.shellescape}\""
+          else
+            raise VerificationFailure, "PECL package #{package_name} not installed" unless remote_assert "TERM= pecl list | grep \"^#{package_name.shellescape}\\\\s\""
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/baptize/plugins/transfer.rb

@@ -0,0 +1,52 @@
+require 'tempfile'
+
+module Capistrano
+  module Baptize
+    module Plugins
+      module Transfer
+        def self.included(base)
+          base.send :alias_method, :original_upload, :upload
+          base.send :alias_method, :upload, :patched_upload
+        end
+
+        # Performs a two-step upload
+        # File is first uploaded to /tmp/, then moved into place
+        # Can optionally roll everything into a tarball
+        # and may chmod the destination afterwards
+        def patched_upload(from, to, options={}, &block)
+          use_tarball = options.delete :tarball
+          set_owner = options.delete :owner
+          if use_tarball
+            raise "Can't tarball streaming upload" if from.kind_of?(IO)
+            exclude = use_tarball[:exclude] if (use_tarball.kind_of?(Hash) && use_tarball[:exclude])
+            tar_options = exclude.map {|glob| "--exclude \"#{glob}\" " }.join('')
+            tempfile = Dir::Tmpname.make_tmpname(['/tmp/baptize-', '.tar.gz'], nil)
+            local_command = "cd #{from.shellescape} ; #{local_tar_bin} -zcf #{tempfile.shellescape} #{tar_options}."
+            raise "Unable to tar #{from}" unless run_locally(local_command)
+            destination = "/tmp/#{File.basename(tempfile)}"
+          else
+            destination = "/tmp/#{File.basename(Dir::Tmpname.make_tmpname('/tmp/baptize-', nil))}"
+          end
+          original_upload(tempfile || from, destination, options, &block)
+          if use_tarball
+            run "tar -zxf #{destination.shellescape} -C #{to.shellescape}"
+            run "rm #{destination.shellescape}"
+          else
+            run "mv #{destination.shellescape} #{to.shellescape}"
+          end
+          if set_owner
+            run "chown -R #{set_owner}:#{set_owner} #{to.shellescape}"
+          end
+          if tempfile
+            File.delete tempfile
+          end
+        end
+
+        protected
+        def local_tar_bin
+          (`uname` =~ /Darwin/ ? "COPYFILE_DISABLE=true /usr/bin/gnutar" : "tar")
+        end
+      end
+    end
+  end
+end

data/lib/baptize.rb

@@ -0,0 +1,21 @@
+require 'baptize/dsl'
+require 'baptize/install'
+require 'baptize/helpers'
+Dir.glob(File.join(File.dirname(__FILE__), "baptize/plugins/**/*.rb")).each do |f|
+  require f
+end
+
+Capistrano::Configuration.instance(:must_exist).load do
+  class << self
+    include Capistrano::Baptize::DSL
+    include Capistrano::Baptize::Helpers
+    Capistrano::Baptize::Plugins.constants.collect do |const_name|
+      Capistrano::Baptize::Plugins.const_get(const_name)
+    end.select do |const|
+      const.class == Module
+    end.each do |m|
+      include m
+    end
+  end
+  Capistrano::Baptize.install(self)
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: baptize
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Troels Knak-Nielsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Baptize is an extension for Capistrano, that allows for server provisioning
+email:
+- troels@knak-nielsen.dk
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.markdown
+files:
+- lib/baptize.rb
+- lib/baptize/dsl.rb
+- lib/baptize/helpers.rb
+- lib/baptize/install.rb
+- lib/baptize/plugins/apt.rb
+- lib/baptize/plugins/base.rb
+- lib/baptize/plugins/pecl.rb
+- lib/baptize/plugins/transfer.rb
+- README.markdown
+homepage: http://github.com/troelskn/baptize
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Baptize is an extension for Capistrano, that allows for server provisioning
+test_files: []