docs: private void setStreamIsBlocked(boolean value,
                                      int blockingReason,
                                      Exception exception,
                                      JsDestinationAddress blockedAddress)
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(this, tc, "setStreamIsBlocked", new Object[] { Boolean.valueOf(value),
                                                                        Integer.valueOf(blockingReason),
                                                                        exception,
                                                                        blockedAddress });
  
          unexpectedBlock = false;
          isStreamBlocked = value;
          streamBlockingAddress = blockedAddress;
  
          // Defect 535791 - Update the health state of the stream to signal that it has either become
          // blocked or unblocked
          if (isStreamBlocked)
          {
              // First we build a string representation of the blocking address, using ":" to delimit the
              // parts of the address (name, bus, ME)
              String blockingAddress = "NULL";
              if (blockedAddress != null)
              {
                  String busName = blockedAddress.getBusName();
                  SIBUuid8 meUuid = blockedAddress.getME();
                  String meUuidStr = null;
                  if (meUuid != null)
                      meUuidStr = meUuid.toString();
  
                  blockingAddress = blockedAddress.getDestinationName();
                  if (busName != null)
                      blockingAddress += ":" + busName;
                  if (meUuidStr != null)
                  {
                      if (busName == null)
                          blockingAddress += ":";
                      blockingAddress += ":" + meUuidStr;
                  }
              }
  
              // Now represent the reason as a simple string
              String reasonText = "NONE";
  
              if (exception == null)
              {
                  switch (blockingReason)
                  {
                      case DestinationHandler.OUTPUT_HANDLER_NOT_FOUND:
                          reasonText = "NOT_FOUND";
                          break;
                      case DestinationHandler.OUTPUT_HANDLER_SEND_ALLOWED_FALSE:
                          reasonText = "SEND_NOT_ALLOWED";
                          break;
                      case DestinationHandler.OUTPUT_HANDLER_ALL_HIGH_LIMIT:
                          reasonText = "DESTINATION_FULL";
                          break;
                  }
              }
              else
              {
                  // If we caught an unexpected failure to process a message, the
                  // stream becomes implicitly blocked. The one time we would 'expect'
                  // this is if we had an authorization problem (as that's not checked
                  // as part of streamCanAcceptNewMessage) so we handle that
                  // explicitly. For anything else, putting out the exception class
                  // name is probably as good as it gets (if anything really nasty happened
                  // then deliverOrderedMessages will probably have FFDC'd too).
                  if (exception instanceof SINotAuthorizedException)
                      reasonText = "NOT_AUTHORIZED";
                  else
                      reasonText = exception.getClass().getSimpleName();
  
                  // If an exception is passed in then we obviously thought the message should
                  // have worked but it actually failed to be delivered for some reason. We need
                  // to handle those failures specially, so remember this fact.
                  unexpectedBlock = true;
              }
  
              String[] inserts = { reasonText, blockingAddress };
  
              // The stream is blocked
              getControlAdapter().getHealthState().updateHealth(HealthStateListener.BLOCKED_TARGET_STREAM_STATE,
                                                                HealthState.AMBER,
                                                                inserts);
          }
          else
          {
              // The link is no longer blocked
              getControlAdapter().getHealthState().updateHealth(HealthStateListener.BLOCKED_TARGET_STREAM_STATE,
                                                                HealthState.GREEN);
              linkBlockingTick = -1;
              blockingCount = 0;
          }
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "setStreamIsBlocked");
      }