auser-poolparty 0.1.2 → 0.2.2

data/lib/poolparty/core/my_open_struct.rb

@@ -0,0 +1,18 @@
+=begin rdoc
+  Create an extended open struct
+=end
+require "ostruct"
+class MyOpenStruct < OpenStruct
+  attr_accessor :keys
+  def initialize(h)
+    @keys = h.keys
+    super
+  end
+  def to_hash
+    m = {}
+    @keys.map do |key|
+      m.update( {key => self.send(key)} )
+    end
+    m
+  end
+end

data/lib/poolparty/core/object.rb

@@ -0,0 +1,54 @@
+=begin rdoc
+  Basic, add an alias_method to the object class
+  Add returning to the object
+=end
+class Object
+  def my_methods
+    self.methods.sort - (self.class.methods + self.class.superclass.methods)
+  end
+  def to_os
+    self
+  end  
+  def alias_method(new_id, original_id)
+    original = self.method(original_id).to_proc
+    define_method(new_id){|*args| original.call(*args)}
+  end
+  def with_options(opts={}, parent=self, &block)
+    @p = parent.clone
+    @p.options.merge!(opts)
+    @p.instance_eval &block if block
+  end  
+  def returning(receiver)
+    yield receiver
+    receiver
+  end
+  def extended(&block)
+    block.in_context(self).call
+    self
+  end
+  def to_option_string
+    case self.class
+    when String
+      self.to_option_string
+    when Array
+      self.each {|a| a.to_option_string }.join(" ")
+    else
+      "#{self}"
+    end
+  end
+  def block_instance_eval(*args, &block)
+    return instance_eval(*args,&block) unless block_given? && !block.arity.zero?
+    old_method = (self.class.instance_method(:__) rescue nil)
+    self.class.send(:define_method, :__, &block)
+    block_method = self.class.instance_method(:__)
+    if old_method
+      self.class.send(:define_method, :__, old_method)
+    else
+      self.class.send(:remove_method, :__)
+    end
+    block_method.bind(self).call(*args)
+  end
+  def meta_def name, &blk
+    (class << self; self; end).instance_eval { define_method name, &blk }
+  end
+end

data/lib/poolparty/core/proc.rb

@@ -0,0 +1,2 @@
+class Proc
+end

data/lib/poolparty/core/string.rb

@@ -0,0 +1,72 @@
+class String
+  def hasherize(format=[])
+    hash = {}
+    i = 0
+    self.split(%r{[\n|\t|\s| ]+}).map {|a| a.strip}.each do |f|
+      next unless format[i]
+      unless f == "" || f.nil?
+        hash[format[i].to_sym] = f
+        i+=1
+      end      
+    end
+    hash
+  end
+  def ^(h={})
+    self.gsub(/:([\w]+)/) {h[$1.to_sym] if h.include?($1.to_sym)}
+  end
+  def arrayable
+    self.strip.split(/\n/)
+  end
+  def runnable(quite=true)
+    # map {|l| l << "#{" >/dev/null 2>/dev/null" if quite}" }.
+    self.strip.split(/\n/).join(" && ")
+  end
+  def top_level_class
+    self.split("::")[-1].downcase rescue self
+  end
+  def sanitize
+    self.gsub(/[\.]*/, '')
+  end
+  def nice_runnable(quite=true)
+    self.split(/ && /).join("\n")
+  end
+  def to_option_string(ns=[])
+    a_template = (self =~ /template/) == 0
+    a_service = self =~ /^[A-Z][a-zA-Z]*\[[a-zA-Z0-9\-\.\"\'_\$\{\}\/]*\]/
+    (a_service || a_template) ? "#{self}" : "'#{self}'"
+  end
+  # Refactor this guy to get the class if the class is defined, and not always create a new one
+  # although, it doesn't really matter as ruby will just reopen the class
+  def class_constant(superclass=nil, opts={}, &block)
+    symc = ((opts && opts[:preserve]) ? ("#{self.classify}Classs") : "PoolParty#{self.classify}Classs").classify
+        
+    kla=<<-EOE
+      class #{symc} #{"< #{superclass}" if superclass}
+      end
+    EOE
+    
+    Kernel.module_eval kla
+    klass = symc.constantize
+    klass.module_eval &block if block
+    
+    klass
+  end
+  
+  def module_constant(&block)
+    symc = "#{self}_Module".classify
+    mod = Object.const_defined?(symc) ? Object.const_get(symc.to_sym) : Module.new(&block)
+    Object.const_set(symc, mod) unless Object.const_defined?(symc)
+    symc.to_s.constantize
+  end
+  def preserved_module_constant(ext="", from="PoolParty::", &block)
+    symc = "#{self}#{ext}".classify
+    mod = Kernel.const_defined?(symc) ? Kernel.const_get(symc.to_sym) : Module.new(&block)
+    Kernel.const_set(symc, mod) unless Kernel.const_defined?(symc)
+    symc.to_s.constantize
+  end
+  def collect_each_line_with_index(&block)
+    returning [] do |arr|
+      arr << self.split(/\n/).collect_with_index(&block)
+    end.flatten
+  end
+end

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,30 @@
+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
+        [                
+            "pool.spec", 
+            "#{Base.remote_storage_directory}/pool.spec", 
+            "#{Base.storage_directory}/pool.spec",
+            ENV["POOL_SPEC"]
+        ].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,25 @@
+module PoolParty
+  module Display
+    
+    def pool_describe(options={})
+      pools.each do |k,v|
+        print v.pretty_print
+      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,61 @@
+require 'optparse' 
+require 'rdoc/usage'
+require 'ostruct'
+require 'date'
+
+module PoolParty
+  class Optioner
+    include Configurable
+    
+    attr_reader :options
+    
+    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 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,226 @@
+=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.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?
+        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?
+        setup_runner(@cloud)
+        write_configure_file
+        
+        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 << custom_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 << custom_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
+        [
+          "export AWS_ACCESS_KEY_ID=#{@cloud.access_key}",
+          "export AWS_SECRET_ACCESS_ID=#{@cloud.secret_access_key}"
+        ] << install_tasks
+      end
+      # Tasks with default configuration tasks
+      # This is run on the provisioner, regardless
+      def default_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 get_puppet_packages_for(os)
+        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(name)
+        self.class.installers[name.to_sym]
+      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
+
+      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 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