A GOAWAY frame has been received; start shutting down this connection
482476
@Override
    public void destroy() {
        httpInboundChannel.stop(50);

        initialVC = null;
        frameReadProcessor = null;
        h2MuxReadCallback = null;
        h2MuxTCPConnectionContext = null;
        h2MuxTCPReadContext = null;
        h2MuxTCPWriteContext = null;
        localConnectionSettings = null;
        remoteConnectionSettings = null;
        readContextTable = null;
        writeContextTable = null;

        super.destroy();
    }
1321915
def shutdown_wr(self):
        
        if self._sock_send is not None:
            self._sock_send.close()
        else:
            return self.shutdown(socket.SHUT_WR)
180256
def stop(self):
        """"""
        self.reconnect = False
        self.logger.debug("Shutting down.")
        if self.transport:
            self.transport.close()
95608
def connectionLost(self, reason):
        """"""
        self.factory.loader.db.session.commit()
        if reactor.running:
            reactor.stop()
572682
def stop(self):
        """"""

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

        self.client.disconnect()
974952
public void stop() {
		
		try {
			if (this.socket != null) {
				this.socket.close();
			}
		} catch (final IOException e1) {
			GPSdEndpoint.LOG.debug("Close forced: " + e1.getMessage());
		}
		
		this.listeners.clear();
		
		if (this.listenThread != null) {
			this.listenThread.halt();
		}
		
		this.listenThread = null;
	}
440485
def halt(self):
        """"""
        self.log.warning('Halting connection to AVR')
        self._halted = True
        if self.protocol.transport:
            self.protocol.transport.close()
523277
def _close_connection(self, frame_in):
        
        self._set_connection_state(Stateful.CLOSED)
        if frame_in.reply_code != 200:
            reply_text = try_utf8_decode(frame_in.reply_text)
            message = (
                'Connection was closed by remote server: %s' % reply_text
            )
            exception = AMQPConnectionError(message,
                                            reply_code=frame_in.reply_code)
            self._connection.exceptions.append(exception)
468073
def Stop(self):
    """"""
    self._shutdown = True
    self._new_updates.set()  # Wake up the transmission thread.

    if self._main_thread is not None:
      self._main_thread.join()
      self._main_thread = None

    if self._transmission_thread is not None:
      self._transmission_thread.join()
      self._transmission_thread = None
538781
def _disconnect(self):
        """"""
        if not self.protocol or not self.protocol.transport:
            self.protocol = None  # Make sure protocol is None
            return
        _LOGGER.info('Disconnecting from gateway')
        self.protocol.transport.close()
        self.protocol = None
714040
public synchronized void stop() {
        if (isRunning()) {
            try {
                setSendingStatus(false);
            } catch (Throwable t) {
                logger.error("Problem stopping sending status during shutdown", t);
            }
            DeviceFinder.getInstance().removeIgnoredAddress(socket.get().getLocalAddress());
            socket.get().close();
            socket.set(null);
            broadcastAddress.set(null);
            updates.clear();
            setTempoMaster(null);
            setDeviceNumber((byte)0);  // Set up for self-assignment if restarted.
            deliverLifecycleAnnouncement(logger, false);
        }
    }
859195
def disconnect(self):
        
        if self.root.ref is not None:
            self.api.disconnect()
        self.root = None
1205587
public void shutdown() {
        /**
         * Probably we don't need this method in practice
         */
        if (initLocker.get() && shutdownLocker.compareAndSet(false, true)) {
            // do shutdown
            log.info("Shutting down transport...");

            // we just sending out ShutdownRequestMessage
            //transport.sendMessage(new ShutdownRequestMessage());
            transport.shutdown();

            executor.shutdown();
            initFinished.set(false);
            initLocker.set(false);
            shutdownLocker.set(false);
        }
    }
1251253
private void onSessionClose(){
        synchronized(pendingQueue){
            while(! pendingQueue.isEmpty()){
                Packet p = pendingQueue.remove();
                onLossPacket(p);
            }
        }
    }
1126703
function () {
			if (winble.deviceManager.isScanning)
				winble.deviceManager.isScanning = false;
			if (winble.deviceManager.connectionWatcher !== null)
				winble.deviceManager.stopConnectionWatcher();
		}
1082097
def shutdown(self):
        

        super(UDPTendrilManager, self).shutdown()

        # Reset the socket and socket event
        self._sock = None
        self._sock_event.clear()
345739
def _on_disconnect(self):
        

        self._logger.info("Connection to device %s was interrupted", self.connection_string)
        self.connection_interrupted = True