poolparty 0.0.4 → 0.2.6

data/lib/pool_party/scheduler.rb

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

data/lib/pool_party/tasks.rb

@@ -1,220 +0,0 @@
-module PoolParty
-  module TaskCommands
-    # Run the command on the local system
-    def run(cmd)
-      system(cmd.runnable)
-    end
-    # Basic setup action
-    def setup_application
-      Application.options({:config_file => (ENV["CONFIG_FILE"] || ENV["config"]) })
-    end
-  end
-  class Tasks
-    include TaskCommands
-    # Setup and define all the tasks
-    def initialize
-      yield self if block_given?
-      define_tasks!
-    end
-    # Define the tasks in the rakefile
-    def define_tasks!
-      # Tasks dealing with only an instance
-      namespace(:instance) do
-        # Find the instance we want to deal with
-        # interface can be: num=0, i=0, inst=0, 0
-        # defaults to the master instance (0)
-        task :init do
-          num = (ENV['num'] || ENV["i"] || ENV["inst"] || ARGV.shift || 0).to_i          
-          raise Exception.new("Please set the number of the instance (i.e. num=1, i=1, or as an argument)") unless num
-          @node = PoolParty::Master.new.get_node(num)
-        end
-        # Ssh into the node
-        desc "Remotely login to the remote instance"
-        task :ssh => [:init] do
-          @node.ssh
-        end
-        # Send a file to the remote instance
-        # as designated by src='' and dest=''
-        desc "Send a file to the remote instance"
-        task :scp => [:init] do
-          @node.scp ENV['src'], ENV['dest']
-        end
-        # Execute a command on the remote instance as designated
-        # by cmd=''
-        desc "Execute cmd on a remote instance"
-        task :exec => [:init] do
-          cmd = ENV['cmd'] || "ls -l"
-          puts @node.ssh(cmd.runnable)
-        end
-        # Restart all the services monitored by monit
-        desc "Restart all the services"
-        task :reload => [:init] do
-          @node.restart_with_monit
-        end
-        # Start all the services monitored by monit
-        desc "Start all services"
-        task :load => [:init] do
-          @node.start_with_monit
-        end
-        # Stop the services monitored by monit
-        desc "Stop all services"
-        task :stop => [:init] do
-          @node.stop_with_monit
-        end
-        # Install the required services on this node
-        desc "Install stack on this node"
-        task :install => :init do          
-          @node.install_stack
-        end
-        # Turnoff this instance
-        desc "Teardown instance"
-        task :shutdown => :init do
-          `ec2-terminate-instances #{@node.instance_id}`
-        end
-        # Configure this node and start the services
-        desc "Configure the stack on this node"
-        task :configure => :init do
-          @node.configure
-          @node.restart_with_monit
-        end
-      end
-      
-      namespace(:dev) do
-        task :init do
-          setup_application
-        end
-        # Setup a basic development environment for the user 
-        desc "Setup development environment specify the config_file"
-        task :setup => :init do
-          keyfilename = ".#{Application.keypair}_pool_keys"
-          run <<-EOR
-            echo 'export ACCESS_KEY=\"#{Application.access_key}\"' > $HOME/#{keyfilename}
-            echo 'export SECRET_ACCESS_KEY=\"#{Application.secret_access_key}\"' >> $HOME/#{keyfilename}
-            echo 'export EC2_HOME=\"#{Application.ec2_dir}\"' >> $HOME/#{keyfilename}
-            echo 'export KEYPAIR_NAME=\"#{Application.keypair}\"' >> $HOME/#{keyfilename}
-            echo 'export CONFIG_FILE=\"#{Application.config_file}\"' >> $HOME/#{keyfilename}
-          EOR
-        end
-      end
-      # Cloud tasks
-      namespace(:cloud) do
-        # Setup
-        task :init do
-          setup_application
-          raise Exception.new("You must specify your access_key and secret_access_key") unless Application.access_key && Application.secret_access_key
-        end
-        # Install the stack on all of the nodes
-        desc "Prepare all servers"
-        task :prepare => :init do
-          PoolParty::Master.new.nodes.each do |node|
-            node.install_stack
-          end
-        end
-        # Start the cloud
-        desc "Start the cloud"
-        task :start => :init do
-          PoolParty::Master.new.start_cloud!
-        end
-        # Reload the cloud with the new updated data
-        desc "Reload all instances with updated data"
-        task :reload => :init do
-          PoolParty::Master.new.nodes.each do |node|
-            node.configure
-            node.restart_with_monit
-          end
-        end
-        # List the cloud
-        desc "List cloud"
-        task :list => :init do
-          PoolParty::Master.new.list
-        end
-        # Shutdown the cloud
-        desc "Shutdown the entire cloud"
-        task :shutdown => :init do
-          PoolParty::Master.new.request_termination_of_all_instances
-        end
-        # Maintain the cloud in a background process
-        desc "Maintain the cloud (run on the master)"
-        task :maintain => :init do
-          begin
-            PoolParty::Master.new.start_monitor!
-          rescue Exception => e
-            puts "There was an error starting the monitor: #{e}"
-          end
-        end
-        # Deploy task. 
-        # TODO: Find a beautiful way of updating the user-defined configuration
-        # data
-        desc "Deploy web application from production git repos specified in config file"
-        task :deploy => :init do
-          puts "Deploying web app on nginx"
-        end
-      end
-      
-      # Nearly antiquated tasks
-      namespace(:ec2) do        
-        task :init do
-          Application.options
-        end
-        # Start a new instance in the cloud
-        desc "Add and start an instance to the pool"
-        task :start_new_instance => [:init] do
-          puts PoolParty::Remoting.new.launch_new_instance!
-        end
-        # Stop all the instances via command-line
-        desc "Stop all running instances"
-        task :stop_running_instances => [:init] do
-          Thread.new {`ec2-describe-instances | grep INSTANCE | grep running | awk '{print $2}' | xargs ec2-terminate-instances`}
-        end
-        # Reboot the instances via commandline
-        desc "Restart all running instances"
-        task :restart_running_instances => [:init] do
-          Thread.new {`ec2-describe-instances | grep INSTANCE | grep running | awk '{print $2}' | xargs ec2-reboot-instances`}
-        end
-      end
-      # Tasks to be run on the server
-      namespace(:server) do                
-        task :init  do
-          PoolParty::Coordinator.init(false)
-        end
-        # bundle, upload and register your bundle on the server
-        desc "Bundle, upload and register your ami"
-        task :all => [:bundle, :upload, :register] do
-          puts "== your ami is ready"
-        end
-        # Cleanup the /mnt directory
-        desc "Clean the /mnt directory"
-        task :clean_mnt do
-          `rm -rf /mnt/image* img*`
-        end
-        # Before we can bundle, we have to make sure we have the cert and pk files
-        desc "Ensure the required bundle files are present in /mnt"
-        task :check_bundle_files do
-          raise Exception.new("You must have a private key in your /mnt directory") unless File.exists?("/mnt/pk-*.pem")
-          raise Exception.new("You must have your access key in your /mnt directory") unless File.exists?("/mnt/cert-*.pem")          
-        end
-        # Bundle the image
-        desc "Bundle this image into the /mnt directory"
-        task :bundle => [:clean_mnt, :check_bundle_files] do
-          puts `ec2-bundle-vol -k /mnt/pk-*.pem -u '#{Planner.user_id}' -d /mnt -c /mnt/cert-*.pem -r i386`
-        end
-        # Upload the bundle into the app_name bucket
-        desc "Upload the bundle to your bucket with a unique name: deletes old ami"
-        task :upload => [:init, :delete_bucket] do
-          puts `ec2-upload-bundle -b #{Planner.app_name} -m /mnt/image.manifest.xml -a #{Planner.access_key} -s #{Planner.secret_access_key}`
-        end
-        # Register the bucket with amazon and get back an ami
-        desc "Register the bundle with amazon"
-        task :register do
-          puts `ec2-register -K /mnt/pk-*.pem -C /mnt/cert-*.pem #{Planner.app_name}/image.manifest.xml`
-        end
-        # Delete the bucket
-        desc "Delete the bucket with the bundle under tha app name"
-        task :delete_bucket do
-          Planner.app_name.delete_bucket 
-        end
-      end      
-    end    
-    
-  end
-end

data/lib/s3/s3_object_store_folders.rb

@@ -1,44 +0,0 @@
-=begin rdoc
-  S3 overloads
-=end
-module AWS
-  module S3
-    class S3Object
-       class << self
-         
-        alias :original_store :store
-        def store(key, data, bucket = nil, options = {})
-          store_folders(key, bucket, options) if options[:use_virtual_directories]
-          original_store(key, data, bucket, options)
-        end
-        
-        def streamed_store(key, filepath, bucket = nil, options = {})
-          store_folders(key, bucket, options) if options[:use_virtual_directories]
-          store(key,File.open(filepath), bucket)
-        end
-        
-        def store_directory(directory, bucket, options = {})
-          Dir[File.join(directory, "*")].each do |file|
-            streamed_store("#{File.basename(File.dirname(file))}/#{File.basename(file)}", file, bucket, options.update(:use_virtual_directories => true))
-          end
-        end
-  
-        def store_folders(key, bucket = nil, options = {})
-          folders = key.split("/")
-          folders.slice!(0)
-          folders.pop
-          current_folder = "/"
-          folders.each {|folder|
-            current_folder += folder
-            store_folder(current_folder, bucket, options)
-            current_folder += "/"
-          }
-        end
-  
-        def store_folder(key, bucket = nil, options = {})
-          original_store(key + "_$folder$", "", bucket, options) # store the magic entry that emulates a folder
-        end
-      end
-    end
-  end
-end

data/spec/application_spec.rb

@@ -1,32 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe "Application" do
-  before(:each) do
-  end
-  it "should have the root_dir defined" do
-    Application.root_dir.should_not be_nil
-  end
-  it "should be able to call on the haproxy_config_file" do
-    Application.haproxy_config_file.should_not be_nil
-  end
-  it "should be able to find the client_port" do
-    Application.options.should_receive(:client_port).and_return(7788)
-    Application.client_port.should == 7788
-  end
-  it "should always have haproxy in the managed services list" do
-    Application.managed_services =~ /haproxy/
-  end
-  it "should be able to say it is in development mode if it is in dev mode" do
-    Application.stub!(:environment).and_return("development")
-    Application.development?.should == true
-  end
-  it "should be able to say it is in production if it is in production" do
-    Application.stub!(:environment).and_return("production")
-    Application.production?.should == true
-  end
-  it "should be able to say it's keypair path is in the $HOME/ directory" do
-    Application.stub!(:ec2_dir).and_return("~/.ec2")
-    Application.stub!(:keypair).and_return("poolparty")
-    Application.keypair_path.should == "~/.ec2/id_rsa-poolparty"
-  end
-end

data/spec/callback_spec.rb

@@ -1,65 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-class TestCallbacks
-  include Callbacks
-  attr_reader :str
-  def hello
-    string << "hello "
-  end
-  def world
-    string << "world"
-  end
-  def thanks
-    string << ", thank you"
-  end
-  before :world, :hello
-  after :world, :thanks
-  def pop
-    string << "pop"
-  end
-  def boom
-    string << " goes boom"
-  end  
-  after :pop, :boom
-  def string
-    @str ||= String.new
-  end
-end
-describe "Callbacks" do
-  before(:each) do
-    @klass = TestCallbacks.new
-  end
-  it "should retain it's class identifier" do
-    @klass.class.should == TestCallbacks
-  end
-  it "should callback the method before the method runs" do
-    @klass.world.should == "hello world, thank you"
-  end
-  it "should callback the method before the method runs" do
-    @klass.pop.should == "pop goes boom"
-  end
-end
-class TestMultipleCallbacks
-  include Callbacks
-  attr_reader :str
-  def hi
-    string << "hi, "
-  end
-  def hello
-    string << "hello "
-  end
-  def world
-    string << "world"
-  end
-  def string
-    @str ||= String.new
-  end
-  before :world, :hi
-  before :world, :hello
-end
-describe "Multiple callbacks" do
-  before(:each) do
-    @klass = TestMultipleCallbacks.new
-  end
-  it "should be able to have multiple callbacks on the same call"
-end