poolparty 0.2.84 → 1.2.2

data/lib/poolparty/poolparty/key.rb

@@ -0,0 +1,78 @@
+=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(fpath=nil)
+      @filepath = (fpath.nil? || fpath.empty?) ? "id_rsa" : fpath
+    end
+    
+    # If the full_filepath is nil, then the key doesn't exist
+    def exists?
+      full_filepath != nil
+    end
+    
+    # Read the content of the key
+    def content
+      @content ||= exists? ? open(full_filepath).read : nil
+    end
+        
+    # Returns the full_filepath of the key. If a full filepath is passed, we just return the expanded filepath
+    # for the keypair, otherwise query where it is against known locations
+    def full_filepath
+      @full_filepath ||= ::File.file?(::File.expand_path(filepath)) ? ::File.expand_path(filepath) : search_in_known_locations
+    end
+    alias :to_s :full_filepath
+    
+    # Basename of the keypair
+    def basename
+      @basename ||= ::File.basename(full_filepath, ::File.extname(full_filepath)) rescue filepath
+    end
+    
+    # Just the filename of the keypair
+    def filename
+      @filename ||= ::File.basename(full_filepath) rescue filepath
+    end
+    
+    # Search for the key in default locations with the entire filepath
+    # if the file exists. If it doesn't exist in the default locations, 
+    # 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), ::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",
+        "#{Default.poolparty_home_path}/keys",
+        PoolParty::Default.base_keypair_path,
+        PoolParty::Default.base_config_directory,
+        PoolParty::Default.base_ssh_path,
+        PoolParty::Default.remote_storage_path,
+        Dir.pwd
+      ]
+    end
+    
+    # Support to add the enumerable each to keys
+    def each
+      yield full_filepath
+    end
+    
+    # Turn the keypair into the a useful json string
+    def to_json
+      "{\"basename\":\"#{basename}\",\"full_filepath\": \"/etc/poolparty/#{filename}\"}"
+    end
+    
+  end
+end

data/lib/poolparty/poolparty/loggable.rb

@@ -1,27 +1,28 @@
-=begin rdoc
-  A logging class to allow us to log to locations
-=end
-class Loggable
-  def initialize    
-    self.class.loggers << file_logger
-    file_logger.level = :info
-  end
-  def file_logger
-    @file_logger ||= Logging.logger( Base.pool_logger_location, logging_opts )
-  end
-  def stdout_logger
-    @stdout_logger ||= Logging.logger(STDOUT, logging_opts.merge({:pattern => "%m\n"}))
-  end
-  def logging_opts
-    {:pattern => "[%d] %-l : %m\n",
-    :date_pattern => "%Y-%m-%d %H:%M:%S.%s"}
-  end
-  %w(info warn debug notice).each do |meth|
-    define_method(meth.to_sym) do |*args|
-      self.class.loggers.each {|l| l.send meth.to_sym, args}
-    end
-  end
-  def self.loggers
-    @loggers ||= []
-  end
-end
+#todo: Deprecate
+# =begin rdoc
+#   A logging class to allow us to log to locations
+# =end
+# class Loggable
+#   def initialize    
+#     self.class.loggers << file_logger
+#     file_logger.level = :info
+#   end
+#   def file_logger
+#     @file_logger ||= Logging.logger( Default.pool_logger_location, logging_opts )
+#   end
+#   def stdout_logger
+#     @stdout_logger ||= Logging.logger(STDOUT, logging_opts.merge({:pattern => "%m\n"}))
+#   end
+#   def logging_opts
+#     {:pattern => "[%d] %-l : %m\n",
+#     :date_pattern => "%Y-%m-%d %H:%M:%S.%s"}
+#   end
+#   %w(info warn debug notice).each do |meth|
+#     define_method(meth.to_sym) do |*args|
+#       self.class.loggers.each {|l| l.send meth.to_sym, args}
+#     end
+#   end
+#   def self.loggers
+#     @loggers ||= []
+#   end
+# end

data/lib/poolparty/poolparty/neighborhoods.rb

@@ -0,0 +1,102 @@
+=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
+    
+    # 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
+        {:instances => data.map {|entry| disect(entry) }}
+      when String
+        {:instances => JSON.parse(data)}#.map "#{inst["instance_id"]}\t#{inst["ip"]}"}}
+      when Hash
+        data
+      end
+      @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.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
+    
+    def disect(line)
+      case line
+      when String
+        arr = line.split("\t")
+        {: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
+    
+    # TODO: Make this into something useful
+    def clump(filepath=nil)
+      out = instances.to_json
+      ::File.open(filepath, "w") {|f| f << out } if filepath
+      out
+    end
+    
+    def self.clump(json, filepath=nil)
+      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
+      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
+end

data/lib/poolparty/poolparty/plugin.rb

@@ -1,33 +1,68 @@
+require "#{::File.dirname(__FILE__)}/service.rb"
+require "#{::File.dirname(__FILE__)}/../provision/boot_strapper.rb"
+
 module PoolParty
-      
   module Plugin
         
-    class Plugin
-      include Configurable
+    class Plugin < PoolParty::Service
       include CloudResourcer
-      include Resources
+      include PoolParty::DependencyResolverCloudExtensions
+      include PoolParty::Callbacks
       
-      class_inheritable_accessor :name
+      def initialize(opts={}, prnt=nil, &block)
+        setup_callbacks
+
+        run_in_context do
+          before_load(opts, &block)
+        end
+        
+        block = Proc.new {enable} unless block
+        
+        @opts = (opts.is_a?(Hash) ? opts : {:name => opts})
+        super(opts, &block)
+        
+        run_in_context do
+          loaded @opts, &block
+        end
+                
+        after_create
+      end
       
-      default_options({})
+      # Overwrite this method
+      def before_load(o={}, &block)        
+      end
+      def loaded(o={}, &block)
+      end
+      # Callbacks available to plugins
+      def after_create
+      end
       
-      def initialize(p=self, opts={}, &block)
-        store_block &block
-        run_setup(p)
-        realize! unless block
+      def enable
+      end
+      def is_plugin?
+        true
       end
-            
-      def realize!(force=false)
-        force ? force_realize! : (@realized ? nil : force_realize!)
+      def cloud
+        @parent
       end
       
-      def force_realize!
-        run_setup(parent, false, &stored_block)
-        enable unless stored_block
+      def bootstrap_gems *gems
+        gems.each do |g|
+          Provision::BootStrapper.gem_list << g unless Provision::BootStrapper.gem_list.include?(g)
+        end
       end
       
-      # Overwrite this method
-      def enable
+      def bootstrap_commands cmds
+        Provision::BootStrapper.class_commands << cmds
+      end
+      
+      def configure_commands cmds
+        Provision::DrConfigure.class_commands << cmds
+      end
+      
+      def self.inherited(subclass)
+        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
       
     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
     
@@ -12,34 +12,31 @@ module PoolParty
       $plugins ||= {}
     end
     
-    class PluginModel      
-      attr_accessor :name, :klass
-      include MethodMissingSugar
-      include Configurable
-      include PrettyPrinter      
+    class PluginModel
+      attr_accessor :klass
       
-      def initialize(name,&block)
-        @name = name
-        # @parent = cld
-        class_string_name = "#{name}"
-        
-        # Create the class to evaluate the plugin on the implemented call
-        @klass = klass = class_string_name.class_constant(PoolParty::Plugin::Plugin)
-        mod = class_string_name.module_constant(&block)
-        
-        klass.send :include, mod
+      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
         # Store the name of the class for pretty printing later
-        klass.name = name
+        # klass.name = name
         # Add the plugin definition to the cloud as an instance method
-        PoolParty::Cloud::Cloud.class_eval <<-EOE
-          def #{name}(parent=self, &block)
-            @pa = parent
-            @#{class_string_name.downcase} ||= returning #{class_string_name.class_constant}.new(parent, &block) do |pl|
-              @pa.plugin_store << pl
+        meth = <<-EOM
+          def #{lowercase_class_name}(opts={}, &block)
+            i = plugin_store.select {|i| i if i.class == #{lowercase_class_name.camelcase}Class }.first if plugin_store
+            if i
+              i
+            else              
+              inst = #{lowercase_class_name.camelcase}Class.new(opts, parent, &block)
+              plugin_store << inst if plugin_store
+              inst
             end
           end
-        EOE
+        EOM
+
+        PoolParty::Cloud::Cloud.class_eval meth
       end
       
     end

data/lib/poolparty/poolparty/pool.rb

@@ -1,9 +1,9 @@
 module PoolParty
   module Pool
     
-    def pool(name=:app, &block)
-      pools.has_key?(name) ? pools[name] : (pools[name] = Pool.new(name, &block))
-    end    
+    def pool(name, &block)
+      pools[name] ||= Pool.new(name, &block)
+    end
     
     def pools
       $pools ||= {}
@@ -14,45 +14,53 @@ module PoolParty
       pl.options.merge!(opts) if pl.options
       pl.run_in_context &block if block
     end
-        
+    
+    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
-      # include PoolParty::Cloud
-      include MethodMissingSugar
-      # include PluginModel
-      include Configurable
+    class Pool < PoolParty::PoolPartyBaseClass
       include PrettyPrinter
-      include CloudResourcer
+      include CloudResourcer # WHY?!?! TODO: check on this
       include Remote
       
-      default_options({
-        :access_key => Base.access_key,
-        :secret_access_key => Base.secret_access_key
-      })
+      default_options Default.default_options
       
       def initialize(name,&block)
-        setup_defaults
         @pool_name = name
         @pool_name.freeze
-        # run_in_context &block if block
-        run_setup(self, &block)        
+        
+        ::PoolParty.context_stack.clear
+        
+        set_pool_specfile get_latest_caller
+        setup_defaults
+
+        super(&block)
       end
-      
-      def name
-        @pool_name
+      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, pool_specfile
+        end
+        # a
+      end
+      def name(*args)
+        @pool_name ||= @pool_name ? @pool_name : (args.empty? ? :default_pool : args.first)
       end
+
+      def parent;nil;end
       
-      def setup_defaults
-        plugin_directory "#{::File.dirname(pool_specfile ? pool_specfile : Dir.pwd)}/plugins"
+      def setup_defaults        
         PoolParty::Extra::Deployments.include_deployments "#{Dir.pwd}/deployments"
       end
-            
-      # This is where the entire process starts
-      def inflate
-      end
       
       def pool_clouds
         returning Array.new do |arr|

data/lib/poolparty/poolparty/poolparty_base_class.rb

@@ -0,0 +1,190 @@
+require "dslify"
+require "parenting"
+module PoolParty
+  
+  def context_stack
+    $context_stack ||= []
+  end
+  
+  class PoolPartyBaseClass
+    include Dslify, Parenting
+    
+    include PoolParty::DependencyResolverCloudExtensions
+    # attr_accessor :depth
+
+    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)
+      
+      o = (opts.is_a?(Hash) ? extra_opts.merge(opts) : extra_opts).merge(:name => @base_name)
+      
+      run_in_context(o, &block)
+      super(&block)
+    end
+    
+    # Overloading the parent run_in_context
+    def run_in_context(o={}, &block)
+      if o
+        context_stack.push self
+        set_vars_from_options(o)
+        instance_eval &block if block
+        context_stack.pop
+      else
+        super
+      end
+    end
+    
+    # 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.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
+    
+    # Try to extract the name from the options
+    def get_name_from_options_and_extra_options(opts={}, extra_opts={})
+      opts.is_a?(Hash) ? (opts.has_key?(:name) ? opts.delete(:name) : nil) : dsl_options[:name] = opts
+    end
+    
+    # Add to the services pool for the manifest listing
+    def add_service(serv, extra_name="")
+      subclass = "#{serv.class.to_s.top_level_class.underscore.downcase}#{extra_name}"
+      lowercase_class_name = subclass.to_s.underscore.downcase || subclass.downcase
+      
+      # (services[lowercase_class_name.to_sym] ||= []) << serv if serv && !serv.empty?
+      ordered_resources << serv
+      # services.merge!({lowercase_class_name.to_sym => serv})
+    end
+    # Container for the services
+    
+    def resources
+      @resources ||= OrderedHash.new
+    end
+    
+    # Add resource
+    # When we are looking to add a resource, we want to make sure the
+    # resources isn't already added. This way we prevent duplicates 
+    # as puppet can be finicky about duplicate resource definitions. 
+    # We'll look for the resource in either a local or global store
+    # If the resource appears in either, return that resource, we'll just append
+    # to the resource config, otherwise instantiate a new resource of the type
+    # and store it into the global and local resource stores
+    # 
+    # A word about stores, the global store stores the entire list of stored
+    # resources. The local resource store is available on all clouds and plugins
+    # which stores the instance variable's local resources. 
+    def add_resource(ty, opts={}, extra_opts={}, &block)    
+      temp_name = get_name_from_options_and_extra_options(opts, extra_opts)
+      
+      if res = get_resource(ty, temp_name, opts)        
+        res
+      else
+        opts = (opts.is_a?(Hash) ? extra_opts.merge(opts) : extra_opts).merge(:name => temp_name)
+        
+        # opts.merge!(:name => temp_name) unless opts.has_key?(:name)
+        res = if PoolParty::Resources::Resource.available_resources.include?(ty.to_s.camelize)
+          "PoolParty::Resources::#{ty.to_s.camelize}".camelize.constantize.new(opts, &block)
+        else
+          "#{ty.to_s.camelize}".camelize.constantize.new(opts.merge(:name), &block)
+        end
+        res.after_create
+        store_in_local_resources(ty, res)
+        ordered_resources << res
+        res
+      end
+    end
+    def store_in_local_resources(ty, obj)
+      resource(ty) << obj
+    end
+    def in_local_resources?(ty, k)
+      !resource(ty).select {|r| r.name == k }.empty? rescue false
+    end
+    def get_local_resource(ty, k)
+      resource(ty).select {|r| r.name == k }.first
+    end
+    
+    def get_resource(ty, n, opts={}, &block)
+      if in_local_resources?(ty, n)
+        get_local_resource(ty, n)
+      elsif parent && parent != self
+        parent.get_resource(ty, n)
+      else
+        nil
+      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
+    
+    def is_a_resource?
+      false
+    end
+    
+    def method_missing(m,*a,&block)
+      if respond_to?(:this_context) && this_context != self && this_context.respond_to?(m)# && !self.is_a?(PoolParty::Resources::Resource)
+        this_context.send m, *a, &block      
+      else
+        # if dsl_options.has_key?(m)
+        #          dsl_options[m]
+        #        elsif parent && parent.respond_to?(:dsl_options) && parent.dsl_options.has_key?(m)
+        #          parent.dsl_options[m]
+        #        elsif self.class.default_options.has_key?(m)
+        #          self.class.default_options[m]
+        #        elsif parent && parent.respond_to?(:dsl_options) && parent.default_options.has_key?(m)
+        #          parent.default_options[m]
+        #        else
+          super
+        # end
+      end
+    end
+    
+    # Adds two methods to the module
+    # Adds the method type:
+    #   has_
+    # and 
+    #   does_not_have_
+    # for the type passed
+    # for instance
+    # add_has_and_does_not_have_methods_for(:file)
+    # gives you the methods has_file and does_not_have_file
+    # TODO: Refactor nicely to include other types that don't accept ensure
+    def self.add_has_and_does_not_have_methods_for(typ=:file)
+      method_name = "__#{typ}"
+      PoolParty::PoolPartyBaseClass.module_eval <<-EOE
+        def has_#{typ}(opts={}, extra={}, &block)
+          #{method_name}({:ensures => :present}.merge(handle_option_values(opts).merge(extra)), &block)
+        end
+        def does_not_have_#{typ}(opts={}, extra={}, &block)
+          #{method_name}({:ensures => :absent}.merge(handle_option_values(opts).merge(extra)), &block)
+        end
+      EOE
+    end
+    
+    def handle_option_values(o)
+      case o.class.to_s
+      when "String"
+        {:name => o}
+      else
+        o
+      end
+    end
+    
+  end
+end