pot 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Njk1ODRkYzQ4Nzk3NGE0YWJiZDdhNTA2NDI0OWNkNjZmZGM3ZmM3OQ==
+  data.tar.gz: !binary |-
+    Njg4MjYxMTQ0ZGRkNDFiNzZkYTU4OTA0YjMxMTUxMzc0ZGZkMGI2Mw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZDQwMmQ5ZDExYTNjOWJkOTA5NWYwOGI0ZDEwZWNmNGI5NGQ5NjYyYmY5ZGM2
+    YjI0YjA4OGUwNjE5NDlhNGQwYjI4ZjRlNzIzM2VjYmEyNDYyMmM3MThlNTVj
+    Y2I0NzdmNzI0MmEyNGM5NzNjOTIxMmZmY2Y3YTNlYjExMzMyZTY=
+  data.tar.gz: !binary |-
+    Y2MzMjJiZGJhY2MyNzdiN2ZjNDYzN2JlNTc2ZjM0MjdkMTYwMzRmNDJmNDU5
+    NGZjZDY1YWZjOTQ1NjU0NTBjYjIwOTg4Mzk1Yzc4MzE2MzlhODVlZDZkYjRj
+    NGJiMzkxYzA5NTc2M2JmN2M4ODc4NGJhNWRkZDQ2Y2I1ZmI2MGY=

data/CREDITS

@@ -0,0 +1,32 @@
+= CREDITS
+
+Marcus Crafter         (https://github.com/crafterm)
+Kristin Baumann        (http://crafterm.net/kristin/blog/)
+Ben Schwarz            (http://germanforblack.com/)
+Jim Freeze             (http://www.artima.com/rubycs/articles/ruby_as_dslP.html)
+Matthew Tanase         (http://www.slicehost.com)
+Jared Kuolt            (http://www.slicehost.com)
+Jamis Buck             (http://www.capify.org)
+Matt Allen             (http://blog.allen.com.au)
+Eric Hodel             (http://blog.segment7.net)
+Pete Yandell           (http://notahat.com)
+Adam Meehan            (http://duckpunching.com)
+Mitchell Hashimoto     (http://mitchellhashimoto.com)
+Ari Lerner             (http://www.citrusbyte.com)
+Jorgen Orehøj Erichsen (http://blog.erichsen.net)
+Joshua Sierles         (http://diluvia.net)
+Julian Russell         (http://github.com/plusplus)
+Dave (Gassto)          (http://github.com/gassto)
+Bodaniel Jeanes        (http://bjeanes.github.com)
+Jacob Harris           (http://open.nytimes.com)
+Justin Pease           (http://jit.nuance9.com)
+Tobias Lütke           (http://blog.leetsoft.com)
+Josh Reynolds          (http://github.com/jreynolds)
+Jan Ulbrich            (http://www.ulbrich.net)
+Chris Gaffney          (http://github.com/gaffneyc)
+Maxmpz                 (http://github.com/maxmpz)
+Geoff Garside          (http://geoffgarside.co.uk/)
+Oliver Kiessler        (http://inceedo.com)
+Nick Plante            (http://blog.zerosum.org)
+
+The transfer installer contains a piece of exception reporting code copied from the Chef library (http://wiki.opscode.com/display/chef/Home)

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,21 @@
+# POT
+
+## DESCRIPTION:
+
+Pot is a software provisioning tool.
+
+Pot is based and inspired by <http://github.com/crafterm/sprinkle>.
+Original code is copyrighted by Marcus Crafter <crafterm@redartisan.com>
+
+Pot use sprinkle package system, but with new approach to deploy.
+
+Pot is a work in progress.
+
+## CREDITS:
+See CREDITS
+
+## LICENSE:
+
+Copyright © 2013 ingeniarius
+
+See MIT-LICENSE

data/bin/pot-console

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+libs << " -I #{File.expand_path(__FILE__) + '/../../lib'}"
+libs << " -r pot.rb"
+libs << " -r pot/console.rb"
+puts "Loading Pot"
+exec "#{irb} #{libs} --simple-prompt"

data/lib/pot.rb

@@ -0,0 +1,17 @@
+require 'pot/version'
+require 'pot/config'
+require 'pot/logger'
+require 'pot/template'
+require 'pot/instance'
+require 'pot/actor'
+require 'pot/verify'
+require 'pot/package'
+require 'pot/bundle'
+require 'pot/policy'
+require 'pot/installer'
+require 'pot/transports/ssh'
+require 'pot/transports/local'
+require 'pot/deployment'
+
+Dir[File.dirname(__FILE__) + '/pot/verifiers/*.rb'].each { |e| require e }
+Dir[File.dirname(__FILE__) + '/pot/installers/*.rb'].each { |e| require e }

data/lib/pot/actor.rb

@@ -0,0 +1,34 @@
+module Pot
+  class Actor
+
+    def initialize(instance, options = {})
+      @transport = Pot::Transports::Ssh.new(instance)
+      @sudo = !!options[:sudo]
+    end
+
+    def execute(commands)
+      commands.each do |command|
+        command = "sudo #{command}" if @sudo
+        @transport.execute(command)
+      end
+    end
+
+    def install(installer)
+      execute(installer.commands)
+    end
+
+    def verify(verifier)
+      command = verifier.commands.join(" && ")
+      @transport.execute(command) == 0
+    end
+
+    def transfer(source, destination, recursive = true)
+      @transport.transfer(source, destination, recursive)
+    end
+
+    def teardown
+      @transport if @transport.respond_to?(:teardown)
+    end
+
+  end
+end

data/lib/pot/bundle.rb

@@ -0,0 +1,66 @@
+module Pot
+  class Bundle
+
+    class UndefinedPackage < ::StandardError
+      def message
+        "Package definition not found for key: #{@message}"
+      end
+    end
+
+    def initialize(packages = [])
+      @packages = [packages].flatten
+    end
+
+    def list
+      all = []
+
+      @packages.each do |package_name|
+        cloud_info "Requires package #{package_name}\n"
+
+        package = Pot::Package::REGISTER[package_name]
+        raise UndefinedPackage, package_name unless package
+        package = select_package(package_name, package) if package.is_a? Array # handle virtual package selection
+
+        tree = package.tree do |parent, child, depth|
+          indent = "\t" * depth; cloud_info "#{indent}Package #{parent.name} requires #{child.name}"
+        end
+
+        all << tree
+      end
+
+      normalize(all)
+    end
+
+    def add(package)
+      @packages << package
+    end
+
+    private
+
+      def cloud_info(message)
+        Pot.logger.info(message) if Pot.config.cloud or Pot.logger.debug?
+      end
+
+      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 = Pot::Package::REGISTER[package]
+        end
+
+        cloud_info "Selecting #{package.to_s} for virtual package #{name}"
+
+        package
+      end
+
+      def normalize(all, &block)
+        all = all.flatten.uniq
+        cloud_info "\n--> Normalized installation order for all packages: #{all.collect(&:name).join(', ')}"
+        all.each &block
+      end
+  end
+end

data/lib/pot/config.rb

@@ -0,0 +1,33 @@
+require 'singleton'
+
+module Pot
+  class Config
+    include Singleton
+
+    attr_accessor :testing,
+                  :verbose,
+                  :force,
+                  :cloud,
+                  :debug
+
+    def initialize
+      @testing = false
+      @verbose = false
+      @force = false
+      @debug = false
+    end
+
+    def testing?
+      @testing
+    end
+
+    def debug?
+      @debug
+    end
+
+  end
+
+  def self.config
+    Pot::Config.instance
+  end
+end

data/lib/pot/console.rb

@@ -0,0 +1,7 @@
+require 'pot/dsl'
+
+include Pot::DSL
+
+Dir[Dir.pwd + '/packages/*.rb'].each { |e| require e }
+Dir[Dir.pwd + '/policies/*.rb'].each { |e| require e }
+Dir[Dir.pwd + '/instances/*.rb'].each { |e| require e }

data/lib/pot/deployment.rb

@@ -0,0 +1,91 @@
+module Pot
+  class Deployment
+
+    class UndefinedInstance < ::StandardError
+      def message
+        "Instance definition not found for key: #{@message}"
+      end
+    end
+
+    class UndefinedPolicy < ::StandardError
+      def message
+        "Policy definition not found for key: #{@message}"
+      end
+    end
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def execute_on_instances(commands, instance_name)
+      instances = find_instances(instance_names)
+      deploy_to_instances(instances) do |actor|
+        actor.execute(commands)
+      end
+    end
+
+    def deploy_policies_to_instances(police_names, instance_names)
+      policies = find_policies(police_names)
+      instances = find_instances(instance_names)
+      deploy_policies_to_instances_internal(policies, instances)
+    end
+
+    def deploy_packages_to_instances(package_names, instance_names)
+      package_tree = Pot::Bundle.new(package_names)
+      instances = find_instances(instance_names)
+      deploy_to_instances(instances) do |actor|
+        package_tree.list.each do |package|
+          package.process(actor)
+        end
+      end
+    end
+
+    def deploy_roles(roles)
+      roles = roles.map(&:to_sym)
+      instances = []
+      Pot::Role::REGISTER.each do |role_name, instance|
+        instances << instance if roles.include?(role_name)
+      end
+      policies = []
+      Pot::Policy::REGISTER.each do |policy_name, policy|
+        policy_roles = [policy.roles].flatten
+        policies << policy unless (policy_roles & roles).empty?
+      end
+      deploy_policies_to_instances_internal(policies, instances)
+    end
+
+    private
+
+      def find_policies(police_names)
+        [police_names].flatten.map do |policy_name|
+          policy = Pot::Policy::REGISTER[policy_name.to_sym]
+          raise UndefinedPolicy, policy_name unless policy
+          policy
+        end
+      end
+
+      def find_instances(instance_names)
+        [instance_names].flatten.map do |instance_name|
+          instance = Pot::Instance::REGISTER[instance_name.to_sym]
+          raise UndefinedInstance, instance_name unless instance
+          instance
+        end
+      end
+
+      def deploy_policies_to_instances_internal(policies, instances)
+        deploy_to_instances(instances) do |actor|
+          policies.each do |policy|
+            policy.process(actor)
+          end
+        end
+      end
+
+      def deploy_to_instances(instances)
+        instances.each do |instance|
+          actor = Pot::Actor.new(instance, @options)
+          yield actor
+        end
+      end
+
+  end
+end

data/lib/pot/dsl.rb

@@ -0,0 +1,39 @@
+module Pot
+  module DSL # :nodoc: all
+    def set(option, value)
+      Pot::Config.instance.send("#{option}=", value)
+    end
+
+    def instance(name, host, options = {})
+      Pot::Instance.new(name, host, options)
+    end
+
+    def package(name, metadata = {}, &block)
+      Pot::Package.new(name, metadata, &block)
+    end
+
+    def policy(name, options = {}, &block)
+      Pot::Policy.new(name, options, &block)
+    end
+
+    def role(role_name, instance_name)
+      Pot::Role.new(role_name, instance_name)
+    end
+
+    def deploy_policies(instances, policies, options = {})
+      deployment = Pot::Deployment.new(options)
+      deployment.deploy_policies_to_instances(policies, instances)
+    end
+
+    def deploy_packages(instances, packages, options = {})
+      deployment = Pot::Deployment.new(options)
+      deployment.deploy_packages_to_instances(packages, instances)
+    end
+
+    def deploy_roles(roles, options = {})
+      deployment = Pot::Deployment.new(options)
+      deployment.deploy_roles(roles)
+    end
+
+  end
+end

data/lib/pot/installer.rb

@@ -0,0 +1,131 @@
+module Pot
+  # Based on ...
+  # Copyright (c) 2008-2009 Marcus Crafter crafterm@redartisan.com
+  #
+  # The base class which all installers must subclass, this class makes
+  # sure all installers share some general features, which are outlined
+  # below.
+  #
+  # = Pre/Post Installation Hooks
+  #
+  # With all installation methods you have the ability to specify multiple
+  # pre/post installation hooks. This gives you the ability to specify
+  # commands to run before and after an installation takes place. All
+  # commands by default are sudo'd so there is no need to include "sudo"
+  # in the command itself. There are three ways to specify a pre/post hook.
+  #
+  # First, a single command:
+  #
+  #   pre :install, 'echo "Hello, World!"'
+  #   post :install, 'rm -rf /'
+  #
+  # Second, an array of commands:
+  #
+  #   commands = ['echo "First"', 'echo "Then Another"']
+  #   pre :install, commands
+  #   post :install, commands
+  #
+  # Third, a block which returns either a single or multiple commands:
+  #
+  #   pre :install do
+  #     amount = 7 * 3
+  #     "echo 'Before we install, lets plant #{amount} magic beans...'"
+  #   end
+  #   post :install do
+  #     ['echo "Now... let's hope they sprout!", 'echo "Indeed they have!"']
+  #   end
+  #
+  # = Other Pre/Post Hooks
+  #
+  # Some installation methods actually grant you more fine grained
+  # control of when commands are run rather than a blanket pre :install
+  # or post :install. If this is the case, it will be documented on
+  # the installation method's corresponding documentation page.
+  class Installer
+    attr_accessor :actor, :package, :options, :pre, :post #:nodoc:
+
+    def initialize(package, options = {}, &block) #:nodoc:
+      @package = package
+      @options = options
+      @pre = {}
+      @post = {}
+      self.instance_eval(&block) if block
+    end
+
+    def pre(stage, *commands)
+      @pre[stage] ||= []
+      @pre[stage] += commands
+      @pre[stage] += [yield] if block_given?
+    end
+
+    def post(stage, *commands)
+      @post[stage] ||= []
+      @post[stage] += commands
+      @post[stage] += [yield] if block_given?
+    end
+
+    def prefix(prefix)
+      @options[:prefix] = prefix
+    end
+
+    def archives(archives)
+      @options[:archives] = archives
+    end
+
+    def builds(builds)
+      @options[:builds] = builds
+    end
+
+    def process(actor) #:nodoc:
+      if Pot.logger.debug?
+        sequence = commands;
+        sequence = sequence.join('; ') if sequence.is_a? Array
+        Pot.logger.debug "#{@package.name} install sequence: #{sequence}\n"
+      end
+
+      unless Pot.config.testing?
+        Pot.logger.info "--> Installing #{package.name}"
+        actor.install(self)
+      end
+    end
+
+    # More complicated installers that have different stages, and require pre/post commands
+    # within stages can override commands and take complete control of the install
+    # command sequence construction (eg. source based installer).
+    def commands
+      commands = pre_commands(:install) + [ install_commands ] + post_commands(:install)
+      commands.flatten
+    end
+
+    protected
+      # A concrete installer (subclass of this virtual class) must override this method
+      # and return the commands it needs to run as either a string or an array.
+      #
+      # <b>Overriding this method is required.</b>
+      def install_commands
+        raise 'Concrete installers implement this to specify commands to run to install their respective packages'
+      end
+
+      def pre_commands(stage) #:nodoc:
+        dress @pre[stage] || [], :pre
+      end
+
+      def post_commands(stage) #:nodoc:
+        dress @post[stage] || [], :post
+      end
+
+      # Concrete installers (subclasses of this virtual class) can override this method to
+      # specify stage-specific (pre-installation, post-installation, etc.) modifications
+      # of commands.
+      #
+      # An example usage of overriding this would be to prefix all commands for a
+      # certain stage to change to a certain directory. An example is given below:
+      #
+      #   def dress(commands, stage)
+      #     commands.collect { |x| "cd #{magic_beans_path} && #{x}" }
+      #   end
+      #
+      # By default, no modifications are made to the commands.
+      def dress(commands, stage); commands; end
+	end
+end