fairchild-poolparty 1.1.4 → 1.1.5

data/lib/poolparty/{base_packages → plugins}/tokyo_tyrant.rb

@@ -1,6 +1,6 @@
 module PoolParty
   class Base
-    plugin :poolparty_base_tokyo_tyrant do
+    plugin :tokyo_tyrant do
       
       def enable
         has_package "build-essential"

data/lib/poolparty/poolparty/cloud.rb

@@ -4,7 +4,7 @@ require File.dirname(__FILE__) + "/resource"
 module PoolParty    
   module Cloud
     # Instantiate a new cloud
-    def cloud(name=:app, &block)
+    def cloud(name, &block)
       clouds[name] ||= Cloud.new(name, &block)
     end
 
@@ -25,13 +25,15 @@ module PoolParty
 
       include CloudResourcer
       include PoolParty::PluginModel
-      include PoolParty::Resources      
+      include PoolParty::Resources
+      include PoolParty::Callbacks
       include PoolParty::DependencyResolverCloudExtensions
       include PrettyPrinter
 
       # Net methods
       include ::PoolParty::Remote
       include PoolParty::CloudDsl
+      include PoolParty::Verification
       # include PoolParty::Monitors
 
       def verbose
@@ -45,7 +47,7 @@ module PoolParty
       # Redefining methods are not allowed
       def self.method_added sym        
         raise "Exception: #{sym.to_s.capitalize} method has been redefined" if immutable_methods.include?(sym) && !respond_to?(sym)
-      end      
+      end
       
       alias :name :cloud_name
       
@@ -68,6 +70,10 @@ module PoolParty
         :user => Default.user
       )
       
+      additional_callbacks [
+        "after_launch_instance"
+      ]
+      
       # 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(name, &block)
@@ -75,8 +81,8 @@ module PoolParty
         @cloud_name.freeze
         
         plugin_directory "#{pool_specfile ? ::File.dirname(pool_specfile) : Dir.pwd}/plugins"        
+        before_create
         super
-        
         after_create
       end
       
@@ -85,35 +91,48 @@ module PoolParty
         @cloud_name ||= @cloud_name ? @cloud_name : (args.empty? ? :default_cloud : args.first)
       end
       
+      def before_create     
+        context_stack.push self
+        (parent ? parent : self).add_poolparty_base_requirements
+        context_stack.pop
+      end
+      
       # Callback
       # called after the cloud has been created, everything has run and is set at this point
       # here the base requirements are added as well as an empty chef recipe is called
       # Also, the after_create hook on the plugins used by the cloud are called here
       def after_create
-        dputs "In after create"
         ::FileUtils.mkdir_p("#{Default.tmp_path}/dr_configure")
+        
         run_in_context do
-          add_poolparty_base_requirements
+          add_optional_enabled_services
           chef do
           end
         end
-        plugin_store.each {|a| a.after_create }
+        
+        plugin_store.each {|a| a.call_after_create_callbacks }
         setup_defaults
+        
+        setup_callbacks
       end
       
       # setup defaults for the cloud
       def setup_defaults
         # this can be overridden in the spec, but ec2 is the default
         using :ec2
-        options[:keypair] ||= keypair.basename rescue nil
-        options[:rules] = {:expand => expand_when, :contract => contract_when}
-        dependency_resolver 'chef'
-        enable :haproxy unless dsl_options[:haproxy] == :disabled
+        options[:keypair] ||= keypair rescue nil
+        options[:rules] = {:expand => dsl_options[:expand_when], :contract => dsl_options[:contract_when]}
+        dependency_resolver 'chef'        
+        # enable :haproxy unless dsl_options[:haproxy] == :disabled
+      end
+      
+      def after_launch_instance(inst=nil)
+        remote_base.send :after_launch_instance, inst
       end
       
       # provide list of public ips to get into the cloud
       def ips
-        list_of_running_instances.map {|ri| ri.ip }
+        nodes(:status => "running").map {|ri| ri.ip }
       end
       
       # TODO: make this be a random ip, since we should not rely on it being the same each time
@@ -159,9 +178,10 @@ module PoolParty
         @build_manifest ||= build_from_existing_file
         unless @build_manifest          
           props = to_properties_hash
-         
+          
           @build_manifest =  options[:dependency_resolver].send(:compile, props, self)
         end
+        dputs "Finished creating manifest"
         @build_manifest
       end
       
@@ -172,6 +192,7 @@ module PoolParty
       end
       
       # If the pp already exists, then let's not recreate it
+      # TODO: Abstract
       def build_from_existing_file
         ::FileTest.file?("#{Default.base_config_directory}/poolparty.pp") ? open("#{Default.base_config_directory}/poolparty.pp").read : nil
       end
@@ -183,18 +204,6 @@ module PoolParty
         ::File.open("#{file_path}/#{file_name}", "w") {|f| f.write output }
         true
       end
-            
-      # Callbacks on bootstrap and configuration
-      %w( before_bootstrap 
-          after_bootstrap 
-          before_configure 
-          after_configure).each do |meth|
-        module_eval <<-EOE
-          def call_#{meth}_callbacks
-            plugin_store.each {|a| a.#{meth} }
-          end
-        EOE
-      end
       
       # Add all the poolparty requirements here
       # NOTE: These are written as plugins in the lib/poolparty/base_packages directory
@@ -203,17 +212,9 @@ module PoolParty
       # all that is necessary in a method called enable
       # which is called when there is no block
       def add_poolparty_base_requirements
-        poolparty_base_heartbeat
+        # poolparty_base_heartbeat
         poolparty_base_ruby
-        poolparty_base_packages
-        
-        add_optional_base_packages
-      end
-      
-      # Add optional base packages included with PP
-      def add_optional_base_packages
-        poolparty_base_haproxy      if enabled? :haproxy
-        poolparty_base_tokyo_tyrant if enabled? :tokyo_tyrant
+        poolparty_base_packages        
       end
       
       # TODO: Deprecate

data/lib/poolparty/poolparty/default.rb

@@ -33,20 +33,10 @@ module PoolParty
       :forwarding_port => "8080",
       :monitor_port => 8081,
       :proxy_mode => "http",
-      :messenger_client_port => 7050,
       :butterfly_port => 8642,
       :minimum_runtime  => 3000, #50.minutes in seconds
       :contract_when => "load < 0.25",
-      :expand_when => "load > 0.9",
-      # :agent_pid_file => ::File.readable?("/var/run/poolparty_agent.pid") ? "/var/run/agent.pid" : "#{Dir.pwd}/agent.pid",
-      # :agent_port => 8081,
-      # EC2 Options
-      :ami => "ami-7cfd1a15",
-      :size => 'm1.small', # must be 'm1.small', 'm1.large', 'm1.xlarge', 'c1.medium', or 'c1.xlarge'  #TODO: change to instance_size
-      :availabilty_zone => "us-east-1a",
-      :security_group => ["default"],
-      # Options that should not be touched pretty much ever
-      :manifest_path => "/etc/puppet/manifests" 
+      :expand_when => "load > 0.9"
     )
     
     def options
@@ -97,6 +87,7 @@ module PoolParty
       def reset!
         @keys = nil
       end
+      
       # Get the instance first instance file that exists on the system from the expected places
       # denoted in the local_instances_list_file_locations
       def get_working_key_file_locations

data/lib/poolparty/poolparty/key.rb

@@ -1,13 +1,14 @@
-# STUB FOR NOW
-# TODO
+=begin rdoc
+  ssh key used to login to remote instances
+=end
 module PoolParty
   class Key
     
     attr_accessor :filepath
     
     # Create a new key that defaults to id_rsa as the name. 
-    def initialize(filepath=nil)
-      @filepath = (filepath.nil? || filepath.empty?) ? "id_rsa" : filepath
+    def initialize(fpath=nil)
+      @filepath = (fpath.nil? || fpath.empty?) ? "id_rsa" : fpath
     end
     
     # If the full_filepath is nil, then the key doesn't exist
@@ -42,20 +43,23 @@ module PoolParty
     # then it returns nil and assumes we it doesn't exist
     def search_in_known_locations
       self.class.keypair_paths.each do |path|
-        full_path = ::File.join( ::File.expand_path(path), filepath)
+        full_path = ::File.join( ::File.expand_path(path), ::File.basename(filepath))
         return full_path if ::File.exists?(full_path)
       end
+      # raise Exception.new("We cannot continue without a keypair. Please define a keypair in your clouds.rb")
+      # TODO: Add raise for keypair
       nil
     end
     
     # Default locations to search for the key
     def self.keypair_paths
-      [ "#{ENV["HOME"]}/.ssh",
+      [ 
+        "#{ENV["HOME"]}/.ssh",
         "#{Default.poolparty_home_path}/keys",
-        Default.base_keypair_path,
-        Default.base_config_directory,
-        Default.base_ssh_path,
-        Default.remote_storage_path,        
+        PoolParty::Default.base_keypair_path,
+        PoolParty::Default.base_config_directory,
+        PoolParty::Default.base_ssh_path,
+        PoolParty::Default.remote_storage_path,
         Dir.pwd
       ]
     end
@@ -67,8 +71,7 @@ module PoolParty
     
     # Turn the keypair into the a useful json string
     def to_json
-      "{\"basename\":\"#{basename}\",
-       \"full_filepath\": \"/etc/poolparty/#{filename}\"}"
+      "{\"basename\":\"#{basename}\",\"full_filepath\": \"/etc/poolparty/#{filename}\"}"
     end
     
   end

data/lib/poolparty/poolparty/neighborhoods.rb

@@ -1,26 +1,55 @@
+=begin rdoc
+  Neighborhood
+  
+  Neighborhoods describes the neighborhood that an instance is in.
+  Neighborhoods are instances that are "near" other instances, either by 
+  association of instantiation or through monitor_rack.   
+=end
+require "#{::File.dirname(__FILE__)}/../modules/pinger"
 require "#{::File.dirname(__FILE__)}/../schema"
 
 module PoolParty
   class Neighborhoods
+    include ::PoolParty::Pinger    
     attr_reader :schema
     
-    def initialize(json)
-      raise Exception.new("You must pass a string or a hash to Neighborhoods") unless json
-      
-      case json
+    # Create a neighborhood from a string, array or hash given.
+    def initialize(data)
+      raise Exception.new("You must pass a string or a hash to Neighborhoods") unless data
+      parsed_data = case data
       when Array
-        json = {:instances => json.map {|entry| disect(entry) }}
+        {:instances => data.map {|entry| disect(entry) }}
       when String
-        json = {:instances => JSON.parse(json).map {|inst| "#{inst["name"]}\t#{inst["ip"]}"}}
+        {:instances => JSON.parse(data)}#.map "#{inst["instance_id"]}\t#{inst["ip"]}"}}
+      when Hash
+        data
       end
-      @schema = PoolParty::Schema.new(json)
+      @schema = PoolParty::Schema.new(parsed_data)
       raise Exception.new("No instances found in the Neighborhoods schema") unless @schema.instances
     end
     
+    # Get the known instances from the neighborhood.json file on the server
     def instances
-      @instances ||= @schema.instances.map {|line| disect(line) }
+      @instances ||= @schema.to_hash[:instances] rescue @schema.instances.collect {|line| disect(line) }
+    end
+    
+    # Returns empty if the neighborhood has no instances
+    def empty?
+      instances.empty?
+    end
+    
+    # Get the next node in the hash
+    def next_node(node_hash)
+      return nil if empty?
+      sort.wrapping_next(node_hash)
     end
     
+    # Sort the instances by ip string, a very basic sort
+    def sort
+      instances.sort {|a, b| a.ip <=> b.ip}
+    end
+    
+    # Get the instances at the specific index of the neighborhood
     def [](at)
       instances[at] if at >= 0 && at < instances.size
     end
@@ -29,14 +58,13 @@ module PoolParty
       case line
       when String
         arr = line.split("\t")
-        {:name => arr[0], :ip => arr[1]}
-      when Hash
-        "#{line[:name]}\t#{line[:ip]}"
+        {:instance_id => arr[0], :ip => arr[1]}
       else
         line
       end
     end
     
+    # Run through an enumeration of the instances
     def each(&block)
       instances.each &block
     end
@@ -52,17 +80,22 @@ module PoolParty
       new(json).clump(filepath)
     end
     
+    # Load the default neighborhood.json file
+    # If the neighborhood.json file exists in 
+    #   /etc/poolparty/neighborhood.json
+    # then load the neighborhood from the file, otherwise
+    # if there is a butterfly server running locally,
+    # query it for the current neighborhood.
+    # Finally, return an empty set of instances
     def self.load_default
-      def_file = [
-        Dir.pwd,
-        Default.base_config_directory,
-        Default.remote_storage_path,
-        Default.poolparty_home_path
-      ].select do |dir|
-        filepath = ::File.expand_path("#{dir}/neighborhood.json")
-        filepath if ::File.file?(filepath)
-      end.first || nil
-      def_file ? new( open(::File.expand_path("#{def_file}/neighborhood.json")).read ) : nil
+      if ::File.file?("/etc/poolparty/neighborhood.json")
+        new( open("/etc/poolparty/neighborhood.json").read )
+      elsif ping_port("127.0.0.1", Default.butterfly_port, 1)# butterfly responding?
+        require "open-uri"
+        new( open("http://127.0.0.1:8642/neighborhood").read )
+      else
+        new("[]")
+      end
     end
     
   end

data/lib/poolparty/poolparty/plugin.rb

@@ -7,6 +7,7 @@ module PoolParty
     class Plugin < PoolParty::Service
       include CloudResourcer
       include PoolParty::DependencyResolverCloudExtensions
+      include PoolParty::Callbacks
             
       default_options({})
       
@@ -21,6 +22,9 @@ module PoolParty
         run_in_context do
           loaded @opts, &block
         end
+        
+        setup_callbacks
+        after_create
       end
       
       # Overwrite this method
@@ -31,14 +35,7 @@ module PoolParty
       # Callbacks available to plugins
       def after_create
       end
-      def before_bootstrap
-      end
-      def after_bootstrap
-      end
-      def before_configure
-      end
-      def after_configure
-      end
+      
       def enable
       end
       def is_plugin?
@@ -59,7 +56,7 @@ module PoolParty
       end
       
       def self.inherited(subclass)
-        method_name = subclass.to_s.top_level_class.gsub(/pool_party_/, '').gsub(/_class/, '').downcase.to_sym        
+        method_name = subclass.to_s.top_level_class.gsub(/pool_party_/, '').gsub(/_class/, '').downcase.to_sym
         add_has_and_does_not_have_methods_for(method_name)
       end
       

data/lib/poolparty/poolparty/plugin_model.rb

@@ -4,7 +4,7 @@ module PoolParty
   module PluginModel
     
     def plugin(name=:plugin, cloud=nil, &block)
-      plugins.has_key?(name) ? plugins[name] : (plugins[name] = PluginModel.new(name, &block))
+      plugins[name] ||= PluginModel.new(name, &block)
     end
     alias_method :register_plugin, :plugin
     
@@ -15,8 +15,8 @@ module PoolParty
     class PluginModel
       attr_accessor :klass
       
-      def initialize(name,&block)
-        symc = "#{name}".top_level_class.camelcase        
+      def initialize(name,&block)        
+        symc = "#{name}".top_level_class.camelcase
         klass = symc.class_constant(PoolParty::Plugin::Plugin, {:preserve => true}, &block)
         
         lowercase_class_name = symc.downcase
@@ -28,9 +28,9 @@ module PoolParty
             i = plugin_store.select {|i| i if i.class == #{lowercase_class_name.camelcase}Class }.first if plugin_store
             if i
               i
-            else
+            else              
               inst = #{lowercase_class_name.camelcase}Class.new(opts, parent, &block)
-              this_context.plugin_store << inst if this_context
+              plugin_store << inst if plugin_store
               inst
             end
           end

data/lib/poolparty/poolparty/pool.rb

@@ -1,7 +1,7 @@
 module PoolParty
   module Pool
     
-    def pool(name=:app, &block)
+    def pool(name, &block)
       pools[name] ||= Pool.new(name, &block)
     end
     
@@ -18,14 +18,18 @@ module PoolParty
     def set_pool_specfile(filename)
       $pool_specfile = filename unless $pool_specfile
     end
-        
+    
+    def pool_specfile
+      $pool_specfile
+    end
+    
     def reset!
       $pools = $clouds = $plugins = @describe_instances = nil
     end
 
     class Pool < PoolParty::PoolPartyBaseClass
       include PrettyPrinter
-      include CloudResourcer # WHY?!?! TODO: investigate
+      include CloudResourcer # WHY?!?! TODO: check on this
       include Remote
       
       default_options Default.default_options
@@ -44,7 +48,7 @@ module PoolParty
       def self.load_from_file(filename=nil)
         # a = new ::File.basename(filename, ::File.extname(filename))
         File.open(filename, 'r') do |f|
-          instance_eval f.read
+          instance_eval f.read, pool_specfile
         end
         # a
       end

data/lib/poolparty/poolparty/poolparty_base_class.rb

@@ -12,26 +12,25 @@ module PoolParty
     include PoolParty::DependencyResolverCloudExtensions
     # attr_accessor :depth
 
-    def initialize(opts={}, extra_opts={}, &block)      
+    def initialize(opts={}, extra_opts={}, &block)
       add_to_parent_if_parent_exists_and_is_a_service
       
       @init_block = block
       @base_name = get_name_from_options_and_extra_options(opts, extra_opts)
       
-      opts = (opts.is_a?(Hash) ? extra_opts.merge(opts) : extra_opts).merge(:name => @base_name)
+      o = (opts.is_a?(Hash) ? extra_opts.merge(opts) : extra_opts).merge(:name => @base_name)
       
-      run_in_context(opts, &block)
+      run_in_context(o, &block)
       super(&block)
     end
     
     # Overloading the parent run_in_context
-    def run_in_context(opts={}, &block)
-      if opts
+    def run_in_context(o={}, &block)
+      if o
         context_stack.push self
-        set_vars_from_options(opts)
+        set_vars_from_options(o)
         instance_eval &block if block
         context_stack.pop
-        head
       else
         super
       end
@@ -40,7 +39,7 @@ module PoolParty
     # Add the parent's options to my own and add myself as a service if I am not a resource
     def add_to_parent_if_parent_exists_and_is_a_service      
       if parent && !parent.is_a?(PoolParty::Resources::Resource)
-        dsl_options(parent.dsl_options) if parent.is_a?(PoolParty::Pool::Pool)
+        dsl_options.merge!(parent.dsl_options) if parent.is_a?(PoolParty::Pool::Pool)
         parent.add_service(self) if parent.respond_to?(:add_service) && !is_a_resource?
       end
     end
@@ -95,6 +94,7 @@ module PoolParty
         end
         res.after_create
         store_in_local_resources(ty, res)
+        ordered_resources << res
         res
       end
     end
@@ -118,10 +118,19 @@ module PoolParty
       end
     end
     
+    # Store the call and use of plugins into an array
+    def plugin_store
+      @plugin_store ||= []
+    end
+    
     def resource(type=:file)
       resources[type.to_sym] ||= []
     end
     
+    def ordered_resources
+      @ordered_resources ||= []
+    end
+    
     def is_plugin?
       false
     end
@@ -130,7 +139,7 @@ module PoolParty
       false
     end
     
-    def method_missing(m,*a,&block)      
+    def method_missing(m,*a,&block)
       if this_context && this_context != self && this_context.respond_to?(m)# && !self.is_a?(PoolParty::Resources::Resource)
         this_context.send m, *a, &block      
       else
@@ -162,10 +171,10 @@ module PoolParty
       method_name = "__#{typ}"
       PoolParty::PoolPartyBaseClass.module_eval <<-EOE
         def has_#{typ}(opts={}, extra={}, &block)
-          #{method_name}(handle_option_values(opts).merge(extra.merge(:ensures => :present)), &block)
+          #{method_name}({:ensures => :present}.merge(handle_option_values(opts).merge(extra)), &block)
         end
         def does_not_have_#{typ}(opts={}, extra={}, &block)
-          #{method_name}(handle_option_values(opts).merge(extra.merge(:ensures => :absent)), &block)
+          #{method_name}({:ensures => :absent}.merge(handle_option_values(opts).merge(extra)), &block)
         end
       EOE
     end

data/lib/poolparty/poolparty/resource.rb

@@ -50,7 +50,7 @@ module PoolParty
             end
             def get_#{lowercase_class_name}(n, opts={}, &block)
               res = get_resource(:#{lowercase_class_name}, n, opts, &block)
-              raise PackageException.new("A required #{lowercase_class_name} \#\{n\} was not found.") unless res
+              raise PackageException.new("Oops. Check that you specified the #{lowercase_class_name} \#\{n\}.") unless res
               res
             end
             public
@@ -75,16 +75,20 @@ module PoolParty
       # the options
       # Finally, it uses the parent's options as the lowest priority
       def initialize(opts={}, extra_opts={}, &block)
-        super(opts, &block)
-        
+        super(opts, extra_opts, &block)
+                
         @resource_name = @base_name
-        dsl_options[:name] = resource_name unless dsl_options.has_key?(:name)        
+        dsl_options[:name] = resource_name unless dsl_options.has_key?(:name)
+        
+        loaded(opts, &block)
+        
+        after_create
       end
             
       # Stub, so you can create virtual resources
       # This is called after the resource is initialized
       # with the options given to it in the init-block
-      def loaded(opts={})
+      def loaded(opts={}, &block)
       end
       
       def resource_name

data/lib/poolparty/poolparty/service.rb

@@ -18,7 +18,9 @@ module PoolParty
       
       meth = <<-EOM
         def __#{lowercase_class_name}(opts={}, &block)
-          PoolParty::#{lowercase_class_name.camelcase}Class.new(opts, &block)
+          i = PoolParty::#{lowercase_class_name.camelcase}Class.new(opts, &block)
+          plugin_store << i if respond_to?(:plugin_store)
+          i
         end
         alias :#{lowercase_class_name} :__#{lowercase_class_name}
       EOM