mt-uv-rays 2.4.7

data/lib/mt-uv-rays/scheduler.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+require 'set'               # ruby std lib
+require 'bisect'            # insert into a sorted array
+require 'tzinfo'            # timezone information
+require 'mt-uv-rays/scheduler/time'
+
+module MTUV
+
+    class ScheduledEvent < ::MTLibuv::Q::DeferredPromise
+        # Note:: Comparable should not effect Hashes
+        # it will however effect arrays
+        include Comparable
+
+        attr_reader :created
+        attr_reader :last_scheduled
+        attr_reader :next_scheduled
+        attr_reader :trigger_count
+
+        def initialize(scheduler)
+            # Create a dummy deferrable
+            reactor = scheduler.reactor
+            defer = reactor.defer
+
+            # Record a backtrace of where the schedule was created
+            @trace = caller
+
+            # Setup common event variables
+            @scheduler = scheduler
+            @created = reactor.now
+            @last_scheduled = @created
+            @trigger_count = 0
+
+            # init the promise
+            super(reactor, defer)
+        end
+
+        # Provide relevant inspect information
+        def inspect
+            insp = String.new("#<#{self.class}:#{"0x00%x" % (self.__id__ << 1)} ")
+            insp << "trigger_count=#{@trigger_count} "
+            insp << "config=#{info} " if self.respond_to?(:info, true)
+            insp << "next_scheduled=#{to_time(@next_scheduled)} "
+            insp << "last_scheduled=#{to_time(@last_scheduled)} created=#{to_time(@created)}>"
+            insp
+        end
+        alias_method :to_s, :inspect
+
+        def to_time(internal_time)
+            if internal_time
+                ((internal_time + @scheduler.time_diff) / 1000).to_i
+            end
+        end
+
+
+        # required for comparable
+        def <=>(anOther)
+            @next_scheduled <=> anOther.next_scheduled
+        end
+
+        # reject the promise
+        def cancel
+            @defer.reject(:cancelled)
+        end
+
+        # notify listeners of the event
+        def trigger
+            @trigger_count += 1
+            @defer.notify(@reactor.now, self)
+        end
+    end
+
+    class OneShot < ScheduledEvent
+        def initialize(scheduler, at)
+            super(scheduler)
+
+            @next_scheduled = at
+        end
+
+        # Updates the scheduled time
+        def update(time)
+            @last_scheduled = @reactor.now
+
+            parsed_time = Scheduler.parse_in(time, :quiet)
+            if parsed_time.nil?
+                # Parse at will throw an error if time is invalid
+                parsed_time = Scheduler.parse_at(time) - @scheduler.time_diff
+            else
+                parsed_time += @last_scheduled
+            end
+
+            @next_scheduled = parsed_time
+            @scheduler.reschedule(self)
+        end
+
+        # Runs the event and cancels the schedule
+        def trigger
+            super()
+            @defer.resolve(:triggered)
+        end
+    end
+
+    class Repeat < ScheduledEvent
+        def initialize(scheduler, every)
+            super(scheduler)
+
+            @every = every
+            next_time
+        end
+
+        # Update the time period of the repeating event
+        #
+        # @param schedule [String] a standard CRON job line or a human readable string representing a time period.
+        def update(every, timezone: nil)
+            time = Scheduler.parse_in(every, :quiet) || Scheduler.parse_cron(every, :quiet, timezone: timezone)
+            raise ArgumentError.new("couldn't parse \"#{o}\"") if time.nil?
+
+            @every = time
+            reschedule
+        end
+
+        # removes the event from the schedule
+        def pause
+            @paused = true
+            @scheduler.unschedule(self)
+        end
+
+        # reschedules the event to the next time period
+        # can be used to reset a repeating timer
+        def resume
+            @paused = false
+            @last_scheduled = @reactor.now
+            reschedule
+        end
+
+        # Runs the event and reschedules
+        def trigger
+            super()
+            @reactor.next_tick do
+                # Do this next tick to avoid needless scheduling
+                # if the event is stopped in the callback
+                reschedule
+            end
+        end
+
+
+        protected
+
+
+        def next_time
+            @last_scheduled = @reactor.now
+            if @every.is_a? Integer
+                @next_scheduled = @last_scheduled + @every
+            else
+                # must be a cron
+                @next_scheduled = (@every.next.to_f * 1000).to_i - @scheduler.time_diff
+            end
+        end
+
+        def reschedule
+            unless @paused
+                next_time
+                @scheduler.reschedule(self)
+            end
+        end
+
+        def info
+            "repeat:#{@every.inspect}"
+        end
+    end
+
+
+    class Scheduler
+        attr_reader :reactor
+        attr_reader :time_diff
+        attr_reader :next
+
+
+        def initialize(reactor)
+            @reactor = reactor
+            @schedules = Set.new
+            @scheduled = []
+            @next = nil     # Next schedule time
+            @timer = nil    # Reference to the timer
+
+            # Not really required when used correctly
+            @critical = Mutex.new
+
+            # Every hour we should re-calibrate this (just in case)
+            calibrate_time
+
+            @calibrate = @reactor.timer do
+                calibrate_time
+                @calibrate.start(3600000)
+            end
+            @calibrate.start(3600000)
+            @calibrate.unref
+        end
+
+
+        # As the libuv time is taken from an arbitrary point in time we
+        #  need to roughly synchronize between it and ruby's Time.now
+        def calibrate_time
+            @reactor.update_time
+            @time_diff = (Time.now.to_f * 1000).to_i - @reactor.now
+        end
+
+        # Create a repeating event that occurs each time period
+        #
+        # @param time [String] a human readable string representing the time period. 3w2d4h1m2s for example.
+        # @param callback [Proc] a block or method to execute when the event triggers
+        # @return [::MTUV::Repeat]
+        def every(time)
+            ms = Scheduler.parse_in(time)
+            event = Repeat.new(self, ms)
+            event.progress &Proc.new if block_given?
+            schedule(event)
+            event
+        end
+
+        # Create a one off event that occurs after the time period
+        #
+        # @param time [String] a human readable string representing the time period. 3w2d4h1m2s for example.
+        # @param callback [Proc] a block or method to execute when the event triggers
+        # @return [::MTUV::OneShot]
+        def in(time)
+            ms = @reactor.now + Scheduler.parse_in(time)
+            event = OneShot.new(self, ms)
+            event.progress &Proc.new if block_given?
+            schedule(event)
+            event
+        end
+
+        # Create a one off event that occurs at a particular date and time
+        #
+        # @param time [String, Time] a representation of a date and time that can be parsed
+        # @param callback [Proc] a block or method to execute when the event triggers
+        # @return [::MTUV::OneShot]
+        def at(time)
+            ms = Scheduler.parse_at(time) - @time_diff
+            event = OneShot.new(self, ms)
+            event.progress &Proc.new if block_given?
+            schedule(event)
+            event
+        end
+
+        # Create a repeating event that uses a CRON line to determine the trigger time
+        #
+        # @param schedule [String] a standard CRON job line.
+        # @param callback [Proc] a block or method to execute when the event triggers
+        # @return [::MTUV::Repeat]
+        def cron(schedule, timezone: nil)
+            ms = Scheduler.parse_cron(schedule, timezone: timezone)
+            event = Repeat.new(self, ms)
+            event.progress &Proc.new if block_given?
+            schedule(event)
+            event
+        end
+
+        # Schedules an event for execution
+        #
+        # @param event [ScheduledEvent]
+        def reschedule(event)
+            # Check promise is not resolved
+            return if event.resolved?
+
+            @critical.synchronize {
+                # Remove the event from the scheduled list and ensure it is in the schedules set
+                if @schedules.include?(event)
+                    remove(event)
+                else
+                    @schedules << event
+                end
+
+                # optimal algorithm for inserting into an already sorted list
+                Bisect.insort(@scheduled, event)
+
+                # Update the timer
+                check_timer
+            }
+        end
+
+        # Removes an event from the schedule
+        #
+        # @param event [ScheduledEvent]
+        def unschedule(event)
+            @critical.synchronize {
+                # Only call delete and update the timer when required
+                if @schedules.include?(event)
+                    @schedules.delete(event)
+                    remove(event)
+                    check_timer
+                end
+            }
+        end
+
+
+        private
+
+
+        # Remove an element from the array
+        def remove(obj)
+            position = nil
+
+            @scheduled.each_index do |i|
+                # object level comparison
+                if obj.equal? @scheduled[i]
+                    position = i
+                    break
+                end
+            end
+
+            @scheduled.slice!(position) unless position.nil?
+        end
+
+        # First time schedule we want to bind to the promise
+        def schedule(event)
+            reschedule(event)
+
+            event.finally do
+                unschedule event
+            end
+        end
+
+        # Ensures the current timer, if any, is still
+        # accurate by checking the head of the schedule
+        def check_timer
+            @reactor.update_time
+
+            existing = @next
+            schedule = @scheduled.first
+            @next = schedule.nil? ? nil : schedule.next_scheduled
+
+            if existing != @next
+                # lazy load the timer
+                if @timer.nil?
+                    new_timer
+                else
+                    @timer.stop
+                end
+
+                if not @next.nil?
+                    in_time = @next - @reactor.now
+
+                    # Ensure there are never negative start times
+                    if in_time > 3
+                        @timer.start(in_time)
+                    else
+                        # Effectively next tick
+                        @timer.start(0)
+                    end
+                end
+            end
+        end
+
+        # Is called when the libuv timer fires
+        def on_timer
+            @critical.synchronize {
+                schedule = @scheduled.shift
+                @schedules.delete(schedule)
+                schedule.trigger
+
+                # execute schedules that are within 3ms of this event
+                # Basic timer coalescing..
+                now = @reactor.now + 3
+                while @scheduled.first && @scheduled.first.next_scheduled <= now
+                    schedule = @scheduled.shift
+                    @schedules.delete(schedule)
+                    schedule.trigger
+                end
+                check_timer
+            }
+        end
+
+        # Provide some assurances on timer failure
+        def new_timer
+            @timer = @reactor.timer { on_timer }
+            @timer.finally do
+                new_timer
+                unless @next.nil?
+                    @timer.start(@next)
+                end
+            end
+        end
+    end
+end

data/lib/mt-uv-rays/tcp_server.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'ipaddress' # IP Address parser
+
+module MTUV
+    class TcpServer < ::MTLibuv::TCP
+        def initialize(reactor, server, port, klass, *args)
+            super(reactor)
+
+            @klass = klass
+            @args = args
+
+            if server == port && port.is_a?(Integer)
+                # We are opening a socket descriptor
+                open(server)
+            else
+                # Perform basic checks before attempting to bind address
+                server = '127.0.0.1' if server == 'localhost'
+                if IPAddress.valid? server
+                    @server = server
+                    bind(server, port) { |client| new_connection(client) }
+                    listen(1024)
+                else
+                    raise ArgumentError, "Invalid server address #{server}"
+                end
+            end
+        end
+
+
+        private
+
+
+        def new_connection(client)
+            # prevent buffering
+            client.enable_nodelay
+
+            # create the connection class
+            c = @klass.new(client)
+            c.post_init *@args
+
+            # start read after post init and call connected
+            client.start_read
+            c.on_connect(client)
+        end
+    end
+end

data/lib/mt-uv-rays/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MTUV
+    VERSION = '2.4.7'
+end

data/lib/mt-uv-rays.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'mt-libuv'
+
+module MTUV
+    autoload :Ping, 'mt-uv-rays/ping'
+
+    # In-memory event scheduling
+    autoload :Scheduler, 'mt-uv-rays/scheduler'
+
+    # Intelligent stream buffering
+    autoload :BufferedTokenizer, 'mt-uv-rays/buffered_tokenizer'
+    autoload :AbstractTokenizer, 'mt-uv-rays/abstract_tokenizer'
+
+    # TCP Connections
+    autoload :TcpServer,          'mt-uv-rays/tcp_server'
+    autoload :Connection,         'mt-uv-rays/connection'
+    autoload :TcpConnection,      'mt-uv-rays/connection'
+    autoload :InboundConnection,  'mt-uv-rays/connection'
+    autoload :OutboundConnection, 'mt-uv-rays/connection'
+    autoload :DatagramConnection, 'mt-uv-rays/connection'
+
+    # HTTP related methods
+    autoload :HttpEndpoint, 'mt-uv-rays/http_endpoint'
+
+
+    # @private
+    def self.klass_from_handler(klass, handler = nil, *args)
+        klass = if handler and handler.is_a?(Class)
+            raise ArgumentError, "must provide module or subclass of #{klass.name}" unless klass >= handler
+            handler
+        elsif handler
+            begin
+                handler::UR_CONNECTION_CLASS
+            rescue NameError
+                handler::const_set(:UR_CONNECTION_CLASS, Class.new(klass) {include handler})
+            end
+        else
+            klass
+        end
+
+        arity = klass.instance_method(:post_init).arity
+        expected = arity >= 0 ? arity : -(arity + 1)
+        if (arity >= 0 and args.size != expected) or (arity < 0 and args.size < expected)
+            raise ArgumentError, "wrong number of arguments for #{klass}#post_init (#{args.size} for #{expected})"
+        end
+
+        klass
+    end
+
+
+    def self.connect(server, port, handler, *args)
+        klass = klass_from_handler(OutboundConnection, handler, *args)
+
+        c = klass.new server, port
+        c.post_init *args
+        c
+    end
+
+    def self.start_server(server, port, handler, *args)
+        thread = reactor   # Get the reactor running on this thread
+        raise ThreadError, "There is no Libuv reactor running on the current thread" if thread.nil?
+
+        klass = klass_from_handler(InboundConnection, handler, *args)
+        MTUV::TcpServer.new thread, server, port, klass, *args
+    end
+
+    def self.attach_server(sock, handler, *args)
+        thread = reactor   # Get the reactor running on this thread
+        raise ThreadError, "There is no Libuv reactor running on the current thread" if thread.nil?
+
+        klass = klass_from_handler(InboundConnection, handler, *args)
+        sd = sock.respond_to?(:fileno) ? sock.fileno : sock
+
+        MTUV::TcpServer.new thread, sd, sd, klass, *args
+    end
+
+    def self.open_datagram_socket(handler, server = nil, port = nil, *args)
+        klass = klass_from_handler(DatagramConnection, handler, *args)
+
+        c = klass.new server, port
+        c.post_init *args
+        c
+    end
+end
+
+module MTLibuv
+    class Reactor
+        def scheduler
+            @scheduler ||= ::MTUV::Scheduler.new(@reactor)
+            @scheduler
+        end
+    end
+end

data/mt-uv-rays.gemspec

@@ -0,0 +1,38 @@
+require File.expand_path("../lib/mt-uv-rays/version", __FILE__)
+
+Gem::Specification.new do |gem|
+    gem.name          = "mt-uv-rays"
+    gem.version       = MTUV::VERSION
+    gem.license       = 'MIT'
+    gem.authors       = ["Giallombardo Nathan"]
+    gem.email         = ["nathan.giallombardo@mapotempo.com"]
+    gem.homepage      = "https://github.com/mapotempo/mt-uv-rays"
+    gem.summary       = "Abstractions for working with Libuv"
+    gem.description   = "Opinionated abstractions for Libuv"
+
+    gem.required_ruby_version = '>= 2.0.0'
+    gem.require_paths = ["lib"]
+
+    gem.add_runtime_dependency     'mt-libuv', '~> 4.1', '>= 4.1.02' # Evented IO
+    gem.add_runtime_dependency     'bisect', '~> 0.1'                # Sorted insertion
+    gem.add_runtime_dependency     'tzinfo', '~> 1.2'                # Ruby timezones info
+    gem.add_runtime_dependency     'cookiejar', '~> 0.3'             # HTTP cookies
+    gem.add_runtime_dependency     'ipaddress', '~> 0.8'             # IP address validation
+    gem.add_runtime_dependency     'parse-cron', '~> 0.1'            # CRON calculations
+    gem.add_runtime_dependency     'addressable', '~> 2.4'           # URI parser
+    gem.add_runtime_dependency     'http-parser', '~> 1.2'           # HTTP tokeniser
+    gem.add_runtime_dependency     'activesupport', '>= 4', '< 6'
+
+    # HTTP authentication helpers
+    gem.add_runtime_dependency     'rubyntlm', '~> 0.6'
+    gem.add_runtime_dependency     'net-http-digest_auth', '~> 1.4'
+
+    gem.add_development_dependency 'rspec', '~> 3.5'
+    gem.add_development_dependency 'rake', '~> 11.2'
+    gem.add_development_dependency 'yard', '~> 0.9'
+    gem.add_development_dependency 'httpi', '~> 2.4.2'
+
+    gem.files = Dir["{lib}/**/*"] + %w(Rakefile mt-uv-rays.gemspec README.md LICENSE)
+    gem.test_files = Dir["spec/**/*"]
+    gem.extra_rdoc_files = ["README.md"]
+end

data/spec/abstract_tokenizer_spec.rb

@@ -0,0 +1,129 @@
+require 'mt-uv-rays'
+
+describe MTUV::AbstractTokenizer do
+    before :each do
+        @buffer = MTUV::AbstractTokenizer.new({
+            indicator: "Start",
+            callback: lambda { |data|
+                return 4 if data.length > 3
+                return false
+            },
+            size_limit: 10,
+            encoding: "ASCII-8BIT"
+        })
+    end
+
+    it "should not return anything when a complete message is not available" do
+        msg1 = "test"
+
+        result = @buffer.extract(msg1)
+        expect(result).to eq([])
+    end
+
+    it "should not return anything when an empty message is present" do
+        msg1 = "test"
+
+        result = @buffer.extract(msg1)
+        expect(result).to eq([])
+    end
+
+    it "should tokenize messages where the data is a complete message" do
+        msg1 = "Start1234"
+
+        result = @buffer.extract(msg1)
+        expect(result).to eq(['1234'])
+    end
+
+    it "should return multiple complete messages" do
+        msg1 = "Start1234Start123456"
+
+        result = @buffer.extract(msg1)
+        expect(result).to eq(['1234', '1234'])
+        expect(@buffer.flush).to eq('56')    # as we've indicated a message length of 4
+    end
+
+    it "should not return junk data" do
+        msg1 = "Start123456Start123456"
+
+        result = @buffer.extract(msg1)
+        expect(result).to eq(['1234', '1234'])
+        expect(@buffer.flush).to eq('56')    # as we've indicated a message length of 4
+    end
+    
+    it "should tokenize messages where the indicator is split" do
+        msg1 = "123Star"
+        msg2 = "twhoaStart1234"
+
+        result = @buffer.extract(msg1)
+        expect(result).to eq([])
+        result = @buffer.extract(msg2)
+        expect(result).to eq(['whoa', '1234'])
+
+        msg1 = "123Star"
+        msg2 = "twhoaSt"
+        msg3 = "art1234"
+
+        result = @buffer.extract(msg1)
+        expect(result).to eq([])
+        result = @buffer.extract(msg2)
+        expect(result).to eq(['whoa'])
+        result = @buffer.extract(msg3)
+        expect(result).to eq(['1234'])
+    end
+
+    it "should empty the buffer if the limit is exceeded" do
+        result = @buffer.extract('1234567890G')
+        expect(result).to eq([])
+
+        # We keep enough to match a possible partial indicator
+        expect(@buffer.flush).to eq('890G')
+    end
+
+    it "should work with regular expressions" do
+        @buffer = MTUV::AbstractTokenizer.new({
+            indicator: /Start/i,
+            callback: lambda { |data|
+                return 4 if data.length > 3
+                return false
+            }
+        })
+
+        result = @buffer.extract('1234567starta')
+        expect(result).to eq([])
+        result = @buffer.extract('bcd')
+        expect(result).to eq(['abcd'])
+    end
+
+    it "should work where the indicator is part of the message" do
+        # i.e. We are looking for \x02\x06\xLEN\x00\x00\x02\x06\x00\xEND
+        # Where the indicator may appear as part of the message body
+
+        msg1 = "StartStartStart123456"
+
+        result = @buffer.extract(msg1)
+        expect(result).to eq(['Star', '1234'])
+        expect(@buffer.flush).to eq('56')    # as we've indicated a message length of 4
+    end
+
+    it "should work with messages that don't have an indicator" do
+        # i.e. there is a header that defines message length
+        msg1 = "\x0612345\x081234567\x031"
+
+        @buffer = MTUV::AbstractTokenizer.new({
+            callback: lambda { |data|
+                len = data.bytes[0]
+                if data.length >= len
+                    len
+                else
+                    false
+                end
+            },
+            size_limit: 10,
+            encoding: "ASCII-8BIT"
+        })
+
+        result = @buffer.extract(msg1)
+        expect(result).to eq(["\x0612345", "\x081234567"])
+        expect(@buffer.flush).to eq("\x031")    # as we've indicated a message length of 3
+    end
+end