Declarative service method for removing an EndpointActivationService.
186262
protected synchronized void removeEndPointActivationService(ServiceReference<EndpointActivationService> reference) {
        String activationSvcId = (String) reference.getProperty(ACT_SPEC_CFG_ID);
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "activationSvcId : " + activationSvcId);
        }

        EndpointActivationServiceInfo easInfo = endpointActivationServices.get(activationSvcId);
        if (easInfo != null) {
            // If the service was being replaced, then the add method would
            // have been called first, and this reference would no longer be
            // set.  If it's still set, then the service is being removed and
            // there is no replacement, so just deactivate all endpoints.
            if (easInfo.serviceRef.equals(reference)) {
                deactivateEndpoints(easInfo.endpointFactories);

                easInfo.setReference(null);
                cleanupEndpointActivationServiceInfo(easInfo);
            } else {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "unset reference already removed");
                }
            }
        }
    }
46777
public void unregisterEndpoint(String endpointId) throws MgcpEndpointNotFoundException {
        MgcpEndpoint endpoint = this.endpoints.remove(endpointId);
        if (endpoint == null) {
            throw new MgcpEndpointNotFoundException("Endpoint " + endpointId + " not found");
        }
        endpoint.forget((MgcpMessageObserver) this);
        endpoint.forget((MgcpEndpointObserver) this);
        
        if (log.isDebugEnabled()) {
            log.debug("Unregistered endpoint " + endpoint.getEndpointId().toString() + ". Count: " + this.endpoints.size());
        }
    }
154935
def stop(self):
        
        self._context.remove_service_listener(self)
        if self.services:
            return [
                (service, reference)
                for reference, service in self.services.items()
            ]

        return None
797565
@Override
    public void removeInstanceChangeListener(String serviceName, ServiceInstanceChangeListener listener) throws ServiceException {
        ServiceInstanceUtils.validateManagerIsStarted(isStarted.get());
        ServiceInstanceUtils.validateServiceName(serviceName);
        if (listener == null) {
            throw new ServiceException(ErrorCode.SERVICE_DIRECTORY_NULL_ARGUMENT_ERROR,
                    ErrorCode.SERVICE_DIRECTORY_NULL_ARGUMENT_ERROR.getMessageTemplate(),
                    "ServiceInstanceChangeListener");
        }

        getLookupService().removeServiceInstanceChangeListener(serviceName, listener);
    }
688804
public void unregisterService(String serviceName, String providerId) {
        getServiceDirectoryClient().unregisterInstance(serviceName, providerId, disableOwnerError);
    }
668123
private void unregisterMBeanInService(String name) {
        ServiceRegistration<DynamicMBean> existingMBean = endpointMBeans.remove(name);
        if (existingMBean != null) {
            existingMBean.unregister();
        }
    }
806352
@Invalidate
    public void stop() {
        unregisterConfigurationsExposedAsServices();
        if (registration != null) {
            registration.unregister();
            registration = null;
            try {
                watcher.removeAndStopIfNeeded(configFile.getParentFile());
            } catch (RuntimeException e) { //NOSONAR
                // An exception can be thrown when the platform is shutting down.
                // ignore it.
            }
        }
    }
842112
private void removeServiceListeners(String id) {
        final ServiceListener[] listeners = serviceListeners.remove(id);
        if (listeners != null)
            for (ServiceListener listener : listeners)
                if (listener != null) {
                    lock.readLock().lock();
                    try {
                        if (bundleContext != null)
                            bundleContext.removeServiceListener(listener);
                    } finally {
                        lock.readLock().unlock();
                    }
                }
    }
259570
def endpoint_delete(service, region=None, profile=None, interface=None, **connection_args):
    '''
    
    '''
    kstone = auth(profile, **connection_args)
    endpoint = endpoint_get(service, region, profile, interface, **connection_args)
    if not endpoint or 'Error' in endpoint:
        return {'Error': 'Could not find any endpoints for the service'}
    kstone.endpoints.delete(endpoint['id'])
    endpoint = endpoint_get(service, region, profile, interface, **connection_args)
    if not endpoint or 'Error' in endpoint:
        return True
188226
protected void deactivate(ComponentContext context) {
        securityServiceRef.deactivate(context);
        unauthSubjectServiceRef.deactivate(context);
        authServiceRef.deactivate(context);
        credServiceRef.deactivate(context);

    }
1116490
public void deactivated()
	{
		// remove EOF submissions
		IPageSite site = fPage.getSite();
		IHandlerService handlerService = (IHandlerService) site.getService(IHandlerService.class);
		IContextService contextService = (IContextService) site.getService(IContextService.class);
		handlerService.deactivateHandler(fActivatedHandler);
		contextService.deactivateContext(fActivatedContext);
		fActivatedContext = null;
		fActivatedHandler = null;
	}
755728
@Invalidate
    public void stop(){
        for(ServiceRegistration registration: registrations){
            registration.unregister();
        }
        registrations.clear();
        names.clear();
    }
173658
def _terminate_service(self):
        """"""
        with self.__lock:
            if self._service:
                self._service.terminate()
            if self._pipe_commands:
                self._pipe_commands.close()
            if self._pipe_service:
                self._pipe_service.close()
            self._pipe_commands = None
            self._pipe_service = None
            self._service_class_name = None
            self._service_name = None
            if self._service_status != CommonService.SERVICE_STATUS_TEARDOWN:
                self.update_status(status_code=CommonService.SERVICE_STATUS_END)
            if self._service:
                self._service.join()  # must wait for process to be actually destroyed
            self._service = None
353443
public void dispose() {
        logDebug("Disposing.");
        mSetupDone = false;
        if (mServiceConn != null) {
            logDebug("Unbinding from service.");
            if (mContext != null) mContext.unbindService(mServiceConn);
        }
        mDisposed = true;
        mContext = null;
        mServiceConn = null;
        mService = null;
        mPurchaseListener = null;
    }
1280904
private void processEndpointDeActivation()
    {
        final String methodName = "processEndpointDeActivation";
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName, new Object[] {});
        }

        String endpointName = null;
        if (_messageEndpointFactory instanceof MDBMessageEndpointFactory)
        {
            try {
                endpointName = ((MDBMessageEndpointFactory) _messageEndpointFactory).getMDBKey().toString();
            } catch (Exception e) {
                FFDCFilter.processException(e,
                                            "com.ibm.ws.sib.ra.inbound.impl.SibRaListener",
                                            "1059", this);
            }

            // Output a message that we are about to pause the endpoint
            SibTr.warning(TRACE, "MESSAGE_ENDPOINT_PAUSED_AUTONOMICALLY_CWSIV0902",
                          new Object[] { endpointName, _destinationAddress });

            // call bus sec action
            try
            {
                // Use reflection here as the class should not be loaded for the stand alone
                // RA (this method should not be driven by the standalone RA and calling it
                // may invoke the use of BusSecurityAction which is not bundled with the stand alone
                // RA.
                Class<?> busAction = Class.forName("com.ibm.ws.sib.ra.inbound.impl.SibRaBusSecurityAction");
                Method performBusSecurityAction = busAction.getDeclaredMethod("performBusSecurityAction",
                                                                              new Class[] { String.class, SIDestinationAddress.class });
                performBusSecurityAction.invoke(null, new Object[] { endpointName, _destinationAddress });
            } catch (Exception ex)
            {
                FFDCFilter.processException(ex, CLASS_NAME + "." + methodName, "1:1128:1.68");
                SibTr.error(TRACE, "INVOKE_MBEAN_EXCEPTION__CWSIV0903",
                            new Object[] { endpointName, _destinationAddress, ex });
            }

        }

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName);
        }
    }
96460
def remove_service(self, zconf, typ, name):
        
        _LOGGER.debug("remove_service %s, %s", typ, name)
        service = self.services.pop(name, None)

        if not service:
            _LOGGER.debug("remove_service unknown %s, %s", typ, name)
            return

        if self.remove_callback:
            self.remove_callback(name, service)
191008
@Override
    public void unregisterService(ServiceInstance<T> service) throws Exception
    {
        Entry<T> entry = services.remove(service.getId());
        internalUnregisterService(entry);
    }