@Override public void handleRequest(final DataInput input, final ActiveOperation.ResultHandler<Void> resultHandler, final ManagementRequestContext<Void> context) throws IOException { final String serverName = input.readUTF(); final int operationId = input.readInt(); serverProcessName = serverName; ROOT_LOGGER.serverConnected(serverName, context.getChannel()); // Execute the registration request context.executeAsync(new ManagementRequestContext.AsyncTask<Void>() { @Override public void execute(final ManagementRequestContext<Void> context) throws Exception { try { final OperationStepHandler stepHandler = new ServerRegistrationStepHandler(serverName, context); final ModelNode result = operationExecutor.joinActiveOperation(EMPTY_OP.getOperation(), OperationMessageHandler.DISCARD, ModelController.OperationTransactionControl.COMMIT, stepHandler, operationId); if(! SUCCESS.equals(result.get(OUTCOME).asString())) { safeWriteResponse(context.getChannel(), context.getRequestHeader(), DomainServerProtocol.PARAM_ERROR); } } catch (Exception e) { safeWriteResponse(context, e); } resultHandler.done(null); } }, registrations); } }
@Override public void handleRequest(final DataInput input, final ActiveOperation.ResultHandler<Void> resultHandler, final ManagementRequestContext<RegistrationContext> context) throws IOException { final byte status = input.readByte(); final String message = input.readUTF(); // Perhaps use message when the host failed final RegistrationContext registration = context.getAttachment(); registration.completeRegistration(context, status == DomainControllerProtocol.PARAM_OK); }
@Override public void sendRequest(final ActiveOperation.ResultHandler<T> resultHandler, final ManagementRequestContext<A> context) throws IOException { final FlushableDataOutput output = context.writeMessage(context.getRequestHeader()); try { sendRequest(resultHandler, context, output); output.writeByte(ManagementProtocol.REQUEST_END); output.close(); } finally { StreamUtils.safeClose(output); } }
@Override public void sendRequest(final ActiveOperation.ResultHandler<OperationResponse> resultHandler, final ManagementRequestContext<ExecuteRequestContext> context) throws IOException { ControllerLogger.MGMT_OP_LOGGER.tracef("sending CompleteTxRequest for %d", context.getOperationId()); context.executeAsync(new ManagementRequestContext.AsyncTask<ExecuteRequestContext>() { @Override public void execute(ManagementRequestContext<ExecuteRequestContext> context) throws Exception { sendRequestInternal(resultHandler, context); } }, false); }
protected FlushableDataOutput writeGenericResponseHeader(final ManagementRequestContext<Void> context) throws IOException { final ManagementResponseHeader header = ManagementResponseHeader.create(context.getRequestHeader()); return context.writeMessage(header); }
protected static void safeWriteResponse(final ManagementRequestContext<?> context, final Exception error) { safeWriteResponse(context.getChannel(), context.getRequestHeader(), error); }
@Override public void handleRequest(final DataInput input, final ActiveOperation.ResultHandler<Void> resultHandler, final ManagementRequestContext<Void> context) throws IOException { byte param = input.readByte(); // If it failed if(param != DomainControllerProtocol.PARAM_OK) { final byte errorCode = input.readByte(); final String message = input.readUTF(); resultHandler.failed(new SlaveRegistrationException(SlaveRegistrationException.ErrorCode.parseCode(errorCode), message)); return; } final ModelNode extensions = new ModelNode(); extensions.readExternal(input); context.executeAsync(new ManagementRequestContext.AsyncTask<Void>() { @Override public void execute(ManagementRequestContext<Void> voidManagementRequestContext) throws Exception { // final ModelNode subsystems = resolveSubsystemVersions(extensions); channelHandler.executeRequest(context.getOperationId(), new RegisterSubsystemsRequest(subsystems)); } }); } }
@Override public void handleRequest(final DataInput input, final ActiveOperation.ResultHandler<Void> resultHandler, final ManagementRequestContext<ExecuteRequestContext> context) throws IOException { if (forExecuteTxRequest) { try { // Read and discard the input ExecutableRequest.parse(input, channelAssociation); } finally { ControllerLogger.MGMT_OP_LOGGER.tracef("aborting (cancel received before request) for %d", context.getOperationId()); ModelNode response = new ModelNode(); response.get(OUTCOME).set(CANCELLED); context.getAttachment().initialize(context); context.getAttachment().failed(response); } } else { // This was a COMPLETE_TX_REQUEST that came in before the original EXECUTE_TX_REQUEST final byte commitOrRollback = input.readByte(); if (commitOrRollback == ModelControllerProtocol.PARAM_COMMIT) { // a cancel would not use PARAM_COMMIT; this was a request that didn't match any existing op // Likely the request was cancelled and removed but the commit message was in process throw ControllerLogger.MGMT_OP_LOGGER.responseHandlerNotFound(context.getOperationId()); } // else this was a cancel request. Do nothing and wait for the initial operation request to come in // and see the pre-existing ActiveOperation and then call this with forExecuteTxRequest=true } }
@Override public void handleRequest(final DataInput input, final ActiveOperation.ResultHandler<Void> resultHandler, final ManagementRequestContext<ExecuteRequestContext> context) throws IOException { final ModelNode operation = new ModelNode(); ProtocolUtils.expectHeader(input, ModelControllerProtocol.PARAM_OPERATION); operation.readExternal(input); ProtocolUtils.expectHeader(input, ModelControllerProtocol.PARAM_INPUTSTREAMS_LENGTH); final int attachmentsLength = input.readInt(); context.executeAsync(new ManagementRequestContext.AsyncTask<ExecuteRequestContext>() { @Override public void execute(ManagementRequestContext<ExecuteRequestContext> context) throws Exception { doExecute(operation, attachmentsLength, context); } }); }
@Override public void handleRequest(DataInput input, ActiveOperation.ResultHandler<Void> resultHandler, ManagementRequestContext<RegistrationContext> context) throws IOException { final byte status = input.readByte(); final ModelNode subsystems = new ModelNode(); subsystems.readExternal(input); final RegistrationContext registration = context.getAttachment(); if(status == DomainControllerProtocol.PARAM_OK) { registration.setSubsystems(subsystems, context); } else { registration.setSubsystems(null, context); } }
@Override public void handleRequest(final DataInput input, final ActiveOperation.ResultHandler<ModelNode> resultHandler, final ManagementRequestContext<ExecuteRequestContext> context) throws IOException { expectHeader(input, ModelControllerProtocol.PARAM_MESSAGE_SEVERITY); final MessageSeverity severity = Enum.valueOf(MessageSeverity.class, input.readUTF()); expectHeader(input, ModelControllerProtocol.PARAM_MESSAGE); final String message = input.readUTF(); expectHeader(input, ManagementProtocol.REQUEST_END); final ExecuteRequestContext requestContext = context.getAttachment(); // perhaps execute async final OperationMessageHandler handler = requestContext.getMessageHandler(); handler.handleReport(severity, message); }
final String operationName = operation.getOperation().require(OP).asString(); if (operationName.equals(FetchMissingConfigurationHandler.OPERATION_NAME)) { handler = new FetchMissingConfigurationHandler(SlaveChannelAttachments.getHostName(context.getChannel()), SlaveChannelAttachments.getTransformers(context.getChannel()), domainController.getExtensionRegistry()); } else { if (operationNode.get(OPERATION_HEADERS).hasDefined(DomainControllerLockIdUtils.DOMAIN_CONTROLLER_LOCK_ID)) { domainControllerLockId = operationNode.get(OPERATION_HEADERS, DomainControllerLockIdUtils.DOMAIN_CONTROLLER_LOCK_ID).asInt(); } else {
@Override public void handleRequest(final DataInput input, final ActiveOperation.ResultHandler<Void> resultHandler, final ManagementRequestContext<RegistrationContext> context) throws IOException { expectHeader(input, DomainControllerProtocol.PARAM_HOST_ID); final String hostName = input.readUTF(); final ModelNode hostInfo = new ModelNode(); hostInfo.readExternal(input); final RegistrationContext registration = context.getAttachment(); registration.initialize(hostName, hostInfo, context); if (domainController.getCurrentRunningMode() == RunningMode.ADMIN_ONLY) { registration.failed(SlaveRegistrationException.ErrorCode.MASTER_IS_ADMIN_ONLY, DomainControllerLogger.ROOT_LOGGER.adminOnlyModeCannotAcceptSlaves(RunningMode.ADMIN_ONLY)); return; } if (!domainController.getLocalHostInfo().isMasterDomainController()) { registration.failed(SlaveRegistrationException.ErrorCode.HOST_IS_NOT_MASTER, DomainControllerLogger.ROOT_LOGGER.slaveControllerCannotAcceptOtherSlaves()); return; } // Read the domain model async, this will block until the registration process is complete context.executeAsync(new ManagementRequestContext.AsyncTask<RegistrationContext>() { @Override public void execute(ManagementRequestContext<RegistrationContext> context) throws Exception { if (Thread.currentThread().isInterrupted()) throw new IllegalStateException("interrupted"); registration.processRegistration(); } }, registrationExecutor); }
@Override public void handleRequest(final DataInput input, final ActiveOperation.ResultHandler<Boolean> resultHandler, final ManagementRequestContext<Void> context) throws IOException { final byte param = input.readByte(); context.executeAsync(new ManagementRequestContext.AsyncTask<Void>() { @Override public void execute(ManagementRequestContext<Void> voidManagementRequestContext) throws Exception { if(param == DomainServerProtocol.PARAM_OK) { // Still in sync with the HC resultHandler.done(Boolean.TRUE); } else { // Out of sync, set restart-required resultHandler.done(Boolean.FALSE); } } }, false); }
@Override public void handleRequest(final DataInput input, final ActiveOperation.ResultHandler<Void> resultHandler, final ManagementRequestContext<ExecuteRequestContext> context) throws IOException { final ExecuteRequestContext executeRequestContext = context.getAttachment(); final byte commitOrRollback = input.readByte(); // Complete transaction, either commit or rollback executeRequestContext.completeTx(context, commitOrRollback == ModelControllerProtocol.PARAM_COMMIT); }
@Override public void handleRequest(final DataInput input, final ActiveOperation.ResultHandler<Void> resultHandler, final ManagementRequestContext<Void> context) throws IOException { final String serverName = input.readUTF(); serverProcessName = serverName; CONTROLLER_MANAGEMENT_LOGGER.serverRegistered(serverName, context.getChannel()); // Execute the registration request context.executeAsync(new ManagementRequestContext.AsyncTask<Void>() { @Override public void execute(final ManagementRequestContext<Void> context) throws Exception { try { final OperationStepHandler stepHandler = new ServerRegistrationStepHandler(serverName, context); final ModelNode result = operationExecutor.execute(EMPTY_OP, OperationMessageHandler.DISCARD, ModelController.OperationTransactionControl.COMMIT, OperationAttachments.EMPTY, stepHandler); if(! SUCCESS.equals(result.get(OUTCOME).asString())) { safeWriteResponse(context.getChannel(), context.getRequestHeader(), DomainServerProtocol.PARAM_ERROR); } } catch (Exception e) { safeWriteResponse(context, e); } resultHandler.done(null); } }, registrations); } }
if (FAILED.equals(result.get(OUTCOME).asString())) { failed(SlaveRegistrationException.ErrorCode.UNKNOWN, result.get(FAILURE_DESCRIPTION).asString()); return; responseChannel.getChannel().addCloseHandler(new CloseHandler<Channel>() { @Override public void handleClose(Channel closed, IOException exception) {
@Override public void handleRequest(final DataInput input, final ActiveOperation.ResultHandler<Void> resultHandler, final ManagementRequestContext<Void> context) throws IOException { expectHeader(input, DomainControllerProtocol.PARAM_SERVER_ID); final String serverName = input.readUTF(); expectHeader(input, DomainControllerProtocol.PARAM_HOST_ID); final String hostName = input.readUTF(); context.executeAsync(new ManagementRequestContext.AsyncTask<Void>() { @Override public void execute(ManagementRequestContext<Void> context) throws Exception { try { HostControllerLogger.ROOT_LOGGER.managedServerUnstable(serverName, hostName); } finally { resultHandler.done(null); } } }); } }
@Override public void handleRequest(final DataInput input, final ActiveOperation.ResultHandler<OperationResponse> resultHandler, final ManagementRequestContext<ExecuteRequestContext> context) throws IOException { ControllerLogger.MGMT_OP_LOGGER.tracef("received response to CompleteTxRequest (%s) for %d", status != ModelControllerProtocol.PARAM_ROLLBACK, context.getOperationId()); // We only accept operationCompleted responses expectHeader(input, ModelControllerProtocol.PARAM_OPERATION_COMPLETED); final ModelNode responseNode = new ModelNode(); responseNode.readExternal(input); // Complete the operation resultHandler.done(createOperationResponse(responseNode, channelAssociation, context.getOperationId())); }
@Override public void handleRequest(final DataInput input, final ActiveOperation.ResultHandler<Void> resultHandler, final ManagementRequestContext<Void> context) throws IOException { final ManagementResponseHeader response = ManagementResponseHeader.create(context.getRequestHeader()); final FlushableDataOutput output = context.writeMessage(response); try { output.write(ManagementProtocol.TYPE_PONG); output.writeLong(connectionId); output.writeByte(ManagementProtocol.RESPONSE_END); output.close(); } finally { StreamUtils.safeClose(output); } resultHandler.done(null); }