docs: @Override
      public void execute(final ModelNode original, final OperationMessageHandler messageHandler, final ProxyOperationControl control,
                          final OperationAttachments attachments, final BlockingTimeout blockingTimeout) {
          // Add blocking support to adhere to the proxy controller API contracts
          final CountDownLatch completed = new CountDownLatch(1);
          final BlockingQueue<TransactionalProtocolClient.PreparedOperation<TransactionalProtocolClient.Operation>> queue = new ArrayBlockingQueue<TransactionalProtocolClient.PreparedOperation<TransactionalProtocolClient.Operation>>(1, true);
          final TransactionalProtocolClient.TransactionalOperationListener<TransactionalProtocolClient.Operation> operationListener = new TransactionalProtocolClient.TransactionalOperationListener<TransactionalProtocolClient.Operation>() {
              @Override
              public void operationPrepared(TransactionalProtocolClient.PreparedOperation<TransactionalProtocolClient.Operation> prepared) {
                  if(! queue.offer(prepared)) {
                      prepared.rollback();
                  }
              }
  
              @Override
              public void operationFailed(TransactionalProtocolClient.Operation operation, ModelNode result) {
                  try {
                      queue.offer(new BlockingQueueOperationListener.FailedOperation<TransactionalProtocolClient.Operation>(operation, result));
                  } finally {
                      // This might not be needed?
                      completed.countDown();
                  }
              }
  
              @Override
              public void operationComplete(TransactionalProtocolClient.Operation operation, OperationResponse response) {
                  try {
                      control.operationCompleted(response);
                  } finally {
                      // Make sure the handler is called before commit/rollback returns
                      completed.countDown();
                  }
              }
          };
          AsyncFuture<OperationResponse> futureResult = null;
          try {
              // Translate the operation
              final PathAddress targetAddress = PathAddress.pathAddress(original.get(OP_ADDR));
              final ModelNode translated = translateOperationForProxy(original, targetAddress);
  
              // Execute the operation
              ControllerLogger.MGMT_OP_LOGGER.tracef("Executing %s for %s", translated.get(OP).asString(), getProxyNodeAddress());
              futureResult = client.execute(operationListener, translated, messageHandler, attachments);
              // Wait for the prepared response
              final TransactionalProtocolClient.PreparedOperation<TransactionalProtocolClient.Operation> prepared;
              if (blockingTimeout == null) {
                  prepared = queue.take();
              } else {
                  long timeout = blockingTimeout.getProxyBlockingTimeout(targetAddress, this);
                  prepared = queue.poll(timeout, TimeUnit.MILLISECONDS);
                  if (prepared == null) {
                      blockingTimeout.proxyTimeoutDetected(targetAddress);
                      futureResult.asyncCancel(true);
                      ModelNode response = getTimeoutResponse(translated.get(OP).asString(), timeout);
                      control.operationFailed(response);
                      ControllerLogger.MGMT_OP_LOGGER.info(response.get(FAILURE_DESCRIPTION).asString());
                      return;
                  }
              }
              if(prepared.isFailed()) {
                  // If the operation failed, there is nothing more to do
                  control.operationFailed(prepared.getPreparedResult());
                  return;
              }
              // Send the prepared notification and wrap the OperationTransaction to block on commit/rollback
              final AsyncFuture cancellable = futureResult;
              control.operationPrepared(new ModelController.OperationTransaction() {
                  @Override
                  public void commit() {
                      prepared.commit();
                      awaitCompletion();
                  }
  
                  @Override
                  public void rollback() {
                      prepared.rollback();
                      awaitCompletion();
                  }
  
                  private void awaitCompletion() {
                      try {
                          // Await the completed notification
                          if (blockingTimeout == null) {
                              completed.await();
                          } else {
                              long timeout = blockingTimeout.getProxyBlockingTimeout(targetAddress, RemoteProxyController.this);
                              if (!completed.await(timeout, TimeUnit.MILLISECONDS)) {
                                  cancellable.asyncCancel(true);
                                  blockingTimeout.proxyTimeoutDetected(targetAddress);
                                  ControllerLogger.MGMT_OP_LOGGER.timeoutAwaitingFinalResponse(translated.get(OP).asString(), getProxyNodeAddress(), timeout);
                              }
                          }
                      } catch (InterruptedException e) {
                          cancellable.asyncCancel(true);
                          ControllerLogger.MGMT_OP_LOGGER.interruptedAwaitingFinalResponse(translated.get(OP).asString(), getProxyNodeAddress());
                          Thread.currentThread().interrupt();
                      } catch (Exception e) {
                          // ignore
                      }
                  }
              }, prepared.getPreparedResult());
  
          } catch (InterruptedException e) {
              if (futureResult != null) { // it won't be null, as IE can only be thrown after it's assigned
                  ControllerLogger.MGMT_OP_LOGGER.interruptedAwaitingInitialResponse(original.get(OP).asString(), getProxyNodeAddress());
                  // Cancel the operation
                  futureResult.asyncCancel(true);
              }
              control.operationFailed(getCancelledResponse());
              Thread.currentThread().interrupt();
          } catch (IOException e) {
              final ModelNode result = new ModelNode();
              result.get(OUTCOME).set(FAILED);
              result.get(FAILURE_DESCRIPTION).set(e.getLocalizedMessage());
              // Notify the proxy control that the operation failed
              control.operationFailed(result);
          }
      }