jubilee 2.1.0.beta-java → 2.1.0.rc1-java

data/lib/core/net.rb

@@ -0,0 +1,251 @@
+# 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

@@ -0,0 +1,77 @@
+# 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

@@ -0,0 +1,105 @@
+# 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/{vertx → core}/shared_data.rb

@@ -33,7 +33,7 @@ module Vertx
   # @author {http://tfox.org Tim Fox}
   class SharedData
 
-    @@j_sd = org.jruby.jubilee.vertx.JubileeVertx.vertx().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.
@@ -211,4 +211,4 @@ module Vertx
 
     end
   end
-end
+end