/** * Apache License * Version 2.0, January 2004 * http://www.apache.org/licenses/ * * TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION * * 1. Definitions. * * "License" shall mean the terms and conditions for use, reproduction, * and distribution as defined by Sections 1 through 9 of this document. * * "Licensor" shall mean the copyright owner or entity authorized by * the copyright owner that is granting the License. * * "Legal Entity" shall mean the union of the acting entity and all * other entities that control, are controlled by, or are under common * control with that entity. For the purposes of this definition, * "control" means (i) the power, direct or indirect, to cause the * direction or management of such entity, whether by contract or * otherwise, or (ii) ownership of fifty percent (50%) or more of the * outstanding shares, or (iii) beneficial ownership of such entity. * * "You" (or "Your") shall mean an individual or Legal Entity * exercising permissions granted by this License. * * "Source" form shall mean the preferred form for making modifications, * including but not limited to software source code, documentation * source, and configuration files. * * "Object" form shall mean any form resulting from mechanical * transformation or translation of a Source form, including but * not limited to compiled object code, generated documentation, * and conversions to other media types. * * "Work" shall mean the work of authorship, whether in Source or * Object form, made available under the License, as indicated by a * copyright notice that is included in or attached to the work * (an example is provided in the Appendix below). * * "Derivative Works" shall mean any work, whether in Source or Object * form, that is based on (or derived from) the Work and for which the * editorial revisions, annotations, elaborations, or other modifications * represent, as a whole, an original work of authorship. For the purposes * of this License, Derivative Works shall not include works that remain * separable from, or merely link (or bind by name) to the interfaces of, * the Work and Derivative Works thereof. * * "Contribution" shall mean any work of authorship, including * the original version of the Work and any modifications or additions * to that Work or Derivative Works thereof, that is intentionally * submitted to Licensor for inclusion in the Work by the copyright owner * or by an individual or Legal Entity authorized to submit on behalf of * the copyright owner. For the purposes of this definition, "submitted" * means any form of electronic, verbal, or written communication sent * to the Licensor or its representatives, including but not limited to * communication on electronic mailing lists, source code control systems, * and issue tracking systems that are managed by, or on behalf of, the * Licensor for the purpose of discussing and improving the Work, but * excluding communication that is conspicuously marked or otherwise * designated in writing by the copyright owner as "Not a Contribution." * * "Contributor" shall mean Licensor and any individual or Legal Entity * on behalf of whom a Contribution has been received by Licensor and * subsequently incorporated within the Work. * * 2. Grant of Copyright License. Subject to the terms and conditions of * this License, each Contributor hereby grants to You a perpetual, * worldwide, non-exclusive, no-charge, royalty-free, irrevocable * copyright license to reproduce, prepare Derivative Works of, * publicly display, publicly perform, sublicense, and distribute the * Work and such Derivative Works in Source or Object form. * * 3. Grant of Patent License. Subject to the terms and conditions of * this License, each Contributor hereby grants to You a perpetual, * worldwide, non-exclusive, no-charge, royalty-free, irrevocable * (except as stated in this section) patent license to make, have made, * use, offer to sell, sell, import, and otherwise transfer the Work, * where such license applies only to those patent claims licensable * by such Contributor that are necessarily infringed by their * Contribution(s) alone or by combination of their Contribution(s) * with the Work to which such Contribution(s) was submitted. If You * institute patent litigation against any entity (including a * cross-claim or counterclaim in a lawsuit) alleging that the Work * or a Contribution incorporated within the Work constitutes direct * or contributory patent infringement, then any patent licenses * granted to You under this License for that Work shall terminate * as of the date such litigation is filed. * * 4. Redistribution. You may reproduce and distribute copies of the * Work or Derivative Works thereof in any medium, with or without * modifications, and in Source or Object form, provided that You * meet the following conditions: * * (a) You must give any other recipients of the Work or * Derivative Works a copy of this License; and * * (b) You must cause any modified files to carry prominent notices * stating that You changed the files; and * * (c) You must retain, in the Source form of any Derivative Works * that You distribute, all copyright, patent, trademark, and * attribution notices from the Source form of the Work, * excluding those notices that do not pertain to any part of * the Derivative Works; and * * (d) If the Work includes a "NOTICE" text file as part of its * distribution, then any Derivative Works that You distribute must * include a readable copy of the attribution notices contained * within such NOTICE file, excluding those notices that do not * pertain to any part of the Derivative Works, in at least one * of the following places: within a NOTICE text file distributed * as part of the Derivative Works; within the Source form or * documentation, if provided along with the Derivative Works; or, * within a display generated by the Derivative Works, if and * wherever such third-party notices normally appear. The contents * of the NOTICE file are for informational purposes only and * do not modify the License. You may add Your own attribution * notices within Derivative Works that You distribute, alongside * or as an addendum to the NOTICE text from the Work, provided * that such additional attribution notices cannot be construed * as modifying the License. * * You may add Your own copyright statement to Your modifications and * may provide additional or different license terms and conditions * for use, reproduction, or distribution of Your modifications, or * for any such Derivative Works as a whole, provided Your use, * reproduction, and distribution of the Work otherwise complies with * the conditions stated in this License. * * 5. Submission of Contributions. Unless You explicitly state otherwise, * any Contribution intentionally submitted for inclusion in the Work * by You to the Licensor shall be under the terms and conditions of * this License, without any additional terms or conditions. * Notwithstanding the above, nothing herein shall supersede or modify * the terms of any separate license agreement you may have executed * with Licensor regarding such Contributions. * * 6. Trademarks. This License does not grant permission to use the trade * names, trademarks, service marks, or product names of the Licensor, * except as required for reasonable and customary use in describing the * origin of the Work and reproducing the content of the NOTICE file. * * 7. Disclaimer of Warranty. Unless required by applicable law or * agreed to in writing, Licensor provides the Work (and each * Contributor provides its Contributions) on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or * implied, including, without limitation, any warranties or conditions * of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A * PARTICULAR PURPOSE. You are solely responsible for determining the * appropriateness of using or redistributing the Work and assume any * risks associated with Your exercise of permissions under this License. * * 8. Limitation of Liability. In no event and under no legal theory, * whether in tort (including negligence), contract, or otherwise, * unless required by applicable law (such as deliberate and grossly * negligent acts) or agreed to in writing, shall any Contributor be * liable to You for damages, including any direct, indirect, special, * incidental, or consequential damages of any character arising as a * result of this License or out of the use or inability to use the * Work (including but not limited to damages for loss of goodwill, * work stoppage, computer failure or malfunction, or any and all * other commercial damages or losses), even if such Contributor * has been advised of the possibility of such damages. * * 9. Accepting Warranty or Additional Liability. While redistributing * the Work or Derivative Works thereof, You may choose to offer, * and charge a fee for, acceptance of support, warranty, indemnity, * or other liability obligations and/or rights consistent with this * License. However, in accepting such obligations, You may act only * on Your own behalf and on Your sole responsibility, not on behalf * of any other Contributor, and only if You agree to indemnify, * defend, and hold each Contributor harmless for any liability * incurred by, or claims asserted against, such Contributor by reason * of your accepting any such warranty or additional liability. * * END OF TERMS AND CONDITIONS * * APPENDIX: How to apply the Apache License to your work. * * To apply the Apache License to your work, attach the following * boilerplate notice, with the fields enclosed by brackets "{}" * replaced with your own identifying information. (Don't include * the brackets!) The text should be enclosed in the appropriate * comment syntax for the file format. We also recommend that a * file or class name and description of purpose be included on the * same "printed page" as the copyright notice for easier * identification within third-party archives. * * Copyright 2014 Edgar Espina * * 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. */ package org.jooby; import com.google.common.base.Preconditions; import com.google.inject.Key; import com.google.inject.TypeLiteral; import static java.util.Objects.requireNonNull; import org.jooby.internal.RouteMatcher; import org.jooby.internal.RoutePattern; import org.jooby.internal.WebSocketImpl; import org.slf4j.LoggerFactory; import javax.annotation.Nonnull; import javax.annotation.Nullable; import java.io.Closeable; import java.util.Map; import java.util.Optional; import java.util.Set; /** *

WebSockets

*

* Creating web sockets is pretty straightforward: *

* * 
 *  {
 *    ws("/", (ws) {@literal ->} {
 *      // connected
 *      ws.onMessage(message {@literal ->} {
 *        System.out.println(message.value());
 *        ws.send("Message Received");
 *      });
 *      ws.send("Connected");
 *    });
 *  }
 *
* * First thing you need to do is to register a new web socket in your App using the * {@link Jooby#ws(String, WebSocket.OnOpen1)} method. * You can specify a path to listen for web socket connection. The path can be a static path or * a path pattern (like routes). * * On new connections the {@link WebSocket.OnOpen1#onOpen(WebSocket)} will be executed from there * you can listen using the {@link #onMessage(OnMessage)}, {@link #onClose(OnClose)} or * {@link #onError(OnError)} events. * * Inside a handler you can send text or binary message. * *

mvc

*

* Starting from 1.1.0 is it possible to use a class as web socket listener (in * addition to the script web sockets supported). Your class must implement * {@link WebSocket#onMessage(OnMessage)}, like: *

* * 
{@code
 * @Path("/ws")
 * class MyHandler implements WebSocket.OnMessage {
 *
 *   private WebSocket ws;
 *
 *   @Inject
 *   public MyHandler(WebSocket ws) {
 *     this.ws = ws;
 *   }
 *
 *   @Override
 *   public void onMessage(String message) {
 *    ws.send("Got it!");
 *   }
 * }
 *
 * {
 *   ws(MyHandler.class);
 * }
 *
 * }
* *

* Optionally, your listener might implements the * {@link WebSocket.OnClose}, * {@link WebSocket.OnError} or {@link WebSocket.OnOpen} callbacks. Or if you want to * implement all them, then just {@link WebSocket.Handler} *

* *

data types

*

* If your web socket is suppose to send/received a specific data type, like: * json it is nice to define a consume and produce types: *

* * 
 *   ws("/", (ws) {@literal ->} {
 *     ws.onMessage(message {@literal ->} {
 *       // read as json
 *       MyObject object = message.to(MyObject.class);
 *     });
 *
 *     MyObject object = new MyObject();
 *     ws.send(object); // convert to text message using a json converter
 *   })
 *   .consumes(MediaType.json)
 *   .produces(MediaType.json);
 *
* *

* Or via annotations for mvc listeners: *

* * 
{@code
 *
 * @Consumes("json")
 * @Produces("json")
 * @Path("/ws")
 * class MyHandler implements WebSocket.OnMessage {
 *
 *   public void onMessage(MyObject message) {
 *     // ...
 *     ws.send(new ResponseObject());
 *   }
 *
 * }
 * }
* *

* The message MyObject will be processed by a json parser and the * response object will be renderered as json too. *

* * @author edgar * @since 0.1.0 */ public interface WebSocket extends Closeable, Registry { /** Websocket key. */ Key> KEY = Key.get(new TypeLiteral>() { }); /** * A web socket connect handler. Executed every time a new client connect to the socket. * * @author edgar * @since 0.1.0 */ interface OnOpen { /** * Inside a connect event, you can listen for {@link WebSocket#onMessage(OnMessage)}, * {@link WebSocket#onClose(OnClose)} or {@link WebSocket#onError(OnError)} events. * * Also, you can send text and binary message. * * @param req Current request. * @param ws A web socket. * @throws Exception If something goes wrong while connecting. */ void onOpen(Request req, WebSocket ws) throws Exception; } /** * A web socket connect handler. Executed every time a new client connect to the socket. * * @author edgar * @since 0.1.0 */ interface OnOpen1 extends OnOpen { @Override default void onOpen(final Request req, final WebSocket ws) throws Exception { onOpen(ws); } /** * Inside a connect event, you can listen for {@link WebSocket#onMessage(OnMessage)}, * {@link WebSocket#onClose(OnClose)} or {@link WebSocket#onError(OnError)} events. * * Also, you can send text and binary message. * * @param ws A web socket. * @throws Exception If something goes wrong while connecting. */ void onOpen(WebSocket ws) throws Exception; } /** * Hold a status code and optionally a reason message for {@link WebSocket#close()} operations. * * @author edgar * @since 0.1.0 */ class CloseStatus { /** A status code. */ private final int code; /** A close reason. */ private final String reason; /** * Create a new {@link CloseStatus} instance. * * @param code the status code */ private CloseStatus(final int code) { this(code, null); } /** * Create a new {@link CloseStatus} instance. * * @param code the status code * @param reason the reason */ private CloseStatus(final int code, final String reason) { Preconditions.checkArgument((code >= 1000 && code < 5000), "Invalid code: %s", code); this.code = code; this.reason = reason == null || reason.isEmpty() ? null : reason; } /** * Creates a new {@link CloseStatus}. * * @param code A status code. * @return A new close status. */ public static CloseStatus of(final int code) { return new CloseStatus(code); } /** * Creates a new {@link CloseStatus}. * * @param code A status code. * @param reason A close reason. * @return A new close status. */ public static CloseStatus of(final int code, final String reason) { requireNonNull(reason, "A reason is required."); return new CloseStatus(code, reason); } /** * @return the status code. */ public int code() { return this.code; } /** * @return the reason or {@code null}. */ public String reason() { return this.reason; } @Override public String toString() { if (reason == null) { return code + ""; } return code + " (" + reason + ")"; } } /** * Web socket message callback. * * @author edgar * @since 0.1.0 * @param Param type. */ interface OnMessage { /** * Invoked from a web socket. * * @param message Client message. * @throws Exception If something goes wrong. */ void onMessage(T message) throws Exception; } interface OnClose { void onClose(CloseStatus status) throws Exception; } /** * Web socket success callback. * * @author edgar * @since 0.1.0 */ interface SuccessCallback { /** * Invoked from a web socket. * * @throws Exception If something goes wrong. */ void invoke() throws Exception; } /** * Web socket err callback. * * @author edgar * @since 0.1.0 */ interface OnError { /** * Invoked if something goes wrong. * * @param err Err cause. */ void onError(Throwable err); } /** * Configure a web socket. * * @author edgar * @since 0.1.0 */ class Definition { /** * A route compiled pattern. */ private RoutePattern routePattern; /** * Defines the media types that the methods of a resource class or can consumes. Default is: * {@literal *}/{@literal *}. */ private MediaType consumes = MediaType.plain; /** * Defines the media types that the methods of a resource class or can produces. Default is: * {@literal *}/{@literal *}. */ private MediaType produces = MediaType.plain; /** A path pattern. */ private String pattern; /** A ws handler. */ private OnOpen handler; /** * Creates a new {@link Definition}. * * @param pattern A path pattern. * @param handler A ws handler. */ public Definition(final String pattern, final OnOpen handler) { requireNonNull(pattern, "A route path is required."); requireNonNull(handler, "A handler is required."); this.routePattern = new RoutePattern("WS", pattern); // normalized pattern this.pattern = routePattern.pattern(); this.handler = handler; } /** * @return A route pattern. */ public String pattern() { return pattern; } /** * Test if the given path matches this web socket. * * @param path A path pattern. * @return A web socket or empty optional. */ public Optional matches(final String path) { RouteMatcher matcher = routePattern.matcher("WS" + path); if (matcher.matches()) { return Optional.of(asWebSocket(matcher)); } return Optional.empty(); } /** * Set the media types the route can consume. * * @param type The media types to test for. * @return This route definition. */ public Definition consumes(final String type) { return consumes(MediaType.valueOf(type)); } /** * Set the media types the route can consume. * * @param type The media types to test for. * @return This route definition. */ public Definition consumes(final MediaType type) { this.consumes = requireNonNull(type, "A type is required."); return this; } /** * Set the media types the route can produces. * * @param type The media types to test for. * @return This route definition. */ public Definition produces(final String type) { return produces(MediaType.valueOf(type)); } /** * Set the media types the route can produces. * * @param type The media types to test for. * @return This route definition. */ public Definition produces(final MediaType type) { this.produces = requireNonNull(type, "A type is required."); return this; } /** * @return All the types this route can consumes. */ public MediaType consumes() { return this.consumes; } /** * @return All the types this route can produces. */ public MediaType produces() { return this.produces; } @Override public boolean equals(final Object obj) { if (obj instanceof Definition) { Definition def = (Definition) obj; return this.pattern.equals(def.pattern); } return false; } @Override public int hashCode() { return pattern.hashCode(); } @Override public String toString() { StringBuilder buffer = new StringBuilder(); buffer.append("WS ").append(pattern()).append("\n"); buffer.append(" consume: ").append(consumes()).append("\n"); buffer.append(" produces: ").append(produces()).append("\n"); return buffer.toString(); } /** * Creates a new web socket. * * @param matcher A route matcher. * @return A new web socket. */ private WebSocket asWebSocket(final RouteMatcher matcher) { return new WebSocketImpl(handler, matcher.path(), pattern, matcher.vars(), consumes, produces); } } interface Handler extends OnClose, OnMessage, OnError, OnOpen { } /** Default success callback. */ SuccessCallback SUCCESS = () -> { }; /** Default err callback. */ OnError ERR = (ex) -> { LoggerFactory.getLogger(WebSocket.class).error("error while sending data", ex); }; /** * "1000 indicates a normal closure, meaning that the purpose for which the connection * was established has been fulfilled." */ CloseStatus NORMAL = new CloseStatus(1000, "Normal"); /** * "1001 indicates that an endpoint is "going away", such as a server going down or a * browser having navigated away from a page." */ CloseStatus GOING_AWAY = new CloseStatus(1001, "Going away"); /** * "1002 indicates that an endpoint is terminating the connection due to a protocol * error." */ CloseStatus PROTOCOL_ERROR = new CloseStatus(1002, "Protocol error"); /** * "1003 indicates that an endpoint is terminating the connection because it has * received a type of data it cannot accept (e.g., an endpoint that understands only * text data MAY send this if it receives a binary message)." */ CloseStatus NOT_ACCEPTABLE = new CloseStatus(1003, "Not acceptable"); /** * "1007 indicates that an endpoint is terminating the connection because it has * received data within a message that was not consistent with the type of the message * (e.g., non-UTF-8 [RFC3629] data within a text message)." */ CloseStatus BAD_DATA = new CloseStatus(1007, "Bad data"); /** * "1008 indicates that an endpoint is terminating the connection because it has * received a message that violates its policy. This is a generic status code that can * be returned when there is no other more suitable status code (e.g., 1003 or 1009) * or if there is a need to hide specific details about the policy." */ CloseStatus POLICY_VIOLATION = new CloseStatus(1008, "Policy violation"); /** * "1009 indicates that an endpoint is terminating the connection because it has * received a message that is too big for it to process." */ CloseStatus TOO_BIG_TO_PROCESS = new CloseStatus(1009, "Too big to process"); /** * "1010 indicates that an endpoint (client) is terminating the connection because it * has expected the server to negotiate one or more extension, but the server didn't * return them in the response message of the WebSocket handshake. The list of * extensions that are needed SHOULD appear in the /reason/ part of the Close frame. * Note that this status code is not used by the server, because it can fail the * WebSocket handshake instead." */ CloseStatus REQUIRED_EXTENSION = new CloseStatus(1010, "Required extension"); /** * "1011 indicates that a server is terminating the connection because it encountered * an unexpected condition that prevented it from fulfilling the request." */ CloseStatus SERVER_ERROR = new CloseStatus(1011, "Server error"); /** * "1012 indicates that the service is restarted. A client may reconnect, and if it * chooses to do, should reconnect using a randomized delay of 5 - 30s." */ CloseStatus SERVICE_RESTARTED = new CloseStatus(1012, "Service restarted"); /** * "1013 indicates that the service is experiencing overload. A client should only * connect to a different IP (when there are multiple for the target) or reconnect to * the same IP upon user action." */ CloseStatus SERVICE_OVERLOAD = new CloseStatus(1013, "Service overload"); /** * @return Current request path. */ @Nonnull String path(); /** * @return The currently matched pattern. */ @Nonnull String pattern(); /** * @return The currently matched path variables (if any). */ @Nonnull Map vars(); /** * @return The type this route can consumes, defaults is: {@code * / *}. */ @Nonnull MediaType consumes(); /** * @return The type this route can produces, defaults is: {@code * / *}. */ @Nonnull MediaType produces(); /** * Register a callback to execute when a new message arrive. * * @param callback A callback * @throws Exception If something goes wrong. */ void onMessage(OnMessage callback) throws Exception; /** * Register an error callback to execute when an error is found. * * @param callback A callback */ void onError(OnError callback); /** * Register an close callback to execute when client close the web socket. * * @param callback A callback * @throws Exception If something goes wrong. */ void onClose(OnClose callback) throws Exception; /** * Gracefully closes the connection, after sending a description message * * @param code Close status code. * @param reason Close reason. */ default void close(final int code, final String reason) { close(CloseStatus.of(code, reason)); } /** * Gracefully closes the connection, after sending a description message * * @param code Close status code. */ default void close(final int code) { close(CloseStatus.of(code)); } /** * Gracefully closes the connection, after sending a description message */ @Override default void close() { close(NORMAL); } /** * True if the websocket is still open. * * @return True if the websocket is still open. */ boolean isOpen(); /** * Gracefully closes the connection, after sending a description message * * @param status Close status code. */ void close(CloseStatus status); /** * Resume the client stream. */ void resume(); /** * Pause the client stream. */ void pause(); /** * Immediately shuts down the connection. * * @throws Exception If something goes wrong. */ void terminate() throws Exception; /** * Send data through the connection. * * If the web socket is closed this method throw an {@link Err} with {@link #NORMAL} close status. * * @param data Data to send. * @throws Exception If something goes wrong. */ default void send(final Object data) throws Exception { send(data, SUCCESS, ERR); } /** * Send data through the connection. * * If the web socket is closed this method throw an {@link Err} with {@link #NORMAL} close status. * * @param data Data to send. * @param success A success callback. * @throws Exception If something goes wrong. */ default void send(final Object data, final SuccessCallback success) throws Exception { send(data, success, ERR); } /** * Send data through the connection. * * If the web socket is closed this method throw an {@link Err} with {@link #NORMAL} close status. * * @param data Data to send. * @param err An err callback. * @throws Exception If something goes wrong. */ default void send(final Object data, final OnError err) throws Exception { send(data, SUCCESS, err); } /** * Send data through the connection. * * If the web socket is closed this method throw an {@link Err} with {@link #NORMAL} close status. * * @param data Data to send. * @param success A success callback. * @param err An err callback. * @throws Exception If something goes wrong. */ void send(Object data, SuccessCallback success, OnError err) throws Exception; /** * Send data to all connected sessions. * * If the web socket is closed this method throw an {@link Err} with {@link #NORMAL} close status. * * @param data Data to send. * @throws Exception If something goes wrong. */ default void broadcast(final Object data) throws Exception { broadcast(data, SUCCESS, ERR); } /** * Send data to all connected sessions. * * If the web socket is closed this method throw an {@link Err} with {@link #NORMAL} close status. * * @param data Data to send. * @param success A success callback. * @throws Exception If something goes wrong. */ default void broadcast(final Object data, final SuccessCallback success) throws Exception { broadcast(data, success, ERR); } /** * Send data to all connected sessions. * * If the web socket is closed this method throw an {@link Err} with {@link #NORMAL} close status. * * @param data Data to send. * @param err An err callback. * @throws Exception If something goes wrong. */ default void broadcast(final Object data, final OnError err) throws Exception { broadcast(data, SUCCESS, err); } /** * Send data to all connected sessions. * * If the web socket is closed this method throw an {@link Err} with {@link #NORMAL} close status. * * @param data Data to send. * @param success A success callback. * @param err An err callback. * @throws Exception If something goes wrong. */ void broadcast(Object data, SuccessCallback success, OnError err) throws Exception; /** * Set a web socket attribute. * * @param name Attribute name. * @param value Attribute value. * @return This socket. */ @Nullable WebSocket set(String name, Object value); /** * Get a web socket attribute. * * @param name Attribute name. * @return Attribute value. */ T get(String name); /** * Get a web socket attribute or empty value. * * @param name Attribute name. * @param Attribute type. * @return Attribute value or empty value. */ Optional ifGet(String name); /** * Clear/remove a web socket attribute. * * @param name Attribute name. * @param Attribute type. * @return Attribute value (if any). */ Optional unset(String name); /** * Clear/reset all the web socket attributes. * * @return This socket. */ WebSocket unset(); /** * Web socket attributes. * * @return Web socket attributes. */ Map attributes(); }