fairchild-poolparty 1.1.3

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

@@ -0,0 +1,69 @@
+require "#{::File.dirname(__FILE__)}/service.rb"
+require "#{::File.dirname(__FILE__)}/../provision/boot_strapper.rb"
+
+module PoolParty
+  module Plugin
+        
+    class Plugin < PoolParty::Service
+      include CloudResourcer
+      include PoolParty::DependencyResolverCloudExtensions
+            
+      default_options({})
+      
+      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 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 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
+    
+  end
+end

data/lib/poolparty/poolparty/plugin_model.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), "resource")
+
+module PoolParty    
+  module PluginModel
+    
+    def plugin(name=:plugin, cloud=nil, &block)
+      plugins.has_key?(name) ? plugins[name] : (plugins[name] = PluginModel.new(name, &block))
+    end
+    alias_method :register_plugin, :plugin
+    
+    def plugins
+      $plugins ||= {}
+    end
+    
+    class PluginModel
+      attr_accessor :klass
+      
+      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
+        # Add the plugin definition to the cloud as an instance method
+        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
+        EOM
+
+        PoolParty::Cloud::Cloud.class_eval meth
+      end
+      
+    end
+    
+  end
+end

data/lib/poolparty/poolparty/pool.rb

@@ -0,0 +1,76 @@
+module PoolParty
+  module Pool
+    
+    def pool(name=:app, &block)
+      pools[name] ||= Pool.new(name, &block)
+    end
+    
+    def pools
+      $pools ||= {}
+    end
+    
+    def with_pool(pl, opts={}, &block)
+      raise CloudNotFoundException.new("Pool not found") unless pl
+      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 reset!
+      $pools = $clouds = $plugins = @describe_instances = nil
+    end
+
+    class Pool < PoolParty::PoolPartyBaseClass
+      include PrettyPrinter
+      include CloudResourcer
+      include Remote
+      
+      default_options Default.default_options
+      
+      def initialize(name,&block)
+        @pool_name = name
+        @pool_name.freeze
+        
+        ::PoolParty.context_stack.clear
+        
+        set_pool_specfile get_latest_caller
+        setup_defaults
+
+        super(&block)
+      end
+      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        
+        PoolParty::Extra::Deployments.include_deployments "#{Dir.pwd}/deployments"
+      end
+      
+      def pool_clouds
+        returning Array.new do |arr|
+          clouds.each do |name, cl|
+            arr << cl if cl.parent.name == self.name
+          end
+        end
+      end
+      
+    end
+    
+    # Helpers
+    def remove_pool(name)
+      pools.delete(name) if pools.has_key?(name)
+    end
+  end
+end

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

data/lib/poolparty/poolparty/resource.rb

@@ -0,0 +1,205 @@
+=begin rdoc
+  The Container
+
+  Container holds the various features for the final compilations
+  for each pool.
+  
+  Most of the Resources will not need to create their own
+=end
+module PoolParty
+  module Resources
+    
+    def custom_file(path, str)
+      write_to_file_in_storage_directory(path, str)
+    end
+    
+    class Resource < PoolParty::PoolPartyBaseClass
+      attr_accessor :prestring, :poststring
+      
+      # include CloudResourcer
+      
+      # For the time being, we'll make puppet the only available dependency resolution
+      # base, but in the future, we can rip this out and make it an option
+      # include PoolParty::DependencyResolutions::Puppet
+      include PoolParty::DependencyResolverResourceExtensions
+      
+      # DSL Overriders
+      include PoolParty::ResourcingDsl
+      
+      # When we subclass Resource, we want to add a few methods to the Resources class
+      # This will anable us to call out to these resources in our DSLified manner
+      # When we call a method from the subclass, say it's the File class
+      # then we want to be able to have the method file() available.
+      # We also want to be able to fetch the resource with a get_file method.
+      # This will just call out to get the resource. If the resource isn't available
+      # in a resource store, we expect to return a nil result. 
+      # Finally, the has_ and does_not_have_ methods are appended. See below for 
+      # those methods. Then we make sure we add these resources as available_resources
+      # onto the class so we know it's available as a resource
+      def self.inherited(subclass)
+        subclass = subclass.to_s.split("::")[-1] if subclass.to_s.index("::")
+        lowercase_class_name = subclass.to_s.underscore.downcase || subclass.downcase
+        method_name = "__#{lowercase_class_name}".to_sym
+        
+        # Add add resource method to the Resources module
+        unless PoolParty::PoolPartyBaseClass.respond_to?(method_name)
+          method =<<-EOE
+            private 
+            def #{method_name}(opts={}, &blk)              
+              add_resource(:#{lowercase_class_name}, opts, &blk)
+            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
+              res
+            end
+            public
+          EOE
+          PoolParty::PoolPartyBaseClass.module_eval method
+          PoolParty::PoolPartyBaseClass.add_has_and_does_not_have_methods_for(lowercase_class_name.to_sym)
+          
+          available_resources << subclass
+        end
+      end
+      
+      # Keep track of the resources that are available. This way we can show some pretty output
+      # later and ensure that we are only calling available resources
+      def self.available_resources
+        @available_resources ||= []
+      end
+      
+      # This is set in order of descending precedence
+      # The options are overwritten from the bottom up
+      # and the resource will use those as the values
+      # Then it takes the value of the block and sets whatever is sent there as 
+      # the options
+      # Finally, it uses the parent's options as the lowest priority
+      def initialize(opts={}, extra_opts={}, &block)
+        super(opts, &block)
+        
+        @resource_name = @base_name
+        dsl_options[:name] = resource_name unless dsl_options.has_key?(:name)        
+      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={})
+      end
+      
+      def resource_name
+        @resource_name ||= nil
+      end
+      
+      def name(*args)
+        resource_name
+      end
+      
+      # After create callback
+      def after_create
+      end
+      
+      # We don't want to inherit the services on a resource, as resources
+      # are a base and should never have services.
+      def services
+      end
+      
+      def cloud
+        2.upto(context_stack.size) do |i|
+          return ::PoolParty.context_stack[-i] if ::PoolParty.context_stack[-i].is_a?(PoolParty::Cloud::Cloud)
+        end
+        nil
+      end
+      
+      def duplicatable?
+        false
+      end
+      def resource?
+        true
+      end
+      # This way we can subclass resources without worry
+      def class_type_name
+        self.class.to_s.top_level_class.underscore.downcase
+      end
+      def self.custom_function(str)
+        custom_functions << str
+      end
+      def self.custom_functions
+        @custom_functions ||= []
+      end
+      def custom_function(str)
+        self.class.custom_functions << str
+      end
+            
+      def self.custom_functions_to_string(pre="")
+        returning Array.new do |output|
+          PoolParty::Resources.available_custom_resources.each do |resource|
+            resource.custom_functions.each do |func|
+              output << "#{pre*2}#{func}"
+            end
+          end
+        end.join("\n")
+      end
+      # Some things in puppet aren't allowed, so let's override them here
+      def disallowed_options
+        []
+      end
+
+      def key
+        name
+      end
+      # def virtual_resource?
+      #   false
+      # end
+      # def printable?
+      #   true
+      # end
+      def is_in_plugin?
+        parent.is_plugin?
+      end
+      
+      def is_a_resource?
+        true
+      end
+      
+      def method_missing(m,*a,&block)
+        if parent && parent.dsl_options.has_key?(m) && is_in_plugin?
+          parent.send m, *a, &block
+        else
+          super
+        end
+      end
+      
+      # Private method just for resource retrievling purposes
+      def class_name_sym
+        self.class.to_s.top_level_class.downcase.to_sym
+      end
+      # We want to gather the options, but if the option sent is nil
+      # then we want to override the option value by sending the key as
+      # a method so that we can override this if necessary. 
+      # Only runs on objects that have options defined, otherwise 
+      # it returns an empty hash
+      def get_modified_options
+        unless @modified_options
+          if dsl_options
+            opts = dsl_options.inject({}) do |sum,h|
+              sum.merge!({h[0].to_sym => ((h[1].nil?) ? self.send(h[0].to_sym) : h[1]) })
+            end
+          else
+            opts = {}
+          end
+          @full_allowed_options ||= allowed_options.reject {|ele| disallowed_options.include?(ele) }
+          @modified_options = opts.reject do |k,v|
+            !@full_allowed_options.include?(k) || 
+              @parent && @parent.respond_to?(:dsl_options) && @parent != self && @parent.dsl_options.has_key?(k) && @parent.dsl_options[k] == dsl_options[k]
+          end
+        end
+        @modified_options
+      end
+      
+    end
+    
+  end
+end
+
+Dir["#{::File.dirname(__FILE__)}/../resources/*.rb"].each {|lib| require "#{lib}"}

data/lib/poolparty/poolparty/script.rb

@@ -0,0 +1,58 @@
+require "parenting"
+module PoolParty
+  
+  class Script
+    include Parenting
+    
+    def self.inflate_file(file)
+      inflate open(file).read if file
+    end
+        
+    def self.inflate(script, file="__SCRIPT__")
+      module_eval script, file
+      # a = new
+      # a.instance_eval <<-EOM
+      #   def run_child(pa)
+      #     context_stack.push pa
+      #     #{str}
+      #     context_stack.pop
+      #     remove_method(:run_child)
+      #     self
+      #   end
+      # EOM
+      # a.run_child(self)
+      # a
+    end
+        
+    def self.to_ruby(opts={},&blk)
+      blk.to_ruby(opts)
+    end
+    
+    def self.for_save_string
+      out = []
+      pools.collect {|n,pl| pl}.each do |pl|
+        out << "pool :#{pl.name} do"
+        clouds.each do |n,cl|
+          # grossy-gross
+          minimum_runnable_options_string = cl.minimum_runnable_options.collect do |o|
+            "#{o} #{cl.send(o).respec_string}" unless cl.send(o).nil?
+          end
+          out << <<-EOE
+cloud :#{cl.name} do
+  #{minimum_runnable_options_string.join("\n")}
+end
+          EOE
+        end
+        out << "end"
+      end
+      out.join("\n")
+    end
+    
+    def self.save!(to_file=true)
+      write_to_file_in_storage_directory(Default.default_specfile_name, for_save_string) if to_file
+      for_save_string
+    end
+    
+  end
+  
+end