@Override public boolean failed(Exception e) { try { boolean failed = ActiveOperationImpl.this.setFailed(e); if(failed) { ProtocolLogger.ROOT_LOGGER.debugf(e, "active-op (%d) failed %s", operationId, attachment); } return failed; } finally { removeActiveOperation(operationId); } }
@Override public void handleError(final Channel channel, final IOException error) { ROOT_LOGGER.tracef(error, "%s error handling incoming data", this); try { channel.close(); } catch (IOException e) { ROOT_LOGGER.errorClosingChannel(e.getMessage()); } }
/** * @deprecated The executor is no longer needed. Here for backwards compatibility */ @Deprecated public void setExecutor(final Executor readExecutor) { boolean warned = warnedExecutor; if (!warned) { warnedExecutor = true; ProtocolLogger.CLIENT_LOGGER.executorNotNeeded(); } } }
protected static void safeWriteResponse(final Channel channel, final ManagementProtocolHeader header, final Exception error) { if(header.getType() == ManagementProtocol.TYPE_REQUEST) { try { writeResponse(channel, (ManagementRequestHeader) header, error); } catch(IOException ioe) { ProtocolLogger.ROOT_LOGGER.tracef(ioe, "failed to write error response for %s on channel: %s", header, channel); } } }
public static void safeClose(final XMLStreamWriter writer) { if (writer != null) try { writer.close(); } catch (Throwable t) { ROOT_LOGGER.failedToCloseResource(t, writer); } } }
public static void safeClose(final ServerSocket serverSocket) { if (serverSocket != null) try { serverSocket.close(); } catch (IOException e) { ROOT_LOGGER.failedToCloseServerSocket(e, serverSocket); } }
@Override public void handleEnd(final Channel channel) { try { channel.close(); } catch (IOException e) { ROOT_LOGGER.errorClosingChannel(e.getMessage()); } }
final ActiveRequest<?, ?> request = requests.remove(response.getResponseId()); if(request == null) { ProtocolLogger.CONNECTION_LOGGER.noSuchRequest(response.getResponseId(), channel); safeWriteErrorResponse(channel, header, ProtocolMessages.MESSAGES.responseHandlerNotFound(response.getResponseId())); } else if(response.getError() != null) {
protected static void safeWriteResponse(final Channel channel, final ManagementProtocolHeader header, byte param) { if(header.getType() == ManagementProtocol.TYPE_REQUEST) { try { writeResponse(channel, (ManagementRequestHeader) header, param); } catch(IOException ioe) { ProtocolLogger.ROOT_LOGGER.tracef(ioe, "failed to write error response for %s on channel: %s", header, channel); } } }
public static void safeClose(final Socket socket) { if (socket != null) try { socket.close(); } catch (Throwable t) { ROOT_LOGGER.failedToCloseResource(t, socket); } }
@Override public synchronized void failed(Exception e) { if(prepared) { final ModelController.OperationTransaction transaction = activeTx; if(transaction != null) { transaction.rollback(); txCompletedLatch.countDown(); } } else if (responseChannel != null) { rollbackOnPrepare = true; // Failed in a step before prepare, send error response final String message = e.getMessage() != null ? e.getMessage() : "failure before rollback " + e.getClass().getName(); final ModelNode response = new ModelNode(); response.get(OUTCOME).set(FAILED); response.get(FAILURE_DESCRIPTION).set(message); try { sendResponse(responseChannel, ModelControllerProtocol.PARAM_OPERATION_FAILED, response); } catch (IOException ignored) { ProtocolLogger.ROOT_LOGGER.debugf(ignored, "failed to process message"); } } }
/** * Safe write error response. * * @param channel the channel * @param header the request header * @param error the exception */ protected static void safeWriteErrorResponse(final Channel channel, final ManagementProtocolHeader header, final Exception error) { if(header.getType() == ManagementProtocol.TYPE_REQUEST) { try { writeErrorResponse(channel, (ManagementRequestHeader) header, error); } catch(IOException ioe) { ProtocolLogger.ROOT_LOGGER.tracef(ioe, "failed to write error response for %s on channel: %s", header, channel); } } }
public static void safeClose(final Closeable closeable) { if (closeable != null) try { closeable.close(); } catch (Throwable t) { ROOT_LOGGER.failedToCloseResource(t, closeable); } }
void sendCompletedMessage() { if(completed.compareAndSet(false, true)) { try { sendResponse(responseChannel, DomainControllerProtocol.PARAM_OK, null); } catch (IOException e) { ProtocolLogger.ROOT_LOGGER.debugf(e, "failed to process message"); } activeOperation.getResultHandler().done(null); } }
@Override public void handleMessage(final Channel channel, final MessageInputStream message) { try { ROOT_LOGGER.tracef("%s handling incoming data", this); lastMessageTime = System.currentTimeMillis(); final DataInput input = new DataInputStream(message); if(type == ManagementProtocol.TYPE_PING) { ROOT_LOGGER.tracef("Received ping on %s", this); handlePing(channel, header); } else if (type == ManagementProtocol.TYPE_PONG) { ROOT_LOGGER.tracef("Received on on %s", this); } else if (type == ManagementProtocol.TYPE_BYE_BYE) { ROOT_LOGGER.tracef("Received bye bye on %s, closing", this); handleChannelReset(channel); } else { } finally { StreamUtils.safeClose(message); ROOT_LOGGER.tracef("%s done handling incoming data", this);
synchronized void completed(final ModelNode response) { assert prepared; assert responseChannel != null; try { // 4) operation-completed (done) sendResponse(responseChannel, ModelControllerProtocol.PARAM_OPERATION_COMPLETED, response); } catch (IOException e) { ProtocolLogger.ROOT_LOGGER.debugf(e, "failed to process message"); } finally { getResultHandler().done(null); } }
synchronized void completed(final ModelNode response) { assert prepared; assert responseChannel != null; try { // 4) operation-completed (done) sendResponse(responseChannel, ModelControllerProtocol.PARAM_OPERATION_COMPLETED, response); } catch (IOException e) { ProtocolLogger.ROOT_LOGGER.debugf(e, "failed to process message"); } finally { getResultHandler().done(null); } }
void failed(byte errorCode, String message) { if(completed.compareAndSet(false, true)) { failed = true; final IOTask<?> task = this.task; if(task != null) { task.setFailed(); } try { sendFailedResponse(responseChannel, errorCode, message); } catch (IOException e) { ProtocolLogger.ROOT_LOGGER.debugf(e, "failed to process message"); } activeOperation.getResultHandler().done(null); } }
@Override public void handleCancelled(AsyncFuture<? extends T> asyncFuture, Object attachment) { removeActiveOperation(operationId); callback.cancelled(); ProtocolLogger.ROOT_LOGGER.debugf("cancelled operation (%d) attachment: (%s) this: %s.", getOperationId(), getAttachment(), ActiveOperationSupport.this); } }, null);
synchronized void failed(final ModelNode response) { if(prepared) { // in case commit or rollback throws an exception, to conform with the API we still send a operation-completed message completed(response); } else { assert responseChannel != null; try { // 2) send the operation-failed message (done) sendResponse(responseChannel, ModelControllerProtocol.PARAM_OPERATION_FAILED, response); } catch (IOException e) { ProtocolLogger.ROOT_LOGGER.debugf(e, "failed to process message"); } finally { getResultHandler().done(null); } } }