auser-poolparty 1.2.12 → 1.3.0

data/lib/poolparty/extra/duration.rb

@@ -1,96 +0,0 @@
-module PoolParty
-  # Provides accurate date and time measurements using Date#advance and 
-  # Time#advance, respectively. It mainly supports the methods on Numeric,
-  # such as in this example:
-  #
-  #   1.month.ago       # equivalent to Time.now.advance(:months => -1)
-  class Duration
-    attr_accessor :value, :parts
-
-    def initialize(value, parts) #:nodoc:
-      @value, @parts = value, parts
-    end
-
-    # Adds another Duration or a Numeric to this Duration. Numeric values
-    # are treated as seconds.
-    def +(other)
-      if Duration === other
-        Duration.new(value + other.value, @parts + other.parts)
-      else
-        Duration.new(value + other, @parts + [[:seconds, other]])
-      end
-    end
-
-    # Subtracts another Duration or a Numeric from this Duration. Numeric
-    # values are treated as seconds.
-    def -(other)
-      self + (-other)
-    end
-
-    def -@ #:nodoc:
-      Duration.new(-value, parts.map { |type,number| [type, -number] })
-    end
-
-    def is_a?(klass) #:nodoc:
-      klass == Duration || super
-    end
-
-    # Returns true if <tt>other</tt> is also a Duration instance with the
-    # same <tt>value</tt>, or if <tt>other == value</tt>.
-    def ==(other)
-      if Duration === other
-        other.value == value
-      else
-        other == value
-      end
-    end
-
-    def self.===(other) #:nodoc:
-      other.is_a?(Duration) rescue super
-    end
-
-    # Calculates a new Time or Date that is as far in the future
-    # as this Duration represents.
-    def since(time = ::Time.current)
-      sum(1, time)
-    end
-    alias :from_now :since
-
-    # Calculates a new Time or Date that is as far in the past
-    # as this Duration represents.
-    def ago(time = ::Time.current)
-      sum(-1, time)
-    end
-    alias :until :ago
-
-    def inspect #:nodoc:
-      consolidated = parts.inject(::Hash.new(0)) { |h,part| h[part.first] += part.last; h }
-      [:years, :months, :days, :minutes, :seconds].map do |length|
-        n = consolidated[length]
-        "#{n} #{n == 1 ? length.to_s.singularize : length.to_s}" if n.nonzero?
-      end.compact.to_sentence
-    end
-
-    protected
-
-      def sum(sign, time = ::Time.current) #:nodoc:
-        parts.inject(time) do |t,(type,number)|
-          if t.acts_like?(:time) || t.acts_like?(:date)
-            if type == :seconds
-              t.since(sign * number)
-            else
-              t.advance(type => sign * number)
-            end
-          else
-            raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
-          end
-        end
-      end
-
-    private
-
-      def method_missing(method, *args, &block) #:nodoc:
-        value.send(method, *args)
-      end
-  end
-end

data/lib/poolparty/helpers/binary.rb

@@ -1,70 +0,0 @@
-require "fileutils"
-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
-  
-  # Helper to print with the nice printer
-  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
-  
-  # Keep the pool_specfile 
-  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.pwd}/#{Default.default_specfile_name}",
-          Dir["#{Dir.pwd}/*/#{Default.default_specfile_name}"],
-          "#{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

@@ -1,43 +0,0 @@
-module PoolParty
-  module Console
-    # 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 << "instances_by_status('running') - 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/hash_printer.rb

@@ -1,44 +0,0 @@
-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

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

data/lib/poolparty/helpers/nice_printer.rb

@@ -1,36 +0,0 @@
-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

@@ -1,161 +0,0 @@
-require 'optparse' 
-require "poolparty"
-require "poolpartycl"
-# require 'rdoc/usage'
-require 'ostruct'
-require 'date'
-
-module PoolParty
-  class Optioner
-    include Dslify
-    
-    attr_accessor :loaded_pool, :loaded_clouds, :loaded_pools
-    
-    dsl_methods :spec,
-                :num,
-                :cloudname,
-                :poolname
-                
-    default_options( :verbose => false, 
-                     :quiet => 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? && verbose
-      
-      if @load_pools
-        @loaded_pool = load_pool( spec ? spec : Binary.get_existing_spec_location)
-        @loaded_clouds = extract_cloud_from_options(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.dsl_options.merge!(self.dsl_options)
-        end
-        loaded_clouds.each do |cl|
-          cl.dsl_options.merge!(self.dsl_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_options
-      puts ""
-    end
-        
-    def output_version
-      puts ::PoolParty::Version
-    end
-    
-    def output_options      
-    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

@@ -1,33 +0,0 @@
-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/installers/base_installer.rb

@@ -1,113 +0,0 @@
-module PoolParty
-  module Installers
-    class BaseInstaller
-
-      include ::PoolParty::Remote
-      include ::PoolParty::Pinger
-      
-      def initialize
-        self.__send__ :welcome_message
-        commands.each {|c| self.__send__ c.to_sym }
-        self.__send__ :closing_message
-      end
-      
-      def welcome_message
-        welcome_msg = <<-EOE
-We are going to take you through the installation process of PoolParty.
-
-First, we'll setup your environment so using PoolParty will be a breeze
-        EOE
-                
-        colored_say "Welcome to PoolParty!", :help
-        say welcome_msg
-        begin
-          t = colored_ask "Press enter to continue or Ctrl+C to exit"
-        rescue Exception => e
-          say <<-EOE
-
-Cancelled PoolParty installation
-
-You can always restart this by typing:
-  install-poolparty
-EOE
-          exit 0
-        end
-        
-      end
-      
-      def closing_message
-closing_message = <<-EOE
-You are now set to ride the waves with PoolParty! You'll notice there is a clouds.rb file in your current directory. You can start your new cloud
-by typing:
-
-cloud start
-
-You can start your clouds.rb. More samples are available here: 
-  http://github.com/auser/poolparty-examples/tree/master
-EOE
-        say closing_message
-      end
-      
-      def commands
-        @commands ||= []
-      end
-      
-      protected
-      
-      def ask_with_help(opts={}, &block)
-        help_str = opts[:help]
-        message = opts[:message]
-
-        o = ask("#{message} (h for help)") do |q|    
-          q.validate = opts[:validate] if opts.has_key?(:validate)
-        end
-
-        if %w(h H).include?(o)
-          colored_say help_str, :help
-          ask_with_help(opts, &block)
-        else
-          block.call(o)
-        end
-        o
-      end
-
-      def rescued_ask(m, r)
-        begin
-          t = colored_ask m
-        rescue Exception => e
-          say r
-        end
-      end
-
-      def colored_ask(str, color = :notice)
-        setup_colors
-        ask("<%= color(\"#{str}\", :#{color}) %>")
-      end
-
-      def colored_say(str, color = :headline)
-        setup_colors
-        say("<%= color(\"#{str}\", :#{color}) %>") 
-      end
-
-      def setup_colors
-          unless @setup_colors
-          ft = HighLine::ColorScheme.new do |cs|
-            cs[:headline]         = [ :bold, :yellow, :on_black ]
-            cs[:horizontal_line]  = [ :bold, :white, :on_blue]
-            cs[:critical]         = [ :yellow, :on_red  ]
-            cs[:error]            = [ :bold, :red  ]
-            cs[:help]             = [ :bold, :white, :on_blue]
-            cs[:notice]           = [ :blue, :on_white]
-          end
-
-          HighLine.color_scheme = ft
-          @setup_colors = true
-        end
-      end
-      
-
-    end
-  end
-end
-
-Dir["#{::File.dirname(__FILE__)}/*.rb"].each {|lib| require lib }