puppet 0.22.4 → 0.23.0

data/lib/puppet/provider/zone/solaris.rb

@@ -4,35 +4,30 @@ Puppet::Type.type(:zone).provide(:solaris) do
     commands :adm => "/usr/sbin/zoneadm", :cfg => "/usr/sbin/zonecfg"
     defaultfor :operatingsystem => :solaris
 
+    mk_resource_methods
+
     # Convert the output of a list into a hash
     def self.line2hash(line)
         fields = [:id, :name, :ensure, :path]
 
-        hash = {}
+        properties = {}
         line.split(":").each_with_index { |value, index|
-            hash[fields[index]] = value
+            properties[fields[index]] = value
         }
 
         # Configured but not installed zones do not have IDs
-        if hash[:id] == "-"
-            hash.delete(:id)
+        if properties[:id] == "-"
+            properties.delete(:id)
         end
 
-        return hash
+        properties[:ensure] = symbolize(properties[:ensure])
+
+        return properties
     end
 
-    def self.list
+    def self.instances
         adm(:list, "-cp").split("\n").collect do |line|
-            hash = line2hash(line)
-
-            obj = nil
-            unless obj = @model[hash[:name]]
-                obj = @model.create(:name => hash[:name])
-            end
-
-            obj.setstatus(hash)
-
-            obj
+            new(line2hash(line))
         end
     end
 
@@ -41,12 +36,12 @@ Puppet::Type.type(:zone).provide(:solaris) do
         # If the thing is entirely absent, then we need to create the config.
         str = %{create -b
 set zonepath=%s
-} % @model[:path]
+} % @resource[:path]
 
         # Then perform all of our configuration steps.  It's annoying
-        # that we need this much internal info on the model.
-        @model.send(:properties).each do |property|
-            if property.is_a? ZoneConfigProperty and ! property.insync?
+        # that we need this much internal info on the resource.
+        @resource.send(:properties).each do |property|
+            if property.is_a? ZoneConfigProperty and ! property.insync?(properties[property.name])
                 str += property.configtext + "\n"
             end
         end
@@ -59,14 +54,39 @@ set zonepath=%s
         zonecfg :delete, "-F"
     end
 
+    def exists?
+        properties[:ensure] != :absent
+    end
+
+    # Clear out the cached values.
+    def flush
+        @property_hash.clear
+    end
+
     def install
         zoneadm :install
     end
 
+    # Look up the current status.
+    def properties
+        if @property_hash.empty?
+            @property_hash = status || {}
+            if @property_hash.empty?
+                @property_hash[:ensure] = :absent
+            else
+                @resource.class.validproperties.each do |name|
+                    @property_hash[name] ||= :absent
+                end
+            end
+
+        end
+        @property_hash.dup
+    end
+
     # We need a way to test whether a zone is in process.  Our 'ensure'
     # property models the static states, but we need to handle the temporary ones.
     def processing?
-        if hash = statushash()
+        if hash = status()
             case hash[:ensure]
             when "incomplete", "ready", "shutting_down"
                 true
@@ -92,7 +112,6 @@ set zonepath=%s
                 current = nil # reset it
             when /^(\S+):\s*(.+)$/:
                 hash[$1.intern] = $2
-                #self.is = [$1.intern, $2]
             when /^\s+(\S+):\s*(.+)$/:
                 if name
                     unless hash.include? name
@@ -111,27 +130,15 @@ set zonepath=%s
                 debug "Ignoring zone output '%s'" % line
             end
         end
-        return hash
-    end
 
-    def retrieve
-        if hash = statushash()
-            setstatus(hash)
-
-            # Now retrieve the configuration itself and set appropriately.
-            getconfig()
-        else
-            @properties.each do |name, property|
-                property.is = :absent
-            end
-        end
+        return hash
     end
 
     # Execute a configuration string.  Can't be private because it's called
     # by the properties.
     def setconfig(str)
-        command = "#{command(:cfg)} -z %s -f -" % @model[:name]
-        debug "Executing '%s' in zone %s with '%s'" % [command, @model[:name], str]
+        command = "#{command(:cfg)} -z %s -f -" % @resource[:name]
+        debug "Executing '%s' in zone %s with '%s'" % [command, @resource[:name], str]
         IO.popen(command, "w") do |pipe|
             pipe.puts str
         end
@@ -143,8 +150,8 @@ set zonepath=%s
 
     def start
         # Check the sysidcfg stuff
-        if cfg = @model[:sysidcfg]
-            path = File.join(@model[:path], "root", "etc", "sysidcfg")
+        if cfg = @resource[:sysidcfg]
+            path = File.join(@resource[:path], "root", "etc", "sysidcfg")
 
             unless File.exists?(path)
                 begin
@@ -164,14 +171,21 @@ set zonepath=%s
     end
 
     # Return a hash of the current status of this zone.
-    def statushash
+    def status
         begin
-            output = adm "-z", @model[:name], :list, "-p"
+            output = adm "-z", @resource[:name], :list, "-p"
         rescue Puppet::ExecutionFailure
             return nil
         end
 
-        return self.class.line2hash(output.chomp)
+        main = self.class.line2hash(output.chomp)
+
+        # Now add in the configuration information
+        config_status.each do |name, value|
+            main[name] = value
+        end
+
+        main
     end
 
     def stop
@@ -188,21 +202,42 @@ set zonepath=%s
 
     private
 
+    # Turn the results of getconfig into status information.
+    def config_status
+        config = getconfig()
+        result = {}
+
+        result[:autoboot] = config[:autoboot] ? config[:autoboot].intern : :absent
+        result[:pool] = config[:pool]
+        result[:shares] = config[:shares]
+        if dir = config["inherit-pkg-dir"]
+            result[:inherit] = dir.collect { |dirs| dirs[:dir] }
+        end
+        if net = config["net"]
+            result[:ip] = net.collect { |params| "%s:%s" % [params[:physical], params[:address]] }
+        end
+
+        result
+    end
+
     def zoneadm(*cmd)
         begin
-            adm("-z", @model[:name], *cmd)
+            adm("-z", @resource[:name], *cmd)
         rescue Puppet::ExecutionFailure => detail
             self.fail "Could not %s zone: %s" % [cmd[0], detail]
         end
     end
 
     def zonecfg(*cmd)
+        # You apparently can't get the configuration of the global zone
+        return "" if self.name == "global"
+
         begin
-            cfg("-z", @model[:name], *cmd)
+            cfg("-z", self.name, *cmd)
         rescue Puppet::ExecutionFailure => detail
             self.fail "Could not %s zone: %s" % [cmd[0], detail]
         end
     end
 end
 
-# $Id: solaris.rb 2169 2007-02-07 06:47:10Z luke $
+# $Id: solaris.rb 2577 2007-06-14 03:39:23Z luke $

data/lib/puppet/rails.rb

@@ -4,36 +4,12 @@ require 'facter'
 require 'puppet'
 
 module Puppet::Rails
-    Puppet.config.setdefaults(:puppetmaster,
-        :dblocation => { :default => "$statedir/clientconfigs.sqlite3",
-            :mode => 0660,
-            :owner => "$user",
-            :group => "$group",
-            :desc => "The database cache for client configurations.  Used for
-                querying within the language."
-        },
-        :dbadapter => [ "sqlite3", "The type of database to use." ],
-        :dbmigrate => [ false, "Whether to automatically migrate the database." ],
-        :dbname => [ "puppet", "The name of the database to use." ],
-        :dbserver => [ "localhost", "The database server for Client caching. Only
-            used when networked databases are used."],
-        :dbuser => [ "puppet", "The database user for Client caching. Only
-            used when networked databases are used."],
-        :dbpassword => [ "puppet", "The database password for Client caching. Only
-            used when networked databases are used."],
-        :railslog => {:default => "$logdir/rails.log",
-            :mode => 0600,
-            :owner => "$user",
-            :group => "$group",
-            :desc => "Where Rails-specific logs are sent"
-        }
-    )
 
     def self.connect
         # This global init does not work for testing, because we remove
         # the state dir on every test.
         unless ActiveRecord::Base.connected?
-            Puppet.config.use(:puppet)
+            Puppet.config.use(:main, :rails, :puppetmasterd)
 
             ActiveRecord::Base.logger = Logger.new(Puppet[:railslog])
             ActiveRecord::Base.allow_concurrency = true
@@ -85,13 +61,6 @@ module Puppet::Rails
         if Puppet[:dbmigrate]
             migrate()
         end
-
-        # For now, we have to use :puppet, too, since non-puppetmasterd processes
-        # (including testing) put the logdir in :puppet, not in :puppetmasterd.
-        Puppet.config.use(:puppetmaster, :puppet)
-
-        # This has to come after we create the logdir with the :use above.
-        ActiveRecord::Base.logger = Logger.new(Puppet[:railslog])
     end
 
     # Migrate to the latest db schema.
@@ -127,7 +96,7 @@ module Puppet::Rails
             raise Puppet::DevError, "No activerecord, cannot init Puppet::Rails"
         end
 
-        Puppet.config.use(:puppetmaster)
+        Puppet.config.use(:puppetmasterd, :rails)
 
         begin
             ActiveRecord::Base.establish_connection(database_arguments())
@@ -148,4 +117,4 @@ if Puppet.features.rails?
     require 'puppet/rails/host'
 end
 
-# $Id: rails.rb 2342 2007-03-21 22:12:25Z luke $
+# $Id: rails.rb 2609 2007-06-18 18:46:00Z luke $

data/lib/puppet/rails/database/schema.rb

@@ -7,7 +7,7 @@ class Puppet::Rails::Schema
             $stdout = File.open("/dev/null", "w")
             ActiveRecord::Schema.define do
                 create_table :resources do |t|
-                    t.column :title, :string, :null => false
+                    t.column :title, :text, :null => false
                     t.column :restype,  :string, :null => false
                     t.column :host_id, :integer
                     t.column :source_file_id, :integer
@@ -15,19 +15,40 @@ class Puppet::Rails::Schema
                     t.column :line, :integer
                     t.column :updated_at, :datetime
                 end
+                add_index :resources, :id, :integer => true
+                add_index :resources, :host_id, :integer => true
+                add_index :resources, :source_file_id, :integer => true
+
+                # Thanks, mysql!  MySQL requires a length on indexes in text fields.
+                # So, we provide them for mysql and handle everything else specially.
+                if Puppet[:dbadapter] == "mysql"
+                    execute "CREATE INDEX typentitle ON resources (restype,title(50));"
+                else
+                    add_index :resources, [:title, :restype]
+                end
 
                 create_table :source_files do |t| 
                     t.column :filename, :string
                     t.column :path, :string
                     t.column :updated_at, :datetime
                 end
+                add_index :source_files, :id, :integer => true
+                add_index :source_files, :filename
+
+                create_table :resource_tags do |t|
+                    t.column :resource_id, :integer
+                    t.column :puppet_tag_id, :integer
+                    t.column :updated_at, :datetime
+                end
+                add_index :resource_tags, :id, :integer => true
+                add_index :resource_tags, :resource_id, :integer => true
+                add_index :resource_tags, :puppet_tag_id, :integer => true
 
-                create_table :puppet_classes do |t| 
+                create_table :puppet_tags do |t| 
                     t.column :name, :string
-                    t.column :host_id, :integer
-                    t.column :source_file_id, :integer
                     t.column :updated_at, :datetime
                 end
+                add_index :puppet_tags, :id, :integer => true
 
                 create_table :hosts do |t|
                     t.column :name, :string, :null => false
@@ -39,51 +60,51 @@ class Puppet::Rails::Schema
                     t.column :updated_at, :datetime
                     t.column :source_file_id, :integer
                 end
+                add_index :hosts, :id, :integer => true
+                add_index :hosts, :source_file_id, :integer => true
+                add_index :hosts, :name
 
                 create_table :fact_names do |t| 
                     t.column :name, :string, :null => false
-                    t.column :host_id, :integer, :null => false
                     t.column :updated_at, :datetime
                 end
+                add_index :fact_names, :id, :integer => true
+                add_index :fact_names, :name
 
                 create_table :fact_values do |t| 
                     t.column :value, :text, :null => false
                     t.column :fact_name_id, :integer, :null => false
+                    t.column :host_id, :integer, :null => false
                     t.column :updated_at, :datetime
                 end 
+                add_index :fact_values, :id, :integer => true
+                add_index :fact_values, :fact_name_id, :integer => true
+                add_index :fact_values, :host_id, :integer => true
 
                 create_table :param_values do |t|
                     t.column :value,  :text, :null => false
                     t.column :param_name_id, :integer, :null => false
+                    t.column :line, :integer
+                    t.column :resource_id, :integer
                     t.column :updated_at, :datetime
                 end
+                add_index :param_values, :id, :integer => true
+                add_index :param_values, :param_name_id, :integer => true
+                add_index :param_values, :resource_id, :integer => true
          
                 create_table :param_names do |t| 
                     t.column :name, :string, :null => false
-                    t.column :resource_id, :integer
-                    t.column :line, :integer
                     t.column :updated_at, :datetime
                 end
-
-                create_table :tags do |t| 
-                    t.column :name, :string
-                    t.column :updated_at, :datetime
-                end 
-
-                create_table :taggings do |t| 
-                    t.column :tag_id, :integer
-                    t.column :taggable_id, :integer
-                    t.column :taggable_type, :string
-                    t.column :updated_at, :datetime
-                end
-            end
-            $stdout.close
-            $stdout = oldout
-            oldout = nil
+                add_index :param_names, :id, :integer => true
+                add_index :param_names, :name
+            end 
         end
     ensure
+        $stdout.close
         $stdout = oldout if oldout
+        oldout = nil
     end
 end
 
-# $Id: schema.rb 2209 2007-02-17 02:06:46Z shadoi $
+# $Id: schema.rb 2590 2007-06-15 19:30:20Z luke $

data/lib/puppet/rails/fact_value.rb

@@ -1,5 +1,6 @@
 class Puppet::Rails::FactValue < ActiveRecord::Base
     belongs_to :fact_name
+    belongs_to :host
 end
 
 # $Id: fact_value.rb 1952 2006-12-19 05:47:57Z luke $

data/lib/puppet/rails/host.rb

@@ -9,16 +9,14 @@ class Puppet::Rails::Host < ActiveRecord::Base
     include Puppet::Util
     include Puppet::Util::CollectionMerger
 
-    has_many :fact_values, :through => :fact_names 
-    has_many :fact_names, :dependent => :destroy
+    has_many :fact_values, :dependent => :destroy
+    has_many :fact_names, :through => :fact_values
     belongs_to :puppet_classes
     has_many :source_files
     has_many :resources,
-        :include => [ :param_names, :param_values ],
+        :include => :param_values,
         :dependent => :destroy
 
-    acts_as_taggable
-
     # If the host already exists, get rid of its objects
     def self.clean(host)
         if obj = self.find_by_name(host)
@@ -41,9 +39,7 @@ class Puppet::Rails::Host < ActiveRecord::Base
         transaction do
             #unless host = find_by_name(name)
             seconds = Benchmark.realtime {
-                #unless host = find_by_name(name, :include => {:resources => {:param_names => :param_values}, :fact_names => :fact_values})
-                unless host = find_by_name(name, :include => {:fact_names => :fact_values})
-                #unless host = find_by_name(name)
+                unless host = find_by_name(name)
                     host = new(:name => name)
                 end
             }
@@ -59,7 +55,6 @@ class Puppet::Rails::Host < ActiveRecord::Base
                 raise ArgumentError, "You must pass resources"
             end
 
-
             seconds = Benchmark.realtime {
                 host.setresources(hash[:resources])
             }
@@ -73,54 +68,88 @@ class Puppet::Rails::Host < ActiveRecord::Base
         return host
     end
 
-    def tags=(tags)
-        tags.each do |tag|   
-            self.tag_with tag
-        end
-    end
-
     # Return the value of a fact.
     def fact(name)
-        if fv = self.fact_values.find(:first, :conditions => "fact_names.name = '#{name}'") 
-            return fv.value
+        if fv = self.fact_values.find(:all, :include => :fact_name,
+                                      :conditions => "fact_names.name = '#{name}'") 
+            return fv
         else
             return nil
         end
     end
+    
+    # returns a hash of fact_names.name => [ fact_values ] for this host.
+    def get_facts_hash
+        fact_values = self.fact_values.find(:all, :include => :fact_name)
+        return fact_values.inject({}) do | hash, value |
+            hash[value.fact_name.name] ||= []
+            hash[value.fact_name.name] << value
+            hash
+        end
+    end
+    
 
     def setfacts(facts)
         facts = facts.dup
-        remove = []
-
-        collection_merge :fact_names, :updates => facts, :modify => Proc.new { |fn, name, value|
-            fn.fact_values.each do |fv|
-                unless value == fv.value
-                    fv.value = value
-                end
-                break
-            end
-        }, :create => Proc.new { |name, value|
-            fn = fact_names.build(:name => name)
-            fn.fact_values = [fn.fact_values.build(:value => value)]
-        }
+        
+        ar_hash_merge(get_facts_hash(), facts, 
+                      :create => Proc.new { |name, values|
+                          fact_name = Puppet::Rails::FactName.find_or_create_by_name(name)
+                          values = [values] unless values.is_a?(Array)
+                          values.each do |value|
+                              fact_values.build(:value => value,
+                                                :fact_name => fact_name)
+                          end
+                      }, :delete => Proc.new { |values|
+                          values.each { |value| self.fact_values.delete(value) }
+                      }, :modify => Proc.new { |db, mem|
+                          mem = [mem].flatten
+                          fact_name = db[0].fact_name
+                          db_values = db.collect { |fact_value| fact_value.value }
+                          (db_values - (db_values & mem)).each do |value|
+                              db.find_all { |fact_value| 
+                                  fact_value.value == value 
+                              }.each { |fact_value|
+                                  fact_values.delete(fact_value)
+                              }
+                          end
+                          (mem - (db_values & mem)).each do |value|
+                              fact_values.build(:value => value, 
+                                                :fact_name => fact_name)
+                          end
+                      })
     end
 
     # Set our resources.
     def setresources(list)
-        compiled = {}
-        remove = []
         existing = nil
         seconds = Benchmark.realtime {
-            #existing = resources.find(:all)
-            existing = resources.find(:all, :include => {:param_names => :param_values})
-            #existing = resources
+
+            # Preload the parameters with the resource query, but not the tags, since doing so makes the query take about 10x longer.
+            # I've left the other queries in so that it's straightforward to switch between them for testing, if we so desire.
+            #existing = resources.find(:all, :include => [{:param_values => :param_name, :resource_tags => :puppet_tag}, :source_file]).inject({}) do | hash, resource |
+            #existing = resources.find(:all, :include => [{:resource_tags => :puppet_tag}, :source_file]).inject({}) do | hash, resource |
+            existing = resources.find(:all, :include => [{:param_values => :param_name}, :source_file]).inject({}) do | hash, resource |
+                hash[resource.ref] = resource
+                hash
+            end
         }
+
         Puppet.notice("Searched for resources in %0.2f seconds" % seconds) if defined?(Puppet::TIME_DEBUG)
-        list.each do |resource|
-            compiled[resource.ref] = resource
-        end
 
-        collection_merge :resources, :existing => existing, :updates => compiled
+        compiled = list.inject({}) do |hash, resource|
+            hash[resource.ref] = resource
+            hash
+        end
+        
+        ar_hash_merge(existing, compiled,
+                      :create => Proc.new { |ref, resource|
+                          resource.to_rails(self)
+                      }, :delete => Proc.new { |resource|
+                          self.resources.delete(resource)
+                      }, :modify => Proc.new { |db, mem|
+                          mem.modify_rails(db)
+                      })
     end
 
     def update_connect_time
@@ -129,4 +158,4 @@ class Puppet::Rails::Host < ActiveRecord::Base
     end
 end
 
-# $Id: host.rb 2350 2007-03-24 21:24:29Z luke $
+# $Id: host.rb 2616 2007-06-18 21:03:18Z luke $