pot 0.1.0

data/lib/pot/policy.rb

@@ -0,0 +1,74 @@
+module Pot
+  # = Policies
+  #
+  # A policy defines a set of packages which are required for a certain
+  # role (app, database, etc.). All policies defined will be run and all
+  # packages required by the policy will be installed. So whereas defining
+  # a Pot::Package merely defines it, defining a Pot::Policy
+  # actually causes those packages to install.
+  #
+  # == A Basic Example
+  #
+  #   policy :blog, :roles => :app do
+  #     require :webserver
+  #     require :database
+  #     require :rails
+  #   end
+  #
+  # This says that for the blog on the app role, it requires certain
+  # packages. The :roles option is <em>exactly</em> the same as a capistrano
+  # or vlad role. A role merely defines what server the commands are run
+  # on. This way, a single Pot script can provision an entire group
+  # of servers.
+  #
+  # To define a role, put in your actor specific configuration file (recipe or
+  # script file):
+  #
+  #   role :app, "208.28.38.44"
+  #
+  # The capistrano and vlad syntax is the same for that. If you're using a
+  # custom actor, you may have to do it differently.
+  #
+  # == Multiple Policies
+  #
+  # You may specify as many policies as you'd like. If the packages you're
+  # requiring are properly defined with verification blocks, then
+  # no software will be installed twice, so you may require a webserver on
+  # multiple packages within the same role without having to wait for
+  # that package to install repeatedly.
+  class Policy #:nodoc:
+    REGISTER = {}
+
+    attr_reader :name,
+                :packages,
+                :roles
+
+    def initialize(name, metadata = {}, &block)
+      raise 'No name provided' unless name
+      raise 'No roles provided' unless metadata[:roles]
+
+      @name = name.to_sym
+      @roles = metadata[:roles]
+      @package_tree = Pot::Bundle.new
+
+      REGISTER[@name] = self
+
+      self.instance_eval(&block)
+    end
+
+    def requires(package, options = {})
+      @package_tree.add(package)
+    end
+
+    def to_s
+      name
+    end
+
+    def process(actor)
+      @package_tree.list do |package|
+        package.process(actor)
+      end
+    end
+
+  end
+end

data/lib/pot/role.rb

@@ -0,0 +1,16 @@
+module Pot
+  class Role
+    REGISTER = {}
+
+    attr_reader :name, :instance
+
+    def initialize(role_name, instance_name)
+      @name = role_name
+      instance = Pot::Instance::REGISTER[instance_name]
+      raise "Undefined instance: #{instance_name}" unless instance
+      @instance = instance
+
+      REGISTER[role_name] = self
+    end
+  end
+end

data/lib/pot/template.rb

@@ -0,0 +1,20 @@
+module Pot
+  class Template
+    def initialize(package, name)
+      @package = package
+      @name = name
+    end
+
+    def path
+      default_file_path = File.join(templates_directory, 'defaults', @package.name.to_s, @name.to_s)
+      raise "Can't read template #{default_file_path}" unless File.readable?(default_file_path)
+      default_file_path
+    end
+
+    private
+
+      def templates_directory
+        File.join(Dir.pwd, 'templates')
+      end
+  end
+end

data/lib/pot/transports/local.rb

@@ -0,0 +1,31 @@
+module Pot
+  module Transports
+    # = Local Delivery Method
+    #
+    # This actor implementation performs any given commands on your local system, as
+    # opposed to other implementations that generally run commands on a remote system
+    # via the network.
+    #
+    # This is useful if you'd like to use Pot to provision your local machine.
+    # To enable this actor, in your Pot script specify the :local delivery mechanism.
+    #
+    #   deployment do
+    #     delivery :local
+    #   end
+    #
+    class Local
+
+      def execute(command)
+        system command
+      end
+
+      def transfer(source, destination, recursive = true)
+        if recursive
+          flags = "-R "
+        end
+
+        system "cp #{flags}#{source} #{destination}"
+      end
+    end
+  end
+end

data/lib/pot/transports/ssh.rb

@@ -0,0 +1,81 @@
+require 'net/ssh'
+require 'net/scp'
+
+module Pot
+  module Transports
+    class Ssh
+
+      attr_reader :instance
+
+      def initialize(instance) #:nodoc:
+        @instance = instance
+      end
+
+      def execute(command)
+        execute_on_connection!(command)
+      end
+
+      def transfer(source, destination, recursive = true)
+        transfer_on_connection!(source, destination, recursive)
+      end
+
+      private
+
+        def connection
+          return @connection if defined?(@connection)
+          options = { }
+          # options[:verbose] = Logger::DEBUG if Pot.config.debug?
+          # options[:verbose] = Logger::INFO
+          options[:password] = instance.password if instance.password
+          options[:port] = instance.port if instance.port
+          @connection = Net::SSH.start(instance.host, instance.user, options)
+          @connection
+        end
+
+        def transfer_on_connection!(source, destination, recursive)
+          scp = Net::SCP.new(connection)
+          scp.upload! source, destination, :recursive => recursive
+        end
+
+        def execute_on_connection!(command)
+          exit_code = nil
+          exit_signal = nil
+
+          connection.open_channel do |channel|
+            Pot.logger.debug("executing remote command: #{command}")
+            channel.exec(command) do |ch, success|
+              unless success
+                abort "FAILED: couldn't execute command (connection.channel.exec)"
+                Pot.logger.error("couldn't run remote command #{command}")
+              end
+
+              channel.on_data do |ch, data|
+                Pot.logger.debug("stdout said-->\n#{data}\n")
+              end
+
+              channel.on_extended_data do |ch, type, data|
+                next unless type == 1  # only handle stderr
+                Pot.logger.debug("stderr said -->\n#{data}\n")
+              end
+
+              channel.on_request("exit-status") do |ch, data|
+                exit_code = data.read_long
+                if exit_code == 0
+                  Pot.logger.debug('success')
+                else
+                  Pot.logger.debug('failed (%d).'%exit_code)
+                end
+              end
+
+              channel.on_request("exit-signal") do |ch, data|
+                exit_signal = data.read_long
+                Pot.logger.debug("#{command} was signaled!: #{data.read_long}")
+              end
+            end
+          end
+          connection.loop
+          exit_code
+        end
+    end
+  end
+end

data/lib/pot/verifiers/apt.rb

@@ -0,0 +1,21 @@
+module Pot
+  module Verifiers
+    # = Apt package Verifier
+    #
+    # Contains a verifier to check the existance of an Apt package.
+    #
+    # == Example Usage
+    #
+    #   verify { has_apt 'ntp' }
+    #
+    module Apt
+      Pot::Verify.register(Pot::Verifiers::Apt)
+
+      # Checks to make sure the apt <tt>package</tt> exists on the remote server.
+      def has_apt(package)
+        @commands << "dpkg --status #{package} | grep \"ok installed\""
+      end
+
+    end
+  end
+end

data/lib/pot/verifiers/brew.rb

@@ -0,0 +1,21 @@
+module Pot
+  module Verifiers
+    # = Brew package Verifier
+    #
+    # Contains a verifier to check the existance of a Homebrew formula.
+    #
+    # == Example Usage
+    #
+    #   verify { has_brew 'ntp' }
+    #
+    module Brew
+      Pot::Verify.register(Pot::Verifiers::Brew)
+
+      # Checks to make sure the brew <tt>formula</tt> exists on the remote server.
+      def has_brew(package)
+        @commands << "brew list | grep  #{package}"
+      end
+
+    end
+  end
+end

data/lib/pot/verifiers/directory.rb

@@ -0,0 +1,16 @@
+module Pot
+  module Verifiers
+    # = Directory Verifier
+    #
+    # Defines a verify which can be used to test the existence of a
+    # directory.
+    module Directory
+      Pot::Verify.register(Pot::Verifiers::Directory)
+
+      # Tests that the directory <tt>dir</tt> exists.
+      def has_directory(dir)
+        @commands << "test -d #{dir}"
+      end
+    end
+  end
+end

data/lib/pot/verifiers/executable.rb

@@ -0,0 +1,53 @@
+module Pot
+  module Verifiers
+    # = Executable Verifier
+    #
+    # Contains a verifier to check the existance of an executable
+    # script on your server.
+    #
+    # == Example Usage
+    #
+    # First, absolute path to an executable:
+    #
+    #   verify { has_executable '/usr/special/secret/bin/scipt' }
+    #
+    # Second, a global executable which would be available anywhere on the
+    # command line:
+    #
+    #   verify { has_executable 'grep' }
+    module Executable
+      Pot::Verify.register(Pot::Verifiers::Executable)
+
+      # Checks if <tt>path</tt> is an executable script. This verifier is "smart" because
+      # if the path contains a forward slash '/' then it assumes you're checking an
+      # absolute path to an executable. If no '/' is in the path, it assumes you're
+      # checking for a global executable that would be available anywhere on the command line.
+      def has_executable(path)
+        # Be smart: If the path includes a forward slash, we're checking
+        # an absolute path. Otherwise, we're checking a global executable
+        if path.include?('/')
+          @commands << "test -x #{path}"
+        else
+          @commands << "which -s #{path}"
+        end
+      end
+
+      # Same as has_executable but with checking for e certain version number.
+      # Last option is the parameter to append for getting the version (which
+      # defaults to "-v").
+      def has_executable_with_version(path, version, get_version = '-v')
+        if path.include?('/')
+          @commands << "[ -x #{path} -a -n \"`#{path} #{get_version} 2>&1 | egrep -e \\\"#{version}\\\"`\" ]"
+        else
+          @commands << "[ -n \"`echo \\`which #{path}\\``\" -a -n \"`\\`which #{path}\\` #{get_version} 2>&1 | egrep -e \\\"#{version}\\\"`\" ]"
+        end
+      end
+
+      # Same as has_executable but checking output of a certain command
+      # with grep.
+      def has_version_in_grep(cmd, version)
+        @commands << "[ -n \"`#{cmd} 2> /dev/null | egrep -e \\\"#{version}\\\"`\" ]"
+      end
+    end
+  end
+end

data/lib/pot/verifiers/file.rb

@@ -0,0 +1,34 @@
+module Pot
+  module Verifiers
+    # = File Verifier
+    #
+    # Contains a verifier to check the existance of a file.
+    #
+    # == Example Usage
+    #
+    #   verify { has_file '/etc/apache2/apache2.conf' }
+    #
+    #   verify { file_contains '/etc/apache2/apache2.conf', 'mod_gzip'}
+    #
+    module File
+      Pot::Verify.register(Pot::Verifiers::File)
+
+      # Checks to make sure <tt>path</tt> is a file on the remote server.
+      def has_file(path)
+        @commands << "test -f #{path}"
+      end
+
+      def file_contains(path, text)
+        @commands << "grep '#{text}' #{path}"
+      end
+      def user_present(username)
+        has_user username
+      end
+      def matches_local(localfile, remotefile, mode=nil)
+        raise "Couldn't find local file #{localfile}" unless ::File.exists?(localfile)
+        local = `md5 #{localfile}`.split.last
+        @commands << %{[ "X$(md5sum #{remotefile}|cut -d\\  -f 1)" = "X#{local}" ]}
+      end
+    end
+  end
+end

data/lib/pot/verifiers/process.rb

@@ -0,0 +1,21 @@
+module Pot
+  module Verifiers
+    # = Process Verifier
+    #
+    # Contains a verifier to check that a process is running.
+    #
+    # == Example Usage
+    #
+    #   verify { has_process 'httpd' }
+    #
+    module Process
+      Pot::Verify.register(Pot::Verifiers::Process)
+
+      # Checks to make sure <tt>process</tt> is a process running
+      # on the remote server.
+      def has_process(process)
+        @commands << "ps -C #{process}"
+      end
+    end
+  end
+end

data/lib/pot/verifiers/ruby.rb

@@ -0,0 +1,25 @@
+module Pot
+  module Verifiers
+    # = Ruby Verifiers
+    #
+    # The verifiers in this module are ruby specific.
+    module Ruby
+      Pot::Verify.register(Pot::Verifiers::Ruby)
+
+      # Checks if ruby can require the <tt>files</tt> given. <tt>rubygems</tt>
+      # is always included first.
+      def ruby_can_load(*files)
+        # Always include rubygems first
+        files = files.unshift('rubygems').collect { |x| "require '#{x}'" }
+
+        @commands << "ruby -e \"#{files.join(';')}\""
+      end
+
+      # Checks if a gem exists by calling "gem list" and grepping against it.
+      def has_gem(name, version = nil)
+        version = version ? "--version '#{version}'" : ''
+        @commands << "gem list '#{name}' --installed #{version} > /dev/null"
+      end
+    end
+  end
+end

data/lib/pot/verifiers/symlink.rb

@@ -0,0 +1,30 @@
+module Pot
+  module Verifiers
+    # = Symlink Verifier
+    #
+    # Contains a verifier to check the existance of a symbolic link.
+    #
+    # == Example Usage
+    #
+    # First, checking for the existence of a symlink:
+    #
+    #   verify { has_symlink '/usr/special/secret/pointer' }
+    #
+    # Second, checking that the symlink points to a specific place:
+    #
+    #   verify { has_symlink '/usr/special/secret/pointer', '/usr/local/realfile' }
+    module Symlink
+      Pot::Verify.register(Pot::Verifiers::Symlink)
+
+      # Checks that <tt>symlink</tt> is a symbolic link. If <tt>file</tt> is
+      # given, it checks that <tt>symlink</tt> points to <tt>file</tt>
+      def has_symlink(symlink, file = nil)
+        if file.nil?
+          @commands << "test -L #{symlink}"
+        else
+          @commands << "test '#{file}' = `readlink #{symlink}`"
+        end
+      end
+    end
+  end
+end