jubilee 2.1.0.rc1-java → 3.0.0.beta2-java

data/lib/core/net.rb

@@ -1,251 +0,0 @@
-# Copyright 2011 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'core/streams'
-require 'core/ssl_support'
-require 'core/tcp_support'
-require 'core/wrapped_handler'
-require 'socket'
-
-
-module Vertx
-
-  # Represents a TCP or SSL Server
-  #
-  # When connections are accepted by the server
-  # they are supplied to the user in the form of a {NetSocket} instance that is passed via the handler
-  # set using {#connect_handler}.
-  #
-  # @author {http://tfox.org Tim Fox}
-  class NetServer
-
-    include SSLSupport, ServerSSLSupport, TCPSupport, ServerTCPSupport
-
-    # Create a new NetServer
-    def initialize
-      @j_del = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.createNetServer
-    end
-
-    # Supply a connect handler for this server. The server can only have at most one connect handler at any one time.
-    # As the server accepts TCP or SSL connections it creates an instance of {NetSocket} and passes it to the
-    # connect handler.
-    # @param [Block] hndlr A block to be used as the handler
-    # @return [NetServer] A reference to self so invocations can be chained
-    def connect_handler(&hndlr)
-      @j_del.connectHandler{ |j_socket| hndlr.call(NetSocket.new(j_socket)) }
-      self
-    end
-
-    # Instruct the server to listen for incoming connections.
-    # @param [FixNum] port. The port to listen on.
-    # @param [FixNum] host. The host name or ip address to listen on.
-    # @param [Block] hndlr. The handler will be called when the server is listening or a failure occurred.
-    def listen(port, host = "0.0.0.0", &hndlr)
-      @j_del.listen(port, host, ARWrappedHandler.new(hndlr) {|j_del| self})
-      self
-    end
-
-    # Close the server. The handler will be called when the close is complete.
-    def close(&hndlr)
-      @j_del.close(ARWrappedHandler.new(hndlr))
-    end
-
-    # Get the port
-    def port
-      @j_del.port
-    end
-
-    # Get the host
-    def host
-      @j_del.host
-    end
-
-  end
-
-  # NetClient is an asynchronous factory for TCP or SSL connections.
-  #
-  # Multiple connections to different servers can be made using the same instance.
-  #
-  # @author {http://tfox.org Tim Fox}
-  class NetClient
-
-    include SSLSupport, ClientSSLSupport, TCPSupport
-
-    # Create a new NetClient
-    def initialize
-      @j_del = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.createNetClient
-    end
-
-    # Attempt to open a connection to a server. The connection is opened asynchronously and the result returned in the
-    # handler.
-    # @param [FixNum] port. The port to connect to.
-    # @param [String] host. The host or ip address to connect to.
-    # @param [Block] hndlr A block to be used as the handler. The handler will be called with an exception or the
-    # {NetSocket}
-    # @return [NetClient] A reference to self so invocations can be chained
-    def connect(port, host = "localhost", &hndlr)
-      hndlr = ARWrappedHandler.new(hndlr) { |j_socket| NetSocket.new(j_socket) }
-      @j_del.connect(port, host, hndlr)
-      self
-    end
-
-    # Set the reconnect attempts
-    def reconnect_attempts=(val)
-      @j_del.setReconnectAttempts(val)
-      self
-    end
-
-    # Set or Get the reconnect attempts for a fluent API
-    def reconnect_attempts(val = nil)
-      if val
-        @j_del.setReconnectAttempts(val)
-        self
-      else
-        @j_del.getReconnectAttempts
-      end
-    end
-
-    # Set the reconnect interval
-    def reconnect_interval=(val)
-      @j_del.setReconnectInterval(val)
-      self
-    end
-
-    # Set or Get the reconnect interval for a fluent API
-    def reconnect_interval(val = nil)
-      if val
-        @j_del.setReconnectInterval(val)
-        self
-      else
-        @j_del.getReconnectInterval
-      end
-    end
-
-    # Set the connect timeout
-    def connect_timeout=(val)
-      @j_del.setConnectTimeout(val)
-      self
-    end
-
-    # Set or Get the connect timeout for a fluent API
-    def connect_timeout(val = nil)
-      if val
-        @j_del.setConnectTimeout(val)
-        self
-      else
-        @j_del.getConnectTimeout
-      end
-    end
-
-    # Close the NetClient. Any open connections will be closed.
-    def close
-      @j_del.close
-    end
-
-  end
-
-
-  # NetSocket is a socket-like abstraction used for reading from or writing
-  # to TCP connections.
-  #
-  # @author {http://tfox.org Tim Fox}
-  class NetSocket
-
-    include ReadStream, WriteStream
-
-    # @private
-    def initialize(j_socket)
-      @j_del = j_socket
-      @local_addr = nil
-      @remote_addr = nil
-      @write_handler_id = EventBus.register_simple_handler { |msg|
-        write(msg.body)
-      }
-      @j_del.closeHandler(Proc.new {
-        EventBus.unregister_handler(@write_handler_id)
-        @close_handler.call if @close_handler
-      })
-    end
-
-    # Upgrade channel to use SSL/TLS. Be aware that for this to work SSL must be configured.
-    def ssl
-      raise 'An handler must be provided' unless block_given?
-      @j_del.ssl InternalHandler.new(Proc.new)
-      self
-    end
-
-    # Returns true if NetSocket is SSL/TSL Encrypted.
-    def ssl?
-      @j_del.isSsl
-    end
-
-    # Write a String to the socket. The handler will be called when the string has actually been written to the wire.
-    # @param [String] str. The string to write.
-    # @param [String] enc. The encoding to use.
-    def write_str(str, enc = "UTF-8")
-      @j_del.write(str, enc)
-      self
-    end
-
-    # Set a closed handler on the socket.
-    # @param [Block] hndlr A block to be used as the handler
-    def close_handler(&hndlr)
-      @close_handler = hndlr
-      self
-    end
-
-    #  Tell the kernel to stream a file directly from disk to the outgoing connection, bypassing userspace altogether
-    # (where supported by the underlying operating system. This is a very efficient way to stream files.
-    # @param [String] file_path. Path to file to send.
-    def send_file(file_path, &block)
-      if block.given?
-        @j_del.sendFile(file_path, ARWrappedHandler.new(block))
-      else
-        @j_del.sendFile(file_path)
-      end
-      self
-    end
-
-    # Close the socket
-    def close
-      @j_del.close
-    end
-
-    # When a NetSocket is created it automatically registers an event handler with the system. The address of that
-    # handler is given by {#write_handler_id}.
-    # Given this ID, a different event loop can send a buffer to that event handler using the event bus. This
-    # allows you to write data to other connections which are owned by different event loops.
-    def write_handler_id
-      @write_handler_id
-    end
-
-    # Return the Addrinfo to which the remote end of the socket is bound
-    def remote_address
-      if !@remote_addr
-        @remote_addr = Addrinfo.tcp(@j_del.remoteAddress().getAddress().getHostAddress(), @j_del.remoteAddress().getPort())
-      end
-      @remote_addr
-    end
-
-
-    # Return the Addrinfo to which the local end of the socket is bound
-    def local_address
-      if !@local_addr
-        @local_addr = Addrinfo.tcp(@j_del.localAddress().getAddress().getHostAddress(), @j_del.localAddress().getPort())
-      end
-      @local_addr
-    end
-  end
-end
-

data/lib/core/network_support.rb

@@ -1,77 +0,0 @@
-# Copyright 2013 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-module Vertx
-
-  # Mixin module that provides all the common Network params that can be set.
-  #
-  # @author {http://tfox.org Tim Fox}
-  module NetworkSupport
-
-    # Set the send buffer size.
-    # @param [FixNum] val. The size in bytes.
-    # @return [] A reference to self so invocations can be chained
-    def send_buffer_size=(val)
-      @j_del.setSendBufferSize(val)
-      self
-    end
-
-    # Get send buffer size for fluent API
-    def send_buffer_size
-      @j_del.getSendBufferSize
-    end
-
-    # Set the receive buffer size.
-    # @param [FixNum] val. The size in bytes.
-    # @return [] A reference to self so invocations can be chained
-    def receive_buffer_size=(val)
-      @j_del.setReceiveBufferSize(val)
-      self
-    end
-
-    #
-    # Gets the receive buffer size.
-    #
-    def receive_buffer_size
-        @j_del.getReceiveBufferSize
-    end
-
-
-    # Set the TCP reuse address setting.
-    # @param [Boolean] val. If true, then TCP reuse address will be enabled.
-    # @return [] A reference to self so invocations can be chained
-    def reuse_address=(val)
-      @j_del.setReuseAddress(val)
-      self
-    end
-
-    # Get TCP reuse address for fluent API
-    def reuse_address?
-      @j_del.isReuseAddress
-    end
-
-    # Set the traffic class setting.
-    # @param [FixNum] val. The TCP traffic class setting.
-    # @return [] A reference to self so invocations can be chained
-    def traffic_class=(val)
-      @j_del.setTrafficClass(val)
-      self
-    end
-
-    # Get traffic class for fluent API
-    def traffic_class
-        @j_del.getTrafficClass
-    end
-  end
-end

data/lib/core/parsetools.rb

@@ -1,105 +0,0 @@
-# Copyright 2011 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-module Vertx
-
-  # A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed
-  # size records.
-  #
-  # Instances of this class take as input {Buffer} instances containing raw bytes, and output records.
-  # For example, if I had a simple ASCII text protocol delimited by '\n' and the input was the following:
-  #
-  #   buffer1:HELLO\nHOW ARE Y
-  #   buffer2:OU?\nI AM
-  #   buffer3: DOING OK
-  #   buffer4:\n
-  #
-  # Then the output would be:
-  #
-  #   buffer1:HELLO
-  #   buffer2:HOW ARE YOU?
-  #   buffer3:I AM DOING OK
-  #
-  # Instances of this class can be changed between delimited mode and fixed size record mode on the fly as
-  # individual records are read, this allows you to parse protocols where, for example, the first 5 records might
-  # all be fixed size (of potentially different sizes), followed by some delimited records, followed by more fixed
-  # size records.
-  #
-  # Instances of this class can't currently be used for protocols where the text is encoded with something other than
-  # a 1-1 byte-char mapping.
-  #
-  # @author {http://tfox.org Tim Fox}
-  class RecordParser
-
-    # @private
-    def initialize(java_parser)
-      @java_parser = java_parser
-    end
-
-    # @private
-    def call(data)
-      input(data)
-    end
-
-    # Convert it to a Proc
-    def to_proc
-      return Proc.new do |data|
-        input(data)
-      end
-    end
-
-    # This method is called to provide the parser with data.
-    # @param [Buffer] data. Input data to the parser.
-    def input(data)
-      @java_parser.handle(data._to_java_buffer)
-    end
-
-    # Create a new RecordParser instance, initially in delimited mode, and where the delimiter can be represented
-    # by a delimiter string endcoded in latin-1 . Don't use this if your String contains other than latin-1 characters.
-    # @param [String] delim. The delimiter string.
-    # @param [Proc] proc A proc to be used as the output handler
-    # @param [Block] output_block A block to be used as the output handler
-    # @return [RecordParser] a new RecordParser
-    def RecordParser.new_delimited(delim, proc = nil, &output_block)
-      output_block = proc if proc
-      RecordParser.new(org.vertx.java.core.parsetools.RecordParser.newDelimited(delim, output_block))
-    end
-
-    # Create a new RecordParser instance, initially in fixed size mode.
-    # @param [FixNum] size. The initial record size.
-    # @param [Proc] proc A proc to be used as the output handler
-    # @param [Block] output_block A block to be used as the output handler
-    # @return [RecordParser] a new RecordParser
-    def RecordParser.new_fixed(size, proc = nil, &output_block)
-      output_block = proc if proc
-      RecordParser.new(org.vertx.java.core.parsetools.RecordParser.newFixed(size, output_block))
-    end
-
-    # Flip the parser into delimited mode. This method can be called multiple times with different values
-    # of delim while data is being parsed.
-    # @param [String] delim. The delimiter string.
-    def delimited_mode(delim)
-      @java_parser.delimitedMode(delim)
-    end
-
-    # Flip the parser into fixed size mode. This method can be called multiple times with different values
-    # of size while data is being parsed.
-    # @param [FixNum] size. The record size.
-    def fixed_size_mode(size)
-      @java_parser.fixedSizeMode(size)
-    end
-
-  end
-
-end

data/lib/core/shared_data.rb

@@ -1,214 +0,0 @@
-# Copyright 2011 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'delegate'
-
-module Vertx
-
-  # Sometimes it is desirable to share immutable data between different event loops, for example to implement a
-  # cache of data.
-  #
-  # This class allows data structures to be looked up and used from different event loops.
-  # The data structures themselves will only allow certain data types to be stored into them. This shields the
-  # user from worrying about any thread safety issues might occur if mutable objects were shared between event loops.
-  #
-  # The following types can be stored in a shareddata data structure:
-  #
-  #   String
-  #   FixNum
-  #   Float
-  #   {Buffer} this will be automatically copied, and the copy will be stored in the structure.
-  #
-  # @author {http://tfox.org Tim Fox}
-  class SharedData
-
-    @@j_sd = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.sharedData()
-
-    # Return a Hash with the specific name. All invocations of this method with the same value of name
-    # are guaranteed to return the same Hash instance.
-    # @param [String] key. Get the hash with the key.
-    # @return [Hash] the hash.
-    def SharedData.get_hash(key)
-      map = @@j_sd.getMap(key)
-      SharedHash.new(map)
-    end
-
-    # Return a Set with the specific name. All invocations of this method with the same value of name
-    # are guaranteed to return the same Set instance.
-    # @param [String] key. Get the set with the key.
-    # @return [SharedSet] the set.
-    def SharedData.get_set(key)
-      set = @@j_sd.getSet(key)
-      SharedSet.new(set)
-    end
-
-    # Remove the hash
-    # @param [String] key. The key of the hash.
-    def SharedData.remove_hash(key)
-      @@j_sd.removeMap(key)
-    end
-
-    # Remove the set
-    # @param [String] key. The key of the set.
-    def SharedData.remove_set(key)
-      @@j_sd.removeSet(key)
-    end
-
-    # Convert to corresponding Java objects
-    # And make copies where appropriate (the underlying java map will also make copies for some data types too)
-    # @private
-    def SharedData.check_obj(obj)
-      if obj.is_a?(Buffer)
-        obj = obj._to_java_buffer
-      end
-      obj
-    end
-
-    # @private
-    class SharedHash < DelegateClass(Hash)
-
-      def initialize(hash)
-        @hash = hash
-        # Pass the object to be delegated to the superclass.
-        super(@hash)
-      end
-
-      def []=(key, val)
-        key = SharedData.check_obj(key)
-        val = SharedData.check_obj(val)
-        super(key, val)
-      end
-
-      alias store []=
-
-      def [](key)
-        # We call the java class directly
-        obj = @hash.get(key)
-        obj = Buffer.new(obj) if obj.is_a? org.vertx.java.core.buffer.Buffer
-        obj
-      end
-
-      def ==(other)
-        if other.is_a?(SharedHash)
-          @hash.equal?(other._to_java_map)
-        else
-          false
-        end
-      end
-
-      def _to_java_map
-        @hash
-      end
-
-    end
-
-    #
-    # @private
-    class SharedSet
-
-      # @private
-      def initialize(j_set)
-        @j_set = j_set
-      end
-
-      def ==(other)
-        if other.is_a?(SharedSet)
-          @j_set.equal?(other._to_java_set)
-        else
-          false
-        end
-      end
-
-      # Add an object to the set
-      # @param [Object] obj. The object to add
-      # @return [SharedSet} self
-      def add(obj)
-        obj = SharedData.check_obj(obj)
-        @j_set.add(obj)
-        self
-      end
-
-      # Add an object to the set
-      # @param [Object] obj. The object to add
-      # @return [SharedSet] self if the object is not already in the set, otherwise nil
-      def add?(obj)
-        obj = SharedData.check_obj(obj)
-        if !@j_set.contains(obj)
-          @j_set.add(obj)
-          self
-        else
-          nil
-        end
-      end
-
-      # Clear the set
-      def clear
-        @j_set.clear
-      end
-
-      # Delete an object from the set
-      # @param [Object] obj. The object to delete
-      def delete(obj)
-        @j_set.remove(obj)
-      end
-
-      # Delete an object from the set
-      # @param [Object] obj. The object to delete
-      # @return [SharedSet] self if the object was in the set before the remove, nil otherwise.
-      def delete?(obj)
-        if @j_set.contains(obj)
-          @j_set.remove(obj)
-          self
-        else
-          nil
-        end
-      end
-
-      # Call the block for every element of the set
-      # @param [Blovk] block. The block to call.
-      def each(&block)
-        iter = @j_set.iterator
-        while iter.hasNext do
-          obj = iter.next
-          obj = Buffer.new(obj) if obj.is_a? org.vertx.java.core.buffer.Buffer
-          block.call(obj)
-        end
-      end
-
-      # @return [Boolean] true if the set is empty
-      def empty?
-        @j_set.isEmpty
-      end
-
-      # Does the set contain an element?
-      # @param [Object] obj, the object to check if the set contains
-      # @return [Boolean] true if the object is contained in the set
-      def include?(obj)
-        obj = obj._to_java_buffer if obj.is_a? Buffer
-        @j_set.contains(obj)
-      end
-
-      # @return [FixNum] The number of elements in the set
-      def size
-        @j_set.size
-      end
-
-      # @private
-      def _to_java_set
-        @j_set
-      end
-
-    end
-  end
-end