pot 0.1.0

data/lib/pot/installers/transfer.rb

@@ -0,0 +1,184 @@
+# Blatantly stole this from Chef
+class TemplateError < RuntimeError
+  attr_reader :original_exception, :context
+  SOURCE_CONTEXT_WINDOW = 2 unless defined? SOURCE_CONTEXT_WINDOW
+
+  def initialize(original_exception, template, context)
+    @original_exception, @template, @context = original_exception, template, context
+  end
+
+  def message
+    @original_exception.message
+  end
+
+  def line_number
+    @line_number ||= $1.to_i if original_exception.backtrace.find {|line| line =~ /\(erubis\):(\d+)/ }
+  end
+
+  def source_location
+    "on line ##{line_number}"
+  end
+
+  def source_listing
+    return nil if line_number.nil?
+
+    @source_listing ||= begin
+      line_index = line_number - 1
+      beginning_line = line_index <= SOURCE_CONTEXT_WINDOW ? 0 : line_index - SOURCE_CONTEXT_WINDOW
+      source_size = SOURCE_CONTEXT_WINDOW * 2 + 1
+      lines = @template.split(/\n/)
+      contextual_lines = lines[beginning_line, source_size]
+      output = []
+      contextual_lines.each_with_index do |line, index|
+        line_number = (index+beginning_line+1).to_s.rjust(3)
+        output << "#{line_number}: #{line}"
+      end
+      output.join("\n")
+    end
+  end
+
+  def to_s
+    "\n\n#{self.class} (#{message}) #{source_location}:\n\n" +
+      "#{source_listing}\n\n  #{original_exception.backtrace.join("\n  ")}\n\n"
+  end
+end
+
+module Pot
+  module Installers
+    # Beware, another strange "installer" coming your way.
+    #
+    # = File transfer installer
+    #
+    # This installer pushes files from the local disk to remote servers.
+    #
+    # == Example Usage
+    #
+    # Installing a nginx.conf onto remote servers
+    #
+    #   package :nginx_conf do
+    #     transfer 'files/nginx.conf', '/etc/nginx.conf'
+    #   end
+    #
+    # If you user has access to 'sudo' and theres a file that requires
+    # priveledges, you can pass :sudo => true
+    #
+    #   package :nginx_conf do
+    #     transfer 'files/nginx.conf', '/etc/nginx.conf', :sudo => true
+    #   end
+    #
+    # By default, transfers are recursive and you can move whole directories
+    # via this method. If you wish to disable recursive transfers, you can pass
+    # recursive => false, although it will not be obeyed when using the Vlad actor.
+    #
+    # If you pass the option :render => true, this tells transfer that the source file
+    # is an ERB template to be rendered locally before being transferred (you can declare
+    # variables in the package scope). When render is true, recursive is turned off. Note
+    # you can also explicitly pass locals in to render with the :locals option.
+    #
+    #   package :nginx_conf do
+    #     nginx_port = 8080
+    #     transfer 'files/nginx.conf', '/etc/nginx.conf', :render => true
+    #   end
+    #
+    # Finally, should you need to run commands before or after the file transfer (making
+    # directories or changing permissions), you can use the pre/post :install directives
+    # and they will be run.
+    class Transfer < Installer
+      attr_accessor :source, :destination #:nodoc:
+
+      def initialize(parent, source, destination, options={}, &block) #:nodoc:
+        super parent, options, &block
+        @source = source
+        @destination = destination
+        # perform the transfer in two steps if we're using sudo
+        if options[:sudo]
+          final = @destination
+          @destination = "/tmp/pod_#{File.basename(@destination)}"
+          post :install, "sudo mv #{@destination} #{final}"
+        end
+      end
+
+      def install_commands
+        nil
+      end
+
+      def self.render_template(template, context, prefix)
+        require 'tempfile'
+        require 'erubis'
+
+        begin
+          eruby = Erubis::Eruby.new(template)
+          output = eruby.result(context)
+        rescue Object => e
+          raise TemplateError.new(e, template, context)
+        end
+
+        final_tempfile = Tempfile.new(prefix.to_s)
+        final_tempfile.print(output)
+        final_tempfile.close
+        final_tempfile
+      end
+
+      def render_template(template, context, prefix)
+        self.class.render_template(template, context, prefix)
+      end
+
+      def render_template_file(path, context, prefix)
+        template = File.read(path)
+        tempfile = render_template(template, context, @package.name)
+        tempfile
+      end
+
+      def process(actor) #:nodoc:
+        if Pot.logger.debug?
+          Pot.logger.debug "transfer: #{@source} -> #{@destination}\n"
+        end
+
+        unless Pot.config.testing?
+          pre = pre_commands(:install)
+          unless pre.empty?
+            sequence = pre
+            sequence = sequence.join('; ') if sequence.is_a? Array
+            Pot.logger.info "#{@package.name} pre-transfer commands: #{sequence}\n"
+            actor.execute [pre].flatten
+          end
+
+          recursive = @options[:recursive]
+
+          if options[:render]
+            if options[:locals]
+              context = {}
+              options[:locals].each_pair do |k,v|
+                if v.respond_to?(:call)
+                  context[k] = v.call
+                else
+                  context[k] = v
+                end
+              end
+            else
+              context = binding()
+            end
+
+            tempfile = render_template_file(@source, context, @package.name)
+            sourcepath = tempfile.path
+            Pot.logger.info "Rendering template #{@source} to temporary file #{sourcepath}"
+            recursive = false
+          else
+            sourcepath = @source
+          end
+
+          Pot.logger.info "--> Transferring #{sourcepath} to #{@destination}"
+          actor.transfer(sourcepath, @destination, recursive)
+
+          post = post_commands(:install)
+          unless post.empty?
+            sequence = post;
+            sequence = sequence.join('; ') if sequence.is_a? Array
+            Pot.logger.info "#{@package.name} post-transfer commands: #{sequence}\n"
+            actor.execute [post].flatten
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pot/installers/user.rb

@@ -0,0 +1,15 @@
+module Pot
+  module Installers
+    class User < Installer
+      def initialize(package, username, options, &block)
+        super package, &block
+        @username = username
+        @options = options
+      end
+      protected
+      def install_commands
+        "adduser #{@options[:flags]} #{@username}"
+      end
+    end
+  end
+end

data/lib/pot/instance.rb

@@ -0,0 +1,21 @@
+module Pot
+  class Instance
+    REGISTER = {}
+
+    attr_reader :name,
+                :host,
+                :user,
+                :password,
+                :port
+
+    def initialize(name, host, options = {})
+      @name = name
+      @host = host
+      @user = options[:user]
+      @password = options[:password]
+      @port = options[:port]
+
+      REGISTER[name] = self
+    end
+  end
+end

data/lib/pot/logger.rb

@@ -0,0 +1,41 @@
+require 'logger'
+
+module Pot
+
+  def self.logger
+    @logger ||= Pot::Logger.new
+  end
+
+  class Logger < ::Logger
+
+    def initialize
+      super $stdout
+      self.formatter = proc do |severity, datetime, progname, msg|
+        "#{msg}\n"
+      end
+      # self.level = Logger::ERROR
+    end
+
+    private
+
+      def color(code, s)
+        "\033[%sm%s\033[0m"%[code,s]
+      end
+
+      def red(s)
+        color(31, s)
+      end
+
+      def yellow(s)
+        color(33, s)
+      end
+
+      def green(s)
+        color(32, s)
+      end
+
+      def blue(s)
+        color(34, s)
+      end
+  end
+end

data/lib/pot/package.rb

@@ -0,0 +1,352 @@
+module Pot
+  # = Packages
+  #
+  # A package defines one or more things to provision onto the server.
+  # There is a lot of flexibility in a way a package is defined but
+  # let me give you a basic example:
+  #
+  #   package :ruby do
+  #     description 'Ruby MRI'
+  #     version '1.8.6'
+  #     apt 'ruby'
+  #
+  #     verify { has_executable 'ruby' }
+  #   end
+  #
+  # The above would define a package named 'ruby' and give it a description
+  # and explicitly say its version. It is installed via apt and to verify
+  # the installation was successful pot will check for the executable
+  # 'ruby' being availble. Pretty simple, right?
+  #
+  # <b>Note:</b> Defining a package does not INSTALL it. To install a
+  # package, you must require it in a Pot::Policy block.
+  #
+  # == Pre-Requirements
+  #
+  # Most packages have some sort of pre-requisites in order to be installed.
+  # Pot allows you to define the requirements of the package, which
+  # will be installed before the package itself. An example below:
+  #
+  #   package :rubygems do
+  #     source 'http://rubyforge.org/rubygems.tgz'
+  #     requires :ruby
+  #   end
+  #
+  # In this case, when rubygems is being installed, Pot will first
+  # provision the server with Ruby to make sure the requirements are met.
+  # In turn, if ruby has requirements, it installs those first, and so on.
+  #
+  # == Verifications
+  #
+  # Most of the time its important to know whether the software you're
+  # attempting to install was installed successfully or not. For this,
+  # Pot provides verifications. Verifications are one or more blocks
+  # which define rules with which Pot can check if it installed
+  # the package successfully. If these verification blocks fail, then
+  # Pot will gracefully stop the entire process. An example below:
+  #
+  #   package :rubygems do
+  #     source 'http://rubyforge.org/rubygems.tgz'
+  #     requires :ruby
+  #
+  #     verify { has_executable 'gem' }
+  #   end
+  #
+  # In addition to verifying an installation was successfully, by default
+  # Pot runs these verifications <em>before</em> the installation to
+  # check if the package is already installed. If the verifications pass
+  # before installing the package, it skips the package. To override this
+  # behavior, set the -f flag on the sprinkle script or set the
+  # :force option to true in Pot.config
+  #
+  # For more information on verifications and to see all the available
+  # verifications, see Pot::Verify
+  #
+  # == Virtual Packages
+  #
+  # Sometimes, there are multiple packages available for a single task. An
+  # example is a database package. It can contain mySQL, postgres, or sqlite!
+  # This is where virtual packages come in handy. They are defined as follows:
+  #
+  #   package :sqlite3, :provides => :database do
+  #     apt 'sqlite3'
+  #   end
+  #
+  # The :provides option allows you to reference this package either by :sqlite3
+  # or by :database. But whereas the package name is unique, multiple packages may
+  # share the same provision. If this is the case, when running Pot, the
+  # script will ask you which provision you want to install. At this time, you
+  # can only install one.
+  #
+  # == Meta-Packages
+  #
+  # A package doesn't require an installer. If you want to define a package which
+  # merely encompasses other packages, that is fine too. Example:
+  #
+  #   package :meta do
+  #     requires :magic_beans
+  #     requires :magic_sauce
+  #   end
+  #
+  #--
+  # FIXME: Should probably document recommendations.
+  #++
+	class Package
+    REGISTER = {}
+
+    attr_accessor :name,
+                  :provides,
+                  :installers,
+                  :dependencies,
+                  :recommends,
+                  :verifications
+
+    def initialize(name, metadata = {}, &block)
+      raise 'No package name supplied' unless name
+
+      @name = name
+      @provides = metadata[:provides]
+      @dependencies = []
+      @recommends = []
+      @optional = []
+      @verifications = []
+      @installers = []
+
+      REGISTER[name] = self
+
+      if @provides
+        (REGISTER[@provides] ||= []) << self
+      end
+
+      self.instance_eval &block
+    end
+
+    def description(desc = nil)
+      @description = desc if desc
+      @description
+    end
+
+    def version(ver = nil)
+      @version = ver if ver
+      @version
+    end
+
+    def template(name)
+      Pot::Template.new(self, name)
+    end
+
+    def add_user(username, options={},  &block)
+      @installers << Pot::Installers::User.new(self, username, options, &block)
+    end
+
+    def add_group(group, options={},  &block)
+      @installers << Pot::Installers::Group.new(self, group, options, &block)
+    end
+
+    def freebsd_pkg(*names, &block)
+      @installers << Pot::Installers::FreebsdPkg.new(self, *names, &block)
+    end
+
+    def freebsd_portinstall(port, &block)
+      @installers << Pot::Installers::FreebsdPortinstall.new(self, port, &block)
+    end
+
+    def openbsd_pkg(*names, &block)
+      @installers << Pot::Installers::OpenbsdPkg.new(self, *names, &block)
+    end
+
+    def opensolaris_pkg(*names, &block)
+      @installers << Pot::Installers::OpensolarisPkg.new(self, *names, &block)
+    end
+
+    def bsd_port(port, &block)
+      @installers << Pot::Installers::BsdPort.new(self, port, &block)
+    end
+
+    def mac_port(port, &block)
+      @installers << Pot::Installers::MacPort.new(self, port, &block)
+    end
+
+    def apt(*names, &block)
+      @installers << Pot::Installers::Apt.new(self, *names, &block)
+    end
+
+    def deb(*names, &block)
+      @installers << Pot::Installers::Deb.new(self, *names, &block)
+    end
+
+    def rpm(*names, &block)
+      @installers << Pot::Installers::Rpm.new(self, *names, &block)
+    end
+
+    def yum(*names, &block)
+      @installers << Pot::Installers::Yum.new(self, *names, &block)
+    end
+
+    def zypper(*names, &block)
+      @installers << Pot::Installers::Zypper.new(self, *names, &block)
+    end
+
+    def brew(*names, &block)
+      @installers << Pot::Installers::Brew.new(self, *names, &block)
+    end
+
+    def gem(name, options = {}, &block)
+      @recommends << :rubygems
+      @installers << Pot::Installers::Gem.new(self, name, options, &block)
+    end
+
+    def source(source, options = {}, &block)
+      @recommends << :build_essential # Ubuntu/Debian
+      @installers << Pot::Installers::Source.new(self, source, options, &block)
+    end
+
+    def binary(source, options = {}, &block)
+      @installers << Pot::Installers::Binary.new(self, source, options, &block)
+    end
+
+    def rake(name, options = {}, &block)
+      @installers << Pot::Installers::Rake.new(self, name, options, &block)
+    end
+
+    def thor(name, options = {}, &block)
+      @installers << Pot::Installers::Thor.new(self, name, options, &block)
+    end
+
+    def noop(&block)
+      @installers << Pot::Installers::Runner.new(self, "echo noop", &block)
+    end
+
+    def push_text(text, path, options = {}, &block)
+      @installers << Pot::Installers::PushText.new(self, text, path, options, &block)
+    end
+
+    def replace_text(regex, text, path, options={}, &block)
+      @installers << Pot::Installers::ReplaceText.new(self, regex, text, path, options, &block)
+    end
+
+    def transfer(source, destination, options = {}, &block)
+      @installers << Pot::Installers::Transfer.new(self, source, destination, options, &block)
+    end
+
+		def runner(cmd, options = {}, &block)
+			@installers << Pot::Installers::Runner.new(self, cmd, options, &block)
+		end
+
+    def verify(description = '', &block)
+      @verifications << Pot::Verify.new(self, description, &block)
+    end
+
+    def pacman(*names, &block)
+      @installers << Pot::Installers::Pacman.new(self, *names, &block)
+    end
+
+    def process(actor)
+      Pot.logger.info "  * #{name}"
+      return if meta_package?
+
+      # Run a pre-test to see if the software is already installed. If so,
+      # we can skip it, unless we have the force option turned on!
+      unless @verifications.empty? || Pot.config.force
+        begin
+          process_verifications(actor, true)
+
+          Pot.logger.info "--> #{self.name} already installed"
+          return
+        rescue Pot::VerificationFailed => e
+          # Continue
+        end
+      end
+
+      @installers.each do |installer|
+        installer.process(actor)
+      end
+
+      process_verifications(actor)
+    end
+
+    def process_verifications(actor, pre = false)
+      return if @verifications.empty?
+
+      if pre
+        Pot.logger.info "--> Checking if #{self.name} is already installed"
+      else
+        Pot.logger.info "--> Verifying #{self.name} was properly installed"
+      end
+
+      @verifications.each do |v|
+        v.process(actor)
+      end
+    end
+
+    def requires(*packages)
+      @dependencies << packages
+      @dependencies.flatten!
+    end
+
+    def recommends(*packages)
+      @recommends << packages
+      @recommends.flatten!
+    end
+
+    def optional(*packages)
+      @optional << packages
+      @optional.flatten!
+    end
+
+    def tree(depth = 1, &block)
+      packages = []
+
+      @recommends.each do |dep|
+        package = REGISTER[dep]
+        next unless package # skip missing recommended packages as they're allowed to not exist
+        block.call(self, package, depth) if block
+        packages << package.tree(depth + 1, &block)
+      end
+
+      @dependencies.each do |dep|
+        package = REGISTER[dep]
+        package = select_package(dep, package) if package.is_a? Array
+
+        raise "Package definition not found for key: #{dep}" unless package
+        block.call(self, package, depth) if block
+        packages << package.tree(depth + 1, &block)
+      end
+
+      packages << self
+
+      @optional.each do |dep|
+        package = REGISTER[dep]
+        next unless package # skip missing optional packages as they're allow to not exist
+        block.call(self, package, depth) if block
+        packages << package.tree(depth + 1, &block)
+      end
+
+      packages
+    end
+
+    def to_s; @name; end
+
+    private
+
+      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 = REGISTER[package]
+        end
+
+        cloud_info "Selecting #{package.to_s} for virtual package #{name}"
+
+        package
+      end
+
+      def meta_package?
+        @installers.empty?
+      end
+  end
+end