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

data/lib/{vertx → core}/buffer.rb

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'vertx/shared_data'
+require 'core/shared_data'
 
 module Vertx
 

data/lib/core/datagram.rb

@@ -0,0 +1,280 @@
+# 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.
+
+require 'core/buffer'
+require 'core/wrapped_handler'
+require 'core/network_support'
+require 'core/streams'
+require 'socket'
+
+module Vertx
+
+
+  #
+  # A Datagram socket which can be used to send data to remote Datagram servers and receive [DatagramPacket]s .
+  #
+  # Usually you use a Datragram Client to send UDP over the wire. UDP is connection-less which means you are not connected
+  # to the remote peer in a persistent way. Because of this you have to supply the address and port of the remote peer
+  # when sending data.
+  #
+  # You can send data to ipv4 or ipv6 addresses, which also include multicast addresses.
+  #
+  # @author Norman Maurer
+  class DatagramSocket
+    include ReadSupport, DrainSupport, NetworkSupport
+
+    def initialize(ipv4=nil)
+      if ipv4 == nil
+        family = nil
+      elsif ipv4
+        family = org.vertx.java.core.datagram.InternetProtocolFamily::IPv4
+      else
+        family = org.vertx.java.core.datagram.InternetProtocolFamily::IPv6
+      end
+      @j_del = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.createDatagramSocket(family)
+      @local_address = nil
+    end
+
+    # Write the given {@link org.vertx.java.core.buffer.Buffer} to the {@link java.net.InetSocketAddress}. The {@link org.vertx.java.core.Handler} will be notified once the
+    # write completes.
+    #
+    # @param [String] host              the host address of the remote peer
+    # @param [FixNum] port              the host port of the remote peer
+    # @param [Buffer] packet            the buffer to write
+    # @param [Block] hndlr              the handler to notify once the write completes.
+    # @return [DatagramSocket] self     itself for method chaining
+    def send(host, port, packet,  &hndlr)
+      @j_del.send(packet._to_java_buffer, host, port, ARWrappedHandler.new(hndlr) { |j_del| self })
+      self
+    end
+
+    #
+    # Write the given {@link String} to the {@link InetSocketAddress} using UTF8 encoding. The {@link Handler} will be notified once the
+    # write completes.
+    #
+    #
+    # @param [String] host              the host address of the remote peer
+    # @param [FixNum] port              the host port of the remote peer
+    # @param [String] str               the data to send
+    # @param [String] enc               the charset to use to encode the data
+    # @param [Block] hndlr              the handler to notify once the write completes.
+    # @return [DatagramSocket] self     itself for method chaining
+    def send_str(host, port, str, enc = 'UTF-8',  &hndlr)
+      @j_del.send(str, enc, host, port, ARWrappedHandler.new(hndlr) { |j_del| self })
+      self
+    end
+
+    #
+    # set the {@link java.net.StandardSocketOptions#SO_BROADCAST} option.
+    #
+    def broadcast=(val)
+      @j_del.setBroadcast(val)
+      self
+    end
+
+    #
+    # set the {@link java.net.StandardSocketOptions#SO_BROADCAST} option.
+    #
+    def broadcast?
+      @j_del.isBroadcast
+    end
+
+    #
+    # Set the {@link java.net.StandardSocketOptions#IP_MULTICAST_LOOP} option.
+    #
+    def multicast_loopback_mode=(val)
+      @j_del.setMulticastLoopbackMode(val)
+       self
+    end
+
+    #
+    # Set the {@link java.net.StandardSocketOptions#IP_MULTICAST_LOOP} option.
+    #
+    def multicast_loopback_mode?
+      @j_del.isMulticastLoopbackMode
+    end
+
+    #
+    # Set  the {@link java.net.StandardSocketOptions#IP_MULTICAST_TTL} option.
+    #
+    def multicast_time_to_live=(val)
+      @j_del.setMulticastTimeToLive(val)
+      self
+    end
+
+    #
+    # Gets  the {@link java.net.StandardSocketOptions#IP_MULTICAST_TTL} option.
+    #
+    def multicast_time_to_live
+      @j_del.getMulticastTimeToLive
+    end
+
+    #
+    # Set the {@link java.net.StandardSocketOptions#IP_MULTICAST_IF} option.
+    #
+    def multicast_network_interface=(val)
+      @j_del.setMulticastNetworkInterface(val)
+      self
+    end
+
+    #
+    # Gets the {@link java.net.StandardSocketOptions#IP_MULTICAST_IF} option.
+    #
+    def multicast_network_interface
+      @j_del.getMulticastNetworkInterface
+    end
+
+
+    #
+    # Close the socket asynchronous and notifies the handler once done.
+    #
+    # @param [Block] hndlr the handler to notify once the opeation completes.
+    def close(&hndlr)
+      if hndlr
+        @j_del.close(ARWrappedHandler.new(hndlr))
+      else
+        @j_del.close
+      end
+    end
+
+    #
+    # Return the Addrinfo to which the local end of the socket is bound
+    #
+    # @return [Addrinfo] local_addr   the local address to which the socket is bound if it is bound at all.
+    def local_address
+      if !@local_address
+        addr = j_del.localAddress
+        if addr != null
+          @local_address = Addrinfo.tcp(@local_address.getAddress().getHostAddress(), @@local_address.getPort())
+        end
+      end
+      @local_address
+    end
+
+    #
+    # Joins a multicast group and so start listen for packets send to it. The {@link Handler} is notified once the operation completes.
+    #
+    #
+    # @param  [String]            multicast_address   the address of the multicast group to join
+    # @param  [String]            source              the address of the source for which we will listen for mulicast packets
+    # @param  [String]            network_interface   the network interface on which to listen for packets.
+    # @param  [Block]             hndlr               the handler to notify once the opeation completes.
+    # @return [DatagramSocket]    self                itself for method chaining
+    def listen_multicast_group(multicast_address, source = nil, network_interface = nil,  &hndlr)
+      if network_interface != nil && source != nil
+        @j_del.listenMulticastGroup(multicast_address, network_interface, source, ARWrappedHandler.new(hndlr) { |j_del| self })
+      else
+        @j_del.listenMulticastGroup(multicast_address, ARWrappedHandler.new(hndlr) { |j_del| self })
+      end
+      self
+    end
+
+    #
+    # Leaves a multicast group and so stop listen for packets send to it on the given network interface.
+    # The {@link Handler} is notified once the operation completes.
+    #
+    #
+    # @param  [String]            multicast_address   the address of the multicast group to leave
+    # @param  [String]            source              the address of the source for which we will listen for mulicast packets
+    # @param  [String]            network_interface   the network interface on which to listen for packets.
+    # @param  [Block]             hndlr               the handler to notify once the opeation completes.
+    # @return [DatagramSocket]    self                itself for method chaining
+    def unlisten_multicast_group(multicast_address, source = nil, network_interface = nil, &hndlr)
+      if network_interface != nil && source != nil
+        @j_del.unlistenMulticastGroup(multicast_address, network_interface, source, ARWrappedHandler.new(hndlr) { |j_del| self })
+      else
+        @j_del.unlistenMulticastGroup(multicast_address, ARWrappedHandler.new(hndlr) { |j_del| self })
+      end
+      self
+    end
+
+    #
+    # Block the given sourceToBlock address for the given multicastAddress on the given network interface and notifies
+    # the {@link Handler} once the operation completes.
+    #
+    #
+    # @param  [String]          multicast_address   the address for which you want to block the sourceToBlock
+    # @param  [String]          source_to_block     the source address which should be blocked. You will not receive an multicast packets
+    #                                               for it anymore.
+    # @param  [String]          network_interface   the network interface on which the blocking should accour.
+    # @param  [Block]           hndlr               the handler to notify once the opeation completes.
+    # @return [DatagramSocket]  self                itself for method chaining
+    #
+    def block_multicast_group(multicast_address, source_to_block, network_interface = nil, &hndlr)
+      if network_interface != nil
+        @j_del.blockMulticastGroup(multicast_address, network_interface, source_to_block, ARWrappedHandler.new(hndlr) { |j_del| self })
+      else
+        @j_del.blockMulticastGroup(multicast_address, source_to_block, ARWrappedHandler.new(hndlr) { |j_del| self })
+      end
+      self
+    end
+
+    #
+    # Listen for incoming [DatagramPacket]s on the given address and port.
+    #
+    #
+    # @param  [FixNum]          port                the port on which to listen for incoming [DatagramPacket]s
+    # @param  [String]          address             the address on which to listen for incoming [DatagramPacket]s
+    # @param  [Block]           hndlr               the handler to notify once the opeation completes.
+    # @return [DatagramSocket]  self                itself for method chaining
+    #
+    def listen(port, address = '0.0.0.0', &hndlr)
+      @j_del.listen(address, port, ARWrappedHandler.new(hndlr) { |j_del| self })
+      self
+    end
+
+
+    # Set a data handler. As data is read, the handler will be called with the data.
+    #
+    # @param [Block] hndlr. The data handler
+    def data_handler(&hndlr)
+      @j_del.dataHandler(Proc.new { |j_packet|
+        hndlr.call(DatagramPacket.new(j_packet))
+      })
+      self
+    end
+  end
+
+
+  # A received Datagram packet (UDP) which contains the data and information about the sender of the data itself.
+  #
+  # @author Norman Maurer
+  class DatagramPacket
+    def initialize(j_packet)
+      @j_packet = j_packet
+      @sender = nil
+      @data = nil
+    end
+
+    # Return the address of the sender of this [DatagramPacket].
+    #
+    # @return [AddrInfo] addr   the address of the sender
+    def sender
+      if !@sender
+        @sender = Addrinfo.tcp(@j_packet.sender().getAddress().getHostAddress(), @j_packet.sender().getPort())
+      end
+      @sender
+    end
+
+    # Return the data which was received
+    #
+    # @return [Buffer] data   the data which was received
+    def data
+      if !@data
+        @data = Buffer.new(@j_packet.data())
+      end
+      @data
+    end
+  end
+end

data/lib/core/dns.rb

@@ -0,0 +1,143 @@
+# 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.
+
+require 'core/wrapped_handler'
+require 'socket'
+
+module Vertx
+
+  MxRecord =  Struct.new(:priority, :name)
+  SrvRecord =  Struct.new(:priority, :weight, :port, :name, :protocol, :service, :target)
+
+  # An async DNS Client
+  #
+  # @author Norman Maurer
+  class DnsClient
+    def initialize(*servers)
+      @j_dns = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.createDnsClient(
+          servers.map { |value| java.net.InetSocketAddress.new(value.ip_address, value.ip_port) }.to_java(java.net.InetSocketAddress))
+    end
+
+    # Try to lookup the A (ipv4) or AAAA (ipv6) record for the given name. The first found will be used.
+    # The handler will be notified once the lookup completes.
+    # @param [Block] hndlr A block to be used as the handler
+    def lookup(name, &hndlr)
+      @j_dns.lookup(name, ARWrappedHandler.new(hndlr) { |addr| addr.getHostAddress()})
+      self
+    end
+
+    # Try to lookup the A (ipv4) record for the given name. The first found will be used.
+    # The handler will be notified once the lookup completes.
+    # @param [Block] hndlr A block to be used as the handler
+    def lookup_4(name, &hndlr)
+      @j_dns.lookup4(name, ARWrappedHandler.new(hndlr) { |addr| addr.getHostAddress()})
+      self
+    end
+
+    # Try to AAAA (ipv6) record for the given name. The first found will be used.
+    # The handler will be notified once the lookup completes.
+    # @param [Block] hndlr A block to be used as the handler
+    def lookup_6(name, &hndlr)
+      @j_dns.lookup6(name, ARWrappedHandler.new(hndlr) { |addr| addr.getHostAddress()})
+      self
+    end
+
+    # Try to resolve all A records for the given name.
+    # The handler will be notified once the operation completes.
+    # @param [Block] hndlr A block to be used as the handler
+    def resolve_a(name, &hndlr)
+      @j_dns.resolveA(name, ARWrappedHandler.new(hndlr) { |j_list|
+        j_list.map { |item|
+          item.getHostAddress()
+        }
+      })
+      self
+    end
+
+    # Try to resolve all AAAA records for the given name.
+    # The handler will be notified once the operation completes.
+    # @param [Block] hndlr A block to be used as the handler
+    def resolve_aaaa(name, &hndlr)
+      @j_dns.resolveAAAA(name, ARWrappedHandler.new(hndlr) { |j_list|
+        j_list.map { |item|
+          item.getHostAddress()
+        }
+      })
+      self
+    end
+
+    # Try to resolve all CNAME records for the given name.
+    # The handler will be notified once the operation completes.
+    # @param [Block] hndlr A block to be used as the handler
+    def resolve_cname(name, &hndlr)
+      @j_dns.resolveCNAME(name, ARWrappedHandler.new(hndlr))
+      self
+    end
+
+    # Try to resolve all MX records for the given name.
+    # The handler will be notified once the operation completes.
+    # @param [Block] hndlr A block to be used as the handler
+    def resolve_mx(name, &hndlr)
+      @j_dns.resolveMX(name, ARWrappedHandler.new(hndlr) { |j_list|
+        j_list.map { |item|
+          MxRecord.new(item.priority(), item.name())
+        }
+      })
+      self
+    end
+
+    # Try to resolve the PTR record for the given name.
+    # The handler will be notified once the operation completes.
+    # @param [Block] hndlr A block to be used as the handler
+    def resolve_ptr(name, &hndlr)
+      @j_dns.resolvePTR(name, ARWrappedHandler.new(hndlr))
+      self
+    end
+
+    # Try to resolve all NS records for the given name.
+    # The handler will be notified once the operation completes.
+    # @param [Block] hndlr A block to be used as the handler
+    def resolve_ns(name, &hndlr)
+      @j_dns.resolveNS(name, ARWrappedHandler.new(hndlr))
+      self
+    end
+
+    def resolve_txt(name, &hndlr)
+      @j_dns.resolveTXT(name, ARWrappedHandler.new(hndlr))
+      self
+    end
+
+    # Try to resolve all SRV records for the given name.
+    # The handler will be notified once the operation completes.
+    # @param [Block] hndlr A block to be used as the handler
+    def resolve_srv(name, &hndlr)
+      @j_dns.resolveSRV(name, ARWrappedHandler.new(hndlr) { |j_list|
+        j_list.map { |item|
+          SrvRecord.new(item.priority(), item.weight(), item.port(), item.name(), item.protocol(), item.service(), item.target())
+        }
+      })
+      self
+    end
+
+    # Try to do a reverse lookup of an ipaddress. This is basically the same as doing trying to resolve a PTR record
+    # but allows you to just pass in the ipaddress and not a valid ptr query string.
+    # The handler will be notified once the operation completes.
+    # @param [Block] hndlr A block to be used as the handler
+    def reverse_lookup(name, &hndlr)
+      @j_dns.reverseLookup(name, ARWrappedHandler.new(hndlr) { |addr| addr.getHostName()})
+      self
+    end
+
+  end
+end

data/lib/{vertx → core}/event_bus.rb

@@ -53,17 +53,39 @@ module Vertx
 
     @@handler_map = {}
 
-    @@j_eventbus = org.jruby.jubilee.vertx.JubileeVertx.vertx().eventBus()
+    @@j_eventbus = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.eventBus()
 
     # Send a message on the event bus
     # @param message [Hash] The message to send
     # @param reply_handler [Block] An optional reply handler.
+    # @param [Integer] timeout if specified sends the message
     # It will be called when the reply from a receiver is received.
-    def EventBus.send(address, message, &reply_handler)
-      EventBus.send_or_pub(true, address, message, reply_handler)
+    def EventBus.send(address, message, timeout = nil, &reply_handler)
+
+      if timeout.nil?
+        EventBus.send_or_pub(true, address, message, reply_handler)
+      else
+        EventBus.send_or_pub(true, address, message, reply_handler, timeout)
+      end
+
       self
     end
 
+    # Sets a default timeout, in ms, for replies. If a messages is sent specify a reply handler
+    # but without specifying a timeout, then the reply handler is timed out, i.e. it is automatically unregistered
+    # if a message hasn't been received before timeout.
+    # The default value for default send timeout is -1, which means "never timeout".
+    # @param timeout
+    def EventBus.default_reply_timeout=(timeout)
+      @@j_eventbus.setDefaultReplyTimeout(timeout)
+      self
+    end
+
+    # Gets the default reply timeout value
+    def EventBus.default_reply_timeout
+      @@j_eventbus.getDefaultReplyTimeout
+    end
+
     # Publish a message on the event bus
     # @param message [Hash] The message to publish
     def EventBus.publish(address, message)
@@ -72,13 +94,17 @@ module Vertx
     end
 
     # @private
-    def EventBus.send_or_pub(send, address, message, reply_handler = nil)
+    def EventBus.send_or_pub(send, address, message, reply_handler = nil, timeout = nil)
       raise "An address must be specified" if !address
       raise "A message must be specified" if message == nil
       message = convert_msg(message)
       if send
         if reply_handler != nil
-          @@j_eventbus.send(address, message, InternalHandler.new(reply_handler))
+          if timeout != nil
+            @@j_eventbus.send_with_timeout address, message, timeout, AsyncInternalHandler.new(reply_handler)
+          else
+            @@j_eventbus.send(address, message, InternalHandler.new(reply_handler))
+          end
         else
           @@j_eventbus.send(address, message)
         end
@@ -165,6 +191,7 @@ module Vertx
     end
   end
 
+
   # Represents a message received from the event bus
   # @author {http://tfox.org Tim Fox}
   class Message
@@ -190,17 +217,61 @@ module Vertx
     # Replying to a message this way is equivalent to sending a message to an address which is the same as the message id
     # of the original message.
     # @param [Hash] Message send as reply
-    def reply(reply, &reply_handler)
+    def reply(reply, timeout = nil, &reply_handler)
       raise "A reply message must be specified" if reply == nil
       reply = EventBus.convert_msg(reply)
       if reply_handler != nil
-        @j_del.reply(reply, InternalHandler.new(reply_handler))
+        if timeout != nil
+          @j_del.reply_with_timeout reply, timeout, AsyncInternalHandler.new(reply_handler)
+        else
+          @j_del.reply(reply, InternalHandler.new(reply_handler))
+        end
       else
         @j_del.reply(reply)
       end
     end
 
+    # Gets the address the message was sent to
+    # @return [String] The recipient's address
+    def address
+      @j_del.address
+    end
+
+    def fail(failure_code, message)
+      @j_del.fail failure_code, message
+    end
+
   end
 
-end
 
+  # Error when the event bus use timeout and doesn't reply in time
+  # Copied from mod-lang-jython
+  class ReplyError
+
+    TIMEOUT = 0
+    NO_HANDLERS = 1
+    RECIPIENT_FAILURE = 2
+
+    def initialize(exception)
+      @exception = exception
+    end
+    def type
+      @exception.failureType().toInt()
+    end
+  end
+
+  # Copied from mod-lang-jython
+  class AsyncInternalHandler
+    include org.vertx.java.core.AsyncResultHandler
+    def initialize(hndlr)
+      @hndlr = hndlr
+    end
+    def handle(result)
+      if result.failed?
+        @hndlr.call(ReplyError.new(result.cause))
+      else
+        @hndlr.call(Message.new(result.result))
+      end
+    end
+  end
+end