Remove all pending transactions from the specified initiator
and do not require heartbeats from that initiator to proceed.
@param initiatorId id of the failed initiator.
962511
public void gotFaultForInitiator(long initiatorId) {
        // calculate the next minimum transaction w/o our dead friend
        noteTransactionRecievedAndReturnLastSeen(initiatorId, Long.MAX_VALUE, DtxnConstants.DUMMY_LAST_SEEN_TXN_ID);

        // remove initiator from minimum. txnid scoreboard
        LastInitiatorData remove = m_initiatorData.remove(initiatorId);
        assert(remove != null);
    }
652580
public final void preCommitRemove(final PersistentTransaction transaction) throws SevereMessageStoreException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "preCommitRemove", transaction);

        synchronized (this)
        {
            SevereMessageStoreException ex = assertCanDelete(transaction);
            if (null != ex)
            {
                throw ex;
            }

            if ((_itemLinkState == ItemLinkState.STATE_REMOVING_EXPIRING)
                || (_itemLinkState == ItemLinkState.STATE_REMOVING_LOCKED)
                || (_itemLinkState == ItemLinkState.STATE_REMOVING_PERSISTENTLY_LOCKED)
                || (_itemLinkState == ItemLinkState.STATE_REMOVING_WITHOUT_LOCK))
            {
                _assertCorrectTransaction(transaction);
                _owningStreamLink._assertCanRemoveChildUnder(transaction);
            }
            else
            {
                if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
                    SibTr.event(this, tc, "Invalid Item state: " + _itemLinkState);
                if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                    SibTr.exit(this, tc, "preCommitRemove");
                throw new StateException(_itemLinkState.toString());
            }

            getItem().eventPrecommitRemove(transaction);
        } // end sync

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "preCommitRemove");
    }
432910
private void onCleanExit(final String processId) {
    this.onResourceStatus(
        ResourceStatusEventImpl.newBuilder()
            .setIdentifier(processId)
            .setState(State.DONE)
            .setExitCode(0)
            .build()
    );
  }
643180
public void removeLocked( MessageLock lockRef ) throws JMSException
    {
    	checkTransactionLock();
    	
    	MessageStore targetStore;
    	if (lockRef.getDeliveryMode() == DeliveryMode.NON_PERSISTENT)
    	    targetStore = volatileStore;
    	else
    	{
    	    targetStore = persistentStore;
    	    if (requiresTransactionalUpdate())
    	    	pendingChanges = true;
    	}
    	
    	synchronized (storeLock)
        {
    		targetStore.delete(lockRef.getHandle());
        }
    }
941310
synchronized void removeCredential(String accountId) throws IOException {
        DataStore<StoredCredential> sc = StoredCredential.getDefaultDataStore(dataStoreFactory);
        sc.delete(accountId);
        calendarService = null;
        geoService = null;
    }
133195
public final void removePseudoDestination(SIBUuid12 destinationUuid)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "removePseudoDestination", destinationUuid);
        destinationIndex.removePseudoUuid(destinationUuid);
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "removePseudoDestination");
    }
1196368
protected void cleanup() {

        final String methodName = "cleanup";
        if (TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName);
        }

        if (_unsuccessfulMessages.size() > 0) {

            try {

                // 250710: Fix to workaround the problem where failed messages are
                // unlocked but the retry count is not incremented. Perform a
                // delete on the messages under a transaction and then roll back
                // the transaction - this will cause the messages to be unlocked
                // and have their retry count incremented. If the an exception
                // is thrown during this processing the messages will remain locked.
                try
				{
                	SIUncoordinatedTransaction localTran = _connection.createUncoordinatedTransaction();
                	deleteMessages(getMessageHandles(_unsuccessfulMessages), localTran);
                	localTran.rollback();
				}
                catch (SIException ex)
				{
                    FFDCFilter.processException(ex, CLASS_NAME + "."
                            + methodName, FFDC_PROBE_2, this);
                    if (TRACE.isEventEnabled()) {
                        SibTr.exception(this, TRACE, ex);
                    }
				}
//                unlockMessages(_unsuccessfulMessages);

            } catch (final ResourceException exception) {

                FFDCFilter.processException(exception, CLASS_NAME + "."
                        + methodName, FFDC_PROBE_1, this);
                if (TRACE.isEventEnabled()) {
                    SibTr.exception(this, TRACE, exception);
                }

            } finally {

                _unsuccessfulMessages.clear();

            }

        }

        if (TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName);
        }

    }
601835
public void purge( MessageSelector selector ) throws JMSException
    {
        if (volatileStore != null)
            purgeStore(volatileStore,selector);
        if (persistentStore != null)
        {
        	openTransaction();
        	try
        	{
        		purgeStore(persistentStore,selector);
        		commitChanges();
        	}
        	finally
        	{
        		closeTransaction();
        	}
        }
    }
8333
private void tryInit() {
    try {
      Configuration conf = getSnapshotConfiguration();
      if (conf != null) {
        // Since this is only used for background loading of transaction snapshots, we use the no-op metrics collector,
        // as there are no relevant metrics to report
        this.storage = new HDFSTransactionStateStorage(conf, new SnapshotCodecProvider(conf),
                                                       new TxMetricsCollector());
        this.storage.startAndWait();
        this.snapshotRefreshFrequency = conf.getLong(TxConstants.Manager.CFG_TX_SNAPSHOT_INTERVAL,
                                                     TxConstants.Manager.DEFAULT_TX_SNAPSHOT_INTERVAL) * 1000;
        this.initialized = true;
      } else {
        LOG.info("Could not load configuration");
      }
    } catch (Exception e) {
      LOG.info("Failed to initialize TransactionStateCache due to: " + e.getMessage());
    }
  }
794590
@Override
	public void removeActions(String nodeID) {

		// Stop local services
		if (this.nodeID.equals(nodeID)) {
			stopAllLocalServices();
		}

		// Remove actions
		final long stamp = lock.writeLock();
		try {
			Iterator<Strategy<ActionEndpoint>> endpoints = strategies.values().iterator();
			while (endpoints.hasNext()) {
				Strategy<ActionEndpoint> strategy = endpoints.next();
				strategy.remove(nodeID);
				if (strategy.isEmpty()) {
					endpoints.remove();
				}
			}

			// Update service names
			names.clear();
			names.addAll(strategies.keySet());

			// Delete cached node descriptor
			if (this.nodeID.equals(nodeID)) {
				clearDescriptorCache();
			}

		} finally {
			lock.unlockWrite(stamp);
		}

		// Reject promises
		Iterator<PendingPromise> pendingPromises = promises.values().iterator();
		boolean removed = false;
		while (pendingPromises.hasNext()) {
			PendingPromise pending = pendingPromises.next();
			if (pending.nodeID.equals(nodeID)) {
				removed = true;
				pendingPromises.remove();
				executor.execute(() -> {
					try {
						pending.promise.complete(new RequestRejectedError(nodeID, pending.action));
					} catch (Throwable cause) {
						logger.warn("Unable to reject action \"" + pending.action + "\"!", cause);
					}
				});
			}
		}

		// Reschedule timeout checker
		if (removed) {
			scheduler.execute(() -> {
				reschedule(Long.MAX_VALUE);
			});
		}

		// Notify listeners
		if (this.nodeID.equals(nodeID)) {

			// Notify local listeners (LOCAL services changed)
			broadcastServicesChanged(true);
		} else {

			// Notify local listeners (REMOTE services changed)
			broadcastServicesChanged(false);
		}
	}
788430
private void cleanup_heartbeat_proxies() {
        // disconnect the pushsupplier to stop receiving events
        Enumeration keys = event_callback_map.keys();
        while (keys.hasMoreElements()) {
            String name = (String) keys.nextElement();
            EventCallBackStruct callback_struct = event_callback_map.get(name);
            try {
                EventChannelStruct ec_struct = channel_map.get(callback_struct.channel_name);
                if (ec_struct.structuredProxyPushSupplier != null) {
                    //System.out.println("Disconnect " + callback_struct.channel_name);
                    ec_struct.structuredProxyPushSupplier.disconnect_structured_push_supplier();
                    ec_struct.structuredProxyPushSupplier = null;
                }
            } catch (Exception e) {
                System.out.println(e);
            }
            event_callback_map.remove(name);
        }
    }
31209
private void destroyInitializer() {
        GdxMaps.clearAll(fieldProcessors, methodProcessors, typeProcessors);
        GdxArrays.clearAll(scannedMetaAnnotations, scannedAnnotations, processors, delayedConstructions,
                manuallyAddedComponents, manuallyAddedProcessors);
    }
368725
public void detachIdentifier(String identifier) {
		if (!StringUtils.equals(identifier, getIdentifier())) {
			Sysprop s = CoreUtils.getInstance().getDao().read(getAppid(), identifier);
			if (s != null && StringUtils.equals(getId(), s.getCreatorid())) {
				deleteIdentifier(identifier);
			}
		}
	}
379946
@Override
    public <E extends Exception> void remove(Iteration<? extends Statement, E> statements) throws RepositoryException, E {
        while(statements.hasNext()){
            Statement st = statements.next();
            getClient().sendRemove(null, st.getSubject(), st.getPredicate(), st.getObject());
        }
    }
85540
public synchronized void removeUpdatesForQueue( String queueName )
    {
    	Iterator<TransactionItem> entries = items.iterator();
    	while (entries.hasNext())
		{
    		TransactionItem item = entries.next();
    		if (item.getDestination().getName().equals(queueName))
    		    entries.remove();
		}
    }
504590
public void remove(Object pKey)
    {
        Identity id;
        if(pKey instanceof Identity)
        {
            id = (Identity) pKey;
        }
        else
        {
            id = transaction.getBroker().serviceIdentity().buildIdentity(pKey);
        }
        mhtObjectEnvelopes.remove(id);
        mvOrderOfIds.remove(id);
    }
1233499
public void removeAndFail(Throwable cause) {
        assert ctx.executor().inEventLoop();
        if (cause == null) {
            throw new NullPointerException("cause");
        }
        PendingWrite write = head;

        if (write == null) {
            return;
        }
        ReferenceCountUtil.safeRelease(write.msg);
        ChannelPromise promise = write.promise;
        safeFail(promise, cause);
        recycle(write, true);
    }