poolparty 0.2.84 → 1.2.2

data/lib/poolparty/modules/configurable.rb

@@ -1,36 +0,0 @@
-#TODO: rdoc: this  defines methods on poolparty objects from a passed hash of options.
-# For example, this is how instance.minimum_runtime is set.  See base.rb line 12 for example of default options that are added as methods in this way. 
-module PoolParty
-  module Configurable
-    module ClassMethods      
-      def default_options(h={})
-        @default_options ||= h
-      end
-    end
-    
-    module InstanceMethods
-      def options(h={})
-        @options ||= self.class.default_options.merge(h)
-      end
-      
-      def configure(h={})
-        options(h).merge!(h)
-      end
-      
-      def reconfigure(h={})
-        @options = nil
-        options(h)
-      end
-      
-      def set_vars_from_options(opts={})
-        opts.each {|k,v| self.send k.to_sym, send_if_method(v) } unless opts.empty?
-      end
-    end
-    
-    def self.included(receiver)
-      receiver.extend         ClassMethods
-      receiver.send :include, InstanceMethods
-      receiver.send :include, MethodMissingSugar
-    end
-  end
-end

data/lib/poolparty/modules/method_missing_sugar.rb

@@ -1,58 +0,0 @@
-=begin rdoc
-  Using method missing gives us the ability to set any attribute on the object into the options
-  such that it can be retrieved later
-=end
-module PoolParty
-  module MethodMissingSugar
-    # Method_Missing
-    # When a method cannot be found on the current object
-    # it is sent to method_missing
-    # First, we check if there is a block given and if the block
-    # is given with a class of the same type, then it is a block to be evaluated on 
-    # itself, so we instantiate it here, otherwise, don't handle it here and let
-    # the super class worry about it.
-    # If the block is not given, then we are going to look for it on the 
-    # options of itself or its parent.
-    # See get_from_options for more information
-    def method_missing(m, *args, &block)
-      if block_given?
-        (args[0].class == self.class) ? args[0].run_in_context(&block) : super
-      else        
-        get_from_options(m, *args, &block)
-      end
-    end
-    
-    # Get the method from the options
-    # First, we check to see if any options are being sent to the method
-    # of the form:
-    # name "Fred"
-    # If there are args sent to it, check to see if it is an array
-    # If it is, we want to send it an array only if the array is contains more than one element.
-    # This becomes important when we are building the manifest
-    # If it is not an array of more than one element, then we just send it the first of the args
-    # If there are no args sent to it, then we check to see if the method is already in the options
-    # which means we are retrieving the property
-    # of the form
-    # @cloud.name => @cloud.options[:name]
-    # Finally, if the method name is not in the options, then we check to make sure it's not set on the 
-    # parent, we don't want the parent's set option and that the parent isnot itself and send it
-    # to the parent to handle. Otherwise, we'll say it's nil instead
-    def get_from_options(m, *args, &block)
-      if args.empty?
-        if options.has_key?(m)
-          options[m]
-        else
-          (parent.nil? || parent.class == self.class || !parent.respond_to?(:options) || parent.options.has_key?(m) || !parent.respond_to?(m)) ? nil : parent.send(m, *args, &block)
-        end        
-      else
-        options[m] = 
-        if (args.is_a?(Array) && args.size > 1)
-          args
-        else
-          args[0]
-        end
-      end
-    end
-    
-  end
-end

data/lib/poolparty/monitors/monitors/cpu_monitor.rb

@@ -1,15 +0,0 @@
-module PoolParty
-  module Monitors
-    
-    class CpuMonitor < BaseMonitor
-      
-      def run
-        stdin, stdout, stderr = Open3.popen3('uptime')
-        stdout.split(/\s+/)[-1].to_f rescue 0.0
-      end
-            
-    end
-    
-    register_monitor :cpu
-  end
-end

data/lib/poolparty/monitors/monitors/web_monitor.rb

@@ -1,18 +0,0 @@
-=begin rdoc
-  Web monitor.
-=end
-module PoolParty
-  module Monitors
-    
-    class WebMonitor < BaseMonitor
-      
-      def run
-        str = %x[httperf]
-        str.split(/\s+/)[-1].to_f rescue 0.0
-      end
-            
-    end
-    
-    register_monitor :cpu
-  end
-end

data/lib/poolparty/net/messenger.rb

@@ -1,72 +0,0 @@
-=begin rdoc
-  The connection to the messenger from poolparty, the client.
-  
-  This class will setup a socket connection to the master's client
-  at the messenger_client_port
-=end
-module PoolParty
-  module Messenger
-    def with_socket(testing=false, &block)
-      host = testing ? "localhost" : (master.ip)
-      vputs "Pinging #{host} with the messenger"
-      socket = TCPSocket.open(host, Base.messenger_client_port)
-      out = yield(socket)
-      socket.close
-      out
-    end
-    # TODO: Fix cookie setting
-    def self.erl_command(hostname, extra="", min_ports=7000, max_ports=7050)
-      command_line_opts = "-pa #{append_dir}/ebin -kernel inet_dist_listen_min #{min_ports} inet_dist_listen_max #{max_ports} -sname #{hostname}"
-      
-      "erl #{command_line_opts} #{extra}"
-    end
-    
-    def self.append_dir
-      ::File.expand_path(::File.join( ::File.dirname(__FILE__), "..", "..", "erlang/messenger" ))
-    end
-    
-    def messenger_send!(msg="get_current_load cpu", testing=false)
-      with_socket(testing) do |sock|
-        sock.send(msg, 0)
-        @str = sock.recv(2000)
-      end
-      vputs "Received #{@str} from #{msg}"
-      @str
-    end
-    
-    def messenger_cast!(msg="force_reconfig")
-      with_socket do |sock|
-        sock.send(msg, 0)
-      end
-    end
-    
-    def self.messenger_send!(cmd="", testing=false)      
-      command = Messenger.erl_command("client#{Time.now.to_i}", "-s pm_client -run pm_client #{cmd} -s erlang halt -noshell")
-      testing ? command : %x[#{command}]
-    end
-    
-    # Helper methods
-    def self.startup_remote_messenger(hostname, testing=false)
-      # messenger_send!("")
-      # testing ? command : %x[#{command}]
-    end
-    
-  end
-end
-
-module PoolParty
-  module Cloud
-    class Cloud
-      include PoolParty::Messenger
-      
-      def get_current_nodes
-        nodes = messenger_send!("get_current_nodes")
-        nodes.split(" ").map {|a| a.split(/@/)[-1] }
-      end
-      
-      def reconfigure_cloud!(msg="force_reconfig")
-        messenger_cast!(msg)
-      end
-    end
-  end
-end

data/lib/poolparty/net/remote.rb

@@ -1,38 +0,0 @@
-require File.dirname(__FILE__) + "/remoter_base"
-require File.dirname(__FILE__) + "/remoter"
-
-module PoolParty  
-  module Remote
-    
-    include PoolParty::Remote::Remoter
-    
-    def using(t)
-      @cloud = self
-      if t && available_bases.include?(t.to_sym)
-        unless using_remoter?
-          self.class.send :attr_reader, :remote_base
-          self.class.send :attr_reader, :parent_cloud
-          mod = "#{t}".preserved_module_constant
-          
-          # mod.send :include, PoolParty::Remote::RemoterBase
-          self.class.send :include, mod
-          self.extend mod
-          
-          @remote_base = "#{t}".preserved_module_constant
-          @parent_cloud = @cloud
-        end
-      else
-        puts "Unknown remote base" 
-      end
-    end
-    
-    def available_bases
-      remote_bases
-    end
-    
-    def using_remoter?
-      @remote_base ||= nil
-    end
-                
-  end  
-end

data/lib/poolparty/net/remote_bases/ec2.rb

@@ -1,190 +0,0 @@
-=begin rdoc
-  EC2 Remoter Base
-  
-  This serves as the basis for running PoolParty on Amazon's ec2 cloud
-  cluster. 
-=end
-require "date"
-require "#{::File.dirname(__FILE__)}/ec2/ec2_response_object"
-
-begin
-  require 'EC2'
-  
-  class String
-    def convert_from_ec2_to_ip
-      self.gsub(/.compute-1.amazonaws.com*/, '').gsub(/ec2-/, '').gsub(/-/, '.')
-    end
-    def parse_datetime
-      DateTime.parse( self.chomp ) rescue self
-    end
-  end
-  module PoolParty
-    module Ec2
-      include PoolParty::Remote::RemoterBase
-      
-      def launch_new_instance!(num=1)
-        instance = ec2.run_instances(
-          :image_id => (ami || Base.ami),
-          :user_data => "",
-          :minCount => 1,
-          :maxCount => num,
-          :key_name => (keypair || Base.keypair),
-          :availability_zone => (availabilty_zone || Base.availabilty_zone),
-          :instance_type => "#{size || Base.size}",
-          :group_id => ["#{security_group || Base.security_group}"])
-        begin
-          h = EC2ResponseObject.get_hash_from_response(instance)
-          #h = instance.instancesSet.item.first
-        rescue Exception => e
-          h = instance
-        end
-        h
-      end
-      # Terminate an instance by id
-      def terminate_instance!(instance_id=nil)
-        ec2.terminate_instances(:instance_id => instance_id)
-      end
-      # Describe an instance's status
-      def describe_instance(id=nil)
-        describe_instances.select {|a| a[:name] == id}[0] rescue nil
-      end
-      def describe_instances
-        id = 0
-        get_instances_description.each_with_index do |h,i|
-          if h[:status] == "running"
-            inst_name = id == 0 ? "master" : "node#{id}"
-            id += 1
-          else
-            inst_name = "#{h[:status]}_node#{i}"
-          end
-          h.merge!({
-            :name => inst_name,
-            :hostname => h[:ip],
-            :ip => h[:ip].convert_from_ec2_to_ip,
-            :index => i,
-            :launching_time => (h[:launching_time])
-          })
-        end.sort {|a,b| a[:index] <=> b[:index] }
-      end
-      # Get the s3 description for the response in a hash format
-      def get_instances_description
-        EC2ResponseObject.get_descriptions(ec2.describe_instances)
-      end
-
-      def after_launch_master(inst=nil)
-        instance = master
-        vputs "Running tasks after launching the master"
-        begin
-          # when_no_pending_instances do
-            if instance
-              ec2.attach_volume(:volume_id => ebs_volume_id, :instance_id => instance.instance_id, :device => ebs_volume_device) if ebs_volume_id && ebs_volume_mount_point
-              # Let's associate the address LAST so that we can still connect to the instance
-              # for the other tasks here              
-              ec2.associate_address(:instance_id => instance.instance_id, :public_ip => set_master_ip_to) if set_master_ip_to              
-              reset_remoter_base!
-            end
-          # end
-        rescue Exception => e        
-          vputs "Error in after_launch_master: #{e}"
-        end
-        reset_remoter_base!
-        when_all_assigned_ips {wait "5.seconds"}
-      end
-
-      # Help create a keypair for the cloud
-      # This is a helper to create the keypair and add them to the cloud for you
-      def create_keypair
-        return false unless keypair
-        unless ::File.exists?( new_keypair_path )
-          FileUtils.mkdir_p ::File.dirname( new_keypair_path )
-          vputs "Creating keypair: #{keypair} in #{new_keypair_path}"
-          Kernel.system "ec2-add-keypair #{keypair} > #{new_keypair_path} && chmod 600 #{new_keypair_path}"
-        end
-      end
-      
-      # wrapper for remote base to perform a snapshot backup for the ebs volume
-      def create_snapshot
-        return nil if ebs_volume_id.nil?
-        ec2.create_snapshot(:volume_id => ebs_volume_id)
-      end
-      
-      # EC2 connections
-      def ec2
-        @ec2 ||= EC2::Base.new( :access_key_id => (access_key || Base.access_key), 
-                                :secret_access_key => (secret_access_key || Base.secret_access_key)
-                              )
-      end
-      
-      def before_configuration_tasks
-        if has_cert_and_key?
-          # copy_file_to_storage_directory(pub_key)
-          # copy_file_to_storage_directory(private_key)
-        end
-      end
-      def has_cert_and_key?
-        pub_key && private_key
-      end
-      # The keys are used only for puppet certificates
-      # and are only used for EC2.
-      # Public key 
-      def pub_key
-        @pub_key ||= ENV["EC2_CERT"] ? ENV["EC2_CERT"] : nil
-      end
-      # Private key
-      def private_key
-        @private_key ||= ENV["EC2_PRIVATE_KEY"] ? ENV["EC2_PRIVATE_KEY"] : nil
-      end
-      
-      def custom_minimum_runnable_options
-        [:ami, :availabilty_zone, :security_group]
-      end
-
-      # Hook
-      #TODO#: Change this so they match with the cap tasks
-      def custom_install_tasks_for(o)
-        arr = if has_cert_and_key?
-          [ 
-            # "mv #{::File.basename(pub_key)} #{Base.base_config_directory}/ssl/public_keys/#{o.name}.pem", 
-            # "mv #{::File.basename(private_key)} #{Base.base_config_directory}/ssl/private_keys/#{o.name}.pem"
-          ]
-          else 
-            []
-          end
-        arr << [
-          "# ec2 installation tasks",
-          "# Set hostname",
-          # "if [ -z $(grep -v '#' /etc/hosts | grep '#{o.name}') ]; then echo \"$(curl http://169.254.169.254/latest/meta-data/public-ipv4) #{o.name}\" >> /etc/hosts; fi",
-          "if [ -z \"$(grep -v '#' /etc/hosts | grep '#{o.name}')\" ]; then echo '127.0.0.1 #{o.name}' >> /etc/hosts; fi",
-          "hostname #{o.name}",
-          "echo #{o.name} > /etc/hostname",
-          "cd /var/poolparty && wget http://rubyforge.org/frs/download.php/43666/amazon-ec2-0.3.1.gem -O amazon-ec2.gem 2>&1",
-          "/usr/bin/gem install -y --no-ri --no-rdoc amazon-ec2.gem 2>&1",
-        ]
-        []
-      end
-
-      def custom_configure_tasks_for(o)
-        [
-        ]
-      end
-
-      def reset_base!
-        @describe_instances = @cached_descriptions = nil
-      end
-    end
-    register_remote_base :Ec2
-  end
-rescue LoadError
-  puts <<-EOM
-Error: In order to use ec2, you need to install the amazon-ec2 gem
-
-Ec2 is the default remoter base for PoolParty. If you intend on using
-a different remoter base, specify it with:
-
-using :remoter_name
-
-in your config file, otherwise, to continue install amazon-ec2 with
-
-gem install amazon-ec2
-EOM
-end