listen 2.10.1 → 3.0.0

data/lib/listen/adapter/tcp.rb

@@ -1,88 +0,0 @@
-require 'celluloid/io'
-
-require 'listen/tcp/message'
-
-module Listen
-  module Adapter
-    # Adapter to receive file system modifications over TCP
-    class TCP < Base
-      OS_REGEXP = // # match any
-
-      include Celluloid::IO
-      finalizer :finalize
-
-      DEFAULTS = {
-        host: 'localhost',
-        port: '4000'
-      }
-
-      attr_reader :buffer, :socket
-
-      # Initializes and starts a Celluloid::IO-powered TCP-recipient
-      def start
-        attempts ||= 3
-        _log :info, "TCP: opening socket #{options.host}:#{options.port}"
-        @socket = TCPSocket.new(options.host, options.port)
-        @buffer = ''
-        async.run
-      rescue Celluloid::Task::TerminatedError
-        _log :debug, "TCP adapter was terminated: #{$ERROR_INFO.inspect}"
-      rescue Errno::ECONNREFUSED
-        sleep 1
-        attempts -= 1
-        _log :warn, "TCP.start: #{$ERROR_INFO.inspect}"
-        retry if attempts > 0
-        _log :error, format('TCP.start: %s:%s', $ERROR_INFO.inspect,
-                            $ERROR_POSITION * "\n")
-        raise
-      rescue
-        _log :error, format('TCP.start: %s:%s', $ERROR_INFO.inspect,
-                            $ERROR_POSITION * "\n")
-        raise
-      end
-
-      # Cleans up buffer and socket
-      def finalize
-        @buffer = nil
-        return unless @socket
-
-        @socket.close
-        @socket = nil
-      end
-
-      # Number of bytes to receive at a time
-      RECEIVE_WINDOW = 1024
-
-      # Continuously receive and asynchronously handle data
-      def run
-        while (data = @socket.recv(RECEIVE_WINDOW))
-          async.handle_data(data)
-        end
-      end
-
-      # Buffers incoming data and handles messages accordingly
-      def handle_data(data)
-        @buffer << data
-        while (message = Listen::TCP::Message.from_buffer(@buffer))
-          handle_message(message)
-        end
-      rescue
-        _log :error, format('TCP.handle_data crashed: %s:%s', $ERROR_INFO,
-                            $ERROR_POSITION * "\n")
-        raise
-      end
-
-      # Handles incoming message by notifying of path changes
-      def handle_message(message)
-        type, change, dir, path, _ = message.object
-        _log(:debug) { "TCP message: #{[type, change, dir, path].inspect}" }
-
-        _queue_change(type.to_sym, Pathname(dir), path, change: change.to_sym)
-      end
-
-      def self.local_fs?
-        false
-      end
-    end
-  end
-end

data/lib/listen/internals/logging.rb

@@ -1,35 +0,0 @@
-require 'celluloid/logger'
-
-module Listen
-  module Internals
-    module Logging
-      def _info(*args, &block)
-        _log(:info, *args, &block)
-      end
-
-      def _warn(*args, &block)
-        _log(:warn, *args, &block)
-      end
-
-      def _debug(*args, &block)
-        _log(:debug, *args, &block)
-      end
-
-      def _log(*args, &block)
-        if block
-          Celluloid::Logger.send(*args, block.call)
-        else
-          Celluloid::Logger.send(*args)
-        end
-      end
-
-      def _format_error(fmt)
-        format(fmt, $ERROR_INFO, ", Backtrace: \n" + $ERROR_POSITION * "\n")
-      end
-
-      def _error_exception(fmt)
-        _log :error, _format_error(fmt)
-      end
-    end
-  end
-end

data/lib/listen/tcp.rb

@@ -1,8 +0,0 @@
-begin
-  require 'celluloid/io'
-rescue LoadError
-  Kernel.fail 'TCP forwarding requires Celluloid::IO to be present. ' \
-              "Please install or add as a dependency: gem 'celluloid-io'"
-end
-
-require 'listen/adapter/tcp'

data/lib/listen/tcp/broadcaster.rb

@@ -1,79 +0,0 @@
-require 'celluloid/io'
-
-module Listen
-  module TCP
-    class Broadcaster
-      include Celluloid::IO
-
-      finalizer :finalize
-
-      # Initializes a Celluloid::IO-powered TCP-broadcaster
-      #
-      # @param [String] host to broadcast on
-      # @param [String] port to broadcast on
-      #
-      # Note: Listens on all addresses when host is nil
-      #
-      def initialize(host, port)
-        @sockets = []
-        _log :debug, format('Broadcaster: tcp server listening on: %s:%s',
-                            host, port)
-        @server = TCPServer.new(host, port)
-      rescue
-        _log :error, format('Broadcaster.initialize: %s:%s', $ERROR_INFO,
-                            $ERROR_POSITION * "\n")
-        raise
-      end
-
-      # Asynchronously start accepting connections
-      def start
-        async.run
-      end
-
-      # Cleans up sockets and server
-      def finalize
-        @sockets.map(&:close) if @sockets
-        @sockets = nil
-
-        return unless @server
-        @server.close
-        @server = nil
-      end
-
-      # Broadcasts given payload to all connected sockets
-      def broadcast(payload)
-        active_sockets = @sockets.select do |socket|
-          _unicast(socket, payload)
-        end
-        @sockets.replace(active_sockets)
-      end
-
-      # Continuously accept and handle incoming connections
-      def run
-        while (socket = @server.accept)
-          @sockets << socket
-        end
-      rescue Celluloid::Task::TerminatedError
-        _log :debug, "TCP adapter was terminated: #{$ERROR_INFO}"
-      rescue
-        _log :error, format('Broadcaster.run: %s:%s', $ERROR_INFO,
-                            $ERROR_POSITION * "\n")
-        raise
-      end
-
-      private
-
-      def _log(type, message)
-        Celluloid::Logger.send(type, message)
-      end
-
-      def _unicast(socket, payload)
-        socket.write(payload)
-        true
-      rescue IOError, Errno::ECONNRESET, Errno::EPIPE
-        _log :debug, "Broadcaster failed: #{socket.inspect}"
-        false
-      end
-    end
-  end
-end

data/lib/listen/tcp/message.rb

@@ -1,50 +0,0 @@
-require 'json'
-
-module Listen
-  module TCP
-    class Message
-      attr_reader :body, :object, :payload, :size
-
-      HEADER_SIZE    = 4
-      HEADER_FORMAT  = 'N'
-      PAYLOAD_FORMAT = "#{HEADER_FORMAT}a*"
-
-      # Initializes a new message
-      #
-      # @param [Object] object to initialize message with
-      #
-      def initialize(*args)
-        self.object = args
-      end
-
-      # Generates message size and payload for given object
-      def object=(obj)
-        @object = obj
-        @body = JSON.generate(@object)
-        @size = @body.bytesize
-        @payload = [@size, @body].pack(PAYLOAD_FORMAT)
-      end
-
-      # Extracts message size and loads object from given payload
-      def payload=(payload)
-        @payload = payload
-        @size, @body = @payload.unpack(PAYLOAD_FORMAT)
-        @object = JSON.parse(@body)
-      end
-
-      # Extracts a message from given buffer
-      def self.from_buffer(buffer)
-        if buffer.bytesize > HEADER_SIZE
-          size = buffer.unpack(HEADER_FORMAT).first
-          payload_size = HEADER_SIZE + size
-          if buffer.bytesize >= payload_size
-            payload = buffer.slice!(0...payload_size)
-            new.tap do |message|
-              message.payload = payload
-            end
-          end
-        end
-      end
-    end
-  end
-end