puppet 0.18.4 → 0.22.4

data/lib/puppet/rails.rb

@@ -3,54 +3,25 @@
 require 'facter'
 require 'puppet'
 
-begin
-    require 'active_record'
-rescue LoadError => detail
-    if Facter["operatingsystem"].value == "Debian" and
-        FileTest.exists?("/usr/share/rails")
-            count = 0
-            Dir.entries("/usr/share/rails").each do |dir|
-                libdir = File.join("/usr/share/rails", dir, "lib")
-                if FileTest.exists?(libdir) and ! $:.include?(libdir)
-                    count += 1
-                    $: << libdir
-                end
-            end
-
-            if count > 0
-                retry
-            end
-    end
-end
-
-# If we couldn't find it the normal way, try using a Gem.
-unless defined? ActiveRecord
-    begin
-        require 'rubygems'
-        require_gem 'rails'
-    rescue LoadError
-        # Nothing
-    end
-end
-
 module Puppet::Rails
     Puppet.config.setdefaults(:puppetmaster,
         :dblocation => { :default => "$statedir/clientconfigs.sqlite3",
-            :mode => 0600,
+            :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 => [ "puppet", "The database server for Client caching. Only
+        :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/puppetrails.log",
+        :railslog => {:default => "$logdir/rails.log",
             :mode => 0600,
             :owner => "$user",
             :group => "$group",
@@ -58,58 +29,123 @@ module Puppet::Rails
         }
     )
 
-    def self.clear
-        @inited = false
+    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)
+
+            ActiveRecord::Base.logger = Logger.new(Puppet[:railslog])
+            ActiveRecord::Base.allow_concurrency = true
+            ActiveRecord::Base.verify_active_connections!
+
+            begin
+                ActiveRecord::Base.establish_connection(database_arguments())
+            rescue => detail
+                if Puppet[:trace]
+                    puts detail.backtrace
+                end
+                raise Puppet::Error, "Could not connect to database: %s" % detail
+            end 
+        end
+    end
+
+    # The arguments for initializing the database connection.
+    def self.database_arguments
+        args = {:adapter => Puppet[:dbadapter]}
+
+        case Puppet[:dbadapter]
+        when "sqlite3":
+            args[:dbfile] = Puppet[:dblocation]
+        when "mysql", "postgresql":
+            args[:host]     = Puppet[:dbserver]
+            args[:username] = Puppet[:dbuser]
+            args[:password] = Puppet[:dbpassword]
+            args[:database] = Puppet[:dbname]
+        else
+            raise ArgumentError, "Invalid db adapter %s" % Puppet[:dbadapter]
+        end
+        args
     end
 
     # Set up our database connection.  It'd be nice to have a "use" system
     # that could make callbacks.
     def self.init
-        unless defined? ActiveRecord::Base
+        unless Puppet.features.rails?
             raise Puppet::DevError, "No activerecord, cannot init Puppet::Rails"
         end
 
-        # This global init does not work for testing, because we remove
-        # the state dir on every test.
-        #unless (defined? @inited and @inited) or defined? Test::Unit::TestCase
-        unless (defined? @inited and @inited)
-            Puppet.config.use(:puppet)
+        connect()
 
-            ActiveRecord::Base.logger = Logger.new(Puppet[:railslog])
-            args = {:adapter => Puppet[:dbadapter]}
-
-            case Puppet[:dbadapter]
-            when "sqlite3":
-                args[:database] = Puppet[:dblocation]
-            when "mysql":
-                args[:host]     = Puppet[:dbserver]
-                args[:username] = Puppet[:dbuser]
-                args[:password] = Puppet[:dbpassword]
-                args[:database] = Puppet[:dbname]
-            end
+        unless ActiveRecord::Base.connection.tables.include?("resources")
+            require 'puppet/rails/database/schema'
+            Puppet::Rails::Schema.init
+        end
+
+        if Puppet[:dbmigrate]
+            migrate()
+        end
 
-            ActiveRecord::Base.establish_connection(args)
+        # 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)
 
-            @inited = true
+        # 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.
+    def self.migrate
+        dbdir = nil
+        $:.each { |d|
+            tmp = File.join(d, "puppet/rails/database")
+            if FileTest.directory?(tmp)
+                dbdir = tmp
+                break
+            end
+        }
+
+        unless dbdir
+            raise Puppet::Error, "Could not find Puppet::Rails database dir"
         end
 
-        if Puppet[:dbadapter] == "sqlite3" and ! FileTest.exists?(Puppet[:dblocation])
-            require 'puppet/rails/database'
-            begin
-                Puppet::Rails::Database.up
-            rescue => detail
-                if Puppet[:debug]
-                    puts detail.backtrace
-                end
-                raise Puppet::Error, "Could not initialize database: %s" % detail
+        Puppet.notice "Migrating"
+
+        begin
+            ActiveRecord::Migrator.migrate(dbdir)
+        rescue => detail
+            if Puppet[:trace]
+                puts detail.backtrace
             end
+            raise Puppet::Error, "Could not migrate database: %s" % detail
         end
+    end
+
+    # Tear down the database.  Mostly only used during testing.
+    def self.teardown
+        unless Puppet.features.rails?
+            raise Puppet::DevError, "No activerecord, cannot init Puppet::Rails"
+        end
+
         Puppet.config.use(:puppetmaster)
+
+        begin
+            ActiveRecord::Base.establish_connection(database_arguments())
+        rescue => detail
+            if Puppet[:trace]
+               puts detail.backtrace
+            end
+            raise Puppet::Error, "Could not connect to database: %s" % detail
+        end 
+
+        ActiveRecord::Base.connection.tables.each do |t| 
+            ActiveRecord::Base.connection.drop_table t
+        end
     end
 end
 
-if defined? ActiveRecord::Base
+if Puppet.features.rails?
     require 'puppet/rails/host'
 end
 
-# $Id: rails.rb 1205 2006-05-17 23:42:22Z luke $
+# $Id: rails.rb 2342 2007-03-21 22:12:25Z luke $

data/lib/puppet/rails/database/001_add_indexes.rb

@@ -0,0 +1,38 @@
+class AddIndexes < ActiveRecord::Migration
+    INDEXES = {
+        :resources => [[:title, :restype], :host_id, :exported],
+        :source_files => [:filename, :path],
+        :puppet_classes => [:name, :host_id],
+        :hosts => [:name, :ip, :updated_at],
+        :fact_names => [:name, :host_id],
+        :fact_values => [:fact_name_id],
+        :param_values => [:param_name_id],
+        :param_names => [:name, :resource_id],
+        :tags => [:name, :updated_at],
+        :taggings => [:tag_id, :taggable_id, :taggable_type]
+    }
+
+    def self.up
+        puts "trying"
+        # Add all of our initial indexes
+        INDEXES.each do |table, indexes|
+            indexes.each do |index|
+                if index.to_s =~ /_id/
+                    add_index table, index, :integer => true
+                else
+                    add_index table, index
+                end
+            end
+        end
+    end
+
+    def self.down
+        INDEXES.each do |table, indexes|
+            indexes.each do |index|
+                remove_index table, index
+            end
+        end
+    end
+end
+
+# $Id: 001_add_indexes.rb 2344 2007-03-22 04:56:05Z luke $

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

@@ -0,0 +1,89 @@
+class Puppet::Rails::Schema
+    def self.init
+        oldout = nil
+        Puppet::Util.benchmark(Puppet, :notice, "Initialized database") do
+            # We want to rewrite stdout, so we don't get migration messages.
+            oldout = $stdout
+            $stdout = File.open("/dev/null", "w")
+            ActiveRecord::Schema.define do
+                create_table :resources do |t|
+                    t.column :title, :string, :null => false
+                    t.column :restype,  :string, :null => false
+                    t.column :host_id, :integer
+                    t.column :source_file_id, :integer
+                    t.column :exported, :boolean
+                    t.column :line, :integer
+                    t.column :updated_at, :datetime
+                end
+
+                create_table :source_files do |t| 
+                    t.column :filename, :string
+                    t.column :path, :string
+                    t.column :updated_at, :datetime
+                end
+
+                create_table :puppet_classes do |t| 
+                    t.column :name, :string
+                    t.column :host_id, :integer
+                    t.column :source_file_id, :integer
+                    t.column :updated_at, :datetime
+                end
+
+                create_table :hosts do |t|
+                    t.column :name, :string, :null => false
+                    t.column :ip, :string
+                    t.column :last_compile, :datetime
+                    t.column :last_freshcheck, :datetime
+                    t.column :last_report, :datetime
+                    #Use updated_at to automatically add timestamp on save.
+                    t.column :updated_at, :datetime
+                    t.column :source_file_id, :integer
+                end
+
+                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
+
+                create_table :fact_values do |t| 
+                    t.column :value, :text, :null => false
+                    t.column :fact_name_id, :integer, :null => false
+                    t.column :updated_at, :datetime
+                end 
+
+                create_table :param_values do |t|
+                    t.column :value,  :text, :null => false
+                    t.column :param_name_id, :integer, :null => false
+                    t.column :updated_at, :datetime
+                end
+         
+                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
+        end
+    ensure
+        $stdout = oldout if oldout
+    end
+end
+
+# $Id: schema.rb 2209 2007-02-17 02:06:46Z shadoi $

data/lib/puppet/rails/external/tagging/acts_as_taggable.rb

@@ -0,0 +1,62 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module Taggable #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)  
+      end
+      
+      module ClassMethods
+        def acts_as_taggable(options = {})
+          write_inheritable_attribute(:acts_as_taggable_options, {
+            :taggable_type => ActiveRecord::Base.send(:class_name_of_active_record_descendant, self).to_s,
+            :from => options[:from]
+          })
+          
+          class_inheritable_reader :acts_as_taggable_options
+
+          has_many :taggings, :as => :taggable, :dependent => :destroy
+          has_many :tags, :through => :taggings
+
+          include ActiveRecord::Acts::Taggable::InstanceMethods
+          extend ActiveRecord::Acts::Taggable::SingletonMethods          
+        end
+      end
+      
+      module SingletonMethods
+        def find_tagged_with(list)
+          find_by_sql([
+            "SELECT #{table_name}.* FROM #{table_name}, tags, taggings " +
+            "WHERE #{table_name}.#{primary_key} = taggings.taggable_id " +
+            "AND taggings.taggable_type = ? " +
+            "AND taggings.tag_id = tags.id AND tags.name IN (?)",
+            acts_as_taggable_options[:taggable_type], list
+          ])
+        end
+        def tags(options = {})
+          options.merge!(:taggable_type => self.to_s)
+          Tag.tags(options)
+        end
+      end
+      
+      module InstanceMethods
+        def tag_with(list)
+          Tag.transaction do
+            taggings.destroy_all
+
+            Tag.parse(list).each do |name|
+              if acts_as_taggable_options[:from]
+                send(acts_as_taggable_options[:from]).tags.find_or_create_by_name(name).on(self)
+              else
+                Tag.find_or_create_by_name(name).on(self)
+              end
+            end
+          end
+        end
+
+        def tag_list
+          tags.collect { |tag| tag.name.include?(" ") ? "'#{tag.name}'" : tag.name }.join(" ")
+        end
+      end
+    end
+  end
+end

data/lib/puppet/rails/external/tagging/init.rb

@@ -0,0 +1,5 @@
+require 'puppet/rails/external/tagging/acts_as_taggable'
+ActiveRecord::Base.send(:include, ActiveRecord::Acts::Taggable)
+
+require 'puppet/rails/external/tagging/tagging'
+require 'puppet/rails/external/tagging/tag'

data/lib/puppet/rails/external/tagging/tag.rb

@@ -0,0 +1,50 @@
+class Tag < ActiveRecord::Base
+  has_many :taggings
+
+  def self.tags(options = {})
+    query = "select tags.id, name, count(*) as count"
+    query << " from taggings, tags"
+    query << " where tags.id = tag_id"
+    query << " group by tag_id"
+    query << " order by #{options[:order]}" if options[:order] != nil
+    query << " limit #{options[:limit]}" if options[:limit] != nil
+    tags = Tag.find_by_sql(query)
+  end
+
+  def self.parse(list)
+    tag_names = []
+
+    # first, pull out the quoted tags
+    list.gsub!(/\"(.*?)\"\s*/ ) { tag_names << $1; "" }
+
+    # then, replace all commas with a space
+    list.gsub!(/,/, " ")
+
+    # then, get whatever's left
+    tag_names.concat list.split(/\s/)
+
+    # strip whitespace from the names
+    tag_names = tag_names.map { |t| t.strip }
+
+    # delete any blank tag names
+    tag_names = tag_names.delete_if { |t| t.empty? }
+    
+    return tag_names
+  end
+
+  def tagged
+    @tagged ||= taggings.collect { |tagging| tagging.taggable }
+  end
+  
+  def on(taggable)
+    taggings.build :taggable => taggable
+  end
+  
+  def ==(comparison_object)
+    super || name == comparison_object.to_s
+  end
+  
+  def to_s
+    name
+  end
+end