websocket-driver 0.6.5-java → 0.7.4-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dcd1cd3f4fbfa7dcdcd3ec1a5190165abc4072bb
-  data.tar.gz: 71104f9f20b82cbd2677ed13cdeb9c71790a26aa
+SHA256:
+  metadata.gz: cd9397ef6b3c46b55d4f5809f8b359f261b983f5a29442d6cbb9791fb40761d8
+  data.tar.gz: 871848fa7118981c4543d4533f4a0a845ff848b5da639e42f16f7f5f6762231a
 SHA512:
-  metadata.gz: 7bfe24e050a4f5b342328af911fbdfe260c0e22ec933f2b56bae8657dc50a08ce77c6c3622be18432dc0da44a9eb2be67df494402c9736029864a10f0725ea6f
-  data.tar.gz: bb1f533ae8da678e7d81142fdc65a4d38e4835782b859183919ed97568636e58c2f1feb289b0e40ce67e7469a0990bd42297fb19680dbcebd9ee07ae38b045d3
+  metadata.gz: 1d9b3b03d2ada8d5757d7a2ea189097a2b31b4ffbd980317d88176826aa77db2be291a89d8280533d3e3f79c46997d157c540a2d2ef77f3a80c2d00b5bd7965c
+  data.tar.gz: f87b7664488e57fc8e976809b6554dd05cac016961fef21efa7331917bb247be14f24dbe4642ae909e295d1c61dedb5a5e42d44d298b10921acbd3bf4aa69293

data/CHANGELOG.md

@@ -1,123 +1,152 @@
+### 0.7.4 / 2021-05-24
+
+- Optimise conversions between strings and byte arrays and related encoding
+  operations, to reduce amount of allocation and copying
+
+### 0.7.3 / 2020-07-09
+
+- Let the client accept HTTP responses that have an empty reason phrase
+  following the `101` status code
+
+### 0.7.2 / 2020-05-22
+
+- Emit `ping` and `pong` events from the `Server` driver
+- Handle draft-76 handshakes correctly if the request's body is a frozen string
+
+### 0.7.1 / 2019-06-10
+
+- Catch any exceptions produced while generating a handshake response and send a
+  `400 Bad Request` response to the client
+- Pick the RFC-6455 protocol version if the request contains any of the headers
+  used by that version
+- Handle errors encountered while handling malformed draft-76 requests
+- Change license from MIT to Apache 2.0
+
+### 0.7.0 / 2017-09-11
+
+- Add `ping` and `pong` to the set of events users can listen to
+
 ### 0.6.5 / 2017-01-22
 
-* Provide a pure-Ruby fallback for the native unmasking code
+- Provide a pure-Ruby fallback for the native unmasking code
 
 ### 0.6.4 / 2016-05-20
 
-* Amend warnings issued when running with -W2
-* Make sure message strings passed in by the app are transcoded to UTF-8
-* Copy strings if necessary for frozen-string compatibility
+- Amend warnings issued when running with -W2
+- Make sure message strings passed in by the app are transcoded to UTF-8
+- Copy strings if necessary for frozen-string compatibility
 
 ### 0.6.3 / 2015-11-06
 
-* Reject draft-76 handshakes if their Sec-WebSocket-Key headers are invalid
-* Throw a more helpful error if a client is created with an invalid URL
+- Reject draft-76 handshakes if their Sec-WebSocket-Key headers are invalid
+- Throw a more helpful error if a client is created with an invalid URL
 
 ### 0.6.2 / 2015-07-18
 
-* When the peer sends a close frame with no error code, emit 1000
+- When the peer sends a close frame with no error code, emit 1000
 
 ### 0.6.1 / 2015-07-13
 
-* Fix how events are stored in `EventEmitter` to fix a backward-compatibility
+- Fix how events are stored in `EventEmitter` to fix a backward-compatibility
   violation introduced in the last release
-* Use the `Array#pack` and `String#unpack` methods for reading/writing numbers
+- Use the `Array#pack` and `String#unpack` methods for reading/writing numbers
   to buffers rather than including duplicate logic for this
 
 ### 0.6.0 / 2015-07-08
 
-* Use `SecureRandom` to generate the `Sec-WebSocket-Key` header
-* Allow the parser to recover cleanly if event listeners raise an error
-* Let the `on()` method take a lambda as a positional argument rather than a block
-* Add a `pong` method for sending unsolicited pong frames
+- Use `SecureRandom` to generate the `Sec-WebSocket-Key` header
+- Allow the parser to recover cleanly if event listeners raise an error
+- Let the `on()` method take a lambda as a positional argument rather than a
+  block
+- Add a `pong` method for sending unsolicited pong frames
 
 ### 0.5.4 / 2015-03-29
 
-* Don't emit extra close frames if we receive a close frame after we already
+- Don't emit extra close frames if we receive a close frame after we already
   sent one
-* Fail the connection when the driver receives an invalid
+- Fail the connection when the driver receives an invalid
   `Sec-WebSocket-Extensions` header
 
 ### 0.5.3 / 2015-02-22
 
-* Don't treat incoming data as WebSocket frames if a client driver is closed
+- Don't treat incoming data as WebSocket frames if a client driver is closed
   before receiving the server handshake
 
 ### 0.5.2 / 2015-02-19
 
-* Don't emit multiple `error` events
+- Don't emit multiple `error` events
 
 ### 0.5.1 / 2014-12-18
 
-* Don't allow drivers to be created with unrecognized options
+- Don't allow drivers to be created with unrecognized options
 
 ### 0.5.0 / 2014-12-13
 
-* Support protocol extensions via the websocket-extensions module
+- Support protocol extensions via the websocket-extensions module
 
 ### 0.4.0 / 2014-11-08
 
-* Support connection via HTTP proxies using `CONNECT`
+- Support connection via HTTP proxies using `CONNECT`
 
 ### 0.3.5 / 2014-10-04
 
-* Fix bug where the `Server` driver doesn't pass `ping` callbacks to its
+- Fix bug where the `Server` driver doesn't pass `ping` callbacks to its
   delegate
-* Fix an arity error when calling `fail_request`
-* Allow `close` to be called before `start` to close the driver
+- Fix an arity error when calling `fail_request`
+- Allow `close` to be called before `start` to close the driver
 
 ### 0.3.4 / 2014-07-06
 
-* Don't hold references to frame buffers after a message has been emitted
-* Make sure that `protocol` and `version` are exposed properly by the TCP driver
-* Correct HTTP header parsing based on RFC 7230; header names cannot contain
+- Don't hold references to frame buffers after a message has been emitted
+- Make sure that `protocol` and `version` are exposed properly by the TCP driver
+- Correct HTTP header parsing based on RFC 7230; header names cannot contain
   backslashes
 
 ### 0.3.3 / 2014-04-24
 
-* Fix problems with loading C and Java native extension code
-* Correct the acceptable characters used in the HTTP parser
-* Correct the draft-76 status line reason phrase
+- Fix problems with loading C and Java native extension code
+- Correct the acceptable characters used in the HTTP parser
+- Correct the draft-76 status line reason phrase
 
 ### 0.3.2 / 2013-12-29
 
-* Expand `max_length` to cover sequences of continuation frames and
+- Expand `max_length` to cover sequences of continuation frames and
   `draft-{75,76}`
-* Decrease default maximum frame buffer size to 64MB
-* Stop parsing when the protocol enters a failure mode, to save CPU cycles
+- Decrease default maximum frame buffer size to 64MB
+- Stop parsing when the protocol enters a failure mode, to save CPU cycles
 
 ### 0.3.1 / 2013-12-03
 
-* Add a `max_length` option to limit allowed frame size
+- Add a `max_length` option to limit allowed frame size
 
 ### 0.3.0 / 2013-09-09
 
-* Support client URLs with Basic Auth credentials
+- Support client URLs with Basic Auth credentials
 
 ### 0.2.3 / 2013-08-04
 
-* Fix bug in EventEmitter#emit when listeners are removed
+- Fix bug in EventEmitter#emit when listeners are removed
 
 ### 0.2.2 / 2013-08-04
 
-* Fix bug in EventEmitter#listener_count for unregistered events
+- Fix bug in EventEmitter#listener_count for unregistered events
 
 ### 0.2.1 / 2013-07-05
 
-* Queue sent messages if the client has not begun trying to connect
-* Encode all strings sent to I/O as `ASCII-8BIT`
+- Queue sent messages if the client has not begun trying to connect
+- Encode all strings sent to I/O as `ASCII-8BIT`
 
 ### 0.2.0 / 2013-05-12
 
-* Add API for setting and reading headers
-* Add Driver.server() method for getting a driver for TCP servers
+- Add API for setting and reading headers
+- Add Driver.server() method for getting a driver for TCP servers
 
 ### 0.1.0 / 2013-05-04
 
-* First stable release
+- First stable release
 
 ### 0.0.0 / 2013-04-22
 
-* First release
-* Proof of concept for people to try out
-* Might be unstable
+- First release
+- Proof of concept for people to try out
+- Might be unstable

data/LICENSE.md

@@ -1,22 +1,12 @@
-# License
+Copyright 2010-2021 James Coglan
 
-(The MIT License)
+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
 
-Copyright (c) 2010-2017 James Coglan
+    http://www.apache.org/licenses/LICENSE-2.0
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the 'Software'), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+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.

data/README.md

@@ -1,4 +1,4 @@
-# websocket-driver [![Build Status](https://travis-ci.org/faye/websocket-driver-ruby.svg)](https://travis-ci.org/faye/websocket-driver-ruby)
+# websocket-driver
 
 This module provides a complete implementation of the WebSocket protocols that
 can be hooked up to any TCP library. It aims to simplify things by decoupling
@@ -10,21 +10,21 @@ pluggable I/O.
 Due to this design, you get a lot of things for free. In particular, if you hook
 this module up to some I/O object, it will do all of this for you:
 
-* Select the correct server-side driver to talk to the client
-* Generate and send both server- and client-side handshakes
-* Recognize when the handshake phase completes and the WS protocol begins
-* Negotiate subprotocol selection based on `Sec-WebSocket-Protocol`
-* Negotiate and use extensions via the
+- Select the correct server-side driver to talk to the client
+- Generate and send both server- and client-side handshakes
+- Recognize when the handshake phase completes and the WS protocol begins
+- Negotiate subprotocol selection based on `Sec-WebSocket-Protocol`
+- Negotiate and use extensions via the
   [websocket-extensions](https://github.com/faye/websocket-extensions-ruby)
   module
-* Buffer sent messages until the handshake process is finished
-* Deal with proxies that defer delivery of the draft-76 handshake body
-* Notify you when the socket is open and closed and when messages arrive
-* Recombine fragmented messages
-* Dispatch text, binary, ping, pong and close frames
-* Manage the socket-closing handshake process
-* Automatically reply to ping frames with a matching pong
-* Apply masking to messages sent by the client
+- Buffer sent messages until the handshake process is finished
+- Deal with proxies that defer delivery of the draft-76 handshake body
+- Notify you when the socket is open and closed and when messages arrive
+- Recombine fragmented messages
+- Dispatch text, binary, ping, pong and close frames
+- Manage the socket-closing handshake process
+- Automatically reply to ping frames with a matching pong
+- Apply masking to messages sent by the client
 
 This library was originally extracted from the [Faye](http://faye.jcoglan.com)
 project but now aims to provide simple WebSocket support for any Ruby server or
@@ -43,12 +43,12 @@ $ gem install websocket-driver
 To build either a server-side or client-side socket, the only requirement is
 that you supply a `socket` object with these methods:
 
-* `socket.url` - returns the full URL of the socket as a string.
-* `socket.write(string)` - writes the given string to a TCP stream.
+- `socket.url` - returns the full URL of the socket as a string.
+- `socket.write(string)` - writes the given string to a TCP stream.
 
 Server-side sockets require one additional method:
 
-* `socket.env` - returns a Rack-style env hash that will contain some of the
+- `socket.env` - returns a Rack-style env hash that will contain some of the
   following fields. Their values are strings containing the value of the named
   header, unless stated otherwise.
   * `HTTP_CONNECTION`
@@ -150,7 +150,16 @@ module Connection
       if WebSocket::Driver.websocket?(@driver.env)
         @driver.start
       else
-        # handle other HTTP requests
+        # handle other HTTP requests, for example
+        body = '<h1>hello</h1>'
+        response = [
+          'HTTP/1.1 200 OK',
+          'Content-Type: text/plain',
+          "Content-Length: #{body.bytesize}",
+          '',
+          body
+        ]
+        send_data response.join("\r\n")
       end
     end
 
@@ -193,8 +202,8 @@ and send outgoing data.
 Client drivers have two additional methods for reading the HTTP data that was
 sent back by the server:
 
-* `driver.status` - the integer value of the HTTP status code
-* `driver.headers` - a hash-like object containing the response headers
+- `driver.status` - the integer value of the HTTP status code
+- `driver.headers` - a hash-like object containing the response headers
 
 
 ### HTTP Proxies
@@ -261,9 +270,9 @@ frames.
 The `options` argument is optional, and is a hash. It may contain the following
 keys:
 
-* `:max_length` - the maximum allowed size of incoming message frames, in bytes.
+- `:max_length` - the maximum allowed size of incoming message frames, in bytes.
   The default value is `2^26 - 1`, or 1 byte short of 64 MiB.
-* `:protocols` - an array of strings representing acceptable subprotocols for
+- `:protocols` - an array of strings representing acceptable subprotocols for
   use over the socket. The driver will negotiate one of these to use via the
   `Sec-WebSocket-Protocol` header if supported by the other peer.
 
@@ -274,27 +283,38 @@ Note that most of these methods are commands: if they produce data that should
 be sent over the socket, they will give this to you by calling
 `socket.write(string)`.
 
-#### `driver.on :open, -> (event) { }`
+#### `driver.on :open, -> (event) {}`
 
 Adds a callback block to execute when the socket becomes open.
 
-#### `driver.on :message, -> (event) { }`
+#### `driver.on :message, -> (event) {}`
 
 Adds a callback block to execute when a message is received. `event` will have a
 `data` attribute containing either a string in the case of a text message or an
 array of integers in the case of a binary message.
 
-#### `driver.on :error, -> (event) { }`
+#### `driver.on :error, -> (event) {}`
 
 Adds a callback to execute when a protocol error occurs due to the other peer
 sending an invalid byte sequence. `event` will have a `message` attribute
 describing the error.
 
-#### `driver.on :close, -> (event) { }`
+#### `driver.on :close, -> (event) {}`
 
 Adds a callback block to execute when the socket becomes closed. The `event`
 object has `code` and `reason` attributes.
 
+#### `driver.on :ping, -> (event) {}`
+
+Adds a callback block to execute when a ping is received. You do not need to
+handle this by sending a pong frame yourself; the driver handles this for you.
+
+#### `driver.on :pong, -> (event) {}`
+
+Adds a callback block to execute when a pong is received. If this was in
+response to a ping you sent, you can also handle this event via the
+`driver.ping(message) { ... }` callback.
+
 #### `driver.add_extension(extension)`
 
 Registers a protocol extension whose operation will be negotiated via the

data/ext/websocket-driver/WebsocketMaskService.java

@@ -1,8 +1,6 @@
 package com.jcoglan.websocket;
 
-import java.lang.Long;
 import java.io.IOException;
-
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.RubyModule;
@@ -15,41 +13,45 @@ import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.load.BasicLibraryService;
 
 public class WebsocketMaskService implements BasicLibraryService {
-  private Ruby runtime;
+    private Ruby runtime;
 
-  public boolean basicLoad(Ruby runtime) throws IOException {
-    this.runtime = runtime;
-    RubyModule websocket = runtime.defineModule("WebSocket");
+    public boolean basicLoad(Ruby runtime) throws IOException {
+        this.runtime = runtime;
 
-    RubyClass webSocketMask = websocket.defineClassUnder("Mask", runtime.getObject(), new ObjectAllocator() {
-      public IRubyObject allocate(Ruby runtime, RubyClass rubyClass) {
-        return new WebsocketMask(runtime, rubyClass);
-      }
-    });
+        RubyModule websocket = runtime.defineModule("WebSocket");
+        RubyClass webSocketMask = websocket.defineClassUnder("Mask", runtime.getObject(), getAllocator());
 
-    webSocketMask.defineAnnotatedMethods(WebsocketMask.class);
-    return true;
-  }
+        webSocketMask.defineAnnotatedMethods(WebsocketMask.class);
+        return true;
+    }
 
-  public class WebsocketMask extends RubyObject {
-    public WebsocketMask(final Ruby runtime, RubyClass rubyClass) {
-      super(runtime, rubyClass);
+    ObjectAllocator getAllocator() {
+        return new ObjectAllocator() {
+            public IRubyObject allocate(Ruby runtime, RubyClass rubyClass) {
+                return new WebsocketMask(runtime, rubyClass);
+            }
+        };
     }
 
-    @JRubyMethod
-    public IRubyObject mask(ThreadContext context, IRubyObject payload, IRubyObject mask) {
-      if (mask.isNil()) return payload;
+    public class WebsocketMask extends RubyObject {
+        public WebsocketMask(final Ruby runtime, RubyClass rubyClass) {
+            super(runtime, rubyClass);
+        }
+
+        @JRubyMethod
+        public IRubyObject mask(ThreadContext context, IRubyObject payload, IRubyObject mask) {
+            if (mask.isNil()) return payload;
 
-      byte[] payload_a = ((RubyString)payload).getBytes();
-      byte[] mask_a    = ((RubyString)mask).getBytes();
-      int i, n         = payload_a.length;
+            byte[] payload_a = ((RubyString)payload).getBytes();
+            byte[] mask_a    = ((RubyString)mask).getBytes();
+            int i, n         = payload_a.length;
 
-      if (n == 0) return payload;
+            if (n == 0) return payload;
 
-      for (i = 0; i < n; i++) {
-        payload_a[i] ^= mask_a[i % 4];
-      }
-      return RubyString.newStringNoCopy(runtime, payload_a);
+            for (i = 0; i < n; i++) {
+                payload_a[i] ^= mask_a[i % 4];
+            }
+            return RubyString.newStringNoCopy(runtime, payload_a);
+        }
     }
-  }
 }