scout_agent 3.0.0

data/lib/scout_agent/assignment/stop.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby -wKU
+
+module ScoutAgent
+  class Assignment
+    class Stop < Assignment
+      def execute
+        @agent = IDCard.new(:lifeline)
+        if @agent.pid_file.exist?
+          puts "Stopping #{ScoutAgent.proper_agent_name} (PID #{@agent.pid})..."
+          signal_and_wait("TERM")
+          if @agent.pid_file.exist?
+            puts "TERM signal was ignored, sending KILL..."
+            signal_and_wait("KILL")
+            if @agent.pid_file.exist?
+              abort_with_failed_to_stop
+            end
+          end
+          puts "Stopped."
+        else
+          abort_with_not_running_notice
+        end
+      end
+      
+      private
+      
+      def signal_and_wait(signal_name, wait_count = 10, wait_delay = 0.5)
+        begin
+          @agent.signal(signal_name)
+        rescue Errno::EPERM  # we don't have permission
+          abort_with_no_permission
+        end
+        wait_count.times do
+          sleep wait_delay
+          break unless @agent.pid_file.exist?
+        end
+      end
+      
+      def abort_with_not_running_notice
+        puts "#{ScoutAgent.proper_agent_name} is not currently running."
+      end
+      
+      def abort_with_no_permission
+        abort <<-END_PERMISSION.trim
+        Unable to signal the daemon.  Please rerun this command with
+        super user privileges:
+        
+            sudo #{$PROGRAM_NAME} stop
+        
+        END_PERMISSION
+      end
+      
+      def abort_with_failed_to_stop
+        abort <<-END_FAILED.trim
+        Unable to stop the daemon.  You may need to use the PID files
+        in #{Plan.pid_dir} to clean up stay processes.
+        END_FAILED
+      end
+    end
+  end
+end

data/lib/scout_agent/assignment/upload_log.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby -wKU
+
+# require standard libraries
+require "tempfile"
+
+module ScoutAgent
+  class Assignment
+    class UploadLog < Assignment
+      def execute
+        file_name = "#{ScoutAgent.agent_name}.log"
+        if date = Array(other_args).shift
+          file_name += ".#{date.delete('^0-9')}"
+        end
+        log_file = Plan.log_dir + file_name
+        
+        unless log_file.exist?
+          abort_with_not_found(file_name)
+        end
+        
+        puts "Preparing file for the server.  This may take a moment..."
+        begin
+          upload_file = Tempfile.new("#{file_name}.gz")
+          gzipped     = Zlib::GzipWriter.new(upload_file)
+          log_file.each_line do |line|
+            gzipped << line
+          end
+          gzipped.close
+          upload_file.open  # reopen what Zlib closed
+        rescue Exception => error  # Zlib or IOError
+          abort_with_preparation_error(error)
+        end
+        puts "Done."
+        
+        
+        puts "Sending file to the server.  This may take a moment..."
+        server = Server.new
+        if server.post_log(upload_file)
+          puts "Log '#{file_name}' received.  Thanks."
+        else
+          abort_with_server_error
+        end
+      end
+      
+      private
+      
+      def abort_with_not_found(log_file_name)
+        abort "'#{log_file_name}' could not be found to upload."
+      end
+      
+      def abort_with_preparation_error(error)
+        abort <<-END_PREPARATION_ERROR
+        Could not prepare file for upload:  #{error.message} (#{error.class})
+        END_PREPARATION_ERROR
+      end
+      
+      def abort_with_server_error
+        abort "A networking error prevented the file from being sent."
+      end
+    end
+  end
+end

data/lib/scout_agent/core_extensions.rb

@@ -0,0 +1,260 @@
+#!/usr/bin/env ruby -wKU
+
+module ScoutAgent
+  # 
+  # This Module holds a handful of extensions to the Ruby core used by our
+  # agent.  This is in no way meant to be an ActiveSupport or Facets level
+  # support library.  Instead, this should house a few simple conveniences that
+  # are intristic to the agent's needs in some way.
+  # 
+  # For example, the agent tries to load matching source files for Classes and
+  # Modules in multiple places.  Given that, it makes sense for us to add helper
+  # methods for these case coversions.
+  # 
+  module CoreExtensions
+    # Extensions for the Array class.
+    module Array
+      #
+      # This method converts an Array into a human readable word list String.
+      # These lists are of the form:
+      # 
+      #   one
+      #   one and two
+      #   one, two, and three
+      #   etc.
+      # 
+      # You can change the +conjuction+ used to join the last two elements.
+      # 
+      def to_word_list(conjuction = "and")
+        case size
+        when 0 then ""
+        when 1 then self[0].to_s
+        when 2 then join(" #{conjuction} ")
+        else        ( self[0..-3] +
+                      [self[-2..-1].join(", #{conjuction} ")] ).join(", ")
+        end
+      end
+    end
+    
+    # Extensions for the Module class.
+    module Module
+      # 
+      # Returns just the last element of a full Module or Class name as a
+      # String.  For example, ScoutAgent::CoreExtensions::Module would be
+      # simplified to <tt>"Module"</tt>.
+      # 
+      def short_name
+        name[/[^:]+\z/]
+      end
+    end
+
+    # Globally available extensions.
+    module Object
+      # 
+      # Tries to require a library with +name+.  If that fails, attempts to load
+      # RubyGems and tries the require again.  If that too fails, this process
+      # will exit with a message about the missing library.
+      # 
+      def require_lib_or_gem(name)
+        require name
+      rescue LoadError    # library not found
+        begin
+          require "rubygems"
+          require name
+        rescue LoadError  # library not found
+          abort <<-END_LOAD_ERROR.trim
+          Unable to load the required '#{name}' library.  Try:
+
+              sudo gem install #{name.tr('_', '-')}
+
+          END_LOAD_ERROR
+        end
+      end
+
+      # 
+      # This is a helper for those libraries that aren't well enough behaved not
+      # to spit out warnings as they work.  Warnings are disabled, your block is
+      # run, then warnings are restored to their previous level.
+      # 
+      def no_warnings
+        old_verbose = $VERBOSE
+        $VERBOSE    = nil
+        yield
+      ensure
+        $VERBOSE = old_verbose
+      end
+      
+      # 
+      # Sets up an at_exit() hander that will only run when this process exits.
+      # Child processes do not inherit +exit_code+.
+      # 
+      def at_my_exit(&exit_code)
+        me = ::Process.pid
+        at_exit do
+          exit_code.call if me == ::Process.pid
+        end
+      end
+
+      # 
+      # This method installs +handler+ for +TERM+ signals.  If the agent is
+      # running as a daemon, the same code will be installed for +INT+ signals
+      # as well.  Otherwise, +INT+ signals will be set to +IGNORE+.
+      # 
+      def install_shutdown_handler(&handler)
+        shutdown_signals = %w[TERM]
+        if ScoutAgent::Plan.run_as_daemon?
+          shutdown_signals << "INT"
+        else
+          trap("INT", "IGNORE")
+        end
+        shutdown_signals.each do |signal|
+          trap(signal, &handler)
+        end
+      end
+    end
+
+    # Module extensions for Process.
+    module ProcessModule
+      # 
+      # A convenience method to ensure +child_pid+ is stopped.  First a friendly
+      # +TERM+ signal is sent.  Then, after +pause+ seconds, +KILL+ will be sent
+      # if the process has not yet exited.  The exit code for the process is
+      # returned if it can be determined (+nil+ is returned otherwise).
+      # 
+      def term_or_kill(child_pid, pause = 1)
+        %w[TERM KILL].each { |signal|
+          begin
+            ::Process.kill(signal, child_pid)  # attempt to stop process
+          rescue Errno::ECHILD, Errno::ESRCH   # no such process
+            break  # the process is stopped
+          end
+          if signal == "TERM"
+            # give them a chance to respond
+            begin
+              Timeout.timeout(pause) {
+                begin
+                  return ::Process.wait2(child_pid).last  # response to signal
+                rescue Errno::ECHILD  # no such child
+                  return nil # we have already caught the child
+                end
+              }
+            rescue Timeout::Error  # the process didn't exit in time
+              # try again with KILL
+            end
+          end
+        }
+        begin
+          ::Process.wait2(child_pid).last
+        rescue Errno::ECHILD  # no such child
+          nil # we have already caught the child
+        end
+      end
+    end
+    
+    # Extensions for the String class.
+    module String
+      ########################
+      ### Case Conversions ###
+      ########################
+
+      # 
+      # Converts a String like "class_name" into "ClassName".  Symbols and 
+      # whitespace are removed.
+      # 
+      def CamelCase
+        tr("^A-Za-z0-9_", "_").
+        gsub(/(?:\A|_)([a-z])/) { $1.capitalize }.
+        delete("_")
+      end
+      alias_method :camel_case, :CamelCase
+
+      # 
+      # Converts a String like "ClassName" into "class_name".  All runs of
+      # symbols and whitespace are replaced with a single "_".
+      # 
+      def snake_case
+        tr("^A-Za-z0-9_",      "_").
+        gsub(/(\D)(\d)/,       "\\1_\\2").
+        gsub(/(\d)(\D)/,       "\\1_\\2").
+        gsub(/([a-z])([A-Z])/, "\\1_\\2").
+        gsub(/_{2,}/,          "_").
+        downcase
+      end
+
+      ######################
+      ### String Cleanup ###
+      ######################
+
+      #
+      # This helper will trim all lines in a String of leading whitespace.  By 
+      # default, it trims the amount of space present on the first line, but you
+      # can override this by setting +width+ manually.
+      # 
+      # This method is handy for removing unwanted spacing in indented heredocs
+      # and thus helps keep the source clean:
+      # 
+      #   def whatever
+      #     puts <<-END_MESSAGE.trim  # clean up message
+      #     <- removes this space
+      #     <- and this
+      #     END_MESSAGE
+      #   end
+      # 
+      def trim(width = self[/\A[ \t]*/].size)
+        gsub(/^[ \t]{#{width}}/, "")
+      end
+
+      # 
+      # This helper swaps all trailing whitespace for two simple spaces.  This
+      # is another method used to cleanup heredocs.
+      # 
+      def to_question
+        rstrip + "  "
+      end
+
+      #
+      # Wraps a String to fit within the specified +width+, if possible.
+      # Newlines are inserted where spaces were, as needed.
+      # 
+      def word_wrap(width = 60)
+        strip.
+        gsub(/\s+/, " ").
+        gsub(/(.{1,#{width}}|\S{#{width + 1},})(?: +|$\n?)/, "\\1\n").
+        strip
+      end
+    end
+    
+    # Class extensions for Time.
+    module TimeClass
+      # 
+      # Converts a String (+str+) in the form <tt>"NNNN-NN-NN NN:NN"</tt> or 
+      # <tt>"NNNN-NN-NN NN:NN:NN"</tt> into a proper Time object.
+      # 
+      def from_db_s(str)
+        if str and str.to_s =~ /\A\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}(?::\d{2})?\z/
+          ::Time.local(*str.to_s.scan(/\d+/))
+        end
+      end
+    end
+
+    # Extensions for the Time class.
+    module Time
+      # 
+      # Returns a String version of this Time in the format expected by SQLite.
+      # If +trim_seconds+ is +true+, the sec() of this Time object will not be
+      # included in the String representation.
+      # 
+      def to_db_s(trim_seconds = false)
+        strftime("%Y-%m-%d %H:%M#{':%S' unless trim_seconds}")
+      end
+    end
+  end
+end
+
+# load all core extensions
+ScoutAgent::CoreExtensions.constants.each do |name|
+  extension = ScoutAgent::CoreExtensions.const_get(name)
+  mixer     = name.sub!(/([a-z])(?:Module|Class)\z/, "\\1") ? :extend : :include
+  core      = Object.const_get(name)
+  core.send(mixer, extension)
+end

data/lib/scout_agent/database.rb

@@ -0,0 +1,386 @@
+#!/usr/bin/env ruby -wKU
+
+module ScoutAgent
+  #
+  # This wrapper over Amalgalite::Database adds database loading by name, schema
+  # migrations when they are loaded, installation of standardized busy handlers
+  # and taps for the agent as a connection is prepared, and helper methods for
+  # managing database locks and building schemas.
+  # 
+  class Database
+    # 
+    # Returns the path to a database file based on the configured data storage
+    # location and the passed +name+ of the database.
+    # 
+    def self.path(name)
+      Plan.db_dir + "#{name}.sqlite"
+    end
+    
+    # 
+    # Loads a database by +name+, optionally preparing +log+ to receive any
+    # error messages.
+    # 
+    # The process loads the proper code wrapper for the database by +name+,
+    # installs the handlers and taps used for all connections by the agent,
+    # migrates the schema up to the latest code, and returns the connection
+    # handle.  If anything goes wrong in this process, +nil+ is returned
+    # instead.
+    # 
+    def self.load(name, log = WireTap.new(nil))
+      require LIB_DIR + "database/#{name}"
+      
+      begin
+        db = ScoutAgent::Database.const_get(name.to_s.CamelCase).new(log)
+        db.prepare_connection
+        db.migrate
+      rescue Amalgalite::SQLite3::Error => error  # failed to migrate database
+        log.error("Database migration error:  #{error.message}.")
+        return nil  # cannot load database
+      end
+      
+      db
+    end
+    
+    #
+    # Builds a new database instance, optionally tied to a +log+.
+    # 
+    # This is very low-level, bypassing the standard preparation and migration
+    # process.  Thus databases should usually be created with load() instead.
+    # 
+    def initialize(log = WireTap.new(nil))
+      @log          = log
+      @sqlite       = Amalgalite::Database.new(path)
+      @read_locked  = false
+      @write_locked = false
+    end
+    
+    # The log file (or bit buckect by default) this database reports to.
+    attr_reader :log
+    
+    # 
+    # This is a shortcut for the class method of the same name, passing a
+    # snake_case version of this Class name as the database name.
+    # 
+    def path
+      self.class.path(self.class.short_name.snake_case)
+    end
+    
+    # 
+    # This method is invoked after a database is openned, but before a
+    # connection is used.  This provides a chance to install handles, taps, and
+    # functions before SQL is executed through the connection.
+    # 
+    def prepare_connection
+      # 
+      # Wait up to 60 seconds for a database lock, attempting to grab it every
+      # 100 milliseconds.
+      # 
+      @sqlite.busy_handler(Amalgalite::BusyTimeout.new(600, 100))
+      # Install a trace tap for SQL when debugging.
+      if log.debug?
+        @sqlite.trace_tap = Amalgalite::TraceTap.new(log, :debug)
+      end
+    end
+    
+    # Returns the current schema version number tracked by SQLite.
+    def schema_version
+      read_from_sqlite { |sqlite| sqlite.pragma(:schema_version).first.first }
+    end
+    
+    # 
+    # This method updates a database schema.  It does that by grabbing a write
+    # lock and then pulling the current schema_version() and feeding that to
+    # update_schema() for SQL to upgrade the database with.  SQL is passed
+    # through filters for type and trigger expansions, then batch processed by
+    # SQLite.  This process will be repeated until update_schema() returns +nil+
+    # to indicate that the schema is now up-to-date.
+    # 
+    # Some maintenance SQL is also inserted with the first migration to
+    # initialize database maintenance tracking.
+    # 
+    def migrate
+      write_to_sqlite do |sqlite|
+        loop do
+          version = schema_version
+          sql     = update_schema(version) or break
+          sql     = "#{add_maintenance_sql(version)}#{sql}"
+          sql.gsub!(/^([ \t]*)(\w+)[ \t]+(\w+_TYPE)\b/) {           # types
+            begin
+              send($3.downcase, $2).gsub(/^/, $1.to_s)
+            rescue NoMethodError  # unsupported type
+              $&
+            end
+          }
+          sql.gsub!(/^[ \t]*(\w+_TRIGGER)[ \t]+(\S.*?)[ \t]*$/) {  # triggers
+            begin
+              send($1.downcase, *$2.split)
+            rescue NoMethodError  # unsupported trigger
+              $&
+            end
+          }
+          sqlite.execute_batch(sql)
+        end
+      end
+    end
+    
+    # 
+    # Subclasses override this method to setup schema migrations as described in
+    # migrate().
+    # 
+    def update_schema(version = schema_version)
+      nil
+    end
+    
+    #
+    # This method should be called periodically to +VACUUM+ databases and
+    # reclaim the space they have consumed on the hard disk.  Returns +true+ if
+    # maintenance was successful, +false+ if it wasn't needed, and +nil+ if
+    # errors prevented the process from completing.  The next scheduled run for
+    # maintenance is stored in a table of the database added during the
+    # migration process.
+    # 
+    # This method uses some external synchronization to ensure that only one
+    # process can be in here at once, thus processes may block for a time when
+    # they call it.
+    # 
+    def maintain
+      # 
+      # This cannot be in a transaction (+VACUUM+ fails).  Given that, we use an
+      # external locking mechanism on the database code file to prevent doubled
+      # +VACUUM+ race conditions.
+      # 
+      (LIB_DIR + "database/#{self.class.short_name.snake_case}.rb").open do |db|
+        db.flock(File::LOCK_EX)
+        begin
+          if @sqlite.first_value_from(
+               "SELECT ROWID FROM maintenance WHERE next_run_at <= ?",
+               Time.now.to_db_s
+             )
+            @sqlite.execute("VACUUM")
+            @sqlite.execute(<<-END_UPDATE_MAINTENANCE_TIME.trim)
+            INSERT OR REPLACE INTO
+              maintenance( ROWID,                            next_run_at )
+              VALUES(          1, datetime('now', 'localtime', '+1 day') );
+            END_UPDATE_MAINTENANCE_TIME
+            true  # maintenance successful
+          else
+            false  # maintenance not needed
+          end
+        ensure
+          db.flock(File::LOCK_UN)
+        end
+      end
+    rescue Amalgalite::SQLite3::Error => error  # failed to +VACUUM+ database
+      log.error("Database maintenance error:  #{error.message}.")
+      nil  # maintenance failed, we will try again later
+    end
+    
+    # Returns +true+ if this connection is currently read locked.
+    def read_locked?
+      @read_locked
+    end
+    
+    # Returns +true+ if this connection is currently write locked.
+    def write_locked?
+      @write_locked
+    end
+    
+    # Returns +true+ if this connection is currently read or write locked.
+    def locked?
+      read_locked? or write_locked?
+    end
+    
+    # 
+    # This method is used to wrap some code in a read lock transaction.  The
+    # block you pass is ensured to be run inside of a transaction.  If one is
+    # already is active, the code will just be run normally.  Otherwise, a new
+    # transaction is started and it will be completed after your block runs.
+    # This ensures that multiple calls to this method nest properly.
+    # 
+    def read_from_sqlite
+      if locked?
+        yield @sqlite
+      else
+        begin
+          @sqlite.transaction("IMMEDIATE") {
+            @read_locked = true
+            yield @sqlite
+          }
+        ensure
+          @read_locked = false
+        end
+      end
+    end
+    
+    # 
+    # Works just like read_from_sqlite(), but with a write lock.
+    # 
+    # This method will +raise+ a +RuntimeError+ if called inside a
+    # read_from_sqlite() block.  It's too late to upgrade to a write lock at
+    # that point as a deadlock condition could be introduced.  Such code must be
+    # reworked to aquire the write lock first.
+    # 
+    def write_to_sqlite
+      if read_locked?
+        raise "Cannot upgrade a read lock to a write lock"
+      elsif write_locked?
+        yield @sqlite
+      else
+        begin
+          @sqlite.transaction("EXCLUSIVE") {
+            @write_locked = true
+            yield @sqlite
+          }
+        ensure
+          @write_locked = false
+        end
+      end
+    end
+    
+    # 
+    # A convenience for running +sql+, with any +params+, in a read lock and
+    # then applying +transform+ to each row before the result set is returned.
+    # 
+    def query(sql, *params, &transform)
+      read_from_sqlite { |sqlite|
+        results = sqlite.execute(sql, *params)
+        results.each(&transform) unless transform.nil?
+        results
+      }
+    end
+    
+    #######
+    private
+    #######
+    
+    # 
+    # Returns the SQL to create and initialize a maintenance table if +version+
+    # is <tt>0</tt>.
+    # 
+    def add_maintenance_sql(version)
+      case version
+      when 0
+        <<-END_MAINTENANCE.trim + "\n"
+        CREATE TABLE maintenance (
+          next_run_at REQUIRED_DATETIME_TYPE
+        );
+        INSERT OR REPLACE INTO
+          maintenance( ROWID,                            next_run_at )
+          VALUES(          1, datetime('now', 'localtime', '+1 day') );
+        END_MAINTENANCE
+      end
+    end
+    
+    # A text SQL type with content validation.
+    def required_text_type(field)
+      "#{field} TEXT NOT NULL CHECK(length(trim(#{field})) > 0)"
+    end
+    
+    # 
+    # An integer SQL type with a default (which should immediately follow
+    # the type definition).
+    # 
+    def default_integer_type(field)
+      "#{field} INTEGER NOT NULL DEFAULT"
+    end
+    
+    # An integer SQL type with validation of a positive value.
+    def positive_integer_type(field)
+      <<-END_POSITIVE_INTEGER.trim.rstrip
+      #{field} INTEGER NOT NULL
+        CHECK(typeof(#{field}) = 'integer' AND #{field} > 0)
+      END_POSITIVE_INTEGER
+    end
+    
+    # A real SQL type with validation of a zero or positive value.
+    def zero_or_positive_real_type(field)
+      <<-END_POSITIVE_REAL.trim.rstrip
+      #{field} REAL NOT NULL
+        CHECK(typeof(#{field}) = 'real' AND #{field} >= 0.0)
+      END_POSITIVE_REAL
+    end
+    
+    # A date and time SQL type with format validation.
+    def required_datetime_type(field)
+      <<-END_DATETIME.trim.rstrip
+      #{field} TEXT NOT NULL COLLATE NOCASE
+        CHECK(datetime(#{field}) IS NOT NULL)
+      END_DATETIME
+    end
+    
+    # 
+    # As required_datetime_type(), but allowing +NULL+ which a trigger can
+    # replace.
+    # 
+    def datetime_type(field)
+      <<-END_DEFAULT_DATETIME.trim.rstrip
+      #{field} TEXT COLLATE NOCASE
+        CHECK(#{field} IS NULL OR datetime(#{field}) IS NOT NULL)
+      END_DEFAULT_DATETIME
+    end
+    
+    # A trigger for defaulting a date and time field to a local time.
+    def default_localtime_trigger(table, field, second_mode = "include_seconds")
+      now = if second_mode == "trim_seconds"
+              "strftime('%Y-%m-%d %H:%M', 'now', 'localtime')"
+            else
+              "datetime('now', 'localtime')"
+            end
+      <<-END_DEFAULT_LOCALTIME_TRIGGER.trim
+      CREATE TRIGGER default_#{field}_on_insert
+      AFTER INSERT ON #{table}
+      BEGIN
+        UPDATE #{table}
+        SET #{field} = #{now}
+        WHERE ROWID = NEW.ROWID AND #{field} IS NULL;
+      END;
+      END_DEFAULT_LOCALTIME_TRIGGER
+    end
+    
+    # 
+    # A trigger for ensuring that a foreign key is valid during +INSERT+ and
+    # +UPDATE+.
+    # 
+    def foreign_key_check_trigger(table, field, foreign_table, foreign_field)
+      <<-END_FOREIGN_KEY_CHECK_TRIGGER.trim
+      CREATE TRIGGER check_#{field}_on_insert
+      BEFORE INSERT ON #{table}
+      BEGIN
+        SELECT CASE
+          WHEN ( SELECT #{foreign_table}.#{foreign_field}
+                 FROM #{foreign_table}
+                 WHERE #{foreign_table}.#{foreign_field} = NEW.#{field}
+                 LIMIT 1 ) IS NULL
+          THEN RAISE(ABORT, '#{table}.#{field} not in database.')
+        END;
+      END;
+      CREATE TRIGGER check_#{field}_on_update
+      BEFORE UPDATE OF #{field} ON #{table}
+      BEGIN
+        SELECT CASE
+          WHEN ( SELECT #{foreign_table}.#{foreign_field}
+                 FROM #{foreign_table}
+                 WHERE #{foreign_table}.#{foreign_field} = NEW.#{field}
+                 LIMIT 1 ) IS NULL
+          THEN RAISE(ABORT, '#{table}.#{field} not in database.')
+        END;
+      END;
+      END_FOREIGN_KEY_CHECK_TRIGGER
+    end
+  
+    # 
+    # A trigger that eliminates old records in +table+ once +limit+ records have
+    # been inserted.
+    # 
+    def limit_table_size_trigger(table, limit)
+      <<-END_LIMIT_TABLE_SIZE_TRIGGER.trim
+      CREATE TRIGGER limit_#{table}_size
+      AFTER INSERT ON #{table}
+      BEGIN
+        DELETE FROM #{table}
+        WHERE       ROWID <= (SELECT MAX(ROWID) FROM #{table}) - #{limit};
+      END;
+      END_LIMIT_TABLE_SIZE_TRIGGER
+    end
+  end
+end