bookie_accounting 0.0.2 → 0.0.3

data/Rakefile

@@ -1,4 +1,5 @@
 #!/usr/bin/env rake
+require 'bundler'
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
@@ -13,3 +14,135 @@ end
 task :docs do
   system("rdoc rdoc lib")
 end
+
+desc "Build RPM and dependencies (intended for IBEST internal use)"
+task :rpm_deps do
+  require 'erb'
+  require 'yaml'
+
+  build_rpms({
+    'bookie_accounting' => {
+      :is_app => true,
+      :has_binaries => true,
+      :gem_file => "bookie_accounting-#{Bookie::VERSION}.gem",
+      :license => 'MIT',
+      :skip_deps => Set.new(['sqlite3']),
+    },
+    'bundler' => {
+
+    },
+    'spreadsheet' => {
+      :has_binaries => true,
+      :license => 'GPL3',
+    },
+    'ruby-ole' => {
+      :license => 'MIT',
+    },
+    'pacct' => {
+      :license => 'MIT',
+    },
+  })
+end
+
+def find_gem_file(gem_name)
+  Dir.glob("#{gem_name}-*.gem")[0]
+end
+ 
+def build_rpms(modules_to_build)
+  this_dir = Dir.pwd
+  pkg_dir = File.join(this_dir, 'pkg')
+
+  home_dir = Etc.getpwuid.dir
+
+  rpmbuild_dir = File.join(home_dir, 'rpmbuild')
+  spec_dir = File.join(rpmbuild_dir, 'SPECS')
+  src_dir = File.join(rpmbuild_dir, 'SOURCES')
+  rpm_dir = File.join(rpmbuild_dir, 'RPMS')
+
+  [spec_dir, src_dir].each do |dir|
+    FileUtils.mkdir_p(dir)
+  end
+
+  #To do: packaging for Ruby versions other than 1.8
+  template = ERB.new(File.read('rpm/spec_template.erb'))
+  lockfile = Bundler::LockfileParser.new(Bundler.read_file("Gemfile.lock"))
+  lockfile.specs.each do |spec|
+    extra_data = modules_to_build[spec.name]
+    next unless extra_data
+
+    gem_name = spec.name
+    version = spec.version
+
+    puts gem_name
+
+    #Has the RPM already been built?
+    next if Dir.glob(File.join(rpm_dir, "*/(rubygem-)?#{gem_name}-#{version}-*.rpm")).length > 0
+    
+    ruby_version = RUBY_VERSION.split('.')[0 .. 1].join('.')
+
+    #Get the gem.
+    Dir.chdir(src_dir)
+    gem_file = extra_data[:gem_file]
+    if gem_file
+      FileUtils.cp(File.join(pkg_dir, gem_file), '.')
+    else
+      gem_file = find_gem_file(gem_name)
+      #To do: handle old versions of gems existing in src_dir
+      system("gem fetch #{gem_name} -v #{version}") unless gem_file && File.exists?(gem_file)
+      gem_file ||= find_gem_file(gem_name)
+    end
+    fail "Unable to find gem file for #{gem_name}" unless gem_file
+    gem = File.basename(gem_file, '.gem')
+    s = YAML.load(`gem spec #{gem_file}`)
+
+    #Build the RPM spec.
+    Dir.chdir(spec_dir)
+    if s.licenses.length > 0
+      license = s.licenses.join(' AND ')
+    else
+      license = extra_data[:license]
+    end
+    url = s.homepage
+    summary = s.summary
+    description = s.description
+    requires = []
+    build_requires = []
+    s.dependencies.each do |dep|
+      case dep.type
+      when :development
+        build_requires.push(dep)
+      else
+        requires.push(dep)
+      end
+    end
+    requires.map!{ |r| "rubygem-#{r.name}" }
+    
+    is_app = extra_data[:is_app]
+    has_binaries = extra_data[:has_binaries]
+
+    if is_app
+      spec_filename = "#{gem_name}.spec"
+    else
+      spec_filename = "rubygem-#{gem_name}.spec"
+    end
+    spec_filename = File.join(spec_dir, spec_filename)
+
+    File.open(spec_filename, "w") do |file|
+      template_filename = File.join(this_dir, "rpm/#{gem_name}.spec.erb")
+      if File.exists?(template_filename)
+         file.write(ERB.new(File.read(template_filename)).result(binding))
+      else
+        file.write(template.result(binding))
+      end
+    end
+
+    msg = `rpmbuild -bb #{spec_filename}`
+    unless $?.success?
+      puts msg
+      exit 1
+    end
+  end
+
+  Dir.chdir(this_dir)
+end
+

data/bin/bookie-data

@@ -8,6 +8,7 @@ require 'optparse'
 require 'bookie/formatter'
 
 jobs = Bookie::Database::Job
+summaries = Bookie::Database::JobSummary
 systems = Bookie::Database::System
 
 config_filename = '/etc/bookie/config.json'
@@ -37,7 +38,7 @@ opts = OptionParser.new do |opts|
   opts.banner = "Usage: bookie-data [options]"
   
   opts.on('-c', '--config FILE', String, "use the given configuration file") do |file|
-    #This is just here so it shows up in the message.
+    #This is just here for validation and so it shows up in the usage message.
   end
   
   opts.on('-d', '--details', "include full details") do
@@ -46,14 +47,22 @@ opts = OptionParser.new do |opts|
   
   opts.on('-u', '--user NAME', "filter by username") do |name|
     jobs = jobs.by_user_name(name)
+    summaries = summaries.by_user_name(name)
   end
   
-  opts.on('-g', '--group NAME' "filter by group") do |name|
+  opts.on('-g', '--group NAME', "filter by group") do |name|
     jobs = jobs.by_group_name(name)
+    summaries = summaries.by_group_name(name)
+  end
+  
+  opts.on('-m', '--command', "filter by command") do |cmd|
+    jobs = jobs.by_command_name(cmd)
+    summaries = summaries.by_command_name(cmd)
   end
   
   opts.on('-s', '--system HOSTNAME', "filter by system") do |hostname|
     jobs = jobs.by_system_name(hostname)
+    summaries = summaries.by_system_name(hostname)
     systems = systems.by_name(hostname)
   end
   
@@ -64,6 +73,7 @@ opts = OptionParser.new do |opts|
       exit 1
     end
     jobs = jobs.by_system_type(t)
+    summaries = summaries.by_system_type(t)
     systems = systems.by_system_type(t)
   end
   
@@ -96,7 +106,7 @@ end
 
 formatter = Bookie::Formatter.new(output_type, filename)
 
-jobs_summary, systems_summary = formatter.print_summary(jobs, systems, t_min, t_max)
+jobs_summary, systems_summary = formatter.print_summary(jobs, summaries, systems, t_min, t_max)
 jobs = jobs.by_time_range_inclusive(t_min, t_max) if t_min
-formatter.print_jobs(jobs_summary[:jobs]) if include_details
+formatter.print_jobs(jobs.all) if include_details
 formatter.flush

data/bookie_accounting.gemspec

@@ -4,6 +4,7 @@ require File.expand_path('../lib/bookie/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Ben Merritt"]
   gem.email         = ["blm768@gmail.com"]
+  gem.license       = "MIT"
   gem.description   = %q{A simple system to record and query process accounting records}
   gem.summary       = %q{A simple system to record and query process accounting records}
   gem.homepage      = "https://github.com/blm768/bookie/"
@@ -15,11 +16,10 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Bookie::VERSION
   
-  gem.add_dependency('json')
   gem.add_dependency('activerecord')
   #For some reason, this is needed for Ruby 1.8.7 using RVM on CentOS.
   #To do: remove when no longer needed
-  gem.add_dependency('mysql2')
+  #gem.add_dependency('mysql2')
   gem.add_dependency('pacct')
   gem.add_dependency('spreadsheet')
   gem.add_development_dependency('mocha')

data/lib/bookie/database.rb

@@ -58,11 +58,19 @@ module Bookie
         return start_time + wall_time
       end
       
+      def self.by_user(user)
+        where('jobs.user_id = ?', user.id)
+      end
+      
       ##
       #Filters by user name
       def self.by_user_name(user_name)
         joins(:user).where('users.name = ?', user_name)
       end
+      
+      def self.by_system(system)
+        where('jobs.system_id = ?', system.id)
+      end
 
       ##
       #Filters by system name
@@ -92,21 +100,20 @@ module Bookie
       
       ##
       #Filters by a range of start times
-      def self.by_start_time_range(start_min, start_max)
-        where('? <= jobs.start_time AND jobs.start_time < ?', start_min, start_max)
+      def self.by_start_time_range(time_range)
+        where('? <= jobs.start_time AND jobs.start_time < ?', time_range.first, time_range.last)
       end
       
       ##
       #Filters by a range of end times
-      def self.by_end_time_range(end_min, end_max)
-        where('? <= jobs.end_time AND jobs.end_time < ?', end_min, end_max)
+      def self.by_end_time_range(time_range)
+        where('? <= jobs.end_time AND jobs.end_time < ?', time_range.first, time_range.last)
       end
       
       ##
       #Finds all jobs whose running intervals overlap the given time range
-      def self.by_time_range_inclusive(min_time, max_time)
-        raise ArgumentError.new('Max time must be greater than or equal to min time') if max_time < min_time
-        where('jobs.start_time < ? AND jobs.end_time > ?', max_time, min_time)
+      def self.by_time_range_inclusive(time_range)
+        where('? <= jobs.end_time AND jobs.start_time < ?', time_range.first, time_range.last)
       end
       
       ##
@@ -114,20 +121,16 @@ module Bookie
       #
       #Returns a hash with the following fields:
       #- <tt>:jobs</tt>: an array of all jobs in the interval
-      #- <tt>:wall_time</tt>: the sum of all the jobs' wall times
       #- <tt>:cpu_time</tt>: the total CPU time used
       #- <tt>:memory_time</tt>: the sum of memory * wall_time for all jobs in the interval
-      #- <tt>:successful</tt>: the proportion of jobs that completed successfully
+      #- <tt>:successful</tt>: the number of jobs that have completed successfully
       #
       #This method should probably not be used with other queries that filter by start/end time.
-      def self.summary(min_time = nil, max_time = nil)
+      def self.summary(time_range = nil)
+        time_range = time_range.normalized if time_range
         jobs = self
-        if min_time
-          raise ArgumentError.new('Max time must be specified with min time') unless max_time
-          jobs = jobs.by_time_range_inclusive(min_time, max_time)
-        end
+        jobs = jobs.by_time_range_inclusive(time_range) if time_range
         jobs = jobs.where('jobs.cpu_time > 0').all_with_relations
-        wall_time = 0
         cpu_time = 0
         successful_jobs = 0
         memory_time = 0
@@ -138,28 +141,27 @@ module Bookie
         jobs.each do |job|
           job_start_time = job.start_time
           job_end_time = job.end_time
-          if min_time
-            job_start_time = [job_start_time, min_time].max
-            job_end_time = [job_end_time, max_time].min
+          if time_range
+            job_start_time = [job_start_time, time_range.first].max
+            job_end_time = [job_end_time, time_range.last].min
           end
           clipped_wall_time = job_end_time.to_i - job_start_time.to_i
-          wall_time += clipped_wall_time
           if job.wall_time != 0
             cpu_time += job.cpu_time * clipped_wall_time / job.wall_time
             #To consider: what should I do about jobs that only report a max memory value?
             memory_time += job.memory * clipped_wall_time
           end
-          successful_jobs += 1 if job.exit_code == 0
+          #Only count the job as successful if it's actually finished by the end of the summary.
+          if job.exit_code == 0 && (!time_range || job.end_time < time_range.end) then
+            successful_jobs += 1
+          end
         end
       
         return {
           :jobs => jobs,
-          #To consider: is this field even useful? It's really in job-seconds, not just seconds.
-          #What about one in just seconds (that considers gaps in activity)?
-          :wall_time => wall_time,
           :cpu_time => cpu_time,
           :memory_time => memory_time,
-          :successful =>  if jobs.length == 0 then 0.0 else Float(successful_jobs) / jobs.length end,
+          :successful => successful_jobs,
         }
       end
       
@@ -219,16 +221,183 @@ module Bookie
       
       validates_presence_of :user, :system, :cpu_time,
         :start_time, :wall_time, :memory, :exit_code
+        
+      validates_each :command_name do |record, attr, value|
+        record.errors.add(attr, 'must not be nil') if value == nil
+      end
        
       validates_each :cpu_time, :wall_time, :memory do |record, attr, value|
         record.errors.add(attr, 'must be a non-negative integer') unless value && value >= 0
       end
+    end
+    
+    class JobSummary < ActiveRecord::Base
+      self.table_name = :job_summaries
+    
+      belongs_to :user
+      belongs_to :system
+      
+      def self.by_date(date)
+        where('job_summaries.date = ?', date)
+      end
+      
+      def self.by_user(user)
+        where('job_summaries.user_id = ?', user.id)
+      end
+      
+      def self.by_user_name(name)
+        joins(:user).where('users.name = ?', name)
+      end
+      
+      def self.by_group(group)
+        joins(:user).where('users.group_id = ?', group.id)
+      end
+      
+      def self.by_group_name(name)
+        group = Group.find_by_name(name)
+        return by_group(group) if group
+        limit(0)
+      end
+      
+      def self.by_system(system)
+        where('job_summaries.system_id = ?', system.id)
+      end
+      
+      def self.by_system_name(name)
+        joins(:system).where('systems.name = ?', name)
+      end
+      
+      def self.by_system_type(type)
+        joins(:system).where('systems.system_type_id = ?', type.id)
+      end
+      
+      def self.by_command_name(cmd)
+        where('job_summaries.command_name = ?', cmd)
+      end
+      
+      def self.find_or_new(date, user_id, system_id, command_name)
+        str = by_date(date).where(:user_id => user_id, :system_id => system_id).by_command_name(command_name).to_sql
+        summary = by_date(date).where(:user_id => user_id, :system_id => system_id).by_command_name(command_name).first
+        summary ||= new(
+          :date => date,
+          :user_id => user_id,
+          :system_id => system_id,
+          :command_name => command_name
+        )
+        summary
+      end
+      
+      def self.summarize(date)
+        jobs = Job
+        unscoped = self.unscoped
+        time_range = date.to_time ... (date + 1).to_time
+        day_jobs = jobs.by_time_range_inclusive(time_range)
+        value_sets = day_jobs.select('user_id, system_id, command_name').uniq
+        value_sets.each do |set|
+          summary_jobs = jobs.where(:user_id => set.user_id).where(:system_id => set.system_id).by_command_name(set.command_name)
+          summary = summary_jobs.summary(time_range)
+          Lock[:job_summaries].synchronize do
+            sum = unscoped.find_or_new(date, set.user_id, set.system_id, set.command_name)
+            #To consider: do we even need this field? (Time-range summaries don't use it because of overlap issues.)
+            sum.num_jobs = summary[:jobs].length
+            sum.cpu_time = summary[:cpu_time]
+            sum.memory_time = summary[:memory_time]
+            sum.successful = summary[:successful]
+            sum.save!
+          end
+        end
+      end
+      
+      def self.summary(opts = {})
+        jobs = opts[:jobs] || Job
+        range = opts[:range]
+        unless range
+          end_time = nil
+          if System.active_systems.any?
+            end_time = Time.now
+          else
+            last_ended_system = System.order('end_time DESC').first
+            end_time = last_ended_system.end_time if last_ended_system
+          end
+          if end_time
+            first_started_system = System.order(:start_time).first
+            range = first_started_system.start_time ... end_time
+          else
+            range = Date.new ... Date.new
+          end
+        end
+        range = range.normalized
+        
+        num_jobs = 0
+        cpu_time = 0
+        memory_time = 0
+        successful = 0
+        
+        #Could there be partial days at the beginning/end?
+        date_range = range
+        unless range.begin.kind_of?(Date) && range.end.kind_of?(Date)
+          date_begin = range.begin.to_date
+          unless date_begin.to_time == range.begin
+            date_begin += 1
+            time_before_max = [date_begin.to_time, range.end].min
+            time_before_min = range.begin
+            summary = jobs.summary(time_before_min ... time_before_max)
+            cpu_time += summary[:cpu_time]
+            memory_time += summary[:memory_time]
+            successful += summary[:successful]
+          end
+
+          date_end = range.end.to_date
+          time_after_min = date_end.to_time
+          unless time_after_min <= range.begin
+            time_after_max = range.end
+            time_after_range = Range.new(time_after_min, time_after_max, range.exclude_end?)
+            unless time_after_range.empty?
+              summary = jobs.summary(time_after_range)
+              cpu_time += summary[:cpu_time]
+              memory_time += summary[:memory_time]
+              successful += summary[:successful]
+            end
+          end
+          
+          date_range = date_begin ... date_end
+        end
+        
+        unscoped = self.unscoped
+        date = date_range.begin
+        while date_range.cover?(date) do
+          #To do: what if there aren't any summaries to be made? Will we just run summarize() each time?
+          summarize(date) if unscoped.by_date(date).empty?
+          summaries = by_date(date)
+          summaries.all.each do |summary|
+            cpu_time += summary.cpu_time
+            memory_time += summary.memory_time
+            successful += summary.successful
+          end
+          date += 1
+        end
+        
+        time_range = Range.new(range.begin.to_time, range.end.to_time, range.exclude_end?)
+        jobs = jobs.by_time_range_inclusive(time_range)
+        num_jobs = (range && range.empty?) ? 0 : jobs.count
+        
+        {
+          :num_jobs => num_jobs,
+          :cpu_time => cpu_time,
+          :memory_time => memory_time,
+          :successful => successful,
+        }
+      end
+      
+      validates_presence_of :user_id, :system_id, :date, :num_jobs, :cpu_time, :memory_time, :successful
       
-      validates_each :start_time do |record, attr, value|
-        value = value.to_time if value.respond_to?(:to_time)
-        record.errors.add(attr, 'must be a time object') unless value.is_a?(Time)
+      validates_each :command_name do |record, attr, value|
+        record.errors.add(attr, 'must not be nil') if value == nil
       end
       
+      validates_each :num_jobs, :cpu_time, :memory_time, :successful do |record, attr, value|
+        record.errors.add(attr, 'must be a non-negative integer') unless value && value >= 0
+      end
     end
     
     ##
@@ -261,6 +430,10 @@ module Bookie
     class User < ActiveRecord::Base
       belongs_to :group
       
+      def self.by_name(name)
+        where('users.name = ?', name)
+      end
+      
       ##
       #Finds a user by name and group, creating it if it doesn't exist
       #
@@ -276,7 +449,8 @@ module Bookie
             user = Bookie::Database::User.find_by_name_and_group_id(name, group.id)
             user ||= Bookie::Database::User.create!(
               :name => name,
-              :group => group)
+              :group => group
+            )
           end
           known_users[[name, group]] = user if known_users
         end
@@ -315,28 +489,28 @@ module Bookie
       end
       
       ##
-      #Finds the active system for a given hostname
-      #
-      #<tt>values</tt> should contain a list of fields, including the name, in the format that would normally be passed to System.create!.
+      #Finds the current system for a given sender and time
       #
       #This method also checks that this system's specifications are the same as those in the database and raises an error if they are different.
       #
       #This uses Lock#synchronize internally, so it probably should not be called within a transaction block.
-      def self.find_active(values)
+      #
+      def self.find_current(sender, time = nil)
+        time ||= Time.now
+        config = sender.config
         system = nil
-        name = values[:name]
+        name = config.hostname
         Lock[:systems].synchronize do
-          system = active_systems.find_by_name(name)
+          system = by_name(config.hostname).where('systems.start_time <= :time AND (:time <= systems.end_time OR systems.end_time IS NULL)', :time => time).first
           if system
-            [:cores, :memory, :system_type].each do |key|
-              #To consider: this also compares the names, which is unnecessary.
-              unless system.send(key) == values[key]
-                raise SystemConflictError.new("The specifications on record for '#{name}' do not match this system's specifications.
-  Please make sure that all previous systems with this hostname have been marked as decommissioned.")
-              end
+            mismatch = !(system.cores == config.cores && system.memory == config.memory)
+            mismatch ||= sender.system_type != system.system_type
+            if mismatch
+              raise SystemConflictError.new("The specifications on record for '#{name}' do not match this system's specifications.
+Please make sure that all previous systems with this hostname have been marked as decommissioned.")
             end
           else
-            raise "There is no active system with hostname '#{values[:name]}' in the database."
+            raise "There is no system with hostname '#{config.hostname}' in the database at #{time}."
           end
         end
         system
@@ -349,31 +523,35 @@ module Bookie
       #- <tt>:avail_cpu_time</tt>: the total CPU time available for the interval
       #- <tt>:avail_memory_time</tt>: the total amount of memory-time available (in kilobyte-seconds)
       #- <tt>:avail_memory_avg</tt>: the average amount of memory available (in kilobytes)
-      def self.summary(min_time = nil, max_time = nil)
+      #
+      #To consider: include the start/end times for the summary (especially if they aren't provided as arguments)?
+      #
+      #To do: make this and other summaries operate differently on inclusive and exclusive ranges.
+      #(Current behavior is as if the range were always exclusive.)
+      def self.summary(time_range = nil)
         current_time = Time.now
         #Sums that are actually returned
         avail_cpu_time = 0
         avail_memory_time = 0
         #Find all the systems within the time range.
         systems = System
-        if min_time
-          raise ArgumentError.new('Max time must be specified with min time') unless max_time
-          raise ArgumentError.new('Max time must be greater than or equal to min time') if max_time < min_time
+        if time_range
+          time_range = time_range.normalized
           #To consider: optimize as union of queries?
           systems = systems.where(
             'systems.start_time < ? AND (systems.end_time IS NULL OR systems.end_time > ?)',
-            max_time,
-            min_time)
+            time_range.last,
+            time_range.first)
         end
         
         systems.all.each do |system|
           system_start_time = system.start_time
           system_end_time = system.end_time
           #Is there a time range constraint?
-          if min_time
-            system_start_time = [system_start_time, min_time].max
-            system_end_time = [system_end_time, max_time].min if system.end_time
-            system_end_time ||= max_time
+          if time_range
+            system_start_time = [system_start_time, time_range.first].max
+            system_end_time = [system_end_time, time_range.last].min if system.end_time
+            system_end_time ||= time_range.last
           else
             system_end_time ||= current_time
           end
@@ -383,8 +561,8 @@ module Bookie
         end
         
         wall_time_range = 0
-        if min_time
-          wall_time_range = max_time - min_time
+        if time_range
+          wall_time_range = time_range.last - time_range.first
         else
           first_started_system = systems.order(:start_time).first
           if first_started_system
@@ -422,11 +600,6 @@ module Bookie
         record.errors.add(attr, 'must be a non-negative integer') unless value && value >= 0
       end
       
-      validates_each :start_time do |record, attr, value|
-        value = value.to_time if value.respond_to?(:to_time)
-        record.errors.add(attr, 'must be a time object') unless value.is_a?(Time)
-      end
-      
       validates_each :end_time do |record, attr, value|
         record.errors.add(attr, 'must be at or after start time') if value && value < record.start_time
       end
@@ -508,7 +681,7 @@ module Bookie
   
     ##
     #Database migrations
-    module Migration 
+    module Migration
       class CreateUsers < ActiveRecord::Migration
         def up
           create_table :users do |t|
@@ -585,7 +758,7 @@ module Bookie
           create_table :jobs do |t|
             t.references :user, :null => false
             t.references :system, :null => false
-            t.string :command_name, :limit => 24
+            t.string :command_name, :limit => 24, :null => false
             t.datetime :start_time, :null => false
             t.datetime :end_time, :null => false
             t.integer :wall_time, :null => false
@@ -607,6 +780,31 @@ module Bookie
         end
       end
       
+      class CreateJobSummaries < ActiveRecord::Migration
+        def up
+          create_table :job_summaries do |t|
+            t.references :user, :null => false
+            t.references :system, :null => false
+            t.date :date, :null => false
+            t.string :command_name, :null => false
+            t.integer :num_jobs, :null => false
+            t.integer :cpu_time, :null => false
+            t.integer :memory_time, :null => false
+            t.integer :successful, :null => false
+          end
+          change_table :job_summaries do |t|
+            #To consider: reorder for optimum efficiency?
+            t.index [:date, :user_id, :system_id, :command_name], :unique => true, :name => 'identity'
+            t.index :command_name
+            t.index :date
+          end
+        end
+        
+        def down
+         drop_table :job_summaries
+        end
+      end
+      
       class CreateLocks < ActiveRecord::Migration
         def up
           create_table :locks do |t|
@@ -616,7 +814,7 @@ module Bookie
             t.index :name, :unique => true
           end
           
-          ['users', 'groups', 'systems', 'system_types'].each do |name|
+          ['users', 'groups', 'systems', 'system_types', 'job_summaries'].each do |name|
             Lock.create!(:name => name)
           end
         end
@@ -630,11 +828,13 @@ module Bookie
         ##
         #Brings up all migrations
         def up
+          ActiveRecord::Migration.verbose = false
           CreateUsers.new.up
           CreateGroups.new.up
           CreateSystems.new.up
           CreateSystemTypes.new.up
           CreateJobs.new.up
+          CreateJobSummaries.new.up
           CreateLocks.new.up
         end
         
@@ -643,14 +843,77 @@ module Bookie
         #
         #Warning: this will destroy all data!
         def down
+          ActiveRecord::Migration.verbose = false
           CreateUsers.new.down
           CreateGroups.new.down
           CreateSystems.new.down
           CreateSystemTypes.new.down
           CreateJobs.new.down
+          CreateJobSummaries.new.down
           CreateLocks.new.down
         end
       end
     end
   end
 end
+
+##
+#Reopened to add some useful methods
+class Range
+  ##
+  #If end < begin, returns an empty range (begin ... begin)
+  #Otherwise, returns the original range
+  def normalized
+    return self.begin ... self.begin if self.end < self.begin
+    self
+  end
+  
+  ##
+  #Returns the empty status of the range
+  #
+  #A range is empty if end < begin or if begin == end and exclude_end? is true.
+  def empty?
+    (self.end < self.begin) || (exclude_end? && (self.begin == self.end))
+  end
+
+#This code probably works, but we're not using it anywhere.  
+#   def intersection(other)
+#     self_n = self.normalized
+#     other = other.normalized
+#     
+#     new_begin, new_end, exclude_end = nil
+#     
+#     if self_n.cover?(other.begin)
+#       new_first = other.begin
+#     elsif other.cover?(self_n.begin)
+#       new_first = self_n.begin
+#     end
+#     
+#     return self_n.begin ... self_n.begin unless new_first
+#     
+#     if self_n.cover?(other.end)
+#       unless other.exclude_end? && other.end == self_n.begin
+#         new_end = other.end
+#         exclude_end = other.exclude_end?
+#       end
+#     elsif other.cover?(self_n.end)
+#       unless self_n.exclude_end? && self_n.end == other.begin
+#         new_end = self_n.end
+#         exclude_end = self_n.exclude_end?
+#       end
+#     end
+#     
+#     #If we still haven't found new_end, try one more case:
+#     unless new_end
+#       if self_n.end == other.end
+#         #We'll only get here if both ranges exclude their ends and have the same end.
+#         new_end = self_n.end
+#         exclude_end = true
+#       end
+#     end
+#     
+#     return self_n.begin ... self_n.begin unless new_end
+# 
+#     Range.new(new_begin, new_end, exclude_end)
+#   end
+end