Close the connection asynchronously, and close any associated
        CBS authentication session.
10037
async def destroy_async(self):
        
        try:
            await self.lock_async()
            _logger.debug("Unlocked connection %r to close.", self.container_id)
            await self._close_async()
        except asyncio.TimeoutError:
            _logger.debug(
                "Connection %r timed out while waiting for lock acquisition on destroy. Destroying anyway.",
                self.container_id)
            await self._close_async()
        finally:
            self.release_async()
        uamqp._Platform.deinitialize()
853125
def close(self):
        
        if not self.closable:
            LOGGER.warning('Closed called while %s', self.state_description)
            raise ConnectionStateError(self.state_description)
        self.state = self.STATE_CLOSING
        LOGGER.info('Closing RabbitMQ connection')
        self.connection.close()
399684
def disconnect(self):
        
        if self._shell:
            self._shell.close()
            self._shell = ""
        if isinstance(self._session, manager.Manager):
            self._session.close_session()
        elif isinstance(self._session, paramiko.client.SSHClient):
            self._session.close()
            self._session = ""
        elif isinstance(self._session, SCPClient):
            self._session.close()
            self._session = ""
            self._scp = ""
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
962608
async def close(self):
        
        if self._server:
            self._server.close()
            self._server = None
            coro = self._close_connections()
            if coro:
                await coro
            self.logger.debug('%s closed', self)
            self.event('stop').fire()
264784
async def close(self):
        
        if self._conn is None:
            return
        await self._run_operation(self._impl.close)
        self._conn = None
192602
def close_connection(self):
        """"""
        self._logger.info('Closing connection')
        self._closing = True
        self._connection.close()
48827
async def close(self):
        """"""
        if not self._conn:
            return
        c = await self._execute(self._conn.close)
        self._conn = None
        return c
1035064
def close(self):
        """"""
        # Instead of actually closing the connection,
        # return it to the pool so it can be reused.
        if self._con is not None:
            self._pool.cache(self._con)
            self._con = None
326496
def close(self):
        
        conn = self.connection
        if conn is None:
            return
        try:
            while self.nextset():
                pass
        finally:
            self.connection = None
707663
async def close(self, *, timeout=None):
        
        try:
            if not self.is_closed():
                await self._protocol.close(timeout)
        except Exception:
            # If we fail to close gracefully, abort the connection.
            self._abort()
            raise
        finally:
            self._cleanup()
616118
def disconnect(self):
        """"""
        try:
            self.cleanup()
            if self.protocol == "ssh":
                self.paramiko_cleanup()
            elif self.protocol == "telnet":
                self.remote_conn.close()
            elif self.protocol == "serial":
                self.remote_conn.close()
        except Exception:
            # There have been race conditions observed on disconnect.
            pass
        finally:
            self.remote_conn_pre = None
            self.remote_conn = None
            self.close_session_log()
831628
def close(self):
        
        logger.info("Closing connection to %s:%s", self._host, self._port)
        self._ioloop_future.cancel()
        try:
            yield from self._ioloop_future
        except asyncio.CancelledError:
            pass
393742
@Override
	public void close() {
		try {
			callbackRegistry.acceptConnectionStateChange(BitfinexConnectionStateEnum.DISCONNECTION_INIT);
			logger.debug("close() called");
			if (heartbeatThread != null) {
				heartbeatThread.interrupt();
				heartbeatThread = null;
			}

			if (websocketEndpoint != null) {
				websocketEndpoint.close();
				websocketEndpoint = null;
			}
			connectionStateChange(BitfinexConnectionStateEnum.DISCONNECTION_SUCCESS);
		} catch (final Exception e) {
			connectionStateChange(BitfinexConnectionStateEnum.DISCONNECTION_FAILED);
			throw new BitfinexClientException(e);
		}
	}
1070872
def stop(self):
        '''
        
        '''
        log.info('Stopping auth process')
        self.__up = False
        self.socket.close()
464201
async def close(self):
        

        # Remove the core NATS Streaming subscriptions.
        await self._close()

        req = protocol.CloseRequest()
        req.clientID = self._client_id
        msg = await self._nc.request(
            self._close_req_subject,
            req.SerializeToString(),
            self._connect_timeout,
            )
        resp = protocol.CloseResponse()
        resp.ParseFromString(msg.data)

        if resp.error != "":
            raise StanError(resp.error)
1370167
def close_connection(self, host):
        """"""
        for h in self._cm.get_all(host):
            self._cm.remove(h)
            h.close()