orchestrator 1.0.1

data/lib/orchestrator/device/transport_makebreak.rb

@@ -0,0 +1,221 @@
+
+module Orchestrator
+    module Device
+        class MakebreakConnection < ::UV::OutboundConnection
+            def post_init(manager, processor, tls)
+                @manager = manager
+                @processor = processor
+                @config = @processor.config
+                @tls = tls
+
+                @connected = false
+                @changing_state = true
+                @disconnecting = false
+                @last_retry = 0
+
+
+                @activity = nil     # Activity timer
+                @connecting = nil   # Connection timer
+                @retries = 2        # Connection retries
+                @write_queue = []
+
+                @timeout = method(:timeout)
+                @reset_timeout = method(:reset_timeout)
+            end
+
+            def transmit(cmd)
+                return if @terminated
+
+                data = cmd[:data]
+
+                if @connected
+                    promise = write(data)
+                    reset_timeout
+                    if cmd[:wait]
+                        promise.catch do |err|
+                            if @processor.queue.waiting == cmd
+                                # Fail fast
+                                @processor.thread.next_tick do
+                                    @processor.__send__(:resp_failure, err)
+                                end
+                            else
+                                cmd[:defer].reject(err)
+                            end
+                        end
+                    end
+                elsif @retries < 2
+                    @write_queue << cmd
+                    reconnect unless @disconnecting
+                else
+                    cmd[:defer].reject(Error::CommandFailure.new "transmit aborted as disconnected")
+                end
+                # discards data when officially disconnected
+            end
+
+            def on_connect(transport)
+                @connected = true
+                @changing_state = false
+
+                if @connecting
+                    @connecting.cancel
+                    @connecting = nil
+                end
+
+                if @terminated
+                    close_connection(:after_writing)
+                else
+                    begin
+                        use_tls(@config) if @tls
+                    rescue => e
+                        @manager.logger.print_error(e, 'error starting tls')
+                    end
+
+                    if @config[:wait_ready]
+                        @delaying = ''
+                    else
+                        init_connection
+                    end
+                end
+            end
+
+            def on_close
+                @delaying = false
+                @connected = false
+                @changing_state = false
+                @disconnecting = false
+
+
+                if @connecting
+                    @connecting.cancel
+                    @connecting = nil
+                end
+
+                # Prevent re-connect if terminated
+                unless @terminated
+                    @retries += 1
+                    the_time = @processor.thread.now
+                    boundry = @last_retry + @config[:thrashing_threshold]
+
+                    # ensure we are not thrashing (rapid connect then disconnect)
+                    # This equals a disconnect and requires a warning
+                    if @retries == 1 && boundry >= the_time
+                        @retries += 1
+                        @manager.logger.warn('possible connection thrashing. Disconnecting')
+                    end
+
+                    @activity.cancel if @activity
+                    @activity = nil
+
+                    if @retries == 1
+                        if @write_queue.length > 0
+                            # We reconnect here as there are pending writes
+                            @last_retry = the_time
+                            reconnect
+                        end
+                    else # retries > 1
+                        @write_queue.clear
+
+                        variation = 1 + rand(2000)
+                        @connecting = @manager.get_scheduler.in(3000 + variation) do
+                            @connecting = nil
+                            reconnect
+                        end
+
+                        # we mark the queue as offline if more than 1 reconnect fails
+                        #  or if the first connect fails
+                        if @retries == 2 || (@retries == 3 && @last_retry == 0)
+                            @processor.disconnected
+                            @processor.queue.offline(@config[:clear_queue_on_disconnect])
+                        end
+                    end
+                end
+            end
+
+            def on_read(data, *args)
+                if @delaying
+                    @delaying << data
+                    result = @delaying.split(@config[:wait_ready], 2)
+                    if result.length > 1
+                        @delaying = false
+                        init_connection
+                        rem = result[-1]
+                        @processor.buffer(rem) unless rem.empty?
+                    end
+                else
+                    @processor.buffer(data)
+                end
+            end
+
+            def terminate
+                @terminated = true
+                @connecting.cancel if @connecting
+                @activity.cancel if @activity
+                close_connection(:after_writing) if @transport.connected
+            end
+
+            def disconnect
+                @connected = false
+                @disconnecting = true
+                close_connection(:after_writing)
+            end
+
+
+            protected
+
+
+            def timeout(*args)
+                @activity = nil
+                disconnect
+            end
+
+            def reset_timeout
+                return if @terminated
+
+                if @activity
+                    @activity.cancel
+                    @activity = nil
+                end
+
+                timeout = @config[:inactivity_timeout] || 0
+                if timeout > 0
+                    @activity = @manager.get_scheduler.in(timeout, @timeout)
+                else # Wait for until queue complete
+                    waiting = @processor.queue.waiting
+                    if waiting
+                        if waiting[:makebreak_set].nil?
+                            waiting[:defer].promise.finally @reset_timeout
+                            waiting[:makebreak_set] = true
+                        end
+                    elsif @processor.queue.length == 0
+                        disconnect
+                    end
+                end
+            end
+
+            def reconnect
+                return if @changing_state || @connected
+                @changing_state = true
+                super
+            end
+
+            def init_connection
+                # Write pending directly
+                queue = @write_queue
+                @write_queue = []
+                while queue.length > 0
+                    transmit(queue.shift)
+                end
+
+                # Notify module
+                if @retries > 1
+                    @processor.queue.online
+                    @processor.connected
+                end
+                @retries = 0
+
+                # Start inactivity timeout
+                reset_timeout
+            end
+        end
+    end
+end

data/lib/orchestrator/device/transport_tcp.rb

@@ -0,0 +1,139 @@
+
+module Orchestrator
+    module Device
+        class TcpConnection < ::UV::OutboundConnection
+            def post_init(manager, processor, tls)
+                @manager = manager
+                @processor = processor
+                @config = @processor.config
+                @tls = tls
+
+                # Delay retry by default if connection fails on load
+                @retries = 1        # Connection retries
+                @connecting = nil   # Connection timer
+
+                # Last retry shouldn't break any thresholds
+                @last_retry = 0
+            end
+
+            def transmit(cmd)
+                return if @terminated
+                promise = write(cmd[:data])
+                if cmd[:wait]
+                    promise.catch do |err|
+                        if @processor.queue.waiting == cmd
+                            # Fail fast
+                            @processor.thread.next_tick do
+                                @processor.__send__(:resp_failure, err)
+                            end
+                        else
+                            cmd[:defer].reject(err)
+                        end
+                    end
+                end
+            end
+
+            def on_connect(transport)
+                if @terminated
+                    close_connection(:after_writing)
+                else
+                    begin
+                        use_tls(@config) if @tls
+                    rescue => e
+                        @manager.logger.print_error(e, 'error starting tls')
+                    end
+
+                    if @config[:wait_ready]
+                        @delaying = ''
+                    else
+                        init_connection
+                    end
+                end
+            end
+
+            def on_close
+                unless @terminated
+                    # Clear the connection delay if in use
+                    @delaying = false if @delaying
+                    @retries += 1
+                    the_time = @processor.thread.now
+                    boundry = @last_retry + @config[:thrashing_threshold]
+
+                    # ensure we are not thrashing (rapid connect then disconnect)
+                    # This equals a disconnect and requires a warning
+                    if @retries == 1 && boundry >= the_time
+                        @retries += 1
+                        @processor.disconnected
+                        @manager.logger.warn('possible connection thrashing. Disconnecting')
+                    end
+
+                    if @retries == 1
+                        @last_retry = the_time
+                        @processor.disconnected
+                        reconnect
+                    else
+                        variation = 1 + rand(2000)
+                        @connecting = @manager.get_scheduler.in(3000 + variation) do
+                            @connecting = nil
+                            reconnect
+                        end
+
+                        if @retries == 2
+                            # NOTE:: edge case if disconnected on first connect
+                            @processor.disconnected if @last_retry == 0
+
+                            # we mark the queue as offline if more than 1 reconnect fails
+                            @processor.queue.offline(@config[:clear_queue_on_disconnect])
+                        end
+                    end
+                end
+            end
+
+            def on_read(data, *args)
+                if @delaying
+                    # Update last retry so we don't trigger multiple
+                    # calls to disconnected as connection is working
+                    @last_retry += 1
+
+                    @delaying << data
+                    result = @delaying.split(@config[:wait_ready], 2)
+                    if result.length > 1
+                        @delaying = false
+                        init_connection
+                        rem = result[-1]
+                        @processor.buffer(rem) unless rem.empty?
+                    end
+                else
+                    @processor.buffer(data)
+                end
+            end
+
+            def terminate
+                @terminated = true
+                @connecting.cancel if @connecting
+                close_connection(:after_writing) if @transport.connected
+            end
+
+            def disconnect
+                # Shutdown quickly
+                close_connection
+            end
+
+
+            protected
+
+
+            def init_connection
+                # Enable keep alive every 30 seconds
+                keepalive(30)
+
+                # We only have to mark a queue online if more than 1 retry was required
+                if @retries > 1
+                    @processor.queue.online
+                end
+                @retries = 0
+                @processor.connected
+            end
+        end
+    end
+end

data/lib/orchestrator/device/transport_udp.rb

@@ -0,0 +1,89 @@
+module Orchestrator
+    module Device
+        class UdpConnection
+            def initialize(manager, processor)
+                @manager = manager
+                @loop = manager.thread
+                @processor = processor
+
+                settings = manager.settings
+                @ip = settings.ip
+                @port = settings.port
+                @on_read = method(:on_read)
+
+                # One per loop unless port specified
+                @udp_server = @loop.udp_service
+
+                if IPAddress.valid? @ip
+                    @attached_ip = @ip
+                    @udp_server.attach(@attached_ip, @port, @on_read)
+                    @loop.next_tick do
+                        # Call connected (we only need to do this once)
+                        @processor.connected
+                    end
+                else
+                    variation = 1 + rand(60000 * 5)  # 5min
+                    @checker = @manager.get_scheduler.in(60000 * 5 + variation) do
+                        find_ip(@ip)
+                    end
+                    find_ip(@ip)
+                end
+            end
+
+            def transmit(cmd)
+                return if @terminated
+                @udp_server.send(@attached_ip, @port, cmd[:data])
+            end
+
+            def on_read(data)
+                # We schedule as UDP server may be on a different thread
+                @loop.schedule do
+                    @processor.buffer(data)
+                end
+            end
+
+            def terminate
+                #@processor.disconnected   # Disconnect should never be called
+                @terminated = true
+                if @searching
+                    @searching.cancel
+                    @searching = nil
+                else
+                    @udp_server.detach(@attached_ip, @port)
+                end
+
+                @checker.cancel if @checker
+            end
+
+            def disconnect; end
+
+
+            protected
+
+
+            def find_ip(hostname)
+                @loop.lookup(hostname).then(proc{ |result|
+                    update_ip(result[0][0])
+                }, proc { |failure|
+                    variation = 1 + rand(8000)
+                    @searching = @manager.get_scheduler.in(8000 + variation) do
+                        @searching = nil
+                        find_ip(hostname)
+                    end
+                })
+            end
+
+            def update_ip(ip)
+                if ip != @attached_ip
+                    if @attached_ip
+                        @udp_server.detach(@attached_ip, @port)
+                    else
+                        @processor.connected
+                    end
+                    @attached_ip = ip
+                    @udp_server.attach(@attached_ip, @port, @on_read)
+                end
+            end
+        end
+    end
+end