Stop this connector, logging out existing sessions, closing their connections, and stopping to accept new
connections.
540598
@Override
    public void stop() {
        synchronized (this.lifecycleMonitor) {
            if (isRunning()) {
                log.info("stop: Stopping ConnectorManager");
                try {
                    connector.stop();
                } finally {
                    running = false;
                }
            }
        }
    }
437816
public function stopConnection()
    {
        $this->connections[$this->counterConnections]['time'] = (time() + microtime(true) - $this->timer);
        $this->counterConnections++;
        $this->timer = 0;
    }
1330659
public synchronized void stop() {
        if (listenerThreads.size() > 0) {
            for (MulticastSocketListenerThread thread : listenerThreads) {
                thread.shutdown();
            }
        }

        listenerThreads.clear();
    }
915341
public synchronized void stop() {
        if (mConnectThread != null) {
            mConnectThread.cancel();
            mConnectThread = null;
        }

        if (mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }

        if (mSecureAcceptThread != null) {
            mSecureAcceptThread.cancel();
            mSecureAcceptThread.kill();
            mSecureAcceptThread = null;
        }
        setState(BluetoothService.STATE_NONE);
    }
27017
public void stop() {
        synchronized (this.startStopMonitor) {
            doStop();

            // If we registered a JVM shutdown hook, we don't need it anymore now:
            // We've already explicitly closed the context.
            if (this.shutdownHook != null) {
                try {
                    Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
                } catch (final IllegalStateException ex) {
                    // ignore - VM is already shutting down
                }
            }
        }
    }
481839
def close(self):
        
        conn = self._conn
        if conn is not None:
            conn = conn()
        if conn is not None:
            if self is conn._active_cursor:
                conn._active_cursor = conn._main_cursor
                self._session = None
            self._conn = None
1280736
@Override
    public void stop() {
        try {
            expectSupport.close();
        } catch (IOException e) {
            log(e, Project.MSG_DEBUG);
        }
    }
993882
def Close(self):
		
		if self.connection is not None:
			try:
				self.connection.commit()
				self.connection.close()
				self.connection = None
			except Exception, e:
				pass
277084
def close(self):
        
        if self.connection:
            logging.info("Closing connection to {}.".format(self.host))
            self.connection.close()
            self.connection = None
977303
def close(self):
        
        if self.connection is not None:
            self.connection.close()
        if self.connection_fd is not None:
            self.connection_fd.close()
322649
def disconnect(self):
        
        if self.r_session:
            self.session_logout()

        self.r_session = None
        self.clear()
1251340
def close(self):
        """"""
        try:
            if not self.session.closed:
                if self.session._connector_owner:
                    self.session._connector.close()
                self.session._connector = None
        except Exception as e:
            Config.dummy_logger.error("can not close session for: %s" % e)
579612
def close_session(self):
        
        with self._graph.as_default():
            self._sess.close()
            self._sess = None
806751
public void disconnect() throws Exception {
		if (session != null) {
			session.getCloseFuture().awaitUninterruptibly();
		}
		if (connector != null) {
			connector.dispose();
		}
	}
1279388
def stop(self):
        """"""
        self._stopped = True
        threads = [self._accept_thread]
        threads.extend(self._server_threads)
        self._listening_sock.close()
        for sock in list(self._server_socks):
            try:
                sock.shutdown(socket.SHUT_RDWR)
            except socket.error:
                pass

            try:
                sock.close()
            except socket.error:
                pass

        with self._unlock():
            for thread in threads:
                thread.join(10)

        if self._uds_path:
            try:
                os.unlink(self._uds_path)
            except OSError:
                pass
572682
def stop(self):
        """"""

        if self._disconnector:
            self._disconnector.stop()

        self.client.disconnect()
1223192
@Override
  public boolean stop()
  {
    if (! _lifecycle.toStopping())
      return false;

    log.finest(this + " stopping");

    closeConnections();

    destroy();

    return true;
  }