poolparty 0.0.4 → 0.2.6

data/lib/poolparty/core/symbol.rb

@@ -0,0 +1,8 @@
+class Symbol
+  def to_string(prev="")
+    "#{prev}#{self.to_s}"
+  end
+  def sanitize
+    self.to_s.sanitize
+  end
+end

data/lib/{core → poolparty/core}/time.rb

@@ -38,4 +38,19 @@ class Numeric
     self * 7.days
   end
   alias :week :weeks
+  
+  def months
+    self * 31.days
+  end
+  alias :month :months
+  
+  def time_ago
+    out = %w(year month week day hour minute).detect {|unit| self > 1.send(unit) }
+    units_ago(out, self) rescue "Less than a minute ago"
+  end
+
+  def units_ago(unit,seconds)
+    in_units = (seconds / 1.send(unit))
+    "#{in_units.to_i} #{in_units != 1 ? unit.to_s.pluralize : unit} ago" 
+  end
 end

data/lib/poolparty/exceptions/RemoteException.rb

@@ -0,0 +1,12 @@
+class RemoteException < Exception
+  EXCEPTION_MESSAGES = {
+    :method_not_defined => "Method is not defined",
+    :invalid_formatting => "Invalid formatting",
+    :could_not_install => "Could not install"
+  }
+  attr_reader :message
+  
+  def initialize(type=:method_not_defined, note="")
+    @message = "Remote Exception: #{EXCEPTION_MESSAGES[type]} #{note}"
+  end
+end

data/lib/poolparty/exceptions/ResourceException.rb

@@ -0,0 +1,7 @@
+class ResourceException < Exception
+  attr_reader :message
+  
+  def initialize(msg="Custom resource exception")
+    @message = "Custom resource error: #{msg}"
+  end
+end

data/lib/poolparty/exceptions/RuntimeException.rb

@@ -0,0 +1,7 @@
+class RuntimeException < Exception
+  attr_reader :message
+  
+  def initialize(msg="Runtime exception")
+    @message = "There was a runtime error: #{msg}"
+  end
+end

data/lib/poolparty/exceptions/SpecException.rb

@@ -0,0 +1,7 @@
+class SpecException < Exception
+  attr_reader :message
+  
+  def initialize(msg="Custom resource exception")
+    @message = "Spec error: #{msg}"
+  end
+end

data/lib/poolparty/exceptions/TemplateNotFound.rb

@@ -0,0 +1,7 @@
+class TemplateNotFound < Exception
+  attr_reader :message
+  
+  def initialize(msg="Custom resource exception")
+    @message = "Template not found: #{msg}"
+  end
+end

data/lib/poolparty/helpers/binary.rb

@@ -0,0 +1,31 @@
+require "ftools"
+module PoolParty
+  module Binary
+    
+    class << self
+            
+      def list_binaries_for(ty="pool")
+        available_binaries_for(ty).join(", ")
+      end
+      def available_binaries_for(ty="pool")
+        Dir["#{binary_directory}/#{ty}-*"].map {|a| File.basename(a.gsub(/#{ty}-/, '')) }.sort
+      end
+      def binary_directory
+        "#{::File.dirname(__FILE__)}/../../../bin"
+      end
+      def get_existing_spec_location
+        [                            
+            "#{Base.base_config_directory}/#{Base.default_specfile_name}",
+            "#{Base.remote_storage_path}/#{Base.default_specfile_name}", 
+            ENV["POOL_SPEC"],
+            "#{Base.default_specfile_name}",
+            "#{Base.storage_directory}/#{Base.default_specfile_name}",            
+        ].reject {|a| a.nil?}.reject do |f|
+          f unless ::File.file?(f)
+        end.first
+      end
+      
+    end
+    
+  end
+end

data/lib/poolparty/helpers/console.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + "/display"
+
+module PoolParty
+  module Console
+    
+    include Display
+    
+    # Load a file that contains a pool into memory
+    def load_pool(filename)
+      unless filename && ::File.file?(filename)
+        puts "Could not load pool"
+        exit
+      else
+        PoolParty::Script.inflate(open(filename).read, File.dirname(filename))
+      end
+    end
+    
+    # Clear all the pools and reload the console
+    # Call within console to reset and reload the entire poolparty base
+    # as well
+    def reload!      
+      reset!
+    end
+    
+  end
+end
+
+class Object
+  include PoolParty::Console
+end

data/lib/poolparty/helpers/display.rb

@@ -0,0 +1,34 @@
+module PoolParty
+  module Display
+    
+    def pool_describe(options={})
+      if pools.size > 0
+        pools.each do |k,v|
+          print v.pretty_print
+        end
+      else
+        prev = "\t"
+        clouds.each do |name, cl|
+          puts cl.pretty_name(prev*2, cl)
+          puts cl.pretty_options(prev*2, cl) #cl.pretty_print("#{prev}\t")
+        end
+      end
+
+      puts ""
+      pools.size
+    end
+    
+    def available_bases
+      puts Remote.available_bases
+    end
+    
+    def header(str="")
+      "*** #{str}"
+    end
+    
+    def subheader(str="")
+      "****** #{str}"
+    end
+    
+  end
+end

data/lib/poolparty/helpers/optioner.rb

@@ -0,0 +1,64 @@
+require 'optparse' 
+require 'rdoc/usage'
+require 'ostruct'
+require 'date'
+
+module PoolParty
+  class Optioner
+    include Configurable
+    include MethodMissingSugar
+        
+    def initialize(args=[], opts={}, &block)
+      @arguments = args
+      @parse_options = opts[:parse_options] ? opts[:parse_options] : true
+      
+      set_default_options
+      parse_options(&block) if @parse_options
+      self
+    end
+    
+    def parent
+      self
+    end
+    
+    def set_default_options
+      @options = {}
+      @options[:verbose] = false
+      @options[:quiet] = false
+      @options[:version] = PoolParty::VERSION::STRING
+    end
+    
+    def parse_options(&blk)
+      opts = OptionParser.new 
+      opts.banner = "Usage: pool [command] [options]"
+
+      opts.separator ""
+      opts.separator "Options:"
+      
+      opts.on('-V', '--version', 'Display the version')    { output_version ; exit 0 }
+      opts.on('-v', '--verbose', 'Be verbose')    { @options[:verbose] = true }  
+      opts.on('-s [file]', '--spec-file [file]', 'Set the spec file')      { |file| self.spec file }
+      opts.on('-t', '--test', 'Testing mode')    { self.testing "true" }
+                  
+      blk.call(opts, self) if blk
+      
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+      
+      opts.parse!(@arguments)
+      
+      process_options      
+      output_options if verbose
+    end
+    def process_options
+      @options[:verbose] = false if @options[:quiet]
+    end
+        
+    def output_version
+      puts version
+    end
+    
+  end
+end

data/lib/poolparty/helpers/provisioner_base.rb

@@ -0,0 +1,250 @@
+=begin rdoc
+  The Provisioner is responsible for provisioning REMOTE servers
+  This class only comes in to play when calling the setup commands on
+  the development machine
+=end
+module PoolParty
+  module Provisioner
+    
+    # Provision master
+    # Convenience method to clean 
+    def self.provision_master(cloud, testing=false)
+      Provisioner::Master.new(cloud).process_install!(testing)
+    end
+
+    def self.configure_master(cloud, testing=false)
+      Provisioner::Master.new(cloud).process_configure!(testing)
+    end
+
+    def self.provision_slaves(cloud, testing=false)
+      cloud.nonmaster_nonterminated_instances.each do |sl|
+        provision_slave(sl, cloud, testing)
+      end
+    end
+
+    def self.configure_slaves(cloud, testing=false)
+      cloud.nonmaster_nonterminated_instances.each do |sl|
+        configure_slave(sl, cloud, testing)
+      end
+    end
+        
+    def self.provision_slave(instance, cloud, testing=false)
+      Provisioner::Slave.new(instance, cloud).process_install!(testing)
+    end
+    
+    def self.configure_slave(instance, cloud, testing=false)
+      Provisioner::Slave.new(instance, cloud).process_configure!(testing)
+    end
+    
+    class ProvisionerBase
+      
+      include Configurable
+      include CloudResourcer
+      
+      def initialize(instance,cloud=self, os=:ubuntu)
+        @instance = instance
+        @cloud = cloud
+        
+        options(cloud.options) if cloud && cloud.respond_to?(:options)
+        set_vars_from_options(instance.options) unless instance.nil? || instance.options.empty?
+        options(instance.options) if instance.respond_to?(:options)
+        
+        @os = os.to_s.downcase.to_sym
+        loaded
+      end
+      # Callback after initialized
+      def loaded      
+      end
+      # This is the actual runner for the installation    
+      def install
+        valid? ? install_string : error
+      end
+      def write_install_file
+        error unless valid?
+        ::FileUtils.mkdir_p Base.storage_directory unless ::File.exists?(Base.storage_directory)
+        provisioner_file = ::File.join(Base.storage_directory, "install_#{name}.sh")
+        ::File.open(provisioner_file, "w+") {|f| f << install }
+      end
+      def process_install!(testing=false)
+        error unless valid?
+        write_install_file
+        setup_runner(@cloud)
+        
+        unless testing
+          puts "Logging on to #{@instance.ip}"
+          @cloud.rsync_storage_files_to(@instance)
+          
+          cmd = "cd #{Base.remote_storage_path}/#{Base.tmp_path} && chmod +x install_#{name}.sh && /bin/sh install_#{name}.sh && rm -rf *"
+          hide_output do
+            @cloud.run_command_on(cmd, @instance)
+          end          
+        end        
+      end
+      def configure
+        valid? ? configure_string : error
+      end
+      def write_configure_file
+        error unless valid?
+        provisioner_file = ::File.join(Base.storage_directory, "configure_#{name}.sh")
+        ::File.open(provisioner_file, "w+") {|f| f << configure }
+      end
+      def process_configure!(testing=false)
+        error unless valid?
+        write_configure_file
+        setup_runner(@cloud)        
+        
+        unless testing
+          @cloud.rsync_storage_files_to(@instance)
+
+          cmd = "cd #{Base.remote_storage_path}/#{Base.tmp_path} && chmod +x configure_#{name}.sh && /bin/sh configure_#{name}.sh && rm -rf *"
+          @cloud.run_command_on(cmd, @instance)
+        end
+      end
+      def setup_runner(cloud)
+        cloud.prepare_to_configuration
+        cloud.build_and_store_new_config_file
+      end
+      def valid?
+        true
+      end
+      def error
+        "Error in installation"
+      end
+      # Gather all the tasks into one string
+      def install_string
+        (default_install_tasks).each do |task|
+          case task.class
+          when String
+            task
+          when Method
+            self.send(task.to_sym)
+          end
+        end.nice_runnable
+      end
+      def configure_string
+        (default_configure_tasks).each do |task|
+          case task.class
+          when String
+            task
+          when Method
+            self.send(task.to_sym)
+          end
+        end.nice_runnable
+      end
+      # Tasks with default tasks 
+      # These are run on all the provisioners, master or slave
+      def default_install_tasks
+        [
+          upgrade_system,
+          install_puppet_master,
+          custom_install_tasks
+        ] << install_tasks
+      end
+      # Tasks with default configuration tasks
+      # This is run on the provisioner, regardless
+      def default_configure_tasks
+        [
+          custom_configure_tasks
+        ] << configure_tasks
+      end
+      # Build a list of the tasks to run on the instance
+      def install_tasks(a=[])
+        @install_task ||= a
+      end
+      def configure_tasks(a=[])
+        @configure_tasks ||= a
+      end
+      # Custom installation tasks
+      # Allow the remoter bases to attach their own tasks on the 
+      # installation process
+      def custom_install_tasks
+        @cloud.custom_install_tasks_for(@instance) || []
+      end
+      # Custom configure tasks
+      # Allows the remoter bases to attach their own
+      # custom configuration tasks to the configuration process
+      def custom_configure_tasks
+        @cloud.custom_configure_tasks_for(@instance) || []
+      end
+      
+      # Get the packages associated with each os
+      def puppet_packages
+        case @os
+        when :fedora
+          "puppet-server puppet factor"
+        else
+          "puppet puppetmaster"
+        end
+      end    
+      # Package installers for general *nix operating systems
+      def self.installers
+        @installers ||= {
+          :ubuntu => "apt-get install -y",
+          :fedora => "yum install",
+          :gentoo => "emerge"
+        }
+      end
+      # Convenience method to grab the installer
+      def installer_for(names=[])
+        packages = names.is_a?(Array) ? names.join(" ") : names
+        "#{self.class.installers[@os]} #{packages}"
+      end
+      
+      # Install from the class-level
+      def self.install(instance, cl=self)
+        new(instance, cl).install
+      end
+
+      def self.configure(instance, cl=self)
+        new(instance, cl).configure
+      end
+      
+      # Template directory from the provisioner base
+      def template_directory
+        File.join(File.dirname(__FILE__), "..", "templates")
+      end
+
+      def create_local_node
+        str = <<-EOS
+  node default {
+    include poolparty
+  }
+        EOS
+         @cloud.list_of_running_instances.each do |ri|
+           str << <<-EOS           
+  node "#{ri.name}" {}
+           EOS
+         end
+        "echo '#{str}' > /etc/puppet/manifests/nodes/nodes.pp"
+      end
+      
+      def upgrade_system
+        case @os
+        when :ubuntu
+          "          
+          touch /etc/apt/sources.list
+          echo 'deb http://mirrors.kernel.org/ubuntu hardy main universe' >> /etc/apt/sources.list
+          apt-get update --fix-missing -y
+          apt-get upgrade -y
+          "
+        else
+          "# No system upgrade needed"
+        end
+      end
+      
+      def install_puppet_master
+        "#{installer_for( puppet_packages )}"
+      end
+
+      def create_poolparty_manifest
+        <<-EOS
+          mv #{Base.remote_storage_path}/poolparty.pp /etc/puppet/manifests/classes
+        EOS
+      end
+    end
+  end  
+end
+## Load the provisioners
+Dir[File.dirname(__FILE__) + "/provisioners/*.rb"].each do |file|
+  require file
+end