| # Licensed to the Apache Software Foundation (ASF) under one or more |
| # contributor license agreements. See the NOTICE file distributed with |
| # this work for additional information regarding copyright ownership. |
| # The ASF licenses this file to You 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. |
| |
| asyncChannelGroup.createFail=Unable to create dedicated AsynchronousChannelGroup for WebSocket clients which is required to prevent memory leaks in complex class loader environments like JavaEE containers |
| |
| asyncChannelWrapperSecure.closeFail=Failed to close channel cleanly |
| asyncChannelWrapperSecure.concurrentRead=Concurrent read operations are not permitted |
| asyncChannelWrapperSecure.concurrentWrite=Concurrent write operations are not permitted |
| asyncChannelWrapperSecure.eof=Unexpected end of stream |
| asyncChannelWrapperSecure.readOverflow=Buffer overflow. [{0}] bytes to write into a [{1}] byte buffer that already contained [{2}] bytes. |
| asyncChannelWrapperSecure.statusUnwrap=Unexpected Status of SSLEngineResult after an unwrap() operation |
| asyncChannelWrapperSecure.statusWrap=Unexpected Status of SSLEngineResult after a wrap() operation |
| asyncChannelWrapperSecure.tooBig=The result [{0}] is too big to be expressed as an Integer |
| asyncChannelWrapperSecure.wrongStateRead=Flag that indicates a read is in progress was found to be false (it should have been true) when trying to complete a read operation |
| asyncChannelWrapperSecure.wrongStateWrite=Flag that indicates a write is in progress was found to be false (it should have been true) when trying to complete a write operation |
| |
| backgroundProcessManager.processFailed=A background process failed |
| |
| caseInsensitiveKeyMap.nullKey=Null keys are not permitted |
| |
| futureToSendHandler.timeout=Operation timed out after waiting [{0}] [{1}] to complete |
| |
| perMessageDeflate.deflateFailed=Failed to decompress a compressed WebSocket frame |
| perMessageDeflate.duplicateParameter=Duplicate definition of the [{0}] extension parameter |
| perMessageDeflate.invalidWindowSize=An invalid windows of [{1}] size was specified for [{0}]. Valid values are whole numbers from 8 to 15 inclusive. |
| perMessageDeflate.unknownParameter=An unknown extension parameter [{0}] was defined |
| |
| transformerFactory.unsupportedExtension=The extension [{0}] is not supported |
| |
| util.notToken=An illegal extension parameter was specified with name [{0}] and value [{1}] |
| util.invalidMessageHandler=The message handler provided does not have an onMessage(Object) method |
| util.invalidType=Unable to coerce value [{0}] to type [{1}]. That type is not supported. |
| util.unknownDecoderType=The Decoder type [{0}] is not recognized |
| |
| # Note the wsFrame.* messages are used as close reasons in WebSocket control |
| # frames and therefore must be 123 bytes (not characters) or less in length. |
| # Messages are encoded using UTF-8 where a single character may be encoded in |
| # as many as 4 bytes. |
| wsFrame.bufferTooSmall=No async message support and buffer too small. Buffer size: [{0}], Message size: [{1}] |
| wsFrame.byteToLongFail=Too many bytes ([{0}]) were provided to be converted into a long |
| wsFrame.closed=New frame received after a close control frame |
| wsFrame.controlFragmented=A fragmented control frame was received but control frames may not be fragmented |
| wsFrame.controlPayloadTooBig=A control frame was sent with a payload of size [{0}] which is larger than the maximum permitted of 125 bytes |
| wsFrame.controlNoFin=A control frame was sent that did not have the fin bit set. Control frames are not permitted to use continuation frames. |
| wsFrame.invalidOpCode= A WebSocket frame was sent with an unrecognised opCode of [{0}] |
| wsFrame.invalidUtf8=A WebSocket text frame was received that could not be decoded to UTF-8 because it contained invalid byte sequences |
| wsFrame.invalidUtf8Close=A WebSocket close frame was received with a close reason that contained invalid UTF-8 byte sequences |
| wsFrame.ioeTriggeredClose=An unrecoverable IOException occurred so the connection was closed |
| wsFrame.messageTooBig=The message was [{0}] bytes long but the MessageHandler has a limit of [{1}] bytes |
| wsFrame.noContinuation=A new message was started when a continuation frame was expected |
| wsFrame.notMasked=The client frame was not masked but all client frames must be masked |
| wsFrame.oneByteCloseCode=The client sent a close frame with a single byte payload which is not valid |
| wsFrame.partialHeaderComplete=WebSocket frame received. fin [{0}], rsv [{1}], OpCode [{2}], payload length [{3}] |
| wsFrame.sessionClosed=The client data cannot be processed because the session has already been closed |
| wsFrame.textMessageTooBig=The decoded text message was too big for the output buffer and the endpoint does not support partial messages |
| wsFrame.wrongRsv=The client frame set the reserved bits to [{0}] for a message with opCode [{1}] which was not supported by this endpoint |
| |
| wsFrameClient.ioe=Failure while reading data sent by server |
| |
| wsRemoteEndpoint.closed=Message will not be sent because the WebSocket session has been closed |
| wsRemoteEndpoint.closedDuringMessage=The remainder of the message will not be sent because the WebSocket session has been closed |
| wsRemoteEndpoint.closedOutputStream=This method may not be called as the OutputStream has been closed |
| wsRemoteEndpoint.closedWriter=This method may not be called as the Writer has been closed |
| wsRemoteEndpoint.changeType=When sending a fragmented message, all fragments must be of the same type |
| wsRemoteEndpoint.concurrentMessageSend=Messages may not be sent concurrently even when using the asynchronous send messages. The client must wait for the previous message to complete before sending the next. |
| wsRemoteEndpoint.flushOnCloseFailed=Batched messages still enabled after session has been closed. Unable to flush remaining batched message. |
| wsRemoteEndpoint.invalidEncoder=The specified encoder of type [{0}] could not be instantiated |
| wsRemoteEndpoint.noEncoder=No encoder specified for object of class [{0}] |
| wsRemoteEndpoint.wrongState=The remote endpoint was in state [{0}] which is an invalid state for called method |
| wsRemoteEndpoint.nullData=Invalid null data argument |
| wsRemoteEndpoint.nullHandler=Invalid null handler argument |
| wsRemoteEndpoint.tooMuchData=Ping or pong may not send more than 125 bytes |
| |
| # Note the following message is used as a close reason in a WebSocket control |
| # frame and therefore must be 123 bytes (not characters) or less in length. |
| # Messages are encoded using UTF-8 where a single character may be encoded in |
| # as many as 4 bytes. |
| wsSession.timeout=The WebSocket session timeout expired |
| |
| wsSession.closed=The WebSocket session [{0}] has been closed and no method (apart from close()) may be called on a closed session |
| wsSession.created=Created WebSocket session [{0}] |
| wsSession.doClose=Closing WebSocket session [{1}] |
| wsSession.duplicateHandlerBinary=A binary message handler has already been configured |
| wsSession.duplicateHandlerPong=A pong message handler has already been configured |
| wsSession.duplicateHandlerText=A text message handler has already been configured |
| wsSession.invalidHandlerTypePong=A pong message handler must implement MessageHandler.Whole |
| wsSession.flushFailOnClose=Failed to flush batched messages on session close |
| wsSession.messageFailed=Unable to write the complete message as the WebSocket connection has been closed |
| wsSession.sendCloseFail=Failed to send close message for session [{0}] to remote endpoint |
| wsSession.removeHandlerFailed=Unable to remove the handler [{0}] as it was not registered with this session |
| wsSession.unknownHandler=Unable to add the message handler [{0}] as it was for the unrecognised type [{1}] |
| wsSession.unknownHandlerType=Unable to add the message handler [{0}] as it was wrapped as the unrecognised type [{1}] |
| wsSession.instanceNew=Endpoint instance registration failed |
| wsSession.instanceDestroy=Endpoint instance unregistration failed |
| |
| # Note the following message is used as a close reason in a WebSocket control |
| # frame and therefore must be 123 bytes (not characters) or less in length. |
| # Messages are encoded using UTF-8 where a single character may be encoded in |
| # as many as 4 bytes. |
| wsWebSocketContainer.shutdown=The web application is stopping |
| |
| wsWebSocketContainer.asynchronousSocketChannelFail=Unable to open a connection to the server |
| wsWebSocketContainer.defaultConfiguratorFail=Failed to create the default configurator |
| wsWebSocketContainer.endpointCreateFail=Failed to create a local endpoint of type [{0}] |
| wsWebSocketContainer.httpRequestFailed=The HTTP request to initiate the WebSocket connection failed |
| wsWebSocketContainer.invalidExtensionParameters=The server responded with extension parameters the client is unable to support |
| wsWebSocketContainer.invalidHeader=Unable to parse HTTP header as no colon is present to delimit header name and header value in [{0}]. The header has been skipped. |
| wsWebSocketContainer.invalidStatus=The HTTP response from the server [{0}] did not permit the HTTP upgrade to WebSocket |
| wsWebSocketContainer.invalidSubProtocol=The WebSocket server returned multiple values for the Sec-WebSocket-Protocol header |
| wsWebSocketContainer.maxBuffer=This implementation limits the maximum size of a buffer to Integer.MAX_VALUE |
| wsWebSocketContainer.missingAnnotation=Cannot use POJO class [{0}] as it is not annotated with @ClientEndpoint |
| wsWebSocketContainer.pathNoHost=No host was specified in URI |
| wsWebSocketContainer.pathWrongScheme=The scheme [{0}] is not supported. The supported schemes are ws and wss |
| wsWebSocketContainer.proxyConnectFail=Failed to connect to the configured Proxy [{0}]. The HTTP response code was [{1}] |
| wsWebSocketContainer.sessionCloseFail=Session with ID [{0}] did not close cleanly |
| wsWebSocketContainer.sslEngineFail=Unable to create SSLEngine to support SSL/TLS connections |
| wsWebSocketContainer.missingLocationHeader=Failed to handle HTTP response code [{0}]. Missing Location header in response |
| wsWebSocketContainer.redirectThreshold=Cyclic Location header [{0}] detected / reached max number of redirects [{1}] of max [{2}] |