docs: public void createLocalDurableSubscription(
                                                 ConsumerDispatcherState subState,
                                                 TransactionCommon transaction)
                      throws
                      SIDurableSubscriptionAlreadyExistsException,
                      SIDiscriminatorSyntaxException,
                      SISelectorSyntaxException,
                      SIResourceException
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(
                          tc,
                          "createLocalDurableSubscription",
                          new Object[] { subState, transaction });
  
          // Create new getCursor and consumer dispatchers to return to the calling method
          ConsumerDispatcher consumerDispatcher = null;
  
          /*
           * Lock the list of durable subscriptions to prevent others creating/using an
           * identical subscription
           */
          synchronized (_consumerDispatchersDurable)
          {
              // If there's already a consumer dispatcher with this client name, then the
              // create must fail according to the current core API semantics.
              consumerDispatcher = getDurableSubscriptionConsumerDispatcher(subState);
  
              if (consumerDispatcher != null)
              {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.exit(
                                 tc,
                                 "createLocalDurableSubscription",
                                 "Sub Already Exists - " + subState);
  
                  throw new SIDurableSubscriptionAlreadyExistsException(
                                  nls.getFormattedMessage(
                                                          "SUBSCRIPTION_ALREADY_EXISTS_ERROR_CWSIP0143",
                                                          new Object[] {
                                                                        subState.getSubscriberID(),
                                                                        _messageProcessor.getMessagingEngineName() },
                                                          null));
              }
              /* We did not find the consumerDispatcher so we create it */
  
              /*
               * If a transaction was not provided...
               * Create a new LocalTransaction to perform the creation of a durable subscription.
               * Operations will include the creation of the itemstream,the persisting of
               * the durable state and the attaching of the consumerpoint.
               */
              boolean tranProvided = true;
              LocalTransaction siTran = null;
  
              if (transaction == null)
              {
                  tranProvided = false;
                  siTran =
                                  _baseDestinationHandler
                                                  .getTransactionManager()
                                                  .createLocalTransaction(false);
                  transaction = siTran;
              }
  
              /*
               * Create the consumerDispatcher, note we do not require this to be done under
               * the localTransaction. If something goes wrong after this operation, the
               * consumerDispatcher will be lost but thats ok.
               */
  
              Transaction msTran = _messageProcessor.resolveAndEnlistMsgStoreTransaction(transaction);
  
              try
              {
                  /*
                   * Create a reference stream to be used by the durable subscription's
                   * consumer dispatcher
                   */
                  final DurableSubscriptionItemStream durableSubscriptionReferenceStream =
                                  new DurableSubscriptionItemStream(
                                                  subState,
                                                  _baseDestinationHandler.getDestinationManager(),
                                                  _pubsubMessageItemStream,
                                                  msTran);
  
                  /* Create the consumer dispatcher to represent the subscription */
                  consumerDispatcher =
                                  configureDurableSubscription(durableSubscriptionReferenceStream);
                  consumerDispatcher.registerControlAdapterAsMBean();
  
                  //Venu mock mock
                  // No ProxyHandler .. so commenting our this 
                  /*
                   * // 166833.2
                   * // Generate the subscribeEvent for this new subscription
                   * // to see if this needs to be forwarded to a Neighbouring ME.
                   * _messageProcessor.getProxyHandler().subscribeEvent(
                   * subState,
                   * msTran);
                   */
              } catch (OutOfCacheSpace e)
              {
                  // No FFDC code needed
                  SibTr.exception(tc, e);
                  // Rollback the transaction
                  if (!tranProvided)
                      _baseDestinationHandler.handleRollback(siTran);
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.exit(
                                 tc,
                                 "createLocalDurableSubscription",
                                 "SIResourceException");
                  throw new SIResourceException(
                                  nls.getFormattedMessage(
                                                          "SUBSCRIPTION_CREATION_FAILED_CWSIP0033",
                                                          new Object[] {
                                                                        _baseDestinationHandler.getName(),
                                                                        subState.getSubscriberID(),
                                                                        e },
                                                          null),
                                  e);
  
              } catch (MessageStoreException e)
              {
                  // MessageStoreException shouldn't occur so FFDC.
                  FFDCFilter.processException(
                                              e,
                                              "com.ibm.ws.sib.processor.impl.destination.PubSubRealization.createLocalDurableSubscription",
                                              "1:1093:1.35.2.4",
                                              this);
                  SibTr.exception(tc, e);
                  // Rollback the transaction
                  if (!tranProvided)
                      _baseDestinationHandler.handleRollback(siTran);
  
                  /*
                   * The message store has thrown an exception, which leaves us stuck. Record an ffst,
                   * write a trace record and throw a SIResourceException to the caller.
                   */
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.exit(tc, "createLocalDurableSubscription", e);
  
                  SibTr.error(
                              tc,
                              "INTERNAL_MESSAGING_ERROR_CWSIP0003",
                              new Object[] {
                                            "com.ibm.ws.sib.processor.impl.destination.PubSubRealization.createLocalDurableSubscription",
                                            "1:1112:1.35.2.4",
                                            e,
                                            _baseDestinationHandler.getName() });
  
                  throw new SIResourceException(
                                  nls.getFormattedMessage(
                                                          "INTERNAL_MESSAGING_ERROR_CWSIP0003",
                                                          new Object[] {
                                                                        "com.ibm.ws.sib.processor.impl.destination.PubSubRealization",
                                                                        "1:1121:1.35.2.4",
                                                                        e,
                                                                        _baseDestinationHandler.getName() },
                                                          null),
                                  e);
              } catch (SIDiscriminatorSyntaxException e)
              {
                  // No FFDC code needed
                  _baseDestinationHandler.handleRollback(siTran);
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.exit(tc, "createLocalDurableSubscription", e);
                  throw e;
              } catch (SISelectorSyntaxException e)
              {
                  // No FFDC code needed
                  _baseDestinationHandler.handleRollback(siTran);
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.exit(tc, "createLocalDurableSubscription", e);
                  throw e;
              }
              //Venu mock mock
              //commenting out as this exception became unreachable
              /*
               * catch (SIResourceException e)
               * {
               * // No FFDC code needed
               * _baseDestinationHandler.handleRollback(siTran);
               * if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
               * SibTr.exit(tc, "createLocalDurableSubscription", e);
               * throw e;
               * }
               */
              catch (RuntimeException e)
              {
                  // FFDC
                  FFDCFilter.processException(
                                              e,
                                              "com.ibm.ws.sib.processor.impl.destination.PubSubRealization.createLocalDurableSubscription",
                                              "1:1153:1.35.2.4",
                                              this);
  
                  if (siTran != null)
                      _baseDestinationHandler.handleRollback(siTran);
                  if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                      SibTr.exit(tc, "createLocalDurableSubscription", e);
                  throw e;
              }
  
              if (!tranProvided)
              {
                  /*
                   * If no transaction was provided, this call must have been made from
                   * the core api (i.e. JMS). We can not provide transaction at runtime.
                   * Since we are creating via JMS, we need to attach the consumer
                   * as part of the create operation.
                   */
                  try
                  {
  
                      /* We have our own transaction so commit it here */
                      siTran.commit();
  
                  } catch (SIException e)
                  {
                      // MessageStoreException shouldn't occur so FFDC.
                      FFDCFilter.processException(
                                                  e,
                                                  "com.ibm.ws.sib.processor.impl.destination.PubSubRealization.createLocalDurableSubscription",
                                                  "1:1182:1.35.2.4",
                                                  this);
  
                      SibTr.exception(tc, e);
                      SibTr.error(
                                  tc,
                                  "INTERNAL_MESSAGING_ERROR_CWSIP0003",
                                  new Object[] {
                                                "com.ibm.ws.sib.processor.impl.destination.PubSubRealization",
                                                "1:1191:1.35.2.4",
                                                e,
                                                _baseDestinationHandler.getName() });
  
                      // Failed to attach consumer, rollback the creation of the durable sub
                      // and throw exception.
                      _baseDestinationHandler.handleRollback(siTran);
  
                      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                          SibTr.exit(tc, "createLocalDurableSubscription", e);
  
                      throw new SIResourceException(
                                      nls.getFormattedMessage(
                                                              "INTERNAL_MESSAGING_ERROR_CWSIP0003",
                                                              new Object[] {
                                                                            "com.ibm.ws.sib.processor.impl.destination.PubSubRealization",
                                                                            "1:1207:1.35.2.4",
                                                                            e,
                                                                            _baseDestinationHandler.getName() },
                                                              null),
                                      e);
                  }
              }
              // Transaction was provided
  
          } // Release the durable subs lock
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "createLocalDurableSubscription");
      }