auser-poolparty 0.1.2 → 0.2.2

data/lib/modules/ec2_wrapper.rb

@@ -1,108 +0,0 @@
-module PoolParty
-  extend self
-  
-  module Ec2Wrapper
-    
-    module ClassMethods      
-    end
-    
-    module InstanceMethods
-      # Run a new instance, with the user_data and the ami described in the config
-      def launch_new_instance!
-        instance = ec2.run_instances(
-          :image_id => Application.ami, 
-          :user_data => "#{Application.launching_user_data}",
-          :minCount => 1,
-          :maxCount => 1,
-          :key_name => "#{Application.keypair}",
-          :availability_zone => nil,
-          :size => "#{Application.size}")
-        begin
-          item = instance#.instancesSet.item
-          EC2ResponseObject.get_hash_from_response(item)
-        rescue Exception => e          
-        end
-      end
-      # Shutdown the instance by instance_id
-      def terminate_instance!(instance_id)
-        ec2.terminate_instances(:instance_id => instance_id)
-      end
-      def associate_address_with(ip, instance_id)
-        ec2.associate_address(:instance_id => instance_id, :public_ip => ip)
-      end
-      # Instance description
-      def describe_instance(id)
-        EC2ResponseObject.get_hash_from_response(ec2.describe_instances(:instance_id => id))
-      end
-      # Get instance by id
-      def get_instance_by_id(id)
-        get_instances_description.select {|a| a.instance_id == id}[0] rescue nil
-      end
-      # Get the s3 description for the response in a hash format
-      def get_instances_description
-        @cached_descriptions ||= EC2ResponseObject.get_descriptions(ec2.describe_instances)
-      end
-      # EC2 connections
-      def ec2
-        @ec2 ||= EC2::Base.new(:access_key_id => Application.access_key, :secret_access_key => Application.secret_access_key)
-      end
-      def reset!
-        @cached_descriptions = nil
-      end      
-    end
-    
-    def self.included(receiver)
-      receiver.extend         ClassMethods
-      receiver.send :include, InstanceMethods
-    end
-  end
-  # Provides a simple class to wrap around the amazon responses
-  class EC2ResponseObject
-    def self.get_descriptions(resp)      
-      rs = get_response_from(resp)
-      
-      # puts rs.methods.sort - rs.ancestors.methods
-      out = begin
-        if rs.respond_to?(:instancesSet)
-          [EC2ResponseObject.get_hash_from_response(rs.instancesSet.item)]
-        else
-          rs.collect {|r| 
-            if r.instancesSet.item.class == Array
-              r.instancesSet.item.map {|t| EC2ResponseObject.get_hash_from_response(t)}
-            else
-              [EC2ResponseObject.get_hash_from_response(r.instancesSet.item)]
-            end            
-          }.flatten.reject {|a| a.nil? }
-        end
-      rescue Exception => e
-        # Really weird bug with amazon's ec2 gem
-        rs.collect {|r| EC2ResponseObject.get_hash_from_response(r)}.reject {|a| a.nil? } rescue []
-      end
-      
-      out
-    end
-    def self.get_response_from(resp)
-      begin
-        rs = resp.reservationSet.item unless resp.reservationSet.nil?
-        rs ||= resp.DescribeInstancesResponse.reservationSet.item
-        rs ||= rs.respond_to?(:instancesSet) ? rs.instancesSet : rs
-        rs.reject! {|a| a.nil? || a.empty? }
-      rescue Exception => e
-      end
-      rs
-    end
-    def self.get_hash_from_response(resp)
-      begin
-        {
-          :instance_id => resp.instanceId, 
-          :ip => resp.dnsName, 
-          :status => resp.instanceState.name,
-          :launching_time => resp.launchTime,
-          :keypair => resp.keyName
-        }        
-      rescue Exception => e
-        nil
-      end      
-    end
-  end
-end

data/lib/modules/file_writer.rb

@@ -1,38 +0,0 @@
-module PoolParty
-  module FileWriter
-    def write_to_file_for(f="haproxy", node=nil, str="", &block)      
-      make_base_directory
-      File.open("#{base_tmp_dir}/#{node ? "#{node.name}-" : ""}#{f}", "w+") do |file|
-        file << str
-        file << block.call if block_given?
-      end
-    end
-    # Write a temp file with the content str
-    def write_to_temp_file(str="")        
-      tempfile = Tempfile.new("#{base_tmp_dir}/poolparty-#{rand(1000)}-#{rand(1000)}")
-      tempfile.print(str)
-      tempfile.flush
-      tempfile
-    end
-    def with_temp_file(str="", &block)
-      Tempfile.open "#{base_tmp_dir}/poolparty-#{rand(10000)}" do |fp|
-        fp.puts str
-        fp.flush
-        block.call(fp)
-      end
-    end
-    
-    def base_tmp_dir
-      File.join(user_dir, "tmp")
-    end
-    def remote_base_tmp_dir
-      "~/tmp"
-    end
-    def make_base_directory
-      `mkdir -p #{base_tmp_dir}` unless File.directory?(base_tmp_dir)
-    end
-    def clear_base_directory
-      `rm -rf #{base_tmp_dir}/*` if File.directory?(base_tmp_dir)
-    end
-  end
-end

data/lib/modules/sprinkle_overrides.rb

@@ -1,27 +0,0 @@
-Sprinkle::Installers::Source.extend Module.new do
-  def custom_dir(dir)
-    @custom_dir = dir
-  end
-  
-  def base_dir
-    if @custom_dir
-      return @custom_dir
-    elsif @source.split('/').last =~ /(.*)\.(tar\.gz|tgz|tar\.bz2|tb2)/
-      return $1
-    end
-    raise "Unknown base path for source archive: #{@source}, please update code knowledge"
-  end  
-end  
-Sprinkle::Installers::Gem.extend Module.new do
-  def platform(platform=nil)
-    @platform ||= platform
-  end
-  protected
-    def install_sequence
-      cmd = "gem install -y #{gem}"
-      cmd << " --version '#{version}'" if version
-      cmd << " --source #{source}" if source
-      cmd << " --platform #{platform}" if platform
-      cmd
-    end
-end

data/lib/modules/vlad_override.rb

@@ -1,83 +0,0 @@
-# require "vlad"
-# class Rake::RemoteTask < Rake::Task  
-#   def run command
-#     cmd = [ssh_cmd, ssh_flags, target_host].compact
-#     result = []
-#     
-#     commander = cmd.join(" ") << " \"#{command}\""
-#     warn commander if $TRACE
-# 
-#     pid, inn, out, err = popen4(commander)
-# 
-#     inn.sync   = true
-#     streams    = [out, err]
-#     out_stream = {
-#       out => $stdout,
-#       err => $stderr,
-#     }
-# 
-#     # Handle process termination ourselves
-#     status = nil
-#     Thread.start do
-#       status = Process.waitpid2(pid).last
-#     end
-# 
-#     until streams.empty? do
-#       # don't busy loop
-#       selected, = select streams, nil, nil, 0.1
-# 
-#       next if selected.nil? or selected.empty?
-# 
-#       selected.each do |stream|
-#         if stream.eof? then
-#           streams.delete stream if status # we've quit, so no more writing
-#           next
-#         end
-# 
-#         data = stream.readpartial(1024)
-#         out_stream[stream].write data
-# 
-#         if stream == err and data =~ /^Password:/ then
-#           inn.puts sudo_password
-#           data << "\n"
-#           $stderr.write "\n"
-#         end
-# 
-#         result << data
-#       end
-#     end
-# 
-#     PoolParty.message "execution failed with status #{status.exitstatus}: #{cmd.join ' '}" unless status.success?
-# 
-#     result.join
-#   end
-#   
-#   def rsync local, remote
-#     cmd = [rsync_cmd, rsync_flags, local, "#{@target_host}:#{remote}"].flatten.compact
-#   
-#     success = system(*cmd.join(" "))
-# 
-#     unless success then
-#       raise Vlad::CommandFailedError, "execution failed: #{cmd.join ' '}"
-#     end
-#   end
-#   def set name, val = nil, &b
-#     rt.set name, val, &b
-#   end
-#   def rt
-#     @rt ||= Rake::RemoteTask
-#   end
-#   
-#   def target_hosts
-#     if hosts = ENV["HOSTS"] then
-#       hosts.strip.gsub(/\s+/, '').split(",")
-#     elsif options[:single]
-#       @roles = {}; @roles[:app] = {}      
-#       @roles[:app][options[:single]] = options[:single]
-#       roles = Rake::RemoteTask.hosts_for(@roles)
-#     else
-#       roles = options[:roles]
-#       roles ? Rake::RemoteTask.hosts_for(roles) : Rake::RemoteTask.all_hosts
-#     end
-#   end
-# end

data/lib/poolparty/application.rb

@@ -1,199 +0,0 @@
-=begin rdoc
-  Application
-  This handles user interaction
-=end
-module PoolParty
-  class Application
-    class << self
-      attr_accessor :verbose, :options
-      
-      # The application options
-      def options(opts={})
-        @options ||= make_options(opts)        
-      end
-      # Make the options with the config_file overrides included
-      # Default config file assumed to be at config/config.yml
-      def make_options(opts={})
-        loading_options = opts.delete(:optsparse) || {}
-        loading_options.merge!( opts || {})
-        
-        load_options!(loading_options) # Load command-line options
-        config_file_location = (default_options[:config_file] || opts[:config_file])
-        
-        # If the config_file options are specified and not empty
-        unless config_file_location.nil? || config_file_location.empty?
-          require "yaml"
-          # Try loading the file if it exists
-          filedata = File.open("#{config_file_location}").read if File.file?("#{config_file_location}")
-          default_options.merge!( YAML.load(filedata) ) if filedata rescue ""
-        end
-        # We want the command-line to overwrite the config file
-        default_options.merge!(local_user_data) unless local_user_data.nil?        
-        OpenStruct.new(default_options)
-      end
-
-      # Load options via commandline
-      def load_options!(opts={})
-        require 'optparse'
-        OptionParser.new do |op|
-          op.banner = opts[:banner] if opts[:banner]
-          op.on('-A key', '--access-key key', "Ec2 access key (ENV['AWS_ACCESS_KEY'])") { |key| default_options[:access_key] = key }
-          op.on('-S key', '--secret-access-key key', "Ec2 secret access key (ENV['AWS_SECRET_ACCESS'])") { |key| default_options[:secret_access_key] = key }
-          op.on('-I ami', '--image-id id', "AMI instance (default: 'ami-40bc5829')") {|id| default_options[:ami] = id }
-          op.on('-k keypair', '--keypair name', "Keypair name (ENV['KEYPAIR_NAME'])") { |key| default_options[:keypair] = key }
-          op.on('-b bucket', '--bucket bucket', "Application bucket") { |bucket| default_options[:shared_bucket] = bucket }
-          # //THIS IS WHERE YOU LEFT OFF
-          op.on('-D working directory', '--dir dir', "Working directory") { |d| default_options[:working_directory] = d }
-          
-          op.on('--ec2-dir dir', "Directory with ec2 data (default: '~/.ec2')") {|id| default_options[:ec2_dir] = id }
-          op.on('-r names', '--services names', "Monitored services (default: '')") {|id| default_options[:services] = id }
-          op.on('-c file', '--config-file file', "Config file (default: '')") {|file| default_options[:config_file] = file }
-          op.on('-l plugin_dir', '--plugin-dir dir', "Plugin directory (default: '')") {|file| default_options[:plugin_dir] = file }
-          op.on('-p port', '--host_port port', "Run on specific host_port (default: 7788)") { |host_port| default_options[:host_port] = host_port }
-          op.on('-m monitors', '--monitors names', "Monitor instances using (default: 'web,memory,cpu')") {|s| default_options[:monitor_load_on] = s }          
-          op.on('-o port', '--client_port port', "Run on specific client_port (default: 7788)") { |client_port| default_options[:client_port] = client_port }
-          op.on('-O os', '--os os', "Configure for os (default: ubuntu)") { |os| default_options[:os] = os }          
-          op.on('-e env', '--environment env', "Run on the specific environment (default: development)") { |env| default_options[:environment] = env }
-          op.on('-a address', '--public-ip address', "Associate this public address with the master node") {|s| default_options[:public_ip] = s}
-          op.on('-s size', '--size size', "Run specific sized instance") {|s| default_options[:size] = s}
-          op.on('-a name', '--name name', "Application name") {|n| default_options[:app_name] = n}
-          op.on('-u username', '--username name', "Login with the user (default: root)") {|s| default_options[:user] = s}
-          op.on('-d user-data','--user-data data', "Extra data to send each of the instances (default: "")") { |data| default_options[:user_data] = data.to_str }
-          op.on('-i', '--install-on-boot', 'Install the PoolParty and custom software on boot (default: false)') {|b| default_options[:install_on_load] = true}
-          op.on('-t seconds', '--polling-time', "Time between polling in seconds (default 50)") {|t| default_options[:polling_time] = t }
-          op.on('-v', '--[no-]verbose', 'Run verbosely (default: false)') {|v| default_options[:verbose] = true}
-          op.on('-n number', '--minimum-instances', "The minimum number of instances to run at all times (default 1)") {|i| default_options[:minimum_instances] = i.to_i}
-          op.on('-x number', '--maximum-instances', "The maximum number of instances to run (default 3)") {|x| default_options[:maximum_instances] = x.to_i}
-          
-          op.on_tail("-V", "Show version") do
-            puts Application.version
-            exit
-          end
-          op.on_tail("-h", "-?", "Show this message") do
-            puts op
-            exit
-          end
-        end.parse!(opts[:argv] ? opts.delete(:argv) : ARGV.dup)
-      end
-      
-      # Basic default options
-      # All can be overridden by the command line
-      # or in a config.yml file
-      def default_options
-        @default_options ||= {
-          :app_name => "application_name",
-          :host_port => 80,
-          :client_port => 8001,
-          :environment => 'development',
-          :verbose => false,
-          :logging => true,
-          :size => "m1.small",
-          :polling_time => "30.seconds",
-          :user_data => "",
-          :heavy_load => 0.80,
-          :light_load => 0.15,
-          :minimum_instances => 2,
-          :maximum_instances => 4,
-          :public_ip => "",
-          :access_key => ENV["AWS_ACCESS_KEY"],
-          :secret_access_key => ENV["AWS_SECRET_ACCESS"],
-          :config_file => if ENV["CONFIG_FILE"] && !ENV["CONFIG_FILE"].empty?
-            ENV["CONFIG_FILE"]
-          elsif File.file?("config/config.yml")
-            "config/config.yml"
-          else
-            nil
-          end,
-          :username => "root",
-          :ec2_dir => (ENV["EC2_HOME"].nil? || ENV["EC2_HOME"].empty?) ? "~/.ec2" : ENV["EC2_HOME"],
-          :keypair => (ENV["KEYPAIR_NAME"].nil? || ENV["KEYPAIR_NAME"].empty?) ? File.basename(`pwd`).strip : ENV["KEYPAIR_NAME"],
-          :ami => 'ami-44bd592d',
-          :shared_bucket => "",
-          :expand_when => "web < 1.5\n memory > 0.85",
-          :contract_when => "cpu < 0.20\n memory < 0.10",
-          :os => "ubuntu",
-          :plugin_dir => "plugins",
-          :install_on_load => false,
-          :working_directory => Dir.pwd
-        }
-      end
-      # Services monitored by Heartbeat
-      def master_managed_services
-        "cloud_master_takeover"
-      end
-      alias_method :managed_services, :master_managed_services
-      def launching_user_data
-        hash_to_launch_with.to_yaml
-      end
-      def hash_to_launch_with
-        @hash ||= { :polling_time => polling_time, 
-          :access_key => access_key, 
-          :secret_access_key => secret_access_key,
-          :user_data => user_data,
-          :keypair => keypair,
-          :keypair_path => "/mnt"
-        }
-      end
-      def local_user_data 
-        @local_user_data ||= begin
-          @@timer.timeout(2.seconds) do
-            YAML.load(open("http://169.254.169.254/latest/user-data").read)
-          end
-        rescue Exception => e
-          {}
-        end
-      end
-      # For testing purposes
-      def reset!
-        @options = nil
-        @local_user_data = nil
-      end
-      # Keypair path
-      # Idiom:
-      #  /Users/username/.ec2/[name]
-      def keypair_path
-        options.keypair_path ? options.keypair_path : "#{ec2_dir}/#{keypair_name}"
-      end
-      def keypair_name
-        "id_rsa-#{keypair}"
-      end
-      # Are we in development or test mode
-      %w(development production test).each do |env|
-        eval <<-EOE
-          def #{env}?
-            environment == '#{env}'
-          end
-        EOE
-      end
-      def environment=(env)
-        environment = env
-      end
-      def maintain_pid_path
-        "/var/run/pool_maintain.pid"
-      end
-      %w(scp_instances_script reconfigure_instances_script).each do |file|
-        define_method "sh_#{file}" do
-          File.join(File.dirname(__FILE__), "../..", "config", "#{file}.sh")
-        end
-      end
-      # Standard configuration files
-      %w(haproxy monit heartbeat heartbeat_authkeys).each do |file|
-        define_method "#{file}_config_file" do
-          File.join(File.dirname(__FILE__), "../..", "config", "#{file}.conf")
-        end
-      end
-      def version
-        PoolParty::Version.string
-      end
-      def install_on_load?(bool=false)
-        options.install_on_load == true || bool
-      end
-      # Call the options from the Application
-      def method_missing(m,*args)
-        options.methods.include?("#{m}") ? options.send(m,args) : super
-      end
-    end
-        
-  end
-    
-end