baptize 0.0.8 → 0.1.1

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZDA4YWUxNDAwNTlmOTQ3MTRkMzllOGVmYjZmMTIyMjIyYjlhZTQzMg==
-  data.tar.gz: !binary |-
-    OTNjN2Q2OTA2MWUwYTg3NGUzZWI3NDM2NDM2MWUwMzBiNTU2MTEzYw==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    Y2MzN2JhNzQwN2RlMjI4YjNmYTVlOWYyZmYwM2ZjYjc4Y2RiNWYxNGRmOWIy
-    ZWUxZmM3Mzc2MzJhMDZjZWYwOTNiYzcxOTc5OWI4NTQ0ZDQ0MjA3ZDE5OGUx
-    ODJjZTgyNzcwNWIyOWJlNTFjOGI5NzNkMjE4Y2Q5MDM0MTk1ZWQ=
-  data.tar.gz: !binary |-
-    ZmMwZWE5OTQ2ZjVjNTliNTFjMjBmYjIxMTA0MmVhNzRlOTA0YzkxNzQ0MDZk
-    ZDIyNzZjNDdiNGZlOGZiMzY2YTQ1YWM4YTFjOTBhNGE0NmI3MzdmNzA5MTQ2
-    NDE5N2FhMmYwM2U4YmVkOGZiOTNjYzY4MmE0YTUzZTIwYTkwNzc=
+SHA1:
+  metadata.gz: 6a940dc1a55b7aa62c6b41fe6134e36024d4e713
+  data.tar.gz: 2ef97b29ab2151e6d59b7a31ed2c2648189a594d
+SHA512:
+  metadata.gz: 4ffae4ac6b4ccd2101d465e0aef62134768a05c3ce1e64227871d636ac53c471154d2f374c254f7d50c75acc5e4d3e18302109149e341166fa3fc3af5187c33d
+  data.tar.gz: 28b85c6a1f3a1038d0b462084544d7a564be7b99f968ebbb853dea98a361cdb0264a4bf0f4f2fa792914974113a98b306b40099ddbb239185dc211f497761c12

data/bin/baptize

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib")
+require 'baptize'
+Baptize::Application.new.run

data/lib/baptize.rb

@@ -1,21 +1,28 @@
+require 'rake'
+require 'sshkit'
+require 'capistrano/application'
+require 'capistrano/dsl'
+require 'capistrano/dsl/env'
+require 'baptize/version'
+require 'baptize/registry'
+require 'baptize/package_definition'
+require 'baptize/execution_scope'
+require 'baptize/verification_failure'
+require 'baptize/plugins/verifications'
+require 'baptize/plugins/execution'
+require 'baptize/plugins/apt'
 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
+require 'baptize/application'
 
-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
+Baptize::Registry.plugins << Capistrano::DSL::Env
+Baptize::Registry.plugins << Baptize::Plugins::Verifications
+Baptize::Registry.plugins << Baptize::Plugins::Execution
+Baptize::Registry.plugins << Baptize::Plugins::Apt
+
+extend Capistrano::DSL
+extend Baptize::DSL
+
+set_if_empty :logger, Proc.new { Baptize::Registry.logger }
+set_if_empty :dry_run, true
+set_if_empty :use_sudo, true
+set_if_empty :ssh_verbose, !!ENV['VERBOSE']

data/lib/baptize/application.rb

@@ -0,0 +1,101 @@
+module Baptize
+  class Application < Rake::Application
+
+    def initialize
+      super
+      @rakefiles = %w(bapfile Bapfile bapfile.rb Bapfile.rb)
+      Rake.application = self
+      require 'baptize/rake'
+    end
+
+    def name
+      "baptize"
+    end
+
+    def sort_options(options)
+      super.push(version, dry_run, roles, hostfilter)
+    end
+
+    def handle_options
+      options.rakelib = ['rakelib']
+      options.trace_output = $stderr
+
+      OptionParser.new do |opts|
+        opts.banner = "Baptize prepares your servers"
+        opts.separator ""
+        opts.separator "Show available tasks:"
+        opts.separator "    bundle exec baptize -T"
+        opts.separator ""
+        opts.separator "Invoke (or simulate invoking) a task:"
+        opts.separator "    bundle exec baptize [--dry-run] TASK"
+        opts.separator ""
+        opts.separator "Advanced options:"
+
+        opts.on_tail("-h", "--help", "-H", "Display this help message.") do
+          puts opts
+          exit
+        end
+
+        standard_rake_options.each { |args| opts.on(*args) }
+        opts.environment('RAKEOPT')
+      end.parse!
+    end
+
+
+    def display_error_message(ex)
+      unless options.backtrace
+        if (loc = Rake.application.find_rakefile_location)
+          whitelist = (@imported.dup << loc[0]).map{|f| File.absolute_path(f, loc[1])}
+          pattern = %r@^(?!#{whitelist.map{|p| Regexp.quote(p)}.join('|')})@
+          Rake.application.options.suppress_backtrace_pattern = pattern
+        end
+        trace "(Backtrace restricted to imported tasks)"
+      end
+      super
+    end
+
+    private
+
+    def version
+      ['--version', '-V',
+       "Display the program version.",
+       lambda { |_value|
+         require 'capistrano/version'
+         puts "Baptize Version: #{Baptize::VERSION} (Capistrano Version: #{Capistrano::VERSION}, Rake Version: #{RAKEVERSION})"
+         exit
+       }
+      ]
+    end
+
+    def dry_run
+      ['--dry-run', '-n',
+       "Do a dry run without executing actions",
+       lambda { |_value|
+         raise "TODO: Port this"
+         Configuration.env.set(:sshkit_backend, SSHKit::Backend::Printer)
+       }
+      ]
+    end
+
+    def roles
+      ['--roles ROLES', '-r',
+       "Run SSH commands only on hosts matching these roles",
+       lambda { |value|
+         raise "TODO: Port this"
+         Configuration.env.add_cmdline_filter(:role, value)
+       }
+      ]
+    end
+
+    def hostfilter
+      ['--hosts HOSTS', '-z',
+       "Run SSH commands only on matching hosts",
+       lambda { |value|
+         raise "TODO: Port this"
+         Configuration.env.add_cmdline_filter(:host, value)
+       }
+      ]
+    end
+
+  end
+end

data/lib/baptize/dsl.rb

@@ -1,198 +1,13 @@
-module Capistrano
-  module Baptize
+module Baptize
 
-    # Raised by verifiers, if conditions aren't met
-    class VerificationFailure < RuntimeError
+  module DSL
+    def package(package_name, &config_block)
+      Registry.define_package(package_name, &config_block)
     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
-                desc "Configures #{policy.role}"
-                task policy.role do
-                  logger.info "Applying policy #{policy.role}"
-                  # 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 = []
-                  for_roles policy.role do
-                    policy.dependencies.each do |task_name|
-                      find_and_execute_task(task_name)
-                    end
-                  end
-                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 && !ENV['FORCE_INSTALL']
-                    logger.info "Skipping previously installed package #{package.name}"
-                  else
-                    if already_installed && ENV['FORCE_INSTALL']
-                      logger.important "Force installing previously installed package #{package.name}"
-                    else
-                      logger.info "Installing package #{package.name}"
-                    end
-                    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
-        if ENV['SKIP_DEPENDENCIES']
-          before package.full_name do
-            logger.important "Skipping dependencies for package #{package.name}"
-          end
-        else
-          package.dependencies.each do |task_name|
-            before package.full_name, task_name
-          end
-        end
-      end
+    def policy(role, *packages)
+      Registry.define_policy role, [packages].flatten
     end
+  end # module DSL
 
-  end
-end
+end # module Baptize

data/lib/baptize/execution_scope.rb

@@ -0,0 +1,7 @@
+module Baptize
+
+  class ExecutionScope
+    # This is emoty .. find all the meat in plugins/
+  end
+
+end # module Baptize

data/lib/baptize/package_definition.rb

@@ -0,0 +1,105 @@
+module Baptize
+
+  class PackageDefinition
+    attr_reader :name, :description, :dependencies, :install_block, :verify_block, :before_block, :after_block
+
+    def initialize(name, execution_scope, registry)
+      @name = name
+      @execution_scope = execution_scope
+      @registry = registry
+      @dependencies = []
+      @install_block = nil
+      @verify_block = nil
+      @before_block = nil
+      @after_block = nil
+    end
+
+    def execute
+      unless @registry.packages_executed.include? full_name
+        @registry.packages_executed << full_name
+        @registry.before(self).each do |task|
+          task.call
+        end
+        instance_eval(&before_block) if self.before_block
+        if verify_block
+          logger.debug "Verifying package #{name}"
+          already_installed = begin
+                                instance_eval(&verify_block)
+                                true
+                              rescue VerificationFailure
+                                false
+                              end
+          if already_installed && !ENV['FORCE_INSTALL']
+            logger.info "Skipping previously installed package #{name}"
+          else
+            if already_installed && ENV['FORCE_INSTALL']
+              logger.important "Force installing previously installed package #{name}"
+            else
+              logger.info "Installing package #{name}"
+            end
+            instance_eval(&install_block)
+            instance_eval(&verify_block)
+          end
+        elsif install_block
+          # logger.important "WARNING: `verify` block not implemented for package #{name}."
+          logger.info "Installing package #{name}"
+          instance_eval(&install_block)
+        else
+          # logger.important "WARNING: `install` block not implemented for package #{name}."
+          logger.info "Nothing to do for package #{name}"
+        end
+        instance_eval(&after_block) if after_block
+        @registry.after(self).each do |task|
+          task.call
+        end
+      end
+    end
+
+    def respond_to?(sym, include_priv = false)
+      super || @execution_scope.any?(sym) || @execution_scope.respond_to?(sym)
+    end
+
+    def method_missing(sym, *args, &block)
+      if @execution_scope.any?(sym)
+        @execution_scope.fetch(sym)
+      elsif @execution_scope.respond_to?(sym)
+        @execution_scope.send(sym, *args, &block)
+      else
+        super
+      end
+    end
+
+    def full_name
+      name.to_s
+    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 << 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
+
+end # module Baptize

data/lib/baptize/plugins/apt.rb

@@ -1,22 +1,23 @@
-module Capistrano
-  module Baptize
-    module Plugins
-      module Apt
+module Baptize
 
-        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
+  module Plugins
 
-        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
+    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(" ")
+        remote_execute "#{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 # module Plugins
+end # module Baptize

data/lib/baptize/plugins/env.rb

@@ -0,0 +1,24 @@
+require 'capistrano/dsl/env'
+
+module Baptize
+  module Plugins
+    module Env
+
+      include Capistrano::DSL::Env
+
+      def respond_to?(sym, include_priv = false)
+        super || any?(sym)
+      end
+
+      def method_missing(sym, *args, &block)
+        if any?(sym)
+          fetch(sym)
+        else
+          super
+        end
+      end
+
+    end
+
+  end # module Plugins
+end # module Baptize

data/lib/baptize/plugins/execution.rb

@@ -0,0 +1,60 @@
+module Baptize
+
+  module Plugins
+
+    module Execution
+
+      # logs the command then executes it locally.
+      # returns the command output as a string
+      def run_locally(cmd)
+        if fetch(: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 ArgumentError, "Command #{cmd} returned status code #{$?}"
+        end
+        logger.trace "command finished in #{(elapsed * 1000).round}ms" if logger
+        output_on_stdout
+      end
+
+      def remote_execute(*args)
+        call_current_ssh_connection :execute, *args
+      end
+
+      def remote_capture(*args)
+        call_current_ssh_connection :capture, *args
+      end
+
+      def remote_assert(command)
+        command = Array(command).flatten.map {|c| "#{c} > /dev/null 2> /dev/null" }.join(" && ")
+        call_current_ssh_connection :test, command
+      end
+
+      private
+      def call_current_ssh_connection(action, *args)
+        ssh = fetch(:current_ssh_connection)
+        old_verbosity = nil
+        if fetch(:ssh_verbose)
+          old_verbosity = SSHKit.config.output_verbosity
+          SSHKit.config.output_verbosity = Logger::DEBUG
+        end
+        begin
+          if fetch(:use_sudo)
+            ssh.send(action, :sudo, *args)
+          else
+            ssh.send(action, *args)
+          end
+        ensure
+          SSHKit.config.output_verbosity = old_verbosity if old_verbosity
+        end
+      end
+
+    end
+
+  end # module Plugins
+end # module Baptize

data/lib/baptize/plugins/variables.rb

@@ -0,0 +1,38 @@
+module Baptize
+
+  module Plugins
+
+    module Variables
+
+      def set(name, value)
+        @variables ||= {}
+        @variables[name.to_sym] = value
+      end
+
+      def fetch(name)
+        if @variables
+          value = @variables[name.to_sym]
+          if value.kind_of?(Proc)
+            value.call
+          else
+            value
+          end
+        end
+      end
+
+      def respond_to?(sym, include_priv = false)
+        super || (@variables && @variables[sym])
+      end
+
+      def method_missing(sym, *args, &block)
+        if @variables && @variables[sym]
+          fetch(sym)
+        else
+          super
+        end
+      end
+
+    end
+
+  end # module Plugins
+end # module Baptize

data/lib/baptize/plugins/verifications.rb

@@ -0,0 +1,11 @@
+module Baptize
+  module Plugins
+
+    module Verifications
+      def fail_verification
+        raise VerificationFailure.new
+      end
+    end
+
+  end
+end

data/lib/baptize/rake.rb

@@ -0,0 +1,21 @@
+Rake.application.in_namespace('baptize') do
+
+  Rake::Task.define_task(:list) do
+    Baptize::Registry.packages.values.each do |package|
+      puts [package.name, "\t", package.description].join
+    end
+  end
+
+  Rake::Task.define_task(:apply) do
+    Baptize::Registry.policies.keys.each do |role|
+      on roles(role), in: :parallel do |host|
+        Baptize::Registry.apply_policy role, host, self
+      end
+    end
+  end
+
+end
+
+Rake::Task.define_task(:default) do
+  Rake::Task['baptize:list'].invoke
+end

data/lib/baptize/registry.rb

@@ -0,0 +1,91 @@
+module Baptize
+
+  module Registry
+
+    def self.plugins
+      @plugins ||= []
+    end
+
+    def self.execution_scope
+      unless @execution_scope
+        @execution_scope = ExecutionScope.new
+        plugins.each do |plugin_module|
+          (class << @execution_scope ; self ; end).send(:include, plugin_module)
+        end
+      end
+      @execution_scope
+    end
+
+    def self.logger
+      @logger ||= ::Logger.new(STDOUT)
+    end
+
+    def self.packages
+      @packages ||= {}
+    end
+
+    def self.packages_executed
+      @packages_executed ||= []
+    end
+
+    def self.before(subject_name, other_task=nil, &block)
+      @befores ||= {}
+      @befores[subject_name] ||= []
+      if other_task
+        task = packages[other_task] if other_task.kind_of?(String)
+        raise "Didn't find a package by that name" if task.nil?
+        @befores[subject_name] << task.method(:execute)
+      elsif block_given?
+        @befores[subject_name] << block
+      end
+      @befores[subject_name]
+    end
+
+    def self.after(subject_name, other_task=nil, &block)
+      @afters ||= {}
+      @afters[subject_name] ||= []
+      if other_task
+        task = packages[other_task] if other_task.kind_of?(String)
+        raise "Didn't find a package by that name" if task.nil?
+        @afters[subject_name] << task.method(:execute)
+      elsif block_given?
+        @afters[subject_name] << block
+      end
+      @afters[subject_name]
+    end
+
+    def self.define_package(package_name, &config_block)
+      package = PackageDefinition.new(package_name, self.execution_scope, self)
+      packages[package.full_name] = package
+      package.instance_eval(&config_block)
+      if ENV['SKIP_DEPENDENCIES']
+        before package.full_name do
+          logger.important "Skipping dependencies for package #{package.name}"
+        end
+      else
+        package.dependencies.each do |task_name|
+          before package.full_name, task_name
+        end
+      end
+    end
+
+    def self.policies
+      @policies ||= {}
+    end
+
+    def self.define_policy(role, package_names)
+      policies[role.to_sym] = package_names.map(&:to_s)
+    end
+
+    def self.apply_policy(role, host, ssh_connection)
+      execution_scope.set :current_host, host
+      execution_scope.set :current_ssh_connection, ssh_connection
+      policies[role.to_sym].each do |package_name|
+        raise "No package '#{package_name}'" unless packages[package_name]
+        packages[package_name].execute
+      end
+    end
+
+  end # module Registry
+
+end # module Baptize

data/lib/baptize/verification_failure.rb

@@ -0,0 +1,4 @@
+module Baptize
+  class VerificationFailure < Exception
+  end
+end

data/lib/baptize/version.rb

@@ -0,0 +1,3 @@
+module Baptize
+  VERSION = "0.1.1"
+end # module Baptize

metadata

@@ -1,47 +1,68 @@
 --- !ruby/object:Gem::Specification
 name: baptize
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.1
 platform: ruby
 authors:
 - Troels Knak-Nielsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-07 00:00:00.000000000 Z
+date: 2016-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.15.5
+        version: '3.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.15.5
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: Baptize is an extension for Capistrano, that allows for server provisioning
 email:
 - troels@knak-nielsen.dk
-executables: []
+executables:
+- baptize
 extensions: []
 extra_rdoc_files:
 - README.markdown
 files:
+- README.markdown
+- bin/baptize
 - lib/baptize.rb
+- lib/baptize/application.rb
 - lib/baptize/dsl.rb
-- lib/baptize/helpers.rb
-- lib/baptize/install.rb
+- lib/baptize/execution_scope.rb
+- lib/baptize/package_definition.rb
 - lib/baptize/plugins/apt.rb
-- lib/baptize/plugins/base.rb
-- lib/baptize/plugins/gem.rb
-- lib/baptize/plugins/pecl.rb
-- lib/baptize/plugins/transfer.rb
-- README.markdown
+- lib/baptize/plugins/env.rb
+- lib/baptize/plugins/execution.rb
+- lib/baptize/plugins/variables.rb
+- lib/baptize/plugins/verifications.rb
+- lib/baptize/rake.rb
+- lib/baptize/registry.rb
+- lib/baptize/verification_failure.rb
+- lib/baptize/version.rb
 homepage: http://github.com/troelskn/baptize
 licenses:
 - MIT
@@ -52,17 +73,17 @@ 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.7
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Baptize is an extension for Capistrano, that allows for server provisioning

data/lib/baptize/helpers.rb

@@ -1,110 +0,0 @@
-module Capistrano
-  module Baptize
-
-    module Helpers
-
-      def for_roles(*roles, &block)
-        old_env_roles = ENV['ROLES']
-        ENV['ROLES'] = Array(roles).flatten.map(&:to_s).join(",")
-        logger.info "Invoking for roles: #{ENV['ROLES']}"
-        block.call
-      ensure
-        ENV['ROLES'] = old_env_roles
-      end
-
-      def asset_path(asset)
-        File.join("#{capistrano_path}/assets", 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
-
-      # Runs a rake command remotely
-      def remote_rake(rake_command, options = {})
-        options = {:bundle_cmd => fetch(:bundle_cmd, "bundle"), :current_path => current_path, :rails_env => rails_env, :env => {}, :pty => false}.merge(options)
-        command = ""
-        command << "cd #{options[:current_path]} && " if options[:current_path]
-        command << "RAILS_ENV=#{options[:rails_env]} " if options[:rails_env]
-        options[:env].each do |k,v|
-          command << "#{k}=#{v.shellescape} "
-        end
-        if options[:bundle_cmd]
-          command << "#{options[:bundle_cmd]} exec rake #{rake_command}"
-        else
-          command << "rake #{rake_command}"
-        end
-        options[:norun] ? command : run(command, :pty => options[:pty])
-      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
-          if fetch(:use_sudo, true)
-            default_run_options[:shell] = 'sudo bash'
-          else
-            default_run_options[:shell].gsub!(/^sudo /, "")
-          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(locals.kind_of?(Binding) ? locals : OpenStruct.new(locals).instance_eval { binding })
-      end
-
-    end
-
-  end
-end

data/lib/baptize/install.rb

@@ -1,87 +0,0 @@
-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.load_configuration :baptize
-          end
-
-          task :default do
-            install
-          end
-
-          desc "Configures all available policies"
-          task :install do
-            load_configuration
-          end
-
-          namespace :policies do
-            desc "List available policies"
-            task :default do
-              load_configuration
-              logger.info "Available 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}:"
-                  logger.info "->  servers:"
-                  top.roles[name.to_sym].servers.each do |s|
-                    logger.info "->    #{s}"
-                  end
-                  logger.info "->  dependencies:"
-                  policy.dependencies.each do |d|
-                    logger.info "->    #{d}"
-                  end
-                end
-              end
-            end
-          end # end namespace policies
-        end # end namespace baptize
-
-        namespace :ssh do
-          desc "Describe available ssh connections"
-          task :default do
-            count = 1
-            roles.each do |name,servers|
-              servers.each do |host|
-                puts "cap ssh:#{count} (#{name}) #{host}"
-                count = count + 1
-              end
-            end
-          end
-
-          1.upto(10).each do |num|
-            task num.to_s.to_sym do
-              count = 1
-              roles.each do |name,servers|
-                servers.each do |host|
-                  if count == num
-                    change_dir = exists?(:deploy_to) ? ("cd " + fetch(:deploy_to) + "/current ; ") : ""
-                    command = "ssh -i #{ssh_options[:keys]} #{user}@#{host} -t '#{change_dir}sudo su'"
-                    puts command
-                    exec command
-                  end
-                  count = count + 1
-                end
-              end
-            end
-          end
-        end # end namespace ssh
-
-      end
-
-    end
-  end
-end

data/lib/baptize/plugins/base.rb

@@ -1,46 +0,0 @@
-module Capistrano
-  module Baptize
-    module Plugins
-      module Base
-        def fail_verification(message = "Assertion failed")
-          raise VerificationFailure, message
-        end
-
-        def has_file(path)
-          remote_assert("test -e #{path.shellescape}") or fail_verification("Remote file #{path} does not exist")
-        end
-
-        def has_directory(path)
-          remote_assert("test -d #{path.shellescape}") or fail_verification("Remote directory #{path} does not exist")
-        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))
-          md5_of_file(remote_path, local_md5) or fail_verification("Remote file #{remote_path} doesn't match local file #{local_path}")
-        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)
-          remote_assert("which #{path.shellescape}") or fail_verification("No executable #{path} found")
-        end
-
-        def has_user(name)
-          remote_assert("id -u #{name.to_s.shellescape}") or fail_verification("No user #{name}")
-        end
-      end
-    end
-  end
-end

data/lib/baptize/plugins/gem.rb

@@ -1,26 +0,0 @@
-module Capistrano
-  module Baptize
-    module Plugins
-      module Gem
-
-        def install_gem(package_name, options = {})
-          cmd = "gem install #{package_name}"
-          cmd << " --version '#{options[:version]}'" if options[:version]
-          cmd << " --source #{options[:source]}" if options[:source]
-          cmd << " --install-dir #{options[:repository]}" if options[:repository]
-          cmd << " --no-rdoc --no-ri" unless options[:build_docs]
-          cmd << " --http-proxy #{options[:http_proxy]}" if options[:http_proxy]
-          cmd << " -- #{options[:build_flags]}" if options[:build_flags]
-          run "TERM= #{cmd}"
-        end
-
-        def has_gem(package_name, options = {})
-          version = options[:version] ? "--version '#{options[:version]}'" : ''
-          cmd = "gem list '#{package_name}' --installed #{version} > /dev/null"
-          raise VerificationFailure, "Gem #{package_name} not installed" unless remote_assert cmd
-        end
-
-      end
-    end
-  end
-end

data/lib/baptize/plugins/pecl.rb

@@ -1,49 +0,0 @@
-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
-              folder = "/etc/php5/conf.d"
-              invoke_command("php --ini") do |ch, stream, out|
-                if /Scan for additional .ini files in: (.*)/.match(out)
-                  folder = $1
-                end
-              end
-              path = "#{folder}/#{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

@@ -1,52 +0,0 @@
-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 = Array(exclude).flatten.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