omega-tariffs-base 0.1.5

data/CHANGELOG

@@ -0,0 +1 @@
+v0.1. Initial code commit. Everything is working and tested.

data/Manifest

@@ -0,0 +1,30 @@
+CHANGELOG
+Manifest
+README.rdoc
+Rakefile
+lib/computer_class_filter.rb
+lib/deny_filter.rb
+lib/filter.rb
+lib/omega-tariffs-base.rb
+lib/packet_filter.rb
+lib/rate_filter.rb
+lib/regioned_calculation.rb
+lib/repeating_filter.rb
+lib/settings.rb
+lib/single_time_filter.rb
+lib/tarif_builder.rb
+lib/weekday_filter.rb
+spec/complex_tarif_spec.rb
+spec/computer_class_filter_spec.rb
+spec/deny_filter_spec.rb
+spec/filter_spec.rb
+spec/lib/active_record_classes_stub.rb
+spec/lib/init.rb
+spec/lib/spec_helper.rb
+spec/packet_filter_spec.rb
+spec/rate_filter_spec.rb
+spec/repeating_filter_spec.rb
+spec/settings_spec.rb
+spec/single_time_filter_spec.rb
+spec/tarif_builder_spec.rb
+spec/weekday_filter_spec.rb

data/README.rdoc

@@ -0,0 +1,10 @@
+= Uniq Systems Omega Sector Generic Tariffs Gem
+
+This gem provides basic code to support Omega Sector tariffs. In order for them to work you've got to redefine
+several classes to support real persistent database storage instead of the in-memory one.
+
+These classes are:
+* PacketFilterRepository
+* SingleTimeFilterRepository
+
+Without those every time you restart the system you'll lose the state, which is probably not what you really want.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'  
+require 'rake'  
+require 'echoe'  
+  
+Echoe.new('omega-tariffs-base', '0.1.5') do |p|  
+  p.description     = "Omega Sector base tariffs"  
+  p.url             = "http://uniqsys.ru/"  
+  p.author          = "Uniq Systems"
+  p.email           = "ivan@uniqsystems.ru"  
+  p.ignore_pattern  = ["tmp/*", "script/*"]  
+  p.runtime_dependencies = p.development_dependencies = ["activesupport =2.3.8"]  
+end  
+  
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }  

data/lib/computer_class_filter.rb

@@ -0,0 +1,37 @@
+module UniqSysOmega
+  module Tariffs
+
+    class ComputerClassFilter < Filter
+      def start_permitted?(computer_id, login_id, options={})
+        computer_class(computer_id).start_permitted?(computer_id, login_id, options)
+      end
+
+      def permitted?(computer_id, login_id, options={})
+        computer_class(computer_id).permitted?(computer_id, login_id, options)
+      end
+
+      def calculate_cost(computer_id, login_id, started_at, amount, options={})
+        computer_class(computer_id).calculate_cost(computer_id, login_id, started_at, amount, options)
+      end
+
+      def process_activity(unprocessed_activity, ft, options={})
+        computer_class(unprocessed_activity.computer_id).process_activity(unprocessed_activity, ft, options)
+      end
+
+    protected
+      def computer_class(computer_id)
+        @classes[Computer.find(computer_id).computer_class_id]
+      end
+
+      def after_initialize
+        raise "Some classes left undefined." unless ComputerClass.all.map { |klass| klass.id }.to_a.sort == settings.to_hash.keys.sort
+        @classes = [ ]
+        settings.to_hash.each do |computer_class_id, settings|
+          @classes[computer_class_id] = TarifBuilder.build Settings.new(settings), tarif_id
+        end
+        @classes.compact.size == ComputerClass.count
+      end
+    end
+
+  end
+end

data/lib/deny_filter.rb

@@ -0,0 +1,24 @@
+module UniqSysOmega
+  module Tariffs
+    
+    class DenyFilter < Filter
+      def start_permitted?(computer_id, login_id, options={})
+        false
+      end
+
+      def permitted?(computer_id, login_id, options={})
+        false
+      end
+
+      def calculate_cost(computer_id, login_id, started_at, amount, options={})
+        Integer::MAX
+      end
+
+      def process_activity(unprocessed_activity, ft, options={})
+        # TODO: add logging, so it doesn't just silently swallow residues of the activities
+        true
+      end
+    end
+    
+  end
+end

data/lib/filter.rb

@@ -0,0 +1,43 @@
+module UniqSysOmega
+  module Tariffs
+
+    class Filter
+      def initialize(settings, tarif_id)
+        @tarif_id = tarif_id
+        @settings = settings
+        after_initialize
+      end
+  
+      def start_permitted?(computer_id, login_id, options={})
+        raise "Unimplemented"
+      end
+
+      def permitted?(computer_id, login_id, options={})
+        raise "Unimplemented"
+      end
+
+      def calculate_cost(computer_id, login_id, started_at, amount, options={})
+        raise "Unimplemented"
+      end
+
+      def process_activity(unprocessed_activity, ft, options={})
+        raise "Unimplemented"
+      end
+
+    protected
+      attr_accessor :tarif_id
+      attr_accessor :settings
+  
+      def after_initialize
+      end
+  
+      def alter_activity_period(unprocessed_activity, new_starts_at, new_amount)
+        unprocessed_activity.dup.tap do |activity|
+          activity.created_at = new_starts_at
+          activity.amount = new_amount
+        end
+      end
+    end
+  
+  end
+end

data/lib/omega-tariffs-base.rb

@@ -0,0 +1,13 @@
+# guerilla patch the Integer class
+class Integer
+  N_BYTES = [42].pack('i').size
+  N_BITS = N_BYTES * 8
+  MAX = 2 ** (N_BITS - 2) - 1
+  MIN = -MAX - 1
+end
+
+# load libraries
+[ :settings, :regioned_calculation, :tarif_builder, :filter, :deny_filter, :weekday_filter,
+  :rate_filter, :repeating_filter, :single_time_filter, :computer_class_filter, :packet_filter ].each do |lib|
+  require File.join(File.dirname(__FILE__), lib.to_s)
+end

data/lib/packet_filter.rb

@@ -0,0 +1,111 @@
+module UniqSysOmega
+  module Tariffs
+
+    class PacketFilterRepository
+      class <<self
+        def register_region(tarif_id, login_id, moment, period_duration)
+          @payments ||= { }
+          @payments[[tarif_id, login_id]] ||= [ ]
+          @payments[[tarif_id, login_id]] << { :period => (moment ... moment + period_duration), :paid => false }
+        end
+    
+        def set_should_end(tarif_id, login_id, time)
+          @end_at ||= { }
+          @end_at[[tarif_id, login_id]] = time
+          true
+        end
+    
+        def should_end?(tarif_id, login_id)
+          return false if @end_at[[tarif_id, login_id]].nil?
+          Time.now > @end_at[[tarif_id, login_id]]
+        end
+
+        def pay_region(tarif_id, login_id, time=Time.now)
+          region = find_region(tarif_id, login_id, time)
+          return false unless region
+          return true if region[:paid]
+          region[:paid] = true
+        end
+
+        def region_registered?(*args)
+          !find_region(*args).nil?
+        end
+    
+        def region_spans?(tarif_id, login_id, moment=Time.now, duration=1)
+          region = find_region(tarif_id, login_id, moment)
+          return false if region.nil?
+          !(region[:period] === (moment + duration))
+        end
+
+        def region_paid?(tarif_id, login_id, moment=Time.now, duration=1)
+          region = find_region(tarif_id, login_id, moment)
+          !region.nil? && region[:period] === (moment + duration) && region[:paid]
+        end
+
+        def reset
+          @payments = { }
+          @end_at = { }
+        end
+
+      protected
+        def find_region(tarif_id, login_id, time=Time.now)
+          return nil unless @payments
+          return nil unless @payments[[tarif_id, login_id]]
+          @payments[[tarif_id, login_id]].find { |r| r[:period] === time }
+        end
+      end
+    end
+
+
+    class PacketFilter < Filter
+      def start_permitted?(computer_id, login_id, options={})
+        single_payment_unneeded?(login_id) and PacketFilterRepository.set_should_end(tarif_id, login_id, nil)
+      end
+
+      def permitted?(computer_id, login_id, options={})
+        return false if PacketFilterRepository.should_end?(tarif_id, login_id)
+        single_payment_unneeded? login_id
+      end
+
+      def calculate_cost(computer_id, login_id, started_at, amount, options={})
+        return Integer::MAX if PacketFilterRepository.region_spans?(tarif_id, login_id, started_at, amount)
+        PacketFilterRepository.region_paid?(tarif_id, login_id, started_at) ?
+                0 : @price
+      end
+
+      def process_activity(unprocessed_activity, ft, options={})
+        if PacketFilterRepository.region_paid?(tarif_id, unprocessed_activity.login_id, unprocessed_activity.created_at)
+          true
+        else
+          make_single_payment(unprocessed_activity.created_at, ft, unprocessed_activity.login_id) and
+          PacketFilterRepository.set_should_end(tarif_id, unprocessed_activity.login_id, unprocessed_activity.created_at+@length)
+        end
+      end
+
+    protected
+      def single_payment_unneeded?(login_id)
+         PacketFilterRepository.region_paid?(tarif_id, login_id) || can_make_single_payment?(login_id)
+      end
+
+      def can_make_single_payment?(login_id)
+        Login.find(login_id).balance - @price >= 0
+      end
+
+      def make_single_payment(time, ft, login_id)
+        return false unless can_make_single_payment?(login_id)
+
+        PacketFilterRepository.register_region(tarif_id, login_id, time, @length)
+
+        ft = ft.dup
+        ft.volume = @price
+        ft.save and PacketFilterRepository.pay_region(tarif_id, login_id, time)
+      end
+
+      def after_initialize
+        @price = settings.price
+        @length = settings.length
+      end
+    end
+    
+  end
+end

data/lib/rate_filter.rb

@@ -0,0 +1,31 @@
+module UniqSysOmega
+  module Tariffs
+
+    class RateFilter < Filter
+      def start_permitted?(computer_id, login_id, options={})
+        true
+      end
+
+      def permitted?(computer_id, login_id, options={})
+        true
+      end
+
+      def calculate_cost(computer_id, login_id, started_at, amount, options={})
+        amount/3600*@rate
+      end
+
+      def process_activity(unprocessed_activity, ft, options={})
+        ft = ft.dup
+        ft.volume = unprocessed_activity.amount/3600*@rate
+        ft.save!
+        true
+      end
+
+    protected
+      def after_initialize
+        @rate = settings.rate
+      end
+    end
+  
+  end
+end

data/lib/regioned_calculation.rb

@@ -0,0 +1,61 @@
+module Math
+  # optimized version of find_root, performs 10000 roots' calculations per sec on Core 2 Duo 2.67  
+  def self.find_root(a, b, precision=0.01, allow_oob_roots=false, &blk)
+    fa, fb = yield(a).to_f, yield(b).to_f
+    sa, sb = fa >= 0 ? 1 : -1, fb >= 0 ? 1 : -1
+    while true do
+      # puts "f(#{a},#{(a/precision).truncate})=#{fa}, f(#{b},#{(b/precision).truncate})=#{fb}"
+      raise "Looking for roots out of bounds" if !allow_oob_roots && sa == sb
+      return a if (a-b).abs < precision || fa.abs <= precision
+      return b if fb.abs <= precision
+      c = (a.to_f + b.to_f) / 2
+      fc = yield(c)
+      sc = fc >= 0 ? 1 : -1
+      if sa != sc
+        b, fb, sb = c, fc, sc
+      else
+        a, fa, sa = c, fc, sc
+      end
+    end
+  end  
+end
+
+class Range
+  def intersection(other)
+    raise ArgumentError, 'value must be a Range' unless other.kind_of?(Range)
+    raise ArgumentError, 'must be the same end inclusive/non-inclusive type' unless exclude_end? == other.exclude_end?
+    
+    min, max = first, last
+    other_min, other_max = other.first, other.last
+
+    new_min = self === other_min ? other_min : other === min ? min : min == other_min ? min : nil
+    new_max = self === other_max ? other_max : other === max ? max : max == other_max ? max : nil
+
+    new_min && new_max ? (exclude_end? ? new_min...new_max : new_min..new_max) : nil
+  end
+
+  def subtract(range)
+    return [ self ] unless range
+    raise ArgumentError, 'must be the same end inclusive/non-inclusive type' unless exclude_end? == range.exclude_end?
+
+    common = self & range
+    return [ self ] unless common
+
+    # отрезок вычли полностью
+    return [ ] if common == self
+
+    if self.end == common.end
+      return [ Range.new( self.begin, common.begin, exclude_end? ) ]
+    end
+
+    if self.begin == common.begin
+      return [ Range.new( common.end, self.end, exclude_end? ) ]
+    end
+
+    [ Range.new( self.begin, common.begin, exclude_end? ),
+      Range.new( common.end, self.end, exclude_end? ) ]    
+  end
+
+  alias_method :&, :intersection
+  alias_method :-, :subtract
+end

data/lib/repeating_filter.rb

@@ -0,0 +1,188 @@
+module UniqSysOmega
+  module Tariffs
+    require 'mathn'
+
+    class SortableRange < Range
+      attr_accessor :filter
+  
+      def <=>(other)
+        self.begin <=> other.begin
+      end
+  
+      def as_range
+        Range.new(self.begin, self.end, self.exclude_end?)
+      end
+    end
+
+    class RepeatingFilterPeriod
+      attr_accessor :starts_at
+      attr_accessor :length
+      attr_accessor :period
+      attr_accessor :filter
+
+      def initialize(starts_at, length, period, filter)
+        raise "period should be more than length, but this assertion is not met: #{length} <= #{period}" if length > period
+        @starts_at = starts_at.to_i
+        @length = length
+        @period = period
+        @filter = filter
+      end
+  
+      def self.from_hash(hash, filter=nil)
+        self.new(hash[:starts_at], hash[:length], hash[:period], filter || hash[:filter])
+      end
+
+      def ===(value)
+        includes?(value)
+      end
+
+      def local_period(value)
+        local_period_start = @starts_at + ((value.to_i-@starts_at)/@period).floor * @period
+        SortableRange.new(local_period_start, local_period_start+@length, true).tap do |range|
+          range.filter = filter
+        end
+      end
+
+      def includes?(value)
+        local_period(value).include?(value.to_i)
+      end
+  
+      def generate_in_range(start, finish)
+        start, finish = start.to_i, finish.to_i
+        [ ].tap do |ranges|
+          local_period_start = @starts_at + ((start-@starts_at).to_f/@period.to_f).ceil * @period
+          while local_period_start+@length <= finish
+            ranges << SortableRange.new(local_period_start, local_period_start+@length, true).tap { |r| r.filter = filter }
+            local_period_start += @period
+          end
+        end
+      end
+  
+      def to_s
+        "RepeatingFilterPeriod(starts_at=#{starts_at}, length=#{length}, period=#{period})"
+      end
+    end
+
+    module RepeatingFilterPeriodsVerification
+    private
+      def fail_because_of_gaps!
+        periods_text = @periods.map { |p| "  - starting: #{p.starts_at}, length: #{p.length}, period: #{p.period}" }.join("\n")
+        gaps_text = gapped_periods.map { |g| "  - starting: #{g.begin}, length: #{g.end-g.begin}" }.join("\n")
+        raise "Inconsistent periods:\n#{periods_text}\n\nGaps:\n#{gaps_text}\n"
+      end
+
+      def fail_because_of_intersections!
+        periods_text = intersecting_periods.map { |p| "  - #{p[0]} and #{p[1]}" }.join("\n")
+        raise "Intersectings periods:\n#{periods_text}"
+      end
+
+      def total_period_start
+        @periods.map { |p| p.starts_at }.min
+      end
+
+      def total_period_length
+        max_period_length = @periods.map { |p| p.starts_at + p.length }.max - total_period_start
+        [ @periods.map { |p| p.period }.inject(&:lcm), max_period_length ].max
+      end
+  
+      def repeating_periods_chunks
+        @periods.map { |period| period.generate_in_range(total_period_start, total_period_start + total_period_length) }.flatten
+      end
+  
+      def gapped_periods
+        @gapped_periods = @gapped_periods || [ (total_period_start ... total_period_start + total_period_length) ].tap do |uncovered_periods|
+          repeating_periods_chunks.each do |period|
+            uncovered_periods.map! { |uncovered_period| uncovered_period - (uncovered_period & period) }
+            uncovered_periods.flatten!
+          end
+        end
+      end
+  
+      def periods_consistent?
+        gapped_periods.size == 0
+      end
+  
+      def intersecting_periods
+        @intersecting_periods = @intersecting_periods || [].tap do |intersecting|
+          chunks = repeating_periods_chunks.sort
+          while chunks.size >= 2
+            intersecting << [chunks[0], chunks[1]] unless (chunks[0] & chunks[1]).nil?
+            chunks.shift
+          end
+        end
+      end
+  
+      def periods_not_intersecting?
+        intersecting_periods.size == 0
+      end
+  
+      def ensure_periods_are_correct!
+        fail_because_of_intersections! unless periods_not_intersecting?
+        fail_because_of_gaps! unless periods_consistent?    
+      end
+    end
+
+    class RepeatingFilter < Filter
+      def start_permitted?(computer_id, login_id, options={})
+        period = period_matching_time(Time.now)
+        period.filter.start_permitted?(computer_id, login_id, options.merge({ :period => period.as_range }))
+      end
+
+      def permitted?(computer_id, login_id, options={})
+        period = period_matching_time(Time.now)
+        period.filter.permitted?(computer_id, login_id, options.merge({ :period => period.as_range }))
+      end
+
+      def calculate_cost(computer_id, login_id, started_at, amount, options={})
+        actual_periods(started_at, amount).inject(0) do |overall, p|
+          overall += p[:actual].filter.calculate_cost(computer_id, login_id, p[:actual].begin, p[:actual].end-p[:actual].begin, options.merge({ :period => p[:covering].as_range }))
+        end
+      end
+
+      def process_activity(unprocessed_activity, ft, options={})
+        actual_periods(unprocessed_activity.created_at, unprocessed_activity.amount).each do |p|
+          p[:actual].filter.process_activity(
+              alter_activity_period(unprocessed_activity, p[:actual].begin, p[:actual].end-p[:actual].begin),
+              ft,
+              options.merge({ :period => p[:covering].as_range})) or return false
+        end
+        true
+      end
+
+    protected
+      include RepeatingFilterPeriodsVerification
+
+      def after_initialize
+        @periods = [ ]
+        settings.to_hash.each do |period, settings|
+          @periods << RepeatingFilterPeriod.from_hash(period, TarifBuilder.build(Settings.new(settings), tarif_id))
+        end
+        ensure_periods_are_correct!
+      end
+  
+      def actual_periods(started_at, amount)
+        covering_periods(started_at, started_at+amount).map do |period| 
+          actual_period = ( period.begin ... period.end ) & ( started_at.to_i ... started_at.to_i+amount  )
+          {
+            :covering => period,
+            :actual =>
+              SortableRange.new(Time.at(actual_period.begin),
+                                Time.at(actual_period.end),
+                                actual_period.exclude_end?).tap { |p| p.filter = period.filter }
+          } unless actual_period.nil?
+        end.compact
+      end
+  
+      def covering_periods(time_start, time_end)
+        time_start -= total_period_length
+        time_end += total_period_length
+        @periods.map { |period| period.generate_in_range(time_start, time_end) }.flatten.sort
+      end
+  
+      def period_matching_time(time)
+        @periods.detect { |p| p === time }.local_period(time)
+      end
+    end
+
+  end
+end