auser-poolparty 1.0.0 → 1.1.1

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,69 @@
+require "#{::File.dirname(__FILE__)}/../schema"
+
+module PoolParty
+  class Neighborhoods
+    attr_reader :schema
+    
+    def initialize(json)
+      raise Exception.new("You must pass a string or a hash to Neighborhoods") unless json
+      
+      case json
+      when Array
+        json = {:instances => json.map {|entry| disect(entry) }}
+      when String
+        json = {:instances => JSON.parse(json).map {|inst| "#{inst["name"]}\t#{inst["ip"]}"}}
+      end
+      @schema = PoolParty::Schema.new(json)
+      raise Exception.new("No instances found in the Neighborhoods schema") unless @schema.instances
+    end
+    
+    def instances
+      @instances ||= @schema.instances.map {|line| disect(line) }
+    end
+    
+    def [](at)
+      instances[at] if at >= 0 && at < instances.size
+    end
+    
+    def disect(line)
+      case line
+      when String
+        arr = line.split("\t")
+        {:name => arr[0], :ip => arr[1]}
+      when Hash
+        "#{line[:name]}\t#{line[:ip]}"
+      else
+        line
+      end
+    end
+    
+    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
+    
+    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
+    end
+    
+  end
+end

data/lib/poolparty/poolparty/plugin.rb

@@ -1,33 +1,66 @@
+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
-      
-      class_inheritable_accessor :name
-      
+      include PoolParty::DependencyResolverCloudExtensions
+            
       default_options({})
       
-      def initialize(p=self, opts={}, &block)
-        store_block &block
-        run_setup(p)
-        realize! unless block
+      def initialize(opts={}, prnt=nil, &block)
+        before_load(opts, &block)
+        
+        block = Proc.new {enable} unless block
+
+        @opts = opts        
+        super(opts, &block)
+        
+        run_in_context do
+          loaded @opts, &block
+        end
+      end
+      
+      # Overwrite this method
+      def before_load(o={}, &block)        
       end
-            
-      def realize!(force=false)
-        force ? force_realize! : (@realized ? nil : force_realize!)
+      def loaded(o={}, &block)
+      end
+      # 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?
+        true
+      end
+      def bootstrap_gems *gems
+        gems.each do |g|
+          Provision::BootStrapper.gem_list << g unless Provision::BootStrapper.gem_list.include?(g)
+        end
       end
       
-      def force_realize!
-        run_setup(parent, false, &stored_block)
-        enable unless stored_block
+      def bootstrap_commands cmds
+        Provision::BootStrapper.class_commands << cmds
       end
       
-      # Overwrite this method
-      def enable
+      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

@@ -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
+        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)            
+              this_context.plugin_store << inst if this_context
+              inst
             end
           end
-        EOE
+        EOM
+
+        PoolParty::Cloud::Cloud.class_eval meth
       end
       
     end

data/lib/poolparty/poolparty/pool.rb

@@ -2,8 +2,8 @@ module PoolParty
   module Pool
     
     def pool(name=:app, &block)
-      pools.has_key?(name) ? pools[name] : (pools[name] = Pool.new(name, &block))
-    end    
+      pools[name] ||= Pool.new(name, &block)
+    end
     
     def pools
       $pools ||= {}
@@ -23,41 +23,40 @@ module PoolParty
       $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 Remote
       
-      default_options({
-        :access_key => Base.access_key,
-        :secret_access_key => Base.secret_access_key
-      })
+      default_options Default.default_options
       
       def initialize(name,&block)
-        set_pool_specfile get_latest_caller        
-        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
+        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 "#{pool_specfile ? ::File.dirname(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,181 @@
+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)
+      
+      opts = (opts.is_a?(Hash) ? extra_opts.merge(opts) : extra_opts).merge(:name => @base_name)
+      
+      run_in_context(opts, &block)
+      super(&block)
+    end
+    
+    # Overloading the parent run_in_context
+    def run_in_context(opts={}, &block)
+      if opts
+        context_stack.push self
+        set_vars_from_options(opts)
+        instance_eval &block if block
+        context_stack.pop
+        head
+      else
+        super
+      end
+    end
+    
+    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)
+        parent.add_service(self) if parent.respond_to?(:add_service) && !is_a_resource?
+      end
+    end
+    
+    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?
+      # services.merge!({lowercase_class_name.to_sym => serv})
+    end
+    # Container for the services
+    def services
+      @services ||= OrderedHash.new
+    end
+    
+    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)
+        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
+    
+    def resource(type=:file)
+      resources[type.to_sym] ||= []
+    end
+    
+    def is_plugin?
+      false
+    end
+    
+    def is_a_resource?
+      false
+    end
+    
+    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
+        # 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}(handle_option_values(opts).merge(extra.merge(:ensures => :present)), &block)
+        end
+        def does_not_have_#{typ}(opts={}, extra={}, &block)
+          #{method_name}(handle_option_values(opts).merge(extra.merge(:ensures => :absent)), &block)
+        end
+      EOE
+    end
+    
+    def handle_option_values(o)
+      case o.class.to_s
+      when "String"
+        {:name => o}
+      else
+        o
+      end
+    end
+    
+  end
+end