poolparty 1.3.15 → 1.4.0

data/lib/mixins/askable.rb

@@ -1,163 +0,0 @@
-require "colors"
-module Askable
-  module ClassMethods
-    def ask(msg="", opts={}, &block)
-      begin
-        answer = Question.new(msg, STDIN).answer
-        
-        unless opts[:no_value]
-          if answer.nil? || answer == ""
-            colored_say("You must enter a value\nTry again\n")
-            ask(msg, &block)
-          end
-        end
-      rescue Exception => e
-        colored_say e.inspect
-        exit 0
-      end
-      answer
-    end
-
-    def ask_with_help(opts={}, &block)
-      help_str = opts[:help]
-      message = opts[:message]
-
-      colored_say("#{message} (h for help)")
-      o = ask("? ")
-      
-      if %w(h H).include?(o)
-        colored_say help_str
-        ask_with_help(opts, &block)
-      else
-        block.call(o) if block
-      end
-      o
-    end
-    
-    def colored_ask(str, o={})
-      ask(substitute_color_tags(str), o)
-    end
-  
-    def rescued_ask(m, r)
-      begin
-        t = colored_ask m
-      rescue Exception => e
-        say r
-      end
-    end
-    
-    def colored_say(str, o={})
-      out = substitute_color_tags(str)
-      o[:no_newline] ? print(out) : puts(out)
-    end
-    
-    def colored_print(str)
-      print substitute_color_tags(str)
-    end
-    
-    def choose(str, choices={}, opts={}, &block)
-      colored_say(str)
-      answer = ask(choices)
-      yield answer if block
-      answer
-    end
-    
-    def wait
-      begin        
-        STDIN.readline unless auto_install # -y passed
-      rescue Interrupt
-        exit 2
-      end
-  	end
-  	
-  	def substitute_color_tags(data)
-      Colors.process(data)
-    end
-    
-  end
-  
-  module InstanceMethods
-    def ask(msg, &block)
-      self.class.ask(msg, &block)
-    end
-
-    def ask_with_help(opts={}, &block); self.class.ask_with_help(opts, &block);end
-
-    def colored_ask(str, o)
-      self.class.colored_ask(str, o)
-    end
-
-    def colored_say(str, o={})
-      self.class.colored_say(str, o)
-    end
-
-    def colored_print(str)
-      self.class.colored_print(str)
-    end
-    
-    def choose(str, choices={}, opts={}, &block); self.class.choose(str, choices, opts, &block); end
-  end
-  
-  def self.included(receiver)
-    receiver.extend         ClassMethods
-    receiver.send :include, InstanceMethods
-  end
-  
-  class Question
-    attr_reader :answer
-    include Askable
-    
-    def initialize(question, input=STDIN, opts={})
-      @question = question
-      @input = input
-      
-      defaults = {
-        :wrap => 60
-      }
-      
-      @opts = defaults.merge(opts)
-      
-      ask
-    end
-    
-    private
-    
-    # get the answer, chomp it, etc.
-    def ask
-      case @question
-      when String
-        ask_string
-      when Hash
-        ask_hash
-      when Array
-        ask_array
-      end
-    end
-    
-    def ask_string
-      colored_say @question, :no_newline => true
-      @answer = @input.gets
-      answer.chomp!
-    end
-    
-    def ask_array
-      @question.each_with_index do |q, i|
-        colored_say "#{i+1}> #{q}"
-      end
-      colored_say "(number 1-#{@question.size})"
-      colored_say "? ", :no_newline => true
-      num = (@input.gets).to_i rescue colored_say("<red>Invalid input, must be a number between 1 and #{@question.size + 1}")
-      @answer = @question[num-1]
-    end
-    
-    def ask_hash
-      @question.sort.each do |k,v|
-        colored_say("#{k}) #{v}")
-      end
-      colored_print((@opts[:prompt] || "> "))
-      pick = @input.gets.to_i
-      @answer = @question[pick]
-    end
-    
-  end
-end

data/lib/mixins/callbacks.rb

@@ -1,56 +0,0 @@
-module Callbacks
-  module ClassMethods
-    def additional_callbacks(arr=[])
-      @additional_callbacks ||= arr
-    end
-    def callback_block(&block)
-      @callback_block ||= block
-    end
-  end
-  
-  module InstanceMethods
-    # Callbacks on bootstrap and configuration
-    # Defines the callback accessors:
-    #   call_before/after_bootstrap/configure_callbacks
-    # 
-    # When called, this method will first check to see if there 
-    # are plugins and call those plugin's callbacks when called
-    # The method (before/after_bootstrap/configure) is called
-    # on self if the callback method is defined on self
-    def callback(call_time, *args, &block)
-      on_all_callbacks(call_time, *args, &block)
-      callback_on_self(call_time, *args, &block)
-    end
-    
-    def callbacks
-      @callbacks ||= []
-    end
-    
-    def on_all_callbacks(call_time, *args, &block)
-      self.class.callback_block.call(self, call_time) if self.class.callback_block
-    end
-    
-    private
-    
-    # TODO: Add docs
-    def callback_on_self(call_time, *args, &block)
-      if respond_to?(call_time)
-        callbacks << call_time.to_sym
-        case self.method(call_time).arity
-        when 0
-          self.send(call_time)
-        when 1
-          self.send(call_time, *args)
-        else
-          self.send(call_time, *args, &block)
-        end
-      end
-    end
-    
-  end
-  
-  def self.included(receiver)
-    receiver.extend         ClassMethods
-    receiver.send :include, InstanceMethods
-  end
-end

data/lib/mixins/delayed.rb

@@ -1,65 +0,0 @@
-=begin rdoc
-  Allow delayed actions to be describe and run only after
-  the initialize block has completed.
-  
-  Usage:
-    class Test
-      include Delayed
-      
-      def initialize(&block)
-        instance_eval &block if block
-        loaded = true
-        
-        run_after_loaded do |b|
-          instance_eval &b if b
-        end
-        
-      end
-    end
-=end
-
-class DelayedProc < Proc
-  def initialize(proxy, &block)
-    @proxy = proxy
-    @proc = block
-  end
-  def result
-    @result ||= @proc.call
-  end
-  def method_missing(m,*a,&block)
-    result.send(m,*a,&block)
-  end
-end
-module Delayed
-  module ClassMethods
-    def delayed_calls
-      @delayed_calls ||= {}
-    end
-  end
-  
-  module InstanceMethods
-    def loaded
-      @loaded ||= false
-    end
-    def loaded!
-      @loaded = true
-    end
-    def run_after_loaded(&block)
-      self.class.delayed_calls.each do |k,b|
-        self.class.delayed_calls[block.object_id] ||= b.result(&block) if b && b.is_a?(Proc)
-      end
-    end
-    def delayed_action(&block)
-      if loaded
-        self.class.delayed_calls[block.object_id] ||= block.call
-      else
-        self.class.delayed_calls[block.object_id] = DelayedProc.new(self, &block) if block
-      end
-    end
-  end
-  
-  def self.included(receiver)
-    receiver.extend         ClassMethods
-    receiver.send :include, InstanceMethods
-  end
-end

data/lib/mixins/pinger.rb

@@ -1,31 +0,0 @@
-module PoolParty
-  module Pinger
-    module ClassMethods
-      # Test to see if the host has the available port open
-      # for response. 
-      def ping_port(host, port=22, retry_times=400)
-        connected = false
-        retry_times.times do |i|
-          begin
-            break if connected = TCPSocket.new(host, port).is_a?(TCPSocket)
-          rescue Exception => e
-            sleep(2)
-          end
-        end
-        connected
-      end
-    end
-  
-    module InstanceMethods
-      def ping_port(ip, port=22, retry_times=500);self.class.ping_port(ip, port, retry_times);end
-      def ping_port_and(ip, port=22, retry_times=500, &block)        
-        block.call if ping_port(ip, port, retry_times) && block
-      end
-    end
-  
-    def self.included(receiver)
-      receiver.extend         ClassMethods
-      receiver.send :include, InstanceMethods
-    end
-  end
-end

data/lib/mixins/printing.rb

@@ -1,35 +0,0 @@
-=begin rdoc
-  Binaries helper moduel
-=end
-module Printing
-  # print_msg
-  # Params
-  #   msg_array - Array of strings
-  # Usage:
-  #   msg = ["hello", "world"]
-  #   print_msg(msg)
-  def print_msg(msg_array)
-    arr = msg_array.map {|line| Colors.process(line) }
-    max_size = arr.sort {|a,b| a.size <=> b.size }.last.size
-    arr.each do |line|
-      puts line.ljust(max_size)
-    end
-    Colors.reset!
-  end
-  
-  # Ask for response
-  def are_you_sure?(msg)
-    puts msg
-    resp = STDIN.gets.chomp
-
-    case resp
-    when "Y"
-    when "yes"
-    when "y"
-      return true
-    else
-      return false
-    end
-  end
-  
-end

data/lib/mixins/searchable_paths.rb

@@ -1,87 +0,0 @@
-=begin rdoc
-  Abstracts out the searchable path for a resource such as a
-  template file, key, or clouds.rb
-  
-  NOTE: this is currently _only_ implemented on templates
-  (PoolParty::Resources::File) and not yet working on clouds.rb or key files.
-  These will eventually be refactored to use this class.
-=end
-
-module SearchablePaths
-  def self.included(mod)
-    mod.extend(ClassMethods)
-  end
-
-  module ClassMethods
-    # Specify that a particular class has methods for searchable paths.
-    # 
-    # Options:
-    # * <tt>:dirs</tt>: array of directories to look in *under* the search paths. (default: <tt>["/"]</tt>)
-    # * <tt>:dir</tt>: set the directory to look in *under* the search paths. Use either dir or dirs, not both. (default: +/+)
-    # * <tt>:paths</tt>: overwrite all default paths and set the paths to this array exactly
-    # * <tt>:append_paths</tt>:  append these paths to any existing paths
-    # * <tt>:prepend_paths</tt>: prepend these paths to any existing paths
-    def has_searchable_paths(opts={})
-      class_eval do
-        @searchable_paths_dirs = [opts[:dir]] if opts[:dir]
-        @searchable_paths_dirs = opts[:dirs]  if opts[:dirs]
-        @paths_override        = opts[:paths] if opts[:paths]
-        @paths_prepend         = opts[:prepend_paths] || []
-        @paths_append          = opts[:append_paths]  || []
-      end
-      extend SearchablePaths::SingletonMethods
-      include SearchablePaths::InstanceMethods
-    end
-    
-    def searchable_paths_dir;  @searchable_paths_dirs.first; end
-    def searchable_paths_dirs
-      @searchable_paths_dirs && @searchable_paths_dirs.size > 0 ? @searchable_paths_dirs : ["/"]
-    end
-   
-    # These are the default search paths in order:
-    # 
-    # * current working directory (Dir.pwd)
-    def default_paths
-      [
-        Dir.pwd
-      ]
-    end
-
-    # returns the full set of valid searchable paths, given the options
-    def searchable_paths
-      return @paths_override if @paths_override && @paths_override.size > 0
-      @searchable_paths ||= @paths_prepend + default_paths + @paths_append
-    end
-  end
-
-  module SingletonMethods
-  end
-
-  module InstanceMethods
-
-    # Searches for +filepath+ in the <tt>searchable_paths</tt> iff +filepath+
-    # doesn't exist. e.g. +filepath+ is interpreted *first* as an absolute
-    # path, if +filepath+ doesn't exist verbatim then it looks for the file
-    # in the searchable_paths.
-    # 
-    # Returns +nil+ if the file cannot be found.
-    def search_in_known_locations(filepath, additional_search_paths=[])
-      return filepath if File.exists?(filepath) # return the file if its an absolute path
-      additional_search_paths.each do |path|
-        full_path = File.expand_path(path / filepath)
-        return full_path if File.exists?(full_path)
-      end
-      self.class.searchable_paths.each do |path|
-        self.class.searchable_paths_dirs.each do |dir|
-          next if path.nil?
-          full_path = File.expand_path(path / dir / filepath)
-          return full_path if File.exists?(full_path)
-        end
-      end
-      nil
-    end
-    alias_method :find_file, :search_in_known_locations
-
-  end
-
-end

data/lib/poolparty/default.rb

@@ -1,33 +0,0 @@
-=begin rdoc
-  Default class
-  
-  Hangs on and defines defaults for PoolParty
-=end
-
-module PoolParty
-  class Default
-    include Dslify
-    
-    default_options(
-      :user => "root",
-      :os => :ubuntu,
-      :ssh_port => 22,
-      :tmp_path => "/tmp/poolparty",
-      :poolparty_home_path => "#{ENV["HOME"]}/.poolparty",
-      :ec2_home => "#{ENV["HOME"]}/.ec2",
-      :poolparty_src_path => File.expand_path("#{::File.dirname(__FILE__)}/../../"),
-      :base_config_directory => "/etc/poolparty",
-      :remote_storage_path => "/var/poolparty",
-      :poolparty_log_path => "#{File.dirname(__FILE__)}/log/poolparty.log",
-      :verbose        => false,
-      :debug          => false,
-      :very_debugging => false
-    )
-        
-    # Method missing
-    def self.method_missing(m,*a,&block)
-      dsl_options.include?(m) ? dsl_options[m] : super
-    end
-    
-  end
-end

data/lib/poolparty/dsl_base.rb

@@ -1,36 +0,0 @@
-=begin rdoc
-  Dsl Base class for all cloud dsl methods
-  
-  Pool and Cloud both are taken from the DslBase so that both
-  carry the same dsl. The methods that apply to either/or
-  are defined in the respective classes
-=end
-
-module PoolParty
-  class DslBase < Base
-    
-    default_options(
-      :minimum_instances        => 2,
-      :maximum_instances        => 5
-    )
-            
-    # Set instances with a range or a number
-    # if passed with a hash, call nodes(hash) to return filtered list of 
-    # instances
-    def instances(arg)
-      case arg
-      when Range
-        minimum_instances arg.first
-        maximum_instances arg.last
-      when Fixnum
-        minimum_instances arg
-        maximum_instances arg
-      when Hash
-        nodes(arg)
-      else
-        raise PoolParty::PoolPartyError.create("DslMethodCall", "You must call instances with either a number, a range or a hash (for a list of nodes)")
-      end
-    end
-    
-  end
-end

data/lib/poolparty/installer.rb

@@ -1,111 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.dirname(__FILE__) + "/poolparty")
-
-require "poolparty"
-
-module PoolParty
-  class Installer
-
-    include PoolParty::Pinger
-    include Askable
-        
-    def run
-      begin
-        self.__send__ :welcome_message
-        steps.each {|c| self.__send__ c.to_sym }
-        self.__send__ :closing_message
-      rescue Exception => e
-        colored_say e.inspect
-        colored_say exit_msg
-      ensure
-        Colors.reset!
-      end
-    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 <blue>breeze</blue>
-      EOE
-
-        @exit_msg = <<-EOE
-
-<line>
-<yellow>Cancelled PoolParty installation</yellow>
-
-You can always restart this by typing:
-<blue>cloud setup</blue>
-
-<line>
-EOE
-
-
-      colored_say "<yellow>Welcome to PoolParty!</yellow>"
-      colored_say welcome_msg
-      colored_ask "Press enter to continue or Ctrl+C to exit", :no_value => true
-      
-    end
-    
-    def closing_message
-closing_message = <<-EOE
-
-<line>
-You are now set to <blue>ride the waves</blue> with PoolParty! You'll notice there is a <blue>clouds.rb</blue> file in your current directory. 
-
-You can start your new cloud by typing in this directory:
-
-<blue>cloud start [-v]</blue>
-
-You can start your clouds.rb. More samples are available here: 
-<yellow>http://github.com/auser/poolparty-examples/tree/master</yellow>
-
-<line>
-EOE
-      colored_say closing_message
-    end
-    
-    def exit_msg
-      @exit_msg || <<-EOE
-<red>--- quiting ---</red>
-You can always restart the installer by typing #{$0}. 
-
-If you need help, feel free to stop by the irc room:
-irc.freenode.net / #poolpartyrb
-      EOE
-    end
-    
-    
-    def steps
-      @steps ||= []
-    end
-    
-    def self.name
-    end
-    
-    def self.description
-    end
-    
-    def self.to_s
-      "#{name} - #{description}"
-    end
-    
-    def self.inherited(subclass)
-      all << subclass
-    end
-    
-    def self.all
-      @all ||= []
-    end
-    
-    def self.find_by_name(nm)
-      all.detect do |i|
-        i.name =~ /#{nm}/i
-      end
-    end
-  end
-end
-
-%w(vmware ec2).each do |lib|
-  require "installers/#{lib}"
-end

data/lib/poolparty/installers/ec2.rb

@@ -1,88 +0,0 @@
-module PoolParty
-  module Installers
-    class Ec2 < Installer
-      
-      def steps
-        [
-          :ask_for_ec2_directory, :ask_for_access_key, :ask_for_private_access_key,
-          :show_env_setup
-        ]
-      end
-      
-      def self.name
-        "Ec2"
-      end
-      
-      def self.description
-        "Ec2 installer"
-      end
-            
-      def ask_for_access_key
-        access_key_help =<<-EOV
-EC2 uses an access key to identify you and allows you to start and stop instances.
-        EOV
-
-        access_key = <<-EOE
-What is your access key?
-        EOE
-        ask_with_help :message => access_key, :help => access_key_help do |k|
-          @access_key = k
-        end
-      end
-      
-      def ask_for_private_access_key
-        private_access_key_help =<<-EOV
-EC2 uses a private access key to identify you and allows you to start and stop instances.
-        EOV
-
-        private_access_key = <<-EOE
-What is your private access key?
-        EOE
-        ask_with_help :message => private_access_key, :help => private_access_key_help do |k|
-          @secret_access_key = k
-        end
-      end
-      
-      
-      def ask_for_ec2_directory
-        ec2_directory_help =<<-EOV
-Ec2 needs to know where you store your certificates and private keys. Amazon expects these to be in the ~/.ec2 directory. We suggest a subdirectory of the ~/.ec2 directory so you can separate ec2 accounts. 
-        EOV
-
-        ec2_directory_msg = <<-EOE
-What's path to your ec2 directory with your cert and pk files?
-        EOE
-        ask_with_help :message => ec2_directory_msg, :help => ec2_directory_help
-      end
-
-      
-      def show_env_setup
-        colored_say <<-EOE
-<line>
-  
-  Setup your environment:
-  
-  export EC2_ACCESS_KEY=#{@access_key}
-  export EC2_SECRET_KEY=#{@secret_access_key}
-
-  export EC2_PRIVATE_KEY=$(ls #{@ec2_directory}/pk-*.pem)
-  export EC2_CERT=$(ls #{@ec2_directory}/cert-*.pem)
-  
-<line>
-        EOE
-        exit 0
-      end
-      
-      private
-      
-      def default_ec2_directories
-        @default_ec2_directories ||= find_default_ec2_directories rescue nil
-      end
-      
-      def find_default_ec2_directories
-        Dir["#{::File.expand_path("~")}/.ec2/*"].reject {|f| File.file?(f) }
-      end
-      
-    end
-  end
-end