poolparty 0.2.18 → 0.2.69

data/lib/poolparty/pool/resource.rb

@@ -17,24 +17,57 @@ module PoolParty
       resources[type] ||= []
     end
     
-    def add_resource(type, opts={}, parent=self, &block)      
-      resource = get_resource(type, opts[:name], parent)
-      if resource
-        resource 
+    def add_resource(type, opts={}, parent=self, &block)
+      if in_a_resource_store?(type, opts[:name])
+        @res = get_resource(type, opts[:name], parent)
+        # if should_duplicate_resource?(type, @res, parent, opts)
+        # unless @res.parent == parent
+        #   @pa = parent
+        #   @res.instance_eval {@parent = @pa}
+        # end
+          # parent.resource(type) << @res
+        # end
       else
-        returning "PoolParty::Resources::#{type.to_s.camelize}".classify.constantize.new(opts, parent, &block) do |o|
-          resource(type) << o
-        end
+        @res = returning "PoolParty::Resources::#{type.to_s.camelize}".camelize.constantize.new(opts, parent, &block) do |o|                    
+          store_into_global_resource_store(o)
+          resource(type) << o          
+        end        
       end
+      @res
     end
-    
-    def get_resource(type, key, parent=self)
-      resource(type).select {|resource| resource.key == key }.first
+    def should_duplicate_resource?(type, res, pare, opts)
+      pare != @res.parent && 
+        pare.cloud != @res.cloud && 
+        in_global_resource_store?(type, opts[:name]) && 
+        !in_resources?(type, res, pare)
+    end
+    def get_resource(ty, key, parent=self)
+      get_from_local_resource_store(ty, key, parent) || get_from_global_resource_store(ty, key)
+    end
+    def get_from_local_resource_store(type, key, parent)
+      resource(type).select {|r| r.key == key }.first
+    end
+    def in_a_resource_store?(type, key, parent=self)
+      !(get_resource(type, key) && in_global_resource_store?(type, key)).nil?
+    end
+    def in_resources?(type, key, parent=self)
+      !get_resource(type, key).nil?
+    end
+    def global_resources_store
+      $global_resources ||= []
+    end
+    def store_into_global_resource_store(r)
+      global_resources_store << r unless in_global_resource_store?(r.class_name_sym, r.key)
+    end
+    def get_from_global_resource_store(ty, key)
+      global_resources_store.select {|r| r if r.same_resources_of(ty, key) }.first
+    end
+    def in_global_resource_store?(ty, key)
+      !get_from_global_resource_store(ty, key).nil?
     end
-            
     #:nodoc:
     def reset_resources!
-      @resources = nil
+      $global_resources = $global_classpackage_store = @resources = nil
     end
         
     # def resources_string(pre="")
@@ -46,7 +79,7 @@ module PoolParty
     def custom_file(path, str)
       write_to_file_in_storage_directory(path, str)
     end
-    
+        
     class Resource
       attr_accessor :prestring, :poststring
       
@@ -58,7 +91,7 @@ module PoolParty
       
       def self.inherited(subclass)
         subclass = subclass.to_s.split("::")[-1] if subclass.to_s.index("::")
-        lowercase_class_name = subclass.to_s.downcase
+        lowercase_class_name = subclass.to_s.underscore
         
         # Add add resource method to the Resources module
         unless PoolParty::Resources.respond_to?(lowercase_class_name.to_sym)          
@@ -66,6 +99,9 @@ module PoolParty
             def #{lowercase_class_name}(opts={}, parent=self, &blk)
               add_resource(:#{lowercase_class_name}, opts, parent, &blk)
             end
+            def get_#{lowercase_class_name}(name)              
+              get_resource(:#{lowercase_class_name}, name) if in_a_resource_store?(:#{lowercase_class_name}, name)
+            end
           EOE
           PoolParty::Resources.module_eval method
           PoolParty::Resources.add_has_and_does_not_have_methods_for(lowercase_class_name.to_sym)
@@ -88,59 +124,79 @@ module PoolParty
       # 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={}, parent=self, &block)
+      def initialize(opts={}, parent=self, &block)                        
+        run_setup(parent, &block)
         # Take the options of the parents
-        set_resource_parent(parent)
         set_vars_from_options(opts) unless opts.empty?
-        self.instance_eval &block if block
+        
+        set_resource_parent
+        
         loaded(opts, @parent)
       end
       
-      def set_resource_parent(parent=nil)
-        if parent && parent != self
-          @parent = parent
-          requires parent.to_s if @parent.is_a?(PoolParty::Resources::Resource) && printable? && @parent.printable?
+      # Helper to set the containing parent on the resource
+      def set_resource_parent
+        if @parent && @parent != self
+          if can_set_requires_for_parent
+            # requires @parent.to_s
+          end
         end
       end
       
-      # def requirement_tree
-      #   p = @parent
-      #   returning Array.new do |arr|
-      #     arr << p.to_s
-      #     while p && p != self && p.is_a?(PoolParty::Resources::Resource) && p.requires
-      #       arr << p.requires
-      #       p = p.parent
-      #     end
-      #   end.flatten.uniq
-      # end
-      
+      def can_set_requires_for_parent
+        @parent.is_a?(PoolParty::Resources::Resource) && 
+          @parent.printable? && 
+          @parent.name != name &&
+          !@parent.is_a?(PoolParty::Resources::Classpackage)
+      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={}, parent=self)
       end
       
+      def cloud
+        @pa = parent
+        while !(@pa.is_a?(PoolParty::Cloud::Cloud) || @pa.nil? || @pa == self)
+          @pa = @pa.respond_to?(:parent) ? @pa.parent : nil
+        end
+        @pa
+      end
+      
+      def parent_tree
+        @pa = self
+        returning Array.new do |arr|
+          while !(@pa.is_a?(PoolParty::Cloud::Cloud) || @pa.nil? || @pa == self)
+            @pa = @pa.respond_to?(:parent) ? @pa.parent : nil
+            arr << @pa
+          end
+        end
+      end
+      
       # DSL Overriders
       include PoolParty::ResourcingDsl
       
+      def same_resources_of(t, k)
+        key == k && class_name_sym == t
+      end
+      def duplicatable?
+        false
+      end
       # This way we can subclass resources without worry
       def class_type_name
-        self.class.to_s.top_level_class
-      end      
-      def self.custom_function(str)
-        custom_functions << str
+        self.class.to_s.top_level_class.underscore
       end
-      
       def self.custom_function(str)
         custom_functions << str
-      end      
+      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|
@@ -154,6 +210,14 @@ module PoolParty
       def disallowed_options
         []
       end
+      def allowed_options
+        [
+          :subscribe, :owner, :group, :path, :mode, :source, :notify, :subscribe, :check, :creates, :cwd, :command, :ensure,
+          :require, :schedule, :range, :alias, :hour, :minute, :user, :month, :monthday, :name, :onlyif, :unless, :refreshonly,
+          :refresh, :content, :template, :ip, :repeat, :provider, :key, :device, :fstype, :remounts, :options, :atboot, :before,
+          :binary, :status, :start, :stop, :restart, :pattern, :recurse
+        ]
+      end
       def key
         name
       end
@@ -163,6 +227,10 @@ module PoolParty
       def printable?
         true
       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. 
@@ -177,7 +245,8 @@ module PoolParty
           else
             opts = {}
           end
-          @modified_options = opts.reject {|k,v| disallowed_options.include?(k) }
+          @full_allowed_options ||= allowed_options.reject {|ele| disallowed_options.include?(ele) }
+          @modified_options = opts.reject {|k,v| !@full_allowed_options.include?(k) }
         end
         @modified_options
       end

data/lib/poolparty/pool/resources/class_package.rb

@@ -1,64 +1,105 @@
 module PoolParty    
   module Resources
     
+    def global_classpackages
+      @global_classpackage_store ||= []
+    end
+    
+    def in_global_classpackages?(name)
+      !get_from_global_classpackage_store(name).nil?
+    end
+    
+    def get_from_global_classpackage_store(key)
+      global_classpackages.select {|a| a if key == a.name }.first
+    end
+    
+    def store_into_global_classpackage_store(r)
+      arr = r.is_a?(Array) ? r : [r]
+      arr.each do |a|
+        global_classpackages << a unless in_global_classpackages?(a.name)
+      end
+    end
+    
     # Wrap all the resources into a class package from 
     def classpackage_with_self(parent=self, &block)
-      @cp = PoolParty::Resources::Classpackage.new(parent.options, parent, &block)
-      @cp.instance_eval {@resources = parent.resources}
-      parent.instance_eval {@resources = nil}
-      @cp
+      name = (parent.options.name || Classpackage.name(parent).to_s).sanitize
+      if in_global_classpackages?(name)
+        returning get_from_global_classpackage_store(name) do |cls|
+          cls.run_in_context(parent, &block) if block
+        end
+      else
+        @@parent_resources = parent.resources
+        @@cp = parent.add_resource(:classpackage, parent.options.merge(:name => name), parent, &block)
+        @@cp = @@cp.is_a?(Array) ? @@cp[-1] : @@cp
+        
+        @@cp.run_in_context(parent) do
+          @@parent_resources.each do |ty, res|
+            resources[ty] = res unless ty == :classpackage
+          end
+        end
+        parent.instance_eval do
+          @resources = {:classpackage => [@@cp]}
+        end
+        @@cp.instance_eval &block if block
+        
+        store_into_global_classpackage_store(@@cp)
+      end      
+      return @@cp
+      @@parent_resources = nil
     end
                 
     class Classpackage < Resource
             
       default_options({
-        :name => nil
+        :name => "custom"
       })
       
       def initialize(opts={}, parent=self, &block)
         # Take the options of the parents
-        set_parent(parent, false) if parent
+        # set_parent(parent, false) if parent
         set_vars_from_options(opts) unless opts.empty?
-        self.instance_eval &block if block
-        # store_block(&block)        
+        # self.instance_eval &block if block
+        run_setup(parent, &block) if block
+        # self.run_in_context &block if block
+        # store_block(&block)
         loaded
       end
                         
-      def to_string
-        returning String.new do |output|
-          output << "# #{name.sanitize}"
-          output << "\nclass #{name.sanitize.downcase} {\n"
-          output << resources_string_from_resources(resources)
-          output << "\n}\n"
+      def to_string(pre="")
+        if resources.size > 0 && not_printed?
+          returning Array.new do |output|
+            output << "#{pre}class #{name.sanitize.downcase} {"
+            output << "#{pre}#{resources_string_from_resources(resources)}"
+            output << "#{pre}}"
+            output << include_string
+            @not_printed = false
+          end.join("\n")
+        else
+          ""
         end
       end
       
+      def not_printed?
+        true
+      end
+      
       def include_string
         "include #{name.sanitize.downcase}"
       end
       
-      def name(*args)
-        args.empty? ? (@name || parent.name) : @name ||= args.first
+      def virtual_resource?
+        true
+      end
+      
+      def printable?
+        false
+      end
+      
+      def self.name(parent=nil)
+        "custom_#{parent ? parent.object_id.to_s : "parent"}"
       end
 
     end
     
-    def resources_string_from_resources(resources, pre="\t")
-      @variables = resources.extract! {|name,resource| name == :variable}
-      returning Array.new do |str|
-        unless @variables.empty?
-          str << "\n# Variables \n"
-          @variables.each do |name, variable|
-            str << variable.to_string("#{pre}")
-          end          
-        end
-        
-        resources.each do |type, resource|
-          str << "\n#{pre*2}# #{type}\n"
-          str << resource.to_string("#{pre*2}")
-        end        
-      end.join("\n")
-    end
-    
   end
 end

data/lib/poolparty/pool/resources/conditional.rb

@@ -1,21 +1,30 @@
 module PoolParty    
   module Resources
     
-    def execute_if(attr_s="$hostname", str="", parent=self, &block)
-      parent = parent.is_a?(PoolParty::Cloud::Cloud) ? parent : parent.parent
-      opts = {:attribute => attr_s, :equal => str}
-      options = parent.respond_to?(:options) ? parent.options.merge!(opts) : opts
-      @c = PoolParty::Resources::Conditional.new(options, parent, &block)
-      parent.instance_eval {add_resource(:conditional, options, parent, &block) }
-      @c
+    def execute_on_master(parent=self, &block)
+      execute_if("$hostname", "master", {}, parent, &block)
+    end
+    
+    def execute_on_node(parent=self, &block)
+      execute_if("$hostname", "master", {:notequal => true}, parent, &block)
+    end
+    
+    def execute_if(attr_s="$hostname", str="", cust_opts={}, parent=self, &block)
+      # parent = parent.is_a?(PoolParty::Cloud::Cloud) ? parent : parent.parent
+      opts = {:attribute => attr_s, :equal => str}.merge(cust_opts)
+      options = (parent.respond_to?(:options) && parent && parent != self) ? parent.options.merge!(opts) : opts
+      # @c = PoolParty::Resources::Conditional.new(options, parent, &block)
+      # conditional(options, parent, &block)
+      add_resource(:conditional, options, parent, &block)
     end
     
     class Conditional < Resource
       
       def initialize(opts={}, parent=self, &block)
-        name "#{opts[:attribute]} == #{opts[:equal]}"
+        name "#{opts[:name] ? opts[:name] : opts[:attribute]} #{opts[:equal]}"
         attribute opts[:attribute]
         equal opts[:equal]
+        notequal opts.has_key?(:notequal) ? opts[:notequal] : false
         super
       end
       
@@ -25,16 +34,29 @@ module PoolParty
         true
       end
       
+      def disallowed_options
+        [:comparison, :notequal]
+      end
+      
       def printable?
         false
       end
       
+      def duplicatable?
+        false
+      end
+      
       def to_string(pre="")
         returning Array.new do |output|
           output << "# #{name.sanitize}"
           output << "case #{attribute} {"
-          output << "#{equal} : { #{resources_string_from_resources(resources)} }"
-          output << "default : {}"
+          if notequal
+            output << "#{equal} : {}"
+            output << "default : { #{resources_string_from_resources(resources)} }"
+          else
+            output << "#{equal} : { #{resources_string_from_resources(resources)} }"
+            output << "default : {}"
+          end                    
           output << "}"
         end.join("\n")
       end

data/lib/poolparty/pool/resources/custom_service.rb

@@ -0,0 +1,30 @@
+module PoolParty    
+  module Resources
+        
+    class Customservice < Resource
+      
+      default_options({
+        :ensure => "running",
+        :provider => "base"
+      })
+      
+      def bin(arg)
+        options.merge!(:binary => arg)
+        options.merge!(:start => arg)
+        options.merge!(:stop => arg.gsub(/start/, 'stop'))
+        options.merge!(:restart => "#{arg.gsub(/start/, 'stop')} && #{arg}")
+      end
+                  
+      def present
+        "running"
+      end
+      def absent
+        "stopping"
+      end
+      def class_type_name
+        "Service"
+      end
+    end
+    
+  end
+end

data/lib/poolparty/pool/resources/exec.rb

@@ -9,11 +9,12 @@ module PoolParty
       
       # Execs cannot have the following parameters
       # We use version in the gempackage resource
-      # So we have to exclude it here. Alternatively, we could
-      # exclude it in the gempackage, but this is an example
-      # of how to exclude it as well
-      def disallowed_options
-        [:ensure, :name, :source, :version]
+      # So we have to exclude it here.
+      def allowed_options
+        [
+          :command, :creates, :cwd, :env, :environment, :group, :logoutput, :user,
+          :onlyif, :path, :refresh, :refreshonly, :returns, :timeout, :unless
+        ]
       end
       
       def key

data/lib/poolparty/pool/resources/gem_package.rb

@@ -0,0 +1,52 @@
+module PoolParty    
+  module Resources
+        
+    class Gempackage < Resource
+      
+      # When we call gempackage, we want the exec to run on the directory we suggest
+      # we also only want it to run if there is NOT a local gem already installed with
+      # the package details (version and name)
+      # 
+      # TODO: Add it so that it tries to pull the gem off the master fileserver first...
+      def loaded(opts={}, parent=self)
+        if download_url
+                    
+          execute_on_master do
+            has_exec(:name => "download-#{name}", :cwd => Base.remote_storage_path, :command => "wget #{download_url} -O #{name}.gem", :ifnot => "test -f #{Base.remote_storage_path}/#{name}.gem")
+          end
+          
+          has_file({
+            :name => "#{Base.remote_storage_path}/#{name}.gem", 
+            :source => "#{Base.fileserver_base}/#{name}.gem",
+            :requires => get_host("master")
+          })
+                    
+          has_exec(opts.merge({:name => "#{name}", :cwd =>"#{Base.remote_storage_path}"})) do
+            command "gem install -y --no-ri --no-rdoc #{Base.remote_storage_path}/#{name}.gem"
+            ifnot "gem list --local #{name} | grep #{name} #{"| grep #{version}" if version}"
+            requires get_file("#{Base.remote_storage_path}/#{name}.gem")
+          end
+          
+        else
+          has_exec(opts.merge({:name => "#{name}", :cwd => "/tmp", :path => "/bin:/usr/bin:/usr/local/bin:/sbin:/usr/sbin:/var/lib/gems/1.8/bin"})) do
+            command "gem install -y --no-ri --no-rdoc #{"--version #{version}" if version} #{"--source #{source}" if source} #{name} <<heredoc
+            1
+            heredoc"
+            ifnot "gem list --local #{name} | grep #{name} #{"| grep #{version}" if version}"
+          end
+        end
+      end
+      def virtual_resource?
+        true
+      end
+      def printable?
+        true
+      end
+      def class_type_name
+        "Exec"
+      end
+      
+    end
+    
+  end
+end

data/lib/poolparty/pool/resources/mount.rb

@@ -0,0 +1,22 @@
+module PoolParty    
+  module Resources
+        
+    class Mount < Resource      
+      
+      default_options({
+        :name => "/data",
+        :remounts => "true",
+        :options => "rw,nosuid,noquota",
+        :fstype => "xfs",
+        :atboot => "yes"
+      })
+      
+      def disallowed_options
+        [:name]
+      end
+            
+      
+    end
+    
+  end
+end

data/lib/poolparty/pool/resources/package.rb

@@ -4,9 +4,19 @@ module PoolParty
     class Package < Resource
       
       default_options({
-        :ensure => "installed",
-        :name => nil
-      })      
+        :ensure => "installed"
+      })
+      
+      def disallowed_options
+        [:name]
+      end
+      
+      def present
+        "installed"
+      end
+      def absent
+        "absent"
+      end
       
     end
     

data/lib/poolparty/pool/resources/sshkey.rb

@@ -5,7 +5,7 @@ module PoolParty
       
       default_options({
         :command => nil,
-        :key => "ALONGSTRINGOFDIGITS",
+        # :key => "ALONGSTRINGOFDIGITS",
         :target => "~/.ssh/poolparty_id_rsa"
       })
       

data/lib/poolparty/pool/resources/variable.rb

@@ -11,6 +11,10 @@ module PoolParty
       def to_string(pre="\t")
         "$#{name} = #{value_string}"
       end
+            
+      def duplicatable?
+        false
+      end
       
       def value_string
         value.to_option_string

data/lib/poolparty/pool/script.rb

@@ -22,14 +22,16 @@ module PoolParty
     
     def self.for_save_string
       returning Array.new do |out|
-        clouds.each do |name, cl|
-          with_cloud(cl) do
+        pools.collect {|n,pl| pl}.each do |pl|
+          out << "pool :#{pl.name} do"
+          clouds.each do |n,cl|
             out << <<-EOE
-cloud :#{name} do
-#{cl.minimum_runnable_options.map {|o| "\t#{o} \"#{cl.send o}\""}.join("\n")}
-end
+  cloud :#{cl.name} do
+    #{cl.minimum_runnable_options.map {|o| "#{o} #{cl.send(o).respec_string}"}.join("\n")}
+  end
             EOE
-          end  
+          end
+          out << "end"
         end
       end.join("\n")
     end

data/lib/poolparty/templates/haproxy.conf

@@ -28,7 +28,7 @@ defaults
   stats uri /poolparty
   stats realm Statistics\ for\ PoolParty
 
-listen <%= name_haproxy %> 
+listen poolparty
     bind 0.0.0.0:<%= ports_haproxy.join(",0.0.0.0:") %>
     cookie POOLPARTYPARTY
     <%- node_ips_haproxy.chomp.split(/\t/).each_with_index do |ip, index| -%>    

data/lib/poolparty/templates/messenger/client/log-run.erb

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec svlogd -tt ./main

data/lib/poolparty/templates/messenger/client/run.erb

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+exec 2>&1
+. /etc/profile && server-start-client

data/lib/poolparty/templates/messenger/master/log-run.erb

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec svlogd -tt ./main

data/lib/poolparty/templates/messenger/master/run.erb

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+exec 2>&1
+. /etc/profile && server-start-master

data/lib/poolparty/templates/messenger/node/log-run.erb

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec svlogd -tt ./main