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

data/lib/core/sock_js.rb

@@ -1,116 +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'
-module Vertx
-
-  # This is an implementation of the server side part of {"https://github.com/sockjs"}
-  #
-  # SockJS enables browsers to communicate with the server using a simple WebSocket-like api for sending
-  # and receiving messages. Under the bonnet SockJS chooses to use one of several protocols depending on browser
-  # capabilities and what appears to be working across the network.
-  #
-  # Available protocols include:
-  #
-  # WebSockets
-  # xhr-polling
-  # xhr-streaming
-  # json-polling
-  # event-source
-  # html-file
-  #
-  # This means, it should just work irrespective of what browser is being used, and whether there are nasty
-  # things like proxies and load balancers between the client and the server.
-  #
-  # For more detailed information on SockJS, see their website.
-  #
-  # On the server side, you interact using instances of {SockJSSocket} - this allows you to send data to the
-  # client or receive data via the {ReadStream#data_handler}.
-  #
-  # You can register multiple applications with the same SockJSServer, each using different path prefixes, each
-  # application will have its own handler, and configuration is described in a Hash.
-  #
-  # @author {http://tfox.org Tim Fox}
-  class SockJSServer
-
-    # Create a new SockJSServer
-    # @param http_server [HttpServer] You must pass in an instance of {HttpServer}
-    def initialize(http_server)
-      @j_server = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.createSockJSServer(http_server._to_java_server)
-    end
-
-    # Install an application
-    # @param config [Hash] Configuration for the application
-    # @param proc [Proc] Proc representing the handler
-    # @param hndlr [Block] Handler to call when a new {SockJSSocket is created}
-    def install_app(config, proc = nil, &hndlr)
-      hndlr = proc if proc
-      j_config = org.vertx.java.core.json.JsonObject.new(config)
-      @j_server.installApp(j_config) { |j_sock|
-        hndlr.call(SockJSSocket.new(j_sock))
-      }
-      self
-    end
-
-    def bridge(config, inbound_permitted, outbound_permitted, auth_timeout = 5 * 60 * 1000, auth_address = nil)
-      j_inbound_permitted = org.vertx.java.core.json.JsonArray.new(inbound_permitted)
-      j_outbound_permitted = org.vertx.java.core.json.JsonArray.new(outbound_permitted)
-      @j_server.bridge(org.vertx.java.core.json.JsonObject.new(config), j_inbound_permitted,
-                       j_outbound_permitted, auth_timeout, auth_address)
-      self
-    end
-
-  end
-
-  # You interact with SockJS clients through instances of SockJS socket.
-  # The API is very similar to {WebSocket}. It implements both
-  # {ReadStream} and {WriteStream} so it can be used with {Pump} to enable
-  # flow control.
-  #
-  # @author {http://tfox.org Tim Fox}
-  class SockJSSocket
-
-    include ReadStream, WriteStream
-
-    # @private
-    def initialize(j_sock)
-      @j_del = j_sock
-      @handler_id = EventBus.register_simple_handler { |msg|
-        write(msg.body)
-      }
-    end
-
-    # Close the socket
-    def close
-      EventBus.unregister_handler(@handler_id)
-      @j_del.close
-    end
-
-    # When a SockJSSocket is created it automatically registers an event handler with the system, the ID of that
-    # handler is given by {#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 SockJSSockets which are owned by different event loops.
-    def handler_id
-      @handler_id
-    end
-
-    # @private
-    def _to_java_socket
-      @j_del
-    end
-
-  end
-
-end

data/lib/core/ssl_support.rb

@@ -1,163 +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 mixin module allowing SSL attributes to be set on classes
-  #
-  # @author {http://tfox.org Tim Fox}
-  module SSLSupport
-
-    # Set whether the server or client will use SSL.
-    # @param [Boolean] val. If true then ssl will be used.
-    # @return [] self. So multiple invocations can be chained.
-    def ssl=(val)
-      @j_del.setSSL(val)
-      self
-    end
-
-    # Set or get ssl for fluent API
-    def ssl(ssl = nil)
-      if ssl
-        @j_del.setSSL(ssl)
-        self
-      else
-        @j_del.isSSL
-      end
-    end
-
-    # Set the path to the SSL key store. This method should only be used with the client/server in SSL mode, i.e. after {#ssl=}
-    # has been set to true.
-    # The SSL key store is a standard Java Key Store, and should contain the client/server certificate. For a client, it's only necessary to supply
-    # a client key store if the server requires client authentication via client certificates.
-    # @param [String] val. The path to the key store
-    # @return [] self. So multiple invocations can be chained.
-    def key_store_path=(val)
-      @j_del.setKeyStorePath(val)
-      self
-    end
-
-    # Set or get key store path for fluent API
-    def key_store_path(path = nil)
-      if path
-        @j_del.setKeyStorePath(path)
-        self
-      else
-        @j_del.getKeyStorePath
-      end
-    end
-
-    # Set the password for the SSL key store. This method should only be used with the client in SSL mode, i.e. after {#ssl=}
-    # has been set to true.
-    # @param [String] val. The password.
-    # @return [] self. So multiple invocations can be chained.
-    def key_store_password=(val)
-      @j_del.setKeyStorePassword(val)
-      self
-    end
-
-    # Set or get key store password for fluent API
-    def key_store_password(password = nil)
-      if password
-        @j_del.setKeyStorePassword(password)
-        self
-      else
-        @j_del.getKeyStorePassword
-      end
-    end
-
-    # Set the path to the SSL trust store. This method should only be used with the client/server in SSL mode, i.e. after {#ssl=}
-    # has been set to true.
-    # The SSL trust store is a standard Java Key Store, and should contain the certificate(s) of the clients/servers that the server/client trusts. The SSL
-    # handshake will fail if the server provides a certificate that the client does not trust, or if client authentication is used,
-    # if the client provides a certificate the server does not trust.<p>
-    # @param [String] val. The path to the trust store
-    # @return [] self. So multiple invocations can be chained.
-    def trust_store_path=(val)
-      @j_del.setTrustStorePath(val)
-      self
-    end
-
-    # Set or get trust store path for fluent API
-    def trust_store_path(path = nil)
-      if path
-        @j_del.setTrustStorePath(path)
-        self
-      else
-        @j_del.getTrustStorePath
-      end
-    end
-
-    # Set the password for the SSL trust store. This method should only be used with the client in SSL mode, i.e. after {#ssl=}
-    # has been set to true.
-    # @param [String] val. The password.
-    # @return [] self. So multiple invocations can be chained.
-    def trust_store_password=(val)
-      @j_del.setTrustStorePassword(val)
-      self
-    end
-
-    # Set or get trust store password for fluent API
-    def trust_store_password(password = nil)
-      if password
-        @j_del.setTrustStorePassword(password)
-        self
-      else
-        @j_del.getTrustStorePassword
-      end
-    end
-
-  end
-
-  # A mixin module allowing Server SSL attributes to be set on classes
-  #
-  # @author {http://tfox.org Tim Fox}
-  module ServerSSLSupport
-
-    def client_auth_required=(val)
-      @j_del.setClientAuthRequired(val)
-      self
-    end
-
-    def client_auth_required(val = nil)
-      if val
-        @j_del.setClientAuthRequired(val)
-        self
-      else
-        @j_del.isClientAuthRequired
-      end
-    end
-  end
-
-  # A mixin module allowing Client SSL attributes to be set on classes
-  #
-  # @author {http://tfox.org Tim Fox}
-  module ClientSSLSupport
-
-    def trust_all=(val)
-      @j_del.setTrustAll(val)
-      self
-    end
-
-    def trust_all(val = nil)
-      if val
-        @j_del.setTrustAll(val)
-        self
-      else
-        @j_del.isTrustAll
-      end
-    end
-  end
-end

data/lib/core/streams.rb

@@ -1,183 +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
-
-  module DrainSupport
-
-    # Set the maximum size of the write queue. You will still be able to write to the stream even
-    # if there is more data than this in the write queue. This is used as an indicator by classes such as
-    # {Pump} to provide flow control.
-    # @param [FixNum] size. The maximum size, in bytes.
-    def write_queue_max_size=(size)
-      @j_del.setWriteQueueMaxSize(size)
-    end
-
-    # For a fluent API
-    def write_queue_max_size(size)
-      @j_del.setWriteQueueMaxSize(size)
-      self
-    end
-
-    # Is the write queue full?
-    # @return [Boolean] true if there are more bytes in the write queue than the max write queue size.
-    def write_queue_full?
-      @j_del.writeQueueFull
-    end
-
-    # Set a drain handler on the stream. If the write queue is full, then the handler will be called when the write
-    # queue has been reduced to maxSize / 2. See {Pump} for an example of this being used.
-    # @param [Block] hndlr. The drain handler
-    def drain_handler(&hndlr)
-      @j_del.drainHandler(hndlr)
-      self
-    end
-
-    # Set an exception handler on the stream.
-    # @param [Block] hndlr. The exception handler
-    def exception_handler(&hndlr)
-      @j_del.exceptionHandler(hndlr)
-      self
-    end
-  end
-
-  # A mixin module which represents a stream of data that can be written to.
-  #
-  # Any class that mixes in this module can be used by a {Pump} to pump data from a {ReadStream} to it.
-  #
-  # @author {http://tfox.org Tim Fox}
-  module WriteStream
-
-    include DrainSupport
-
-    # Write some data to the stream. The data is put on an internal write queue, and the write actually happens
-    # asynchronously. To avoid running out of memory by putting too much on the write queue,
-    # check the {#write_queue_full?} method before writing. This is done automatically if using a {Pump}.
-    # @param [Buffer]. The buffer to write.
-    def write(buff)
-      @j_del.write(buff._to_java_buffer)
-      self
-    end
-
-    # @private
-    def _to_write_stream
-      @j_del
-    end
-
-  end
-
-
-  module ReadSupport
-
-    # 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_buff|
-        hndlr.call(Buffer.new(j_buff))
-      })
-      self
-    end
-
-    # Pause the ReadStream. After calling this, the ReadStream will aim to send no more data to the {#data_handler}
-    def pause
-      @j_del.pause
-      self
-    end
-
-    # Resume reading. If the ReadStream has been paused, reading will recommence on it.
-    def resume
-      @j_del.resume
-      self
-    end
-
-    # Set an execption handler on the stream.
-    # @param [Block] hndlr. The exception handler
-    def exception_handler(&hndlr)
-      @j_del.exceptionHandler(hndlr)
-      self
-    end
-  end
-
-  # A mixin module which represents a stream of data that can be read from.
-  #
-  # Any class that mixes in this module can be used by a {Pump} to pump data from a {ReadStream} to it.
-  #
-  # @author {http://tfox.org Tim Fox}
-  module ReadStream
-
-    include ReadSupport
-
-    # Set an end handler on the stream. Once the stream has ended, and there is no more data to be read, this handler will be called.
-    # @param [Block] hndlr. The exception handler
-    def end_handler(&hndlr)
-      @j_del.endHandler(hndlr)
-      self
-    end
-
-    # @private
-    def _to_read_stream
-      @j_del
-    end
-
-  end
-
-  # Pumps data from a {ReadStream} to a {WriteStream} and performs flow control where necessary to
-  # prevent the write stream from getting overloaded.
-  #
-  # Instances of this class read bytes from a ReadStream and write them to a WriteStream. If data
-  # can be read faster than it can be written this could result in the write queue of the WriteStream growing
-  # without bound, eventually causing it to exhaust all available RAM.
-  # To prevent this, after each write, instances of this class check whether the write queue of the WriteStream
-  # is full, and if so, the ReadStream is paused, and a {WriteStream#drain_handler} is set on the WriteStream.
-  # When the WriteStream has processed half of its backlog, the drain_handler will be called,
-  # which results in the pump resuming the ReadStream.
-  #
-  # This class can be used to pump from any {ReadStream} to any { WriteStream},
-  # e.g. from an {HttpServerRequest} to an {AsyncFile}, or from {NetSocket} to a {WebSocket}.
-  #
-  # @author {http://tfox.org Tim Fox}
-  class Pump
-    def initialize(read_stream, write_stream)
-      raise "read_stream is not a ReadStream" if !read_stream.is_a? ReadStream
-      raise "write_stream is not a WriteStream" if !write_stream.is_a? WriteStream
-      j_rs = read_stream._to_read_stream
-      j_ws = write_stream._to_write_stream
-      @j_pump = org.vertx.java.core.streams.Pump.createPump(j_rs, j_ws)
-    end
-
-    # Set the write queue max size
-    # @param [FixNum] The write queue max size
-    def write_queue_max_size=(val)
-      @j_pump.setWriteQueueMaxSize(val)
-      self
-    end
-
-    # Start the Pump. The Pump can be started and stopped multiple times.
-    def start
-      @j_pump.start
-      self
-    end
-
-    # Stop the Pump. The Pump can be started and stopped multiple times.
-    def stop
-      @j_pump.stop
-      self
-    end
-
-    # @return [FixNum] Return the total number of bytes pumped by this pump.
-    def bytes_pumped
-      @j_pump.bytesPumped
-    end
-  end
-end