auser-poolparty 1.2.12 → 1.3.0

data/lib/poolparty/cloud.rb

@@ -0,0 +1,246 @@
+module PoolParty  
+  class Cloud < DslBase
+    has_searchable_paths
+    
+    # Options we want on the output of the compiled script
+    # but want to take the options from the parent if they
+    # are nil on the cloud
+    default_options(
+      :minimum_instances        => 2,     # minimum_instances default
+      :maximum_instances        => 5,     # maximum_instances default
+      :minimum_runtime          => 3600,  # minimum_instances default: 1 hour
+      :contract_when            => nil,
+      :expand_when              => nil,
+      :cloud_provider_name      => :ec2,
+      :dependency_resolver_name => nil,
+      :os                       => nil,
+      :bootstrap_script         => nil
+    )
+    
+    # Define what gets run on the callbacks
+    # This is where we can specify what gets called
+    # on callbacks
+    #   parameters: cld, time
+    #   cld - the cloud the callback came from
+    #   callback - the callback called (i.e. :after_provision)
+    callback_block do |cld, callback|
+    end
+    
+    # Freeze the cloud_name so we can't modify it at all, set the plugin_directory
+    # call and run instance_eval on the block and then call the after_create callback
+    def initialize(n, o={}, &block)
+      @cloud_name = n
+      @cloud_name.freeze
+      
+      # @init_block = block
+      @init_opts = compile_opts(o)
+      
+      @init_block = Proc.new do
+        super(n,o,&block)
+      end
+      
+    end
+    
+    # returns an instance of Keypair
+    # You can pass either a filename which will be searched for in ~/.ec2/ and ~/.ssh/
+    # Or you can pass a full filepath
+    def keypair(n=nil)
+      @keypair ||= Keypair.new(n)
+    end
+    
+    # Declare the CloudProvider for a cloud
+    #  Create an instance of the cloud provider this cloud is using
+    def using(provider_symbol, o={}, &block)
+      return @cloud_provider if @cloud_provider
+      self.cloud_provider_name = provider_symbol
+      cloud_provider(o, &block)
+    end
+    
+    # Cloud provider methods
+    def nodes(o={}); delayed_action {cloud_provider.nodes(o)}; end
+    def run_instance(o={}); cloud_provider.run_instance(o);end
+    def terminate_instance!(o={}); cloud_provider.terminate_instance!(o);end
+    def describe_instances(o={}); cloud_provider.describe_instances(o);end
+    def describe_instance(o={}); cloud_provider.describe_instance(o);end
+    
+    # Terminate all instances in the cloud
+    def terminate!
+      nodes.collect{|n| n.terminate! }
+    end
+    
+    # The actual cloud_provider instance
+    def cloud_provider(opts={}, &block)
+      return @cloud_provider if @cloud_provider
+      klass_name = "CloudProviders::#{cloud_provider_name}".classify
+      if provider_klass = CloudProviders.all.detect {|k| k.to_s == klass_name }
+        opts.merge!(:cloud => self, :keypair_name => self.keypair.basename)
+        @cloud_provider = provider_klass.new(dsl_options.merge(opts), &block)
+      else
+        raise PoolParty::PoolPartyError.create("UnknownCloudProviderError", "Unknown cloud_provider: #{cloud_provider_name}")
+      end
+      @cloud_provider
+    end
+    
+    # 1.) Launches a new instance,
+    # 2.) Waits for the instance to get an ip address
+    # 3.) Waits for port 22 to be open
+    # 4.) Calls call_after_launch_instance callbacks
+    # 5.) Executes passed &block, if any
+    # 6.) Returns the new instance object
+    def expand(opts={}, &block)
+      timeout = opts.delete(:timeout) || 300
+      callback :before_launch_instance
+      instance = cloud_provider.run_instance(opts)
+      instance.cloud = self
+      @instance = instance
+      #wait for an ip and then wait for ssh port, then configure instance
+      if instance.wait_for_public_ip(timeout) && instance.wait_for_port(22, :timeout=>timeout)
+        callback :after_launch_instance
+        instance.callback :before_bootstrap
+        instance.bootstrap!
+        instance.callback :after_bootstrap
+        instance.callback :before_configure
+        instance.configure!
+        instance.callback :after_configure
+        block.call(instance) if block
+        instance
+      else
+         raise StandardError.new("Instance port 22 not available")
+      end
+      instance.refresh!
+      instance
+    end
+    
+    # Contract the cloud
+    def contract!(hsh={})
+      inst=nodes(hsh).last
+      inst.callback :before_terminate
+      inst.terminate!
+      inst.callback :after_terminate
+      inst
+    end
+    
+    # convenience method to loop thru all the nodes and configure them
+    def configure!(opts={}, threaded=true)
+      nodes.collect{|n| n.configure!}
+    end
+    
+    # Run command/s on all nodes in the cloud.
+    # Returns a hash of instance_id=>result pairs
+    def run(commands, opts={})
+      results = {}
+      threads = nodes.collect do |n|
+         Thread.new{ results[n.name] = n.run(commands, opts)  }
+      end
+      threads.each{ |aThread|  aThread.join }
+      results
+      # Serial implementation #
+      # nodes.inject({})do |results, n|
+      #   results[n.instance_id] = n.run(commands, opts)
+      #   results
+      # end
+    end
+    
+    # Temporary path
+    # Starts at the global default tmp path and appends the pool name
+    # and the cloud name
+    def tmp_path
+      Default.tmp_path / pool.name / name
+    end
+    
+    # The pool this cloud belongs to
+    def pool
+      parent
+    end
+    
+    # compile
+    
+    # Resolve with the dependency resolver
+    def resolve_with(a)
+      if DependencyResolvers.const_defined?(a.classify)        
+        dependency_resolver DependencyResolvers.module_eval("#{a.classify}")
+      else
+        raise PoolParty::PoolPartyError.create("DependencyResolverError", "Undefined dependency resolver: #{a}. Please specify one of the following: #{DependencyResolvers.all.join(", ")}")
+      end
+    end
+    
+    # Set the dependency resolver
+    def dependency_resolver(sym=nil)
+      @dependency_resolver ||= case sym
+      when :chef, nil
+        dsl_options[:dependency_resolver_name] = :chef
+        DependencyResolvers::Chef
+      end
+    end
+    
+    # Take the cloud's resources and compile them down using 
+    # the defined (or the default dependency_resolver, chef)
+    def compile(caller=nil)
+      FileUtils.mkdir_p tmp_path unless File.directory?(tmp_path)
+      ddputs("Compiling cloud #{self.name} to #{tmp_path/"etc"/"#{dependency_resolver_name}"}")
+      dependency_resolver.compile_to(ordered_resources, tmp_path/"etc"/"#{dependency_resolver_name}", caller)
+    end
+    
+    # Get the os of the first node if it was not explicity defined, we'll assume they are
+    # all homogenous
+    def os(sym=nil)
+      if sym
+        dsl_options[:os] = sym
+      else
+        nodes.size > 0 ? nodes.first.os : dsl_options[:os]
+      end
+    end
+    alias :platform :os
+    
+    # The public_ip of the cloud is equivalent to the public_ip
+    # of the cloud's oldest node
+    def public_ip
+      nodes.first.public_ip
+    end
+    
+    ### MONITORS ###
+    # Create a new monitor on the cloud
+    # == Usage
+    #   monitor :cpu do |v|
+    #     vote_for(:expand) if v > 0.8
+    #   end
+    def monitor(monitor_symbol, &block)
+      monitors[monitor_symbol] ||= PoolParty::Monitor.new(monitor_symbol, &block)
+    end
+    
+    # Run the monitor logic
+    def run_monitor(monitor_name, value)
+      mon = monitors[monitor_name.to_sym]
+      if mon
+        mon.run(value.to_f)
+      else
+        "unhandled monitor"
+      end
+    end
+    
+    # Store the monitors in an array
+    def monitors
+      @monitors ||= {}
+    end
+    
+    ##### Internal methods #####
+    # Methods that only the cloud itself will use
+    # and thus are private
+    
+    # Form the cloud
+    # Run the init block with the init_opts
+    # on the cloud
+    # This is run after the cloud.rb file has been consumed
+    def form_clouds
+      run_with_callbacks(@init_opts, &@init_block)
+      loaded!
+    end
+    
+    def after_all_loaded
+      run_after_loaded do |b|
+        run_in_context(&b)
+      end
+    end
+    
+  end
+end

data/lib/poolparty/default.rb

@@ -0,0 +1,32 @@
+=begin rdoc
+  Default class
+  
+  Hangs on and defines defaults for PoolParty
+=end
+
+module PoolParty
+  class Default
+    include Dslify
+    
+    default_options(
+      :user => "root",
+      :os => :ubuntu,
+      :tmp_path => "/tmp/poolparty",
+      :poolparty_home_path => "#{ENV["HOME"]}/.poolparty",
+      :ec2_home => "#{ENV["HOME"]}/.ec2",
+      :poolparty_src_path => File.expand_path("#{::File.dirname(__FILE__)}/../../"),
+      :base_config_directory => "/etc/poolparty",
+      :remote_storage_path => "/var/poolparty",
+      :poolparty_log_path => "#{File.dirname(__FILE__)}/log/poolparty.log",
+      :verbose        => false,
+      :debug          => false,
+      :very_debugging => false
+    )
+        
+    # Method missing
+    def self.method_missing(m,*a,&block)
+      dsl_options.include?(m) ? dsl_options[m] : super
+    end
+    
+  end
+end

data/lib/poolparty/dsl_base.rb

@@ -0,0 +1,36 @@
+=begin rdoc
+  Dsl Base class for all cloud dsl methods
+  
+  Pool and Cloud both are taken from the DslBase so that both
+  carry the same dsl. The methods that apply to either/or
+  are defined in the respective classes
+=end
+
+module PoolParty
+  class DslBase < Base
+    
+    default_options(
+      :minimum_instances        => 2,
+      :maximum_instances        => 5
+    )
+            
+    # Set instances with a range or a number
+    # if passed with a hash, call nodes(hash) to return filtered list of 
+    # instances
+    def instances(arg)
+      case arg
+      when Range
+        minimum_instances arg.first
+        maximum_instances arg.last
+      when Fixnum
+        minimum_instances arg
+        maximum_instances arg
+      when Hash
+        nodes(arg)
+      else
+        raise PoolParty::PoolPartyError.create("DslMethodCall", "You must call instances with either a number, a range or a hash (for a list of nodes)")
+      end
+    end
+    
+  end
+end

data/lib/poolparty/installer.rb

@@ -0,0 +1,107 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.dirname(__FILE__) + "/poolparty")
+
+require "poolparty"
+
+module PoolParty
+  class Installer
+
+    include PoolParty::Pinger
+    include Askable
+        
+    def run
+      begin
+        self.__send__ :welcome_message
+        steps.each {|c| self.__send__ c.to_sym }
+        self.__send__ :closing_message
+      rescue Exception => e
+        # colored_say e.inspect
+        colored_say exit_msg
+      ensure
+        Colors.reset!
+      end
+    end
+    
+    def welcome_message
+      welcome_msg = <<-EOE
+We are going to take you through the installation process of PoolParty.
+
+First, we'll setup your environment so using PoolParty will be a <blue>breeze</blue>
+      EOE
+
+        @exit_msg = <<-EOE
+
+<line>
+<yellow>Cancelled PoolParty installation</yellow>
+
+You can always restart this by typing:
+<blue>install-poolparty</blue>
+
+<line>
+EOE
+
+
+      colored_say "<yellow>Welcome to PoolParty!</yellow>"
+      colored_say welcome_msg
+      colored_ask "Press enter to continue or Ctrl+C to exit", :no_value => true
+      
+    end
+    
+    def closing_message
+closing_message = <<-EOE
+
+<line>
+You are now set to <blue>ride the waves</blue> with PoolParty! You'll notice there is a <blue>clouds.rb</blue> file in your current directory. 
+
+You can start your new cloud by typing in this directory:
+
+<blue>cloud start [-v]</blue>
+
+You can start your clouds.rb. More samples are available here: 
+<yellow>http://github.com/auser/poolparty-examples/tree/master</yellow>
+
+<line>
+EOE
+      colored_say closing_message
+    end
+    
+    def exit_msg
+      @exit_msg || <<-EOE
+<red>--- quiting ---</red>
+You can always restart the installer by typing #{$0}. 
+
+If you need help, feel free to stop by the irc room:
+irc.freenode.net / #poolpartyrb
+      EOE
+    end
+    
+    
+    def steps
+      @steps ||= []
+    end
+    
+    def self.name
+    end
+    
+    def self.description
+    end
+    
+    def self.to_s
+      "#{name} - #{description}"
+    end
+    
+    def self.inherited(subclass)
+      all << subclass
+    end
+    
+    def self.all
+      @all ||= []
+    end
+
+
+  end
+end
+
+%w(vmware ec2).each do |lib|
+  require "installers/#{lib}"
+end

data/lib/poolparty/installers/ec2.rb

@@ -1,141 +1,30 @@
 module PoolParty
   module Installers
-    class Ec2 < BaseInstaller
+    class Ec2 < Installer
       
-      def commands
+      def steps
         [
-          :get_access_key, :get_secret_access_key, :show_cert_message,
-          # :get_ec2_api_tools,
-          :get_keypair, :write_clouds_rb
+          :todo
         ]
       end
       
-      def get_access_key        
-        key_help_str = <<-EOE
-Now you need to get your keys from Amazon AWS.
-If you don't already have your keys setup, navigate to http://aws.amazon.com
-and click on Your Account. Click on the Access Identifiers tab and find:
-Your Access Key ID. This is your access key.
-        EOE
-        access_key_str = <<-EOE
-Since you'll be using ec2, we'll have to set some things up before
-we can get going on PoolParty. Don't worry, this information will stay between us.
-
-        EOE
-        say access_key_str
-        ask_with_help :message => "First, what's your access key?",
-                      :help => key_help_str do |t|
-          @access_key = t
-        end
+      def self.name
+        "Ec2"
       end
       
-      def get_secret_access_key
-        key_help_str = <<-EOE
-If you don't already have your keys setup, navigate to http://aws.amazon.com
-and click on Your Account. Click on the Access Identifiers tab and find:
-Your Secret Access Key ID. Click on the - show button.
-This is your secret access key.
-        EOE
-        ask_with_help :message => "Awesome. Now what's your secret access key? ",
-                      :help => key_help_str do |t|
-          @secret_access_key = t
-        end
+      def self.description
+        "Ec2 installer"
       end
       
-      def show_cert_message
-        rescued_ask_str = <<-EOS
-Super duper! You'll need to make sure you have yout X.509 certificate downloaded too.
-Save this in your ~/.ec2 directory.
-
-Press enter when you're ready
-EOS
-
-        cert_help_str = <<-EOE
-To get your X.509 certificates, navigate to http://aws.amazon.com and login. Click on
-Your Account and scroll down. The X.509 Certificate box is at the bottom. Make sure you
-click download and save the cert-*.pem file. If you don't know or don't have the pk-*.pem file
-you may have to recreate it. Not to worry though, it's super easy. Click on the Create New button. 
-From there, you can download the cert-*.pem and the pk-*.pem files.
-
+      def todo
+        colored_say <<-EOE
+          <line>
+          <red>Not implemented yet</red>
+          <line>
         EOE
-
-        ask_with_help :message => rescued_ask_str,
-                      :help => cert_help_str do |t|
-          @cert = true
-        end
-      end
-      
-      def get_ec2_api_tools
-        url = "http://developer.amazonwebservices.com/connect/entry.jspa?externalID=351&categoryID=88"
-        download_url = "http://www.amazon.com/gp/redirect.html/ref=aws_rc_ec2tools?location=http://s3.amazonaws.com/ec2-downloads/ec2-api-tools.zip&token=A80325AA4DAB186C80828ED5138633E3F49160D9"
-        require 'open-uri'
-        ::File.open("ec2-commandline-tools.zip", "w") {|f| f << open(download_url).read }
+        exit 0
       end
       
-      def get_keypair
-        begin
-          ec2 = PoolParty::Remote::Ec2.ec2({:access_key => @access_key, :secret_access_key => @secret_access_key})
-          keypairs = ec2.describe_keypairs["keySet"]["item"]
-          keynames = keypairs.map {|k| k["keyName"]}  
-        rescue Exception => e
-          colored_say "There was an error: #{e}. Recheck your access_key and secret_access_key to make sure you copied them correctly"
-          exit 1
-        end
-
-        key_str =<<-EOK
-
-Finally, what's the name of the keypair you'd like to use?
-
-You already have the following keypairs setup:
-\t#{keynames.join("\n\t")}
-
-You can use one of these keys, or create a new one.
-EOK
-
-        key_str_help =<<-EOH
-  To make a new keypair, make sure you have the ec2 tools installed. You can create a new one by typing the command:
-    ec2-add-keypair
-
-  Save this into a file in your ~/.ec2 directory. Enter the name of the keypair here.
-EOH
-        ask_with_help :message => key_str,
-                      :help => key_str_help do |t|
-            @keypair = t
-            say <<-EOE
-
-In your clouds.rb, you can use this keypair in your clouds.
-
-Create one for each cloud you want to use.
-
-          EOE
-        end
-      end
-      
-      def write_clouds_rb
-        clds =<<-EOC
-pool :my_pool do
-  cloud :my_app do
-
-    # Copy these lines and source them in your .profile or .bashrc file
-    # export AWS_ACCESS_KEY="#{@access_key}"
-    # export AWS_SECRET_ACCESS_KEY="#{@secret_access_key}"
-    # export EC2_PRIVATE_KEY=$(ls ~/.ec2/pk-*.pem)
-    # export EC2_CERT=$(ls ~/.ec2/cert-*.pem)
-
-    access_key "#{@access_key}"
-    secret_access_key "#{@secret_access_key}"
-    keypair "#{@keypair}"
-
-    has_file "/etc/motd" do
-      content "Welcome to your first PoolParty instance!"
-    end
-  end
-end             
-        EOC
-
-        ::File.open("clouds.rb", "w") {|f| f << clds}
-      end
-
     end
   end
 end