poolparty 0.0.4

data/lib/pool_party/monitors.rb

@@ -0,0 +1,13 @@
+=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/optioner.rb

@@ -0,0 +1,16 @@
+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/ubuntu.rb

@@ -0,0 +1,78 @@
+=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/os.rb

@@ -0,0 +1,11 @@
+=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/remote_instance.rb

@@ -0,0 +1,180 @@
+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

@@ -0,0 +1,112 @@
+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

data/lib/pool_party/scheduler.rb

@@ -0,0 +1,93 @@
+module PoolParty
+  extend self
+  # Schedule tasks container
+  class ScheduleTasks
+    attr_reader :tasks
+    include ThreadSafeInstance
+    # Initialize tasks array and run
+    def initialize
+      @tasks = []
+      run
+    end
+    # Synchronize the running threaded tasks
+    def run
+      unless @tasks.empty?
+        self.class.synchronize do
+          @tasks.reject!{|a| 
+            begin
+              a.run;a.join
+            rescue Exception => e    
+              puts "There was an error in the task: #{e} #{e.backtrace.join("\n")}"
+            end
+            true
+          }
+        end
+      end
+    end
+    # Add a task in a new thread
+    def <<(a)
+      @tasks.push( Thread.new {a.call} )
+    end
+    alias_method :push, :<<
+    # In the ThreadSafeInstance
+    make_safe :<<
+  end
+  # Scheduler class
+  module Scheduler
+    attr_reader :tasks
+    # Get the tasks or ScheduleTasks
+    def tasks
+      @tasks ||= ScheduleTasks.new
+    end
+    # Add a task to the new threaded block
+    def add_task(&blk)
+      tasks.push proc{blk.call}
+    end
+    # Grab the polling_time
+    def interval
+      @interval ||= Application.polling_time
+    end
+    # Run the threads
+    def run_threads
+      tasks.run
+    end
+    # Daemonize the process
+    def daemonize
+      puts "Daemonizing..."
+      
+      pid = fork do
+        Signal.trap('HUP', 'IGNORE') # Don't die upon logout
+        File.open("/dev/null", "r+") do |devnull|
+          $stdout.reopen(devnull)
+          $stderr.reopen(devnull)
+          $stdin.reopen(devnull) unless @use_stdin
+        end
+        yield if block_given?
+      end
+      Process.detach(pid)      
+    end
+    # Run the loop and wait the amount of time between running the tasks
+    # You can send it daemonize => true and it will daemonize
+    def run_thread_loop(opts={})
+      block = lambda {        
+        loop do
+          begin
+            yield if block_given?
+            run_threads
+            wait interval
+            reset!
+          rescue Exception => e
+            puts "There was an error in the run_thread_loop: #{e}"
+          end
+        end
+      }
+      # Run the tasks
+      opts[:daemonize] ? daemonize(&block) : block.call   
+    end
+    # Reset
+    def reset!
+      cached_variables.each {|cached| cached = nil }
+    end
+        
+  end
+end