Stops a process engine, failures are logged but no exceptions are thrown.
964175
private void stopProcessEngine(String serviceName, PlatformServiceContainer serviceContainer) {

    try {
      serviceContainer.stopService(serviceName);
    }
    catch(Exception e) {
      LOG.exceptionWhileStopping("Process Engine", serviceName, e);
    }

  }
886636
public synchronized void stop() throws Exception {
        if (!running) {
            return;
        }

        for (Connector each : this.connectors) {
            try {
                each.stop();
                each.setServer( null );
            } catch (Exception e) {
                // ignore
            }
        }

        running = false;
    }
995512
def stop(self, timeout=None):
        

        self.stopping = True

        for process in list(self.processes):
            self.stop_process(process, timeout=timeout)
841186
def stop(self):
        """"""
        self._end.value = True
        if self.background_process:
            try:
                self.background_process.terminate()
            except Exception:
                pass
        for task_id, values in self.current_tasks.items():
            try:
                values['proc'].terminate()
            except Exception:
                pass
1033947
def stop(self):
        """"""
        LOGGER.info('Attempting to stop the process')
        self.set_state(self.STATE_STOP_REQUESTED)

        # Call shutdown for classes to add shutdown steps
        self.shutdown()

        # Wait for the current run to finish
        while self.is_running and self.is_waiting_to_stop:
            LOGGER.info('Waiting for the process to finish')
            time.sleep(self.SLEEP_UNIT)

        # Change the state to shutting down
        if not self.is_stopping:
            self.set_state(self.STATE_STOPPING)

        # Call a method that may be overwritten to cleanly shutdown
        self.on_shutdown()

        # Change our state
        self.set_state(self.STATE_STOPPED)
208816
@Override
	public void stop() {
		if (state.stop()){
			try{
				doStop();
				state.finishStopping();
			}catch(Exception e){
				state.failStopping();
				logger.warn("Failed to stop {}", this.getClass().getName(), e);
			}
		}

	}
390388
@Override
    public void stop(Throwable cause) throws Exception {
        stopping = true;
        if (task != null) {
            task.cancel(true);
        }
        super.stop(cause);
    }
1101455
public void stop() throws Exception {
        // verify server isn't null
        if (server == null) {
            throw new NullPointerException("Internal server instance was null, server already stopped perhaps?");
        }
        
        logger.info("HttpServer [{}] on [{}] stopping...", configuration.safeGetName(), configuration.getPortString());

        server.stop();

        logger.info("HttpServer [{}] on [{}] stopped", configuration.safeGetName(), configuration.getPortString());
    }
142280
@Override
    public void stop() {

        // Make sure to return the system streams to the state they were in
        // before we mucked with them
        restoreSystemStreams();

        unregisterLoggerHandlerSingleton();

        // Close writers, however they were allocated
        LoggingFileUtils.tryToClose(messagesLog);
        LoggingFileUtils.tryToClose(traceLog);
    }
648086
public void stop() {
		if (serverThread != null) {
			try {
				//close and force IOException in server process
				server.close();
				//server thread will end as well
			} catch (IOException ioe) {
				System.out.println(new LogEntry(Level.CRITICAL, ioe.getMessage(), ioe));
			}
		}

		//close client connections as well
		for (Connection client : new HashSet<Connection>(connectedClients)) {
			if (!client.isClosed()) {
				client.close("server shut down...");
			}
		}
	}
399401
public synchronized void stop() throws ManagedProcessException {
        if (mysqldProcess.isAlive()) {
            logger.debug("Stopping the database...");
            mysqldProcess.destroy();
            logger.info("Database stopped.");
        } else {
            logger.debug("Database was already stopped.");
        }
    }
340778
public synchronized void stop() throws ServerLifecycleException {
		try {
			server.stop();
			LOG.info("WebDavServer stopped.");
		} catch (Exception e) {
			throw new ServerLifecycleException("Server couldn't be stopped", e);
		}
	}
169898
def on_stop(self, *largs):
        """"""
        self.strings.save()
        self.funcs.save()
        self.engine.commit()
        self.procman.shutdown()
        self.config.write()
641502
@TaskAction
  public void stopAction() {
    DevServer server =
        devServers.newDevAppServer(CloudSdkOperations.getDefaultHandler(getLogger()));
    try {
      server.stop(runConfig.toStopConfiguration());
    } catch (AppEngineException ex) {
      getLogger().error("Failed to stop server: " + ex.getMessage());
    }
  }
30263
@PreDestroy
    public void stop() throws Exception {
        JmxUtils2.unregisterObject(queryMbeanObjectName, embeddedJmxTrans.getMbeanServer());

        for (OutputWriter outputWriter : outputWriters) {
            outputWriter.stop();
        }
    }
8444
def stop(self):
        
        if self.pid is None:

            return None

        try:

            while True:

                self.send(signal.SIGTERM)
                time.sleep(0.1)

        except RuntimeError as err:

            if "No such process" in str(err):

                LOG.info("Succesfully stopped the process.")
                return None

            LOG.exception("Failed to stop the process:")
            sys.exit(exit.STOP_FAILED)

        except TypeError as err:

            if "an integer is required" in str(err):

                LOG.info("Succesfully stopped the process.")
                return None

            LOG.exception("Failed to stop the process:")
            sys.exit(exit.STOP_FAILED)
724597
public void stop(long timeout, TimeUnit timeoutUnit) {
    if (lifecycle.tryToMoveTo(Lifecycle.State.STOPPING)) {
      stopGracefully(timeout, timeoutUnit);
      if (process != null && process.isAlive()) {
        LOG.info("{} failed to stop in a timely fashion. Killing it.", processId.getKey());
      }
      // enforce stop and clean-up even if process has been gracefully stopped
      stopForcibly();
    } else {
      // already stopping or stopped
      waitForDown();
    }
  }