Stops all the clients (agents and DM).
<p>
Mostly for tests.
</p>
4546
void stopAll() {

		try {
			this.dmClient.closeConnection();
			stop();

		} catch( Throwable t ) {
			this.logger.warning( "An error occurred while closing the connection of the DM client." );
			Utils.logException( this.logger, new RuntimeException( t ));
		}
	}
1117543
public void stop() {
        CompletableFuture.runAsync(() -> {
            try {
                bootstrap.getInjector().getInstance(Server.class).stop();
            } catch (Exception ignore) {
                // Ignore NPE. At this point the server REALLY should be possible to find
            }
            bootstrap.shutdown();
        });
    }
430745
public void stop() {
        if (mCacheDispatcher != null) {
            mCacheDispatcher.quit();
        }
        for (int i = 0; i < mDispatchers.length; i++) {
            if (mDispatchers[i] != null) {
                mDispatchers[i].quit();
            }
        }
    }
697456
public void stop() {
        synchronized (LOCK) {
            if (this.active) {
                this.active = false;
                logger.info("Stopping UDP Manager");
                stopTasks();
                closeSelectors();
                cleanResources();
                logger.info("UDP Manager has stopped");
            }
        }
    }
257822
@Override public void stop() {
        lock.lock();
        try {
            if (process != null) {
                destroyProcess();
            }
            process = null;
        } finally {
            lock.unlock();
        }
    }
454674
public void shutdownComponent() {
        if (discoveryClient != null) {
            try {
                discoveryClient.shutdown();
                discoveryClient = null;
            } catch (Throwable th) {
                logger.error("Error in shutting down client", th);
            }
        }
    }
189637
public void shutdown () {
        synchronized ( this.queueDiscoverers ) {
            for (MBeanDestinationDiscovererScheduler oneDiscovererScheduler : this.queueDiscoverers.values()) {
                oneDiscovererScheduler.stop();
            }
        }

        synchronized ( this.brokerPollerMap ) {
            for ( ActiveMQBrokerPoller onePoller : this.brokerPollerMap.values() ) {
                onePoller.stop();
            }
        }

        this.discovererExecutorService.shutdown();
    }
448974
public void stop()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "stop");

    if(started)
    {
      started = false;
      if(keyGroup != null)
        keyGroup.stopMember();
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "stop");
  }
755728
@Invalidate
    public void stop(){
        for(ServiceRegistration registration: registrations){
            registration.unregister();
        }
        registrations.clear();
        names.clear();
    }
1280736
@Override
    public void stop() {
        try {
            expectSupport.close();
        } catch (IOException e) {
            log(e, Project.MSG_DEBUG);
        }
    }
1223192
@Override
  public boolean stop()
  {
    if (! _lifecycle.toStopping())
      return false;

    log.finest(this + " stopping");

    closeConnections();

    destroy();

    return true;
  }
318525
@Override
	public void stop()
	{
		if (!started)
			return;
		
		log.info("Stopping listener ["+getName()+"]");
		
		// Close the listen socket
		multiplexer.unregisterServerSocketHandler(this);
		multiplexer.stop();
		multiplexer = null;
		
		// Close remaining clients
		closeRemainingClients();
		
		started = false;
	}
1241667
public static void stopServices(IServiceManager manager) {
		final List<Service> otherServices = new ArrayList<>();
		final List<Service> infraServices = new ArrayList<>();
		final LinkedList<DependencyNode> serviceQueue = new LinkedList<>();
		final Accessors accessors = new StoppingPhaseAccessors();

		// Build the dependency graph
		buildInvertedDependencyGraph(manager, serviceQueue, infraServices, otherServices, accessors);

		// Launch the services
		runDependencyGraph(serviceQueue, infraServices, otherServices, accessors);

		manager.awaitStopped();
	}
1238027
@Override
  public void stop() {
    cancellable.cancel();

    for (final SocketChannelSelectionProcessor processor : processors) {
      processor.close();
    }

    try {
      selector.close();
    } catch (Exception e) {
      logger().log("Failed to close selctor for: '" + name + "'", e);
    }

    try {
      channel.close();
    } catch (Exception e) {
      logger().log("Failed to close channel for: '" + name + "'", e);
    }

    super.stop();
  }
45293
public void stop() {
        try {
            safeClose(myServerSocket);
            closeAllConnections();
            myThread.join();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
737582
@Override
    public void stop(){
        if(isStarted){
            synchronized (this) {
                if (isStarted) {
                    if (getLookupService() instanceof Closable) {
                        ((Closable) getLookupService()).stop();
                    }
                    isStarted = false;
                }
            }
        }
    }
968090
@Override
    public void stopPlatform() {
        try {
            for (Entry<String, AgentController> e : this.createdAgents
                    .entrySet()) {
                AgentController ac = e.getValue();
                ac.kill();
            }
            for (Entry<String, ContainerController> e : this.platformContainers
                    .entrySet()) {
                ContainerController cc = e.getValue();
                cc.kill();
            }
            this.mainContainer.kill();
            this.runtime.shutDown();
        } catch (Exception e) {
            logger.warning("Warning shuting down JADE platform: "
                    + e.getMessage());
        }
    }