poolparty 0.0.4 → 0.2.6

data/lib/pool_party/monitors.rb

@@ -1,13 +0,0 @@
-=begin rdoc
-  Basic monitors for the master
-=end
-module PoolParty  
-  module Monitors    
-    class Monitor
-    end    
-  end  
-end
-
-Dir["#{File.dirname(__FILE__)}/monitors/*"].each do |file|
-  require file
-end

data/lib/pool_party/monitors/cpu.rb

@@ -1,18 +0,0 @@
-=begin rdoc
-  Basic monitor on the cpu stats
-=end
-module PoolParty
-  module Monitors
-    module Cpu
-      def self.monitor!
-        IO.popen("uptime") do |up|
-          ret = monitor_from_string(up)
-        end
-        ret
-      end
-      def self.monitor_from_string(str="")
-        str.split(/\s+/)[-3].to_f
-      end
-    end
-  end
-end

data/lib/pool_party/monitors/memory.rb

@@ -1,21 +0,0 @@
-=begin rdoc
-  Basic memory monitor on the instance
-=end
-module PoolParty
-  module Monitors
-    module Memory
-      def self.monitor!
-        IO.popen("free -m | grep -i mem") { |io|
-          ret = monitor_from_string(io)
-        }
-        ret
-      end
-      def self.monitor_from_string(str="")
-        total_memory = str.split[1].to_f
-        used_memory = str.split[2].to_f
-        
-        used_memory / total_memory
-      end
-    end
-  end
-end

data/lib/pool_party/monitors/web.rb

@@ -1,18 +0,0 @@
-=begin rdoc
-  Monitor the web stats for the request rate the server can handle at a time
-=end
-module PoolParty
-  module Monitors
-    module Web
-      def self.monitor!(port)
-        IO.popen("httperf --server localhost --port #{port} --num-conn 3 --timeout 5 | grep 'Request rate'") do |io|
-          @req = monitor_from_string(io.gets)
-        end
-        @req
-      end
-      def self.monitor_from_string(str="")
-        str[/[.]* ([\d]*\.[\d]*) [.]*/, 0].chomp.to_f
-      end
-    end
-  end
-end

data/lib/pool_party/optioner.rb

@@ -1,16 +0,0 @@
-module PoolParty
-  class Optioner
-    # Parse the command line options for options without a switch
-    def self.parse(argv, safe=[])
-      args = []
-      argv.each_with_index do |arg,i|
-        unless arg.index("-")
-          args << arg 
-        else
-          argv.delete_at(i+1) unless safe.include?(arg)
-        end
-      end
-      args
-    end
-  end
-end

data/lib/pool_party/os.rb

@@ -1,11 +0,0 @@
-=begin rdoc
-  Os specific container
-=end
-module PoolParty
-  module Os
-  end
-end
-
-Dir["#{File.dirname(__FILE__)}/os/*"].each do |file|
-  require file
-end

data/lib/pool_party/os/ubuntu.rb

@@ -1,78 +0,0 @@
-=begin rdoc
-  Ubuntu specific install tasks for PoolParty
-=end
-module PoolParty
-  module Os    
-    module Ubuntu
-      def install_stack
-        install_haproxy
-        install_heartbeat
-        install_monit
-        install_s3fuse
-      end
-      def install_haproxy
-        cmd=<<-EOC
-          apt-get -y install haproxy
-          sed -i 's/ENABLED=0/ENABLED=1/g' /etc/default/haproxy
-          sed -i 's/SYSLOGD=\"\"/SYSLOGD=\"-r\"/g' /etc/default/syslogd
-          echo 'local0.* /var/log/haproxy.log' >> /etc/syslog.conf && killall -9 syslogd && syslogd
-        EOC
-        ssh cmd.runnable
-      end
-      def install_monit
-        cmd=<<-EOC
-          apt-get -y install monit
-          mkdir /etc/monit
-          sed -i 's/startup=0/startup=1/g' /etc/default/monit
-          /etc/init.d/monit start
-        EOC
-        ssh cmd.runnable
-      end
-      def install_nginx
-        cmd=<<-EOC
-          apt-get -y install nginx
-        EOC
-        ssh cmd.runnable
-      end
-      def install_heartbeat
-        cmd=<<-EOC
-          apt-get -y install heartbeat-2
-        EOC
-        ssh cmd.runnable
-      end
-      def install_s3fuse
-        cmd=<<-EOC
-          cd /usr/local/src && wget http://s3fs.googlecode.com/files/s3fs-r166-source.tar.gz 
-          tar -zxf s3fs-r166-source.tar.gz
-          cd s3fs/ && make
-          mv s3fs /usr/bin
-          mkdir /data
-        EOC
-        ssh("apt-get -y install build-essential libcurl4-openssl-dev libxml2-dev libfuse-dev")
-        ssh(cmd.runnable)
-      end
-      # We want to slim this down...
-      def install_ruby_and_rubygems
-        cmd=<<-EOC
-          echo 'Installing ruby...'
-          ln -sf /usr/bin/ruby1.8 /usr/local/bin/ruby
-          ln -sf /usr/bin/ri1.8 /usr/local/bin/ri
-          ln -sf /usr/bin/rdoc1.8 /usr/local/bin/rdoc
-          ln -sf /usr/bin/irb1.8 /usr/local/bin/irb
-          echo '-- Installing Rubygems'
-          cd /usr/local/src
-          wget http://rubyforge.org/frs/download.php/35283/rubygems-1.1.1.tgz
-          tar -xzf rubygems-1.1.1.tgz
-          cd rubygems-1.1.1
-          ruby setup.rb --no-rdoc --no-ri
-          ln -sf /usr/bin/gem1.8 /usr/bin/gem
-          gem1.8 update --system
-          gem1.8 install aws-s3 amazon-ec2 aska rake poolparty --no-rdoc --no-ri --no-test
-        EOC
-        ssh("apt-get -y install build-essential ruby1.8-dev ruby1.8 ri1.8 rdoc1.8 irb1.8 libreadline-ruby1.8 libruby1.8")
-        ssh(cmd.runnable)
-      end
-    end
-    
-  end
-end

data/lib/pool_party/remote_instance.rb

@@ -1,180 +0,0 @@
-module PoolParty
-  class RemoteInstance
-    include PoolParty # WTF -> why isn't message included
-    include Callbacks
-    
-    attr_reader :ip, :instance_id, :name, :number, :status, :launching_time, :stack_installed
-    attr_accessor :name
-    
-    def initialize(obj)
-      @ip = obj[:ip]
-      @instance_id = obj[:instance_id]      
-      @name = obj[:name] || "node"
-      @number = obj[:number] || 0 # Defaults to the master
-      @status = obj[:status] || "running"
-      @launching_time = obj[:launching_time] || Time.now
-    end
-    
-    # Host entry for this instance
-    def hosts_entry
-      "#{@ip}\t#{name}"
-    end
-    # Internal host entry for this instance
-    def local_hosts_entry
-      "127.0.0.1 #{name}\n127.0.0.1 localhost.localdomain localhost ubuntu"
-    end
-    # Node entry for heartbeat
-    def node_entry
-      "node #{name}"
-    end    
-    # Internal naming scheme
-    def name
-      "#{@name}#{@number}"
-    end
-    # Entry for the heartbeat config file
-    def heartbeat_entry
-      "#{name} #{ip} #{Application.managed_services}"
-    end
-    # Entry for haproxy
-    def haproxy_entry
-      "server #{name} #{@ip}:#{Application.client_port} weight 1 check"
-    end
-    def haproxy_resources_entry
-      "#{name}\t#{@ip}"
-    end
-    # Is this the master?
-    def master?
-      @number == 0
-    end
-    # Let's define some stuff for monit
-    %w(stop start restart).each do |cmd|
-      define_method "#{cmd}_with_monit" do
-        ssh("monit #{cmd} all")
-      end
-    end
-    # Gets called everytime the cloud reloads itself
-    # This is how the cloud reconfigures itself
-    def configure
-      configure_master if master?
-      configure_linux
-      configure_hosts
-      configure_haproxy
-      configure_heartbeat if Master.requires_heartbeat?
-      configure_s3fuse
-      configure_monit      
-    end
-    # Setup the master tasks
-    def configure_master
-      message "configuring master (#{name})"
-      install_ruby_and_rubygems # Install ruby and the gems required to run the master
-      scp(Application.config_file, "~/.config")
-      ssh("pool maintain -C ~/.config") # Let's set it to maintain, ey?
-    end
-    # Change the hostname for the instance
-    def configure_linux
-      ssh("'hostname -v #{name}'") rescue message "error in setting hostname"
-    end
-    # Configure s3fs if the bucket is specified in the config.yml
-    def configure_s3fuse
-      message("Configuring s3fuse")
-      
-      unless Application.shared_bucket.empty?
-        install_s3fuse unless ssh("s3fs -v") =~ /missing\ bucket/
-        ssh("/usr/bin/s3fs #{Application.shared_bucket} -ouse_cache=/tmp -o accessKeyId=#{Application.access_key} -o secretAccessKey=#{Application.secret_access_key} -o nonempty /data")
-      end
-    end
-    # Configure heartbeat only if there is enough servers
-    def configure_heartbeat
-      message "Configuring heartbeat"
-      install_heartbeat unless has?("heartbeat")
-      
-      file = write_to_temp_file(open(Application.heartbeat_authkeys_config_file).read.strip)
-      scp(file.path, "/etc/ha.d/authkeys")
-      
-      file = Master.build_heartbeat_config_file_for(self)
-      scp(file.path, "/etc/ha.d/ha.cf")
-      
-      file = Master.build_heartbeat_resources_file_for(self)
-      scp(file.path, "/etc/ha.d/haresources")
-    end
-    # Some configures for monit
-    def configure_monit
-      message "Configuring monit"
-      install_monit unless has?("monit -V")
-      
-      scp(Application.monit_config_file, "/etc/monit/monitrc")
-      ssh("mkdir /etc/monit.d")
-      Dir["#{File.dirname(Application.monit_config_file)}/monit/*"].each do |f|
-        scp(f, "/etc/monit.d/#{File.basename(f)}")
-      end
-    end
-    # Configure haproxy
-    def configure_haproxy
-      message "Configuring haproxy"
-      install_haproxy unless has?("haproxy")
-      
-      file = Master.new.build_haproxy_file
-      scp(file.path, "/etc/haproxy.cfg")
-    end
-    # Configure the hosts for the linux file
-    def configure_hosts
-      message "Configuring hosts"
-      file = Master.build_hosts_file_for(self)
-      scp(file.path, "/etc/hosts") rescue message "Error in uploading new /etc/hosts file"
-    end
-    # Restart all services with monit
-    # Send a generic version command to test if the stdout contains
-    # any information to test if the software is on the instance
-    def has?(str)
-      !ssh("#{str} -v").empty?
-    end
-    # MONITORS
-    # Monitor the number of web requests that can be accepted at a time
-    def web
-      Monitors::Web.monitor_from_string ssh("httperf --server localhost --port #{Application.client_port} --num-conn 3 --timeout 5 | grep 'Request rate'") rescue 0.0
-    end
-    # Monitor the cpu status of the instance
-    def cpu
-      Monitors::Cpu.monitor_from_string ssh("uptime") rescue 0.0
-    end
-    # Monitor the memory
-    def memory
-      Monitors::Memory.monitor_from_string ssh("free -m | grep -i mem") rescue 0.0
-    end    
-    # Scp src to dest on the instance
-    def scp(src="", dest="")
-      `scp -i #{Application.keypair_path} #{src} #{Application.username}@#{@ip}:#{dest}`
-    end
-    # Ssh into the instance or run a command, if the cmd is set
-    def ssh(cmd="")
-      ssh = "ssh -i #{Application.keypair_path} #{Application.username}@#{@ip}"
-      
-      cmd.empty? ? system("#{ssh}") : %x[#{ssh} '#{cmd.runnable}']
-    end
-    
-    # Description in the rake task
-    def description
-      case @status
-      when "running"
-        "#{@number}: INSTANCE: #{name} - #{@ip} - #{@instance_id} - #{@launching_time}"
-      when "shutting-down"
-        "(terminating) INSTANCE: #{name} - #{@ip} - #{@instance_id} - #{@launching_time}"
-      when "pending"
-        "(booting) INSTANCE: #{name} - #{@ip} - #{@instance_id} - #{@launching_time}"
-      end
-    end
-    def stack_installed?
-      @stack_installed == true
-    end
-    def mark_installed
-      @stack_installed = true
-    end
-    # Include the os specific tasks as specified in the application options (config.yml)
-    instance_eval "include PoolParty::Os::#{Application.os.capitalize}"
-    
-    # CALLBACKS
-    after :install_stack, :configure # After we install the stack, let's make sure we configure it too
-    before :configure, :mark_installed # We want to make sure
-    after :configure, :restart_with_monit # Anytime we configure the server, we want the server to restart it's services
-  end
-end

data/lib/pool_party/remoting.rb

@@ -1,112 +0,0 @@
-module PoolParty
-  extend self
-  
-  class Remoting
-    include PoolParty
-    include Ec2Wrapper
-    include Scheduler
-                
-    # == GENERAL METHODS    
-    # == LISTING
-    # List all the running instances associated with this account
-    def list_of_running_instances
-      list_of_nonterminated_instances.select {|a| a[:status] =~ /running/}
-    end
-    # Get a list of the pending instances
-    def list_of_pending_instances
-      list_of_nonterminated_instances.select {|a| a[:status] =~ /pending/}
-    end
-    # list of shutting down instances
-    def list_of_terminating_instances
-      list_of_nonterminated_instances.select {|a| a[:status] =~ /shutting/}
-    end
-    # list all the nonterminated instances
-    def list_of_nonterminated_instances
-      list_of_instances.reject {|a| a[:status] =~ /terminated/}
-    end
-    # List the instances, regardless of their states
-    def list_of_instances
-      get_instances_description
-    end
-    # Get number of pending instances
-    def number_of_pending_instances
-      list_of_pending_instances.size
-    end
-    # get the number of running instances
-    def number_of_running_instances
-      list_of_running_instances.size
-    end
-    # get the number of pending and running instances
-    def number_of_pending_and_running_instances
-      number_of_running_instances + number_of_pending_instances
-    end
-    # == LAUNCHING
-    # Request to launch a new instance
-    def request_launch_new_instance
-      if can_start_a_new_instance?
-        request_launch_one_instance_at_a_time
-        return true
-      else
-        return false
-      end
-    end
-    # Can we start a new instance?
-    def can_start_a_new_instance?
-      maximum_number_of_instances_are_not_running?
-    end
-    # Are the maximum number of instances running?
-    def maximum_number_of_instances_are_not_running?
-      list_of_running_instances.size < Application.maximum_instances
-    end
-    # Request to launch a number of instances
-    def request_launch_new_instances(num=1)
-      out = []
-      num.times {out << request_launch_one_instance_at_a_time}
-      out
-    end
-    # Launch one instance at a time
-    def request_launch_one_instance_at_a_time
-      reset!
-      while !number_of_pending_instances.zero?
-        wait "5.seconds"
-        reset!
-      end
-      return launch_new_instance!
-    end
-    # == SHUTDOWN
-    # Terminate all running instances
-    def request_termination_of_running_instances
-      list_of_running_instances.each {|a| terminate_instance!(a[:instance_id])}
-    end
-    # Request termination of all instances regardless of their state (includes pending instances)
-    def request_termination_of_all_instances
-      get_instances_description.each {|a| terminate_instance!(a[:instance_id])}
-    end
-    # Terminate instance by id
-    def request_termination_of_instance(id)
-      if can_shutdown_an_instance?
-        terminate_instance! id
-        return true
-      else
-        return false
-      end
-    end
-    # Can we shutdown an instance?
-    def can_shutdown_an_instance?
-      minimum_number_of_instances_are_running?
-    end
-    # Are the minimum number of instances running?
-    def minimum_number_of_instances_are_running?
-      list_of_running_instances.size > Application.minimum_instances
-    end
-    # Get the cached running_instances
-    def running_instances
-      @running_instances ||= update_instance_values
-    end
-    # Update the instance values
-    def update_instance_values
-      @running_instances = list_of_running_instances.collect {|a| RemoteInstance.new(a) }.sort
-    end
-  end
-    
-end