poolparty 1.3.15 → 1.4.0

data/lib/cloud_providers/ssh/ssh_instance.rb

@@ -1,41 +0,0 @@
-module CloudProviders
-  
-  class SshInstance < CloudProviderInstance
-      
-      default_options(
-        :user     => 'root',
-        :status   => 'running',
-        :hostname => nil,
-        :cloud    => nil
-      )
-      
-      def instance_id
-        self.name
-      end
-      
-      def initialize(opts={}, &block)
-        @host = opts[:name] || name || dns_name
-        super
-      end
-      
-      def cloud_provider(o={}, &block)
-        @cloud_provider ||= if cloud
-          cloud.cloud_provider
-        else
-          options_for_cloud_provider = o.choose{|k,v| Ssh.default_options.has_key?(k)}
-          Ssh.new( options_for_cloud_provider, &block)
-        end
-      end
-      
-      def refresh!
-        run 'uptime'
-        name(run('hostname'))
-        dns_name(name)
-        status('running') if name
-        # :internal_ip  => nil, # TODO
-        # :public_ip    => nil, #TODO
-        self
-      end
-    
-    end
-end

data/lib/cloud_providers/vmware/vmware.rb

@@ -1,130 +0,0 @@
-=begin rdoc
-  The Vmrun remote base uses the vmrun command to implement a cloud remoter base.
-  The Vmrun remoter base has been tested with Vmware fusion on the mac.
-  
-  In order to use the Vmrun remoter base you will need to setup a few things.
-  First, you will need to have the Vmware fusion installed and vmrun command in your path.
-  The default location of the vmrun binary is /Library/Application Support/VMware Fusion/vmrun.
-  You will then of course need a virtual machine installed and available.  
-  Once you have your instance installed and running, you need to setup your ssh keys so that poolparty can ssh into the instance. Get the ip of you instnace with ifconfig inside the running instance.
-  For example:
-    
-    ssh root@172.0.1.129 "mkdir /root/.ssh && chmod 600 /root/.ssh"
-    scp my_key.pub root@172.0.1.129:/root/.ssh/authorized_keys
-    
-  provide a using :vmrun block in your clouds.rb
-  for example:
-    
-    using :vmrun do
-      vmx_hash(::File.expand_path("~/Documents/Virtual\ Machines.localized/Ubuntu-jaunty.vmwarevm/Ubuntu-jaunty.vmx") => '172.16.68.129')
-    end
-   
-   The vmx file fulfills a similar purpose as the ami id in ec2. Note that expand path.  vmrun return fuill paths, so we must provide full paths so things match up later. W
-   Vmrun does not provide a meta server like ec2 has, so you need to list the ip address of your VM.  For this reason it is recommended that you use NAT addressing on your VM to maintain consistent addressing across different physical networks.
-  
-  Also, note that vmrun does not copy the VM to a new distinct VM on each run, so if you want to be able to start from a known state, you should make a snapshot before using your vm with poolparty.  Then, you can rollback to this initial state if you want to ensure you can repeat a fresh cloud-start.
-
-=end
-require "open3"
-
-require "#{File.dirname(__FILE__)}/vmware_instance"
-
-module CloudProviders
-  class Vmware < CloudProvider
-    include SearchablePaths
-    
-    has_searchable_paths(:paths => [
-      File.expand_path("/Library/Application Support/VMware Fusion"),
-      File.expand_path("#{ENV["HOME"]}/Library/Application Support/VMware Fusion"),
-      "/usr/bin"
-    ])
-    
-    default_options(
-      :image_id             => nil,
-      :public_ip            => nil,
-      :default_cli_options  => 'gui',
-      :terminate_options    => 'soft',
-      :keypair_name         => nil,
-      :images_repo_path     => ::File.expand_path("#{ENV["HOME"]}/Documents/Virtual_Machines.localized/")
-      )
-    
-    attr_reader :cloud
-    
-    def initialize(o={}, &block)
-      @cloud = o.delete(:cloud)
-      super
-    end
-    
-    # Start a new instance with the given options
-    def run_instance(o={})
-      vmrun("start #{vmx_file}")
-      vmware_instance
-    end
-    
-    # Will select the first instance matching the provided criteria hash
-    def describe_instance(hash_of_criteria_to_select_instance_against)
-      describe_instances.first
-    end
-    
-    # Describe instances
-    def describe_instances(o={})
-      output = vmrun("list")
-      if output.first =~ /Total running VMs: 0/
-        []
-      else
-        output.shift if output.first =~ /Total running/
-        output.map do |line|
-          vmware_instance(:vmx_file => line)
-        end
-      end
-    end
-    
-    # Terminate an instance (or instances) by passing :instance_id and :instance_ids
-    def terminate_instance!(o={})
-      set_vars_from_options o
-      vmrun("stop #{vmx_file}")
-      describe_instances
-    end
-    
-    # The nodes in the cloud_provider
-    def nodes(hsh={})
-      describe_instances
-    end
-    
-    # Basic vmware_instance
-    def vmware_instance(o={})
-      VmwareInstance.new( :instance_id => (o[:vmx_file] || vmx_file), :public_ip => public_ip, :dns_name => public_ip,
-                          :cloud_provider => self.dsl_options, :keypair_name => keypair.basename)
-    end
-    
-    # Search for the vmrun binary
-    def path_to_binary
-      @path_to_binary ||= search_in_known_locations("vmrun")
-    end
-    
-    # Run vmrun on the command-line
-    def vmrun(cmd, o={})
-      stdin, stdout, stderr = Open3.popen3("'#{path_to_binary}' #{cmd}")
-      unless $?.success?
-        $stderr.puts "FAILED: #{cmd}\n code = #{$?}"
-        raise StandardError.new("ERROR: vmrun") if o.delete(:raise_on_error)
-      end
-      stdout.readlines
-    end
-        
-    # Search for the vmx_file
-    def vmx_file
-      return @vmx_file if @vmx_file
-      o = if File.file?(f = File.expand_path(image_id))
-        f
-      elsif File.file?(f = File.expand_path(images_repo_path, image_id))
-        f
-      end
-      @vmx_file = "'#{o}'"
-    end
-
-    def before_compile(args); end
-    def after_compile(args); end
-    
-  end
-end

data/lib/cloud_providers/vmware/vmware_instance.rb

@@ -1,56 +0,0 @@
-require "#{::File.dirname(__FILE__)}/vmware"
-
-module CloudProviders
-
-  class VmwareInstance < CloudProviderInstance
-    
-    default_options(
-      :launching_time   => nil,
-      :vmx_file         => nil,
-      :instance_id      => nil,
-      :public_ip        => nil,
-      :status           => "running",
-      :dns_name         => nil
-    )
-    
-    # A new instance will be created from a hash.
-    # The parent clouds describe_instances list will be searched for the first one matching any of this instance's provided unique identifiers.
-    # If an instance is found, this instance's properties will be set to the properties provided
-    # If the found instance has properties of the same key as the provided options, the found instance's values will override the passed in options
-    def initialize(opts={}, &block)
-      set_vars_from_options(opts)
-      super
-    end
-    
-    # Printing. This is how we extract the instances into the listing on the 
-    # local side into the local listing file
-    def to_s
-      "#{name}\t#{dns_name}\t#{instance_id}"
-    end
-    
-    def status
-      "running"
-    end
-    
-    # Since we aren't actually getting any ips from a list, only using 
-    # the one vmx file, we don't actually need to refresh anything
-    def wait_for_public_ip(timeout=60)
-      public_ip      
-    end
-    
-    def refresh!
-      self
-    end
-    
-    def cloud_provider(o={}, &block)
-      @cloud_provider ||= if cloud
-        cloud.cloud_provider
-      else        
-        options_for_cloud_provider = o.choose{|k,v| Vmware.default_options.has_key?(k)}
-        Vmware.new( options_for_cloud_provider, &block)
-      end
-    end
-    
-  end
-
-end

data/lib/core/file.rb

@@ -1,12 +0,0 @@
-class File
-  class << self
-    alias_method :old_symlink, :symlink
-    def symlink(old_name, new_name)
-      begin
-        old_symlink(old_name, new_name)
-      rescue Errno::EEXIST
-        $stderr.puts "warning: symlinking #{old_name} -> #{new_name}. Already exists"
-      end
-    end
-  end
-end

data/lib/core/integer.rb

@@ -1,11 +0,0 @@
-class Integer
-  def months
-    self * 30.days
-  end
-  alias :month :months
-
-  def years
-    self * 365.25.days
-  end
-  alias :year :years
-end

data/lib/core/module.rb

@@ -1,14 +0,0 @@
-class Module
-  
-  # Default accessors
-  # Provides an accessor with a default class
-  # Usage:
-  #   default_attr_reader :a, ["b"]
-  def default_attr_reader(sym, default)
-    define_method :"#{sym}_default" do
-      default
-    end
-    module_eval "def #{sym};@#{sym} ||= #{sym}_default;end"
-  end
-  
-end

data/lib/core/proc.rb

@@ -1,55 +0,0 @@
-class Proc
-  
-  # Get the code, based on the inspect's filename and line number start
-  def code(filename=source_file)
-    return @code if @code
-    current_block_count = 1
-    line_count = 0
-    
-    source(filename).each do |line|
-      if line =~ /do(\W*?)$/
-        current_block_count+=1
-      elsif line =~ /end$/
-        current_block_count-=1
-        if current_block_count == 0
-          return @code = source(filename)[0..(line_count-1)].join("\n")
-        end        
-      end
-      line_count+=1
-    end    
-  end
-  
-  # Source
-  def source(filename = source_file, start_line = source_line_number)
-    @source ||= if File.exist?(filename)
-      begin
-        open(filename).read.split("\n")[start_line .. -1]
-      rescue
-        nil
-      end
-    else
-      raise StandardError.new("Cannot find the source file for #{self.inspect}")
-    end
-  end
-  
-  # Grab the location of the proc by filename
-  def source_file
-    @source_file ||= proc_info[0]
-  end
-  
-  # Grab the line number in the source_file
-  def source_line_number
-    @source_line_number ||= proc_info[1]
-  end
-  
-  # Grab the source location from the inspect method
-  def proc_info
-    return @proc_info if @proc_info
-    if md = /^#<Proc:0x[0-9A-Fa-f]+@(.+):(\d+)>$/.match(inspect)
-      filename, line = md.captures
-      @proc_info = File.expand_path(filename), line.to_i
-    end
-    @proc_info
-  end
-  
-end

data/lib/core/time.rb

@@ -1,62 +0,0 @@
-=begin rdoc
-  Based off the rails Numeric class.
-  Gives us the ability to use nice phrases such as
-  30.seconds, 5.days, etc.
-=end
-class Numeric
-  def ago(time = Time.now)
-    time - self
-  end
-  alias :until :ago
-
-  def since(time = Time.now)
-    time + self
-  end
-  alias :from_now :since
-  
-  def seconds
-    self
-  end
-  alias :second :seconds
-
-  def minutes
-    self * 60
-  end
-  alias :minute :minutes  
-
-  def hours
-    self * 60.minutes
-  end
-  alias :hour :hours
-
-  def days
-    self * 24.hours
-  end
-  alias :day :days
-
-  def weeks
-    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
-
-class Time
-  def to_time
-    self
-  end
-end

data/lib/dependency_resolver.rb

@@ -1,11 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-module DependencyResolvers
-  def self.all
-    @all ||= []
-  end
-end
-
-%w(proxy_object base chef).each do |lib|
-  require "dependency_resolvers/#{lib}"
-end

data/lib/dependency_resolvers/base.rb

@@ -1,115 +0,0 @@
-=begin rdoc
-  Base dependency_resolver
-=end
-module DependencyResolvers
-  
-  class Base
-    
-    def self.inherited(subclass)
-      DependencyResolvers.all << subclass unless DependencyResolvers.all.include?(subclass)
-    end
-    
-    def self.compile_to(resources=[], outdir=Dir.pwd, caller=nil)
-      @compile_directory = outdir
-      @caller = caller
-      compile(resources)
-    end
-    
-    def self.caller
-      @caller
-    end
-    
-    def self.compile(resources=[])
-      before_compile
-      o = case resources
-      when PoolParty::Cloud
-        compile(resources.ordered_resources)
-      when Array
-        compile_array(resources)
-      when PoolParty::Resource
-        compile_resource(resources)
-      end
-      after_compile(o)
-      o
-    end
-    
-    # CALLBACKS
-    # Called before anything is compiled
-    def self.before_compile
-    end
-    # Called after everything is compiled
-    def self.after_compile(o)
-    end
-    
-    # The name of the method that the resource
-    # should respond to to compile
-    # Format:
-    #   print_to_<dependency_resolver.name>
-    def self.compile_method_name
-      @compile_method_name ||= "print_to_#{name.to_s.top_level_class}".to_sym
-    end
-    
-    private
-    
-    # Compile a resource directly
-    def self.compile_resource(res)
-      return "" unless res.respond_to?(compile_method_name)
-      res.before_compile
-      po = ProxyObject.new(res, @caller)
-      out = po.compile(compile_method_name)
-      res.after_compile
-      out
-    end
-    
-    # Compile an array of resources
-    def self.compile_array(array_of_resources=[])
-      out = []
-      array_of_resources.each do |res|
-        out << compile_resource(res)
-      end
-      out.join("\n")
-    end
-    
-    def self.compile_directory
-      @compile_directory
-    end
-    
-    def self.compile_directory=(d)
-      @compile_directory = d
-    end
-    
-    # Print objects
-    def self.handle_print_variable(obj)
-      case obj
-      when Fixnum
-        case obj
-        when /^\d{3}$/
-          "0#{obj.to_i}"
-        else
-          "#{obj.to_i}"
-        end
-      when String
-        "\"#{obj}\""
-      when Proc
-        obj.call # eh
-      when Array
-        # If we are sending a notifies with a second argument
-        if obj[1] && [:immediately, :delayed].include?(obj[1])
-          "#{handle_print_variable(obj[0])}, :#{obj[1]}"
-        else
-          "[ #{obj.map {|e| handle_print_variable(e) }.reject {|a| a.nil? || a.empty? }.join(", ")} ]"
-        end        
-      when nil
-        nil
-      when Symbol
-        ":#{obj}"
-      when Hash
-        "{#{obj.map {|k,v| ":#{k} => #{handle_print_variable(v)}" unless v == obj }.compact.join(",")}}"
-      else
-        "#{obj}"
-      end
-    end
-    
-  end
-  
-end

data/lib/dependency_resolvers/chef/resources/chef_attributes_file.rb

@@ -1,51 +0,0 @@
-=begin rdoc
-== ChefAttributesFile
-
-Allows for an attributes file to be added to the chef recipe.
-
-== Usage
-
-  has_chef_attributes_file "full_path_to_attributes_file"
-
-== Options
-
-* <tt>file</tt> The location of the attributes file
-
-== Examples
-
-  has_chef_attributes_file PoolParty.lib_dir/"vendor"/"chef"/"apache2"/"attributes"/"apache.rb"
-=end
-module PoolParty
-  module Resources
-    
-    class ChefAttributesFile < Resource
-      
-      default_options(
-        :file    => nil
-      )
-      
-      def valid?
-        f = (file || name)
-        raise PoolPartyError.create("ChefAttributesFileError", "You must specify a file that exists for a chef_attributes_file: #{f}") unless File.file?(full_path)
-      end
-      
-      def path
-        @path ||= file || name
-      end
-      
-      def full_path
-        File.expand_path(path)
-      end
-      
-      def content
-        open(path).read
-      end
-      
-      def print_to_chef
-        ""
-      end
-      
-    end
-    
-  end
-end

data/lib/dependency_resolvers/chef/resources/chef_recipe.rb

@@ -1,51 +0,0 @@
-=begin rdoc
-== ChefRecipeFile
-
-Allows for a chef recipe to be included in the PoolParty output
-
-== Usage
-
-  has_chef_recipe "full_path_to_attributes_file"
-
-== Options
-
-* <tt>file</tt> The directory of the recipe
-
-== Examples
-
-  has_chef_recipe PoolParty.lib_dir/"vendor"/"chef"/"apache2"/"attributes"/"apache.rb"
-=end
-module PoolParty
-  module Resources
-    
-    class ChefRecipe < Resource
-      
-      default_options(
-        :file    => nil
-      )
-      
-      def valid?
-        f = (file || name)
-        raise PoolPartyError.create("ChefAttributesFileError", "You must specify a file that exists for a chef_attributes_file: #{f}") unless File.directory?(full_path)
-      end
-      
-      def path
-        @path ||= file || name
-      end
-      
-      def full_path
-        File.expand_path(path)
-      end
-      
-      def basename
-        File.basename(name)
-      end
-      
-      def print_to_chef
-        "recipe \"#{basename}\""
-      end
-      
-    end
-    
-  end
-end

data/lib/dependency_resolvers/chef/resources/http_request.rb

@@ -1,39 +0,0 @@
-=begin rdoc
-== HttpRequest
-  
-  Allows you to send an http request to a url
- 
-== Usage
-  
-  has_http_request "http://google.com/", :message => "{q : 'search term'}"
-  
-== Options
-* <tt>url</tt> The url to send the request to (this can also be the name)
-* <tt>message</tt> The payload to deliver with the http_request
-  
-=end
-module PoolParty
-  module Resources
-    
-    class HttpRequest < Resource
-      
-      default_options(
-        :action   => :get,
-        :message  => nil,
-        :url      => nil
-      )
-      
-      def print_to_chef
-        <<-EOE
-http_request "<%= name %>" do
-  action :<%= action ? action : (exists ? :get : :delete) %>
-  url <%= print_variable(url) %>
-  message <%= print_variable(message || name) %>
-end
-        EOE
-      end
-      
-    end
-    
-  end
-end