fairchild-poolparty 1.1.3

data/lib/poolparty/helpers/binary.rb

@@ -0,0 +1,67 @@
+require "ftools"
+module PoolParty
+  
+  # Load a file that contains a pool into memory
+  def load_pool(filename=nil)
+    filename = filename || Binary.get_existing_spec_location
+    dputs "Using spec at #{filename}"
+    
+    unless filename && ::File.readable?(filename)
+      puts "Please specify your cloud with -s, move it to ./clouds.rb or in your POOL_SPEC environment variable"
+      exit(1)
+    else
+      $pool_specfile = filename
+      PoolParty::Pool::Pool.load_from_file filename
+    end
+  end
+  
+  def print_with_nice_printer(header=nil, strs=[], &block)
+    printer = NicePrinter.new
+    printer.header
+    printer.center(header) if header
+    yield(printer)
+    strs.each {|st| printer << st if st}
+    printer.footer
+    printer.print
+  end
+  
+  def pool_specfile
+    $pool_specfile
+  end
+  
+  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
+      # These are the locations the spec file can be before the cloud
+      # aborts because it cannot load the cloud
+      def get_existing_spec_location
+        [          
+          Dir["#{Dir.pwd}/*/clouds.rb"],
+          "#{Default.remote_storage_path}/#{Default.default_specfile_name}", 
+          "#{Default.default_specfile_name}",            
+          "#{Default.base_config_directory}/#{Default.default_specfile_name}",
+          "#{Default.poolparty_home_path}/#{Default.default_specfile_name}",          
+          ENV["POOL_SPEC"]
+        ].flatten.reject {|a| a.nil?}.reject do |f|
+          f unless ::File.readable?(f)
+        end.first
+      end
+      # Daemonize the process
+      def daemonize(&block)
+        Daemonize.daemonize(&block)
+      end
+      
+    end
+    
+  end
+end

data/lib/poolparty/helpers/console.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + "/display"
+
+module PoolParty
+  module Console
+    
+    include Display
+    
+    # Print help commands for the console
+    # level 0 - Basic help
+    # level 1 - Commands
+    def help(level=0)
+      @np = NicePrinter.new(60)
+      @np.header
+      @np.center "PoolParty console help"      
+      @np.center "Basics"
+      @np << "Load your pool with load_pool(filename)"
+      @np << "Reference clouds with"
+      @np << "c = cloud :cloudname"
+      @np.empty
+      if level >= 1
+        @np.center "CloudSpeak"
+        @np << "All the commands set on your cloud can be called within the console"
+        @np << "list_of_running_instances - get list of running nodes"
+        @np << "list_of_pending_instances - get list of pending nodes"
+        @np << "available_monitors - get list of the available monitors on the cloud"
+        @np << "  note: all monitors can be called as a method on the cloud"
+        @np << "    i.e. CpuMonitor makes the method cpu available on the cloud"
+        @np.empty
+      end
+      @np.footer
+      @np.print
+    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!
+      require File.dirname(__FILE__) + "/../../../poolparty"
+      require File.dirname(__FILE__) + "/../../../poolpartycl"
+    end
+    
+  end
+end
+
+class Object
+  include PoolParty::Console
+end

data/lib/poolparty/helpers/display.rb

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

data/lib/poolparty/helpers/hash_printer.rb

@@ -0,0 +1,44 @@
+module PoolParty
+  class HashPrinter
+    def self.print_to_string(props={})
+<<-EOE
+Top Level
+  #{print_hash(props, 1)}
+EOE
+    end
+    def self.print_hash(props={}, tabs=0)
+      out = []
+      if props[:options]
+        out << props[:options].map {|k,v| "#{print_tabs(tabs)}#{k} => #{print_value(v)}"}.join("#{print_tabs(tabs)}\n")
+      end
+      if props[:resources]
+        props[:resources].each do |ty,r|
+          out << [
+            "#{print_tabs(tabs)}#{ty.to_s.capitalize}",
+            r.map {|h| h.map {|k,v| "#{print_tabs(tabs+1)}#{k} => #{print_value(v)}"}}.join("#{print_tabs(tabs+1)}\n")
+          ].join("\n")
+        end
+      end
+      if props[:services]
+        props[:services].each do |nm,s|
+          out << [
+            "#{print_tabs(tabs)}#{nm.to_s.capitalize}",
+            print_hash(s,tabs+1)
+          ].join("\n")
+        end
+      end
+      out.join("\n")
+    end
+    def self.print_tabs(tabs=1)
+      "#{"\t"*tabs}"
+    end
+    def self.print_value(v)
+      case v
+      when Array
+        "[#{v.join(", ")}]"
+      else
+        v
+      end
+    end
+  end
+end

data/lib/poolparty/helpers/loading.rb

@@ -0,0 +1,4 @@
+module PoolParty
+  module Loading
+  end
+end

data/lib/poolparty/helpers/nice_printer.rb

@@ -0,0 +1,36 @@
+class NicePrinter
+  
+  attr_accessor :num_lines
+  attr_reader :centered_lines
+  
+  def initialize(num_lines=60)
+    @num_lines = num_lines
+    @centered_lines = @num_lines - 4
+  end
+  
+  def center(line)
+    lines << "* #{line.center(@centered_lines)} *"
+  end
+  def left(line)
+    lines << "* #{line.ljust(@centered_lines)} *"
+  end
+  def header
+    lines << "*"*@num_lines
+  end
+  def footer
+    header
+  end
+  def empty
+    lines << "* #{" ".ljust(@centered_lines)} *"
+  end
+  def print
+    puts lines.join("\n")
+    ""
+  end
+  def <<(line)
+    left(line)
+  end
+  def lines
+    @lines ||= []
+  end
+end

data/lib/poolparty/helpers/optioner.rb

@@ -0,0 +1,149 @@
+require 'optparse' 
+require "poolparty"
+require "poolpartycl"
+# require 'rdoc/usage'
+require 'ostruct'
+require 'date'
+
+module PoolParty
+  class Optioner
+    include Dslify
+    
+    default_options(:verbose => false, 
+                     :quiet => false, 
+                     :cloudname => false, 
+                     :poolname => false)
+    
+    def initialize(args=[], opts={}, &block)      
+      boolean_args << opts[:boolean_args] if opts.has_key?(:boolean_args)
+      
+      @arguments = parse_args(args)
+      @extra_help = opts.has_key?(:extra_help) ? opts[:extra_help] : ""
+      @abstract = opts.has_key?(:abstract) ? opts[:abstract] : false
+      @load_pools = opts.has_key?(:load_pools) ? opts[:load_pools] : !@abstract
+      @parse_options = opts.has_key?(:parse_options) ? opts[:parse_options] : true
+      @command = opts.has_key?(:command) ? opts[:command] : false
+      
+      parse_options(&block) if @parse_options
+      self
+    end
+    def daemonizeable
+      @opts.on('-D', '--daemonize', 'Daemonize starting the cloud')    { self.daemon true }
+    end
+    def cloudnames
+      @opts.on('-n cloudname', '--name name', 'Start cloud by this name')    { |c| self.cloudname c }
+    end 
+    def unflagged_args
+      @unflagged_args ||= []
+    end
+    def flagged_args
+      @flagged_args ||= []
+    end
+    def boolean_args
+      @boolean_args ||= ['-V', '-h', '-t', '-v', '--debug']
+    end
+    
+    # Break ARGV into 2 arrays, one for flagged options one for unflagged
+    # For example the "command -v -i 1 five six -x"
+    # becomes ['-v', '-i', 1, '-x'] and ['five', 'six']
+    # Boolean options, such as -v, must be specified in the optioner definition
+    def parse_args(args=[])
+      i=0
+      while i < args.length
+        if boolean_args.include?(args[i])
+          flagged_args << args[i]
+        else
+          if args[i][0].chr == "-"
+            flagged_args << args[i]
+            flagged_args << args[i+1] if (args[i+1] and !args[i+1].nil?)
+            i+=1
+          else
+            unflagged_args << args[i]
+          end
+        end
+        i+=1
+      end
+      args
+    end
+    
+    # def parent
+    #   self
+    # end
+    
+    def parent
+      self
+    end
+    
+    def parse_options(&blk)
+      self.spec = nil
+      self.num = nil
+      
+      progname = $0.include?("-") ? "#{::File.basename($0[/(\w+)-/, 1])} #{::File.basename($0[/-(.*)/, 1])}" : ::File.basename($0)
+      @opts = OptionParser.new
+      @opts.extend(Dslify)
+      @opts.banner = "Usage: #{progname} #{@abstract ? "[command] " : ""}[options]"
+
+      @opts.separator ""
+      
+      unless @abstract
+        @opts.separator "Options:"
+        
+        @opts.on('-v', '--verbose', 'Be verbose') { self.verbose true }  
+        @opts.on('-d', "--debug", "Debug setting") { self.debugging true }
+        @opts.on('-s [file]', '--spec-file [file]', 'Set the spec file') { |file| self.spec file.chomp }
+        @opts.on('-t', '--test', 'Testing mode') { self.testing true }
+        
+        blk.call(@opts, self) if blk
+      end
+      
+      @opts.on('-V', '--version', 'Display the version')    { output_version ; exit 0 }
+      @opts.on_tail("-h", "--help", "Show this message") do
+        puts @opts
+        puts @extra_help
+        exit
+      end
+      
+      @opts.parse(@arguments.dup)
+      
+      process_options
+      output_options if verbose
+      
+      if @load_pools
+        self.loaded_pool load_pool( spec? ? spec : Binary.get_existing_spec_location)
+        self.loaded_clouds extract_cloud_from_options(self)
+        self.loaded_pools extract_pool_from_options(self)
+
+        reject_junk_options!
+        raise CloudNotFoundException.new("Please specify your cloud with -s, move it to ./clouds.rb or in your POOL_SPEC environment variable") unless loaded_clouds && !loaded_clouds.empty?
+        loaded_pools.each do |pl|
+          pl.options(self.options)
+        end
+        loaded_clouds.each do |cl|
+          cl.options(self.options)
+        end
+      end
+    end
+    
+    def reject_junk_options!
+      %w(loaded_pool cloudname extract_pool_from_options).each do |opt|
+        @dsl_options.delete(opt.to_sym)
+      end
+    end
+    
+    def process_options
+    end
+        
+    def output_version
+      puts ::PoolParty::Version
+    end
+    
+  end
+  
+  def extract_cloud_from_options(o)
+    o.cloudname ? [cloud(o.cloudname.downcase.to_sym)] : clouds.collect {|n,cl| cl}
+  end
+  
+  def extract_pool_from_options(o)
+    o.poolname ? [pool(o.poolname.downcase.to_sym)] : pools.collect {|n,pl| pl}
+  end
+end

data/lib/poolparty/helpers/ruberl.rb

@@ -0,0 +1,33 @@
+require "socket"
+module PoolParty
+  module Ruberl
+    class Base
+      attr_accessor :host, :port
+      def initialize(host="localhost", port=7050)
+        @host = host
+        @port = port
+      end
+      def with_socket(&block)
+        begin
+          socket = TCPSocket.open(@host, @port)
+          out = yield(socket)
+          socket.close
+          out
+        rescue Exception => e
+        end
+      end
+      def messenger_send!(msg="get_current_load cpu")
+        with_socket do |sock|
+          sock.send(msg, 0)
+          @str = sock.recv(2000)      
+        end
+        @str
+      end
+      def messenger_cast!(msg="force_reconfig")
+        with_socket do |sock|
+          sock.send(msg, 0)
+        end
+      end
+    end
+  end
+end

data/lib/poolparty/lite.rb

@@ -0,0 +1,20 @@
+require "rubygems"
+require "json"
+require("#{::File.dirname(__FILE__)}/../../vendor/gems/dslify/lib/dslify")
+require "#{::File.dirname(__FILE__)}/poolparty/default"
+require "#{::File.dirname(__FILE__)}/schema"
+require "#{::File.dirname(__FILE__)}/net/init"
+require "#{::File.dirname(__FILE__)}/exceptions/RemoteException.rb"
+
+module PoolParty
+  def self.load_cloud_from_json(json_file_path=nil)
+    json_file = json_file_path || PoolParty::Default.properties_hash_file
+    PoolParty::Schema.new( ::File.read(json_file) ) rescue exit 1
+  end
+end
+
+class String
+  def camelcase
+    gsub(/(^|_|-)(.)/) { $2.upcase }
+  end
+end

data/lib/poolparty/modules/cloud_dsl.rb

@@ -0,0 +1,20 @@
+module PoolParty
+  module CloudDsl
+        
+    def mount_ebs_volume_at(id="", loc="/data")
+      ebs_volume_id id
+      ebs_volume_mount_point loc
+      ebs_volume_device "/dev/#{id.sanitize}"
+            
+      has_mount(:name => loc, :device => ebs_volume_device)
+      has_directory(:name => loc)
+    end
+    
+    def dependency_resolver(name='puppet')
+      klass = name.preserved_class_constant("Resolver")
+      raise DependencyResolverException.new("Unknown resolver") unless klass
+      dsl_options[:dependency_resolver] = klass unless dsl_options[:dependency_resolver]
+    end
+    
+  end
+end

data/lib/poolparty/modules/cloud_resourcer.rb

@@ -0,0 +1,122 @@
+=begin rdoc
+  CloudResourcer provides the cloud with convenience methods
+  that you can call on your cloud. This is where the 
+  
+    instances 2..10
+    
+  method is stored, for instance. It's also where the key convenience methods are written
+=end
+require "ftools"
+
+module PoolParty
+  module CloudResourcer
+    
+    def plugin_directory(arr=[])
+      arr = [arr] if arr.is_a?(String)
+      arr << [
+        "#{::File.expand_path(Dir.pwd)}/plugins",
+        "#{::File.expand_path(Default.poolparty_home_path)}/plugins"
+      ]
+      arr.flatten.each {|arg|    
+        Dir["#{arg}/*/*.rb"].each {|f| require f } if ::File.directory?(arg)
+      }
+    end
+    
+    # Store block
+    def store_block(&block)
+      @stored_block ||= block ? block : nil
+    end
+    
+    def stored_block
+      @stored_block
+    end
+    
+    # This will run the blocks after they are stored if there is a block
+    # associated
+    def run_stored_block
+      self.run_in_context @stored_block if @stored_block
+    end
+    
+    # Set instances with a range or a number
+    def instances(arg)
+      case arg
+      when Range
+        minimum_instances arg.first
+        maximum_instances arg.last
+      when Fixnum
+        minimum_instances arg
+        maximum_instances arg
+      else
+        raise SpecException.new("Don't know how to handle instances cloud input #{arg}")
+      end
+    end
+    
+    def setup_dev
+      return true if keypair || master.nil?
+    end
+    
+    def using(t)
+      @cloud = self
+      if t && self.class.available_bases.include?(t.to_sym)
+        unless using_remoter?
+          self.class.send :attr_reader, :remote_base
+          self.class.send :attr_reader, :parent_cloud
+          klass_string = "#{t}".classify
+          klass = "::PoolParty::Remote::#{klass_string}".constantize
+          @remote_base = klass.send :new, self
+          options[:remote_base] = klass.to_s if respond_to?(:options)
+                    
+          remote_instance_klass = "::PoolParty::Remote::#{klass_string}RemoteInstance"
+          options[:remote_instance_base] = remote_instance_klass if respond_to?(:options)
+          
+          @parent_cloud = @cloud
+          instance_eval "def #{t};@remote_base;end;"
+        end
+      else
+        puts "Unknown remote base" 
+      end
+    end
+    
+    def using_remoter?
+      @remote_base
+    end
+    
+    # Keypairs
+    # Use the keypair path
+    def keypair(*args)
+      if args && !args.empty?
+        args.each {|arg| _keypairs.unshift Key.new(arg) }
+      else
+        _keypairs.select {|key| key.exists? }.first
+      end
+    end
+    
+    alias :set_keypairs :keypair
+    
+    def _keypairs
+      dsl_options[:keypairs] ||= [Key.new]
+    end
+    
+    def full_keypair_path      
+      @full_keypair_path ||= keypair.full_filepath
+    end
+    
+    # TODO: deprecate
+    def number_of_resources
+      arr = resources.map do |n, r|
+        r.size
+      end
+      resources.map {|n,r| r.size}.inject(0){|sum,i| sum+=i}
+    end
+    
+    def plugin_store
+      @plugin_store ||= []
+    end
+    
+    # TODO: deprecate
+    def realize_plugins!(force=false)
+      plugin_store.each {|plugin| puts "plugin: #{plugin}";plugin.realize!(force) if plugin }
+    end
+    
+  end
+end