Closes the control channel
514057
public void close() throws IOException {
        logger.debug("ftp socket closed");
        if (ftpIn != null)
            ftpIn.close();
        if (ftpOut != null)
            ftpOut.close();
        if (socket != null)
            socket.close();

        hasBeenOpened = false;
    }
671880
def close(self):
        
        # If we aren't already closed ask for server to close
        if not self.is_closed():
            self._closing = True
            # Let the ChannelActor do the actual close operations.
            # It will do the work on CloseOK
            self.sender.send_Close(
                0, 'Channel closed by application', 0, 0)
            try:
                yield from self.synchroniser.wait(spec.ChannelCloseOK)
            except AMQPError:
                # For example if both sides want to close or the connection
                # is closed.
                pass
        else:
            if self._closing:
                log.warn("Called `close` on already closing channel...")
179227
private function close()
    {
        if (null !== $this->pipe && $this->pipe->isOpen()) {
            $this->pipe->close();
        }

        if (is_resource($this->socket)) {
            fclose($this->socket);
        }

        $this->thread = null;
        $this->channel = null;
    }
884894
public void stop() {
			if (this.channels.size() > 0) 
			{
	            logger.info(regularConfiguration.getName() + " currently has [" + this.channels.size() + "] open child channel(s) that will be closed as part of stop()");
	        }
			this.channelFactory.shutdown();
			this.channels.close().awaitUninterruptibly();
			this.regularBootstrap.shutdown();
			if(this.securedBootstrap!=null)
			this.securedBootstrap.shutdown();
	        logger.info(regularConfiguration.getName() + " stopped at " + regularConfiguration.getHost());
		}
149646
protected void closeDatagramChannel ()
    {
        if (_selector != null) {
            try {
                _selector.close();
            } catch (IOException ioe) {
                log.warning("Error closing selector: " + ioe);
            }
            _selector = null;
        }
        if (_datagramChannel != null) {
            log.debug("Closing datagram socket channel.");

            try {
                _datagramChannel.close();
            } catch (IOException ioe) {
                log.warning("Error closing datagram socket: " + ioe);
            }
            _datagramChannel = null;

            // clear these out because they are probably large and in charge
            _uout = null;
            _sequencer = null;
        }
    }
109934
@Override
    public void close() {
        ((ForkProtocolStack)prot_stack).remove(fork_channel_id);
        if(state == State.CLOSED)
            return;
        disconnect();  // leave cluster if connected
        prot_stack.destroy();
        state=State.CLOSED;
        notifyChannelClosed(this);
    }
557242
public void close() {

        if (this.xaConnection != null) {
            this.xaConnection.doClose();
        }
        this.closed = true;
        this.notifyClosed();

        if (LOG.isDebugEnabled()) {
            LOG.debug("PhynixxXAResource[" + this.getId() + "]:closed ");
        }
    }
878875
def close(self):
        """"""
        close_command = StandardSend(self._address,
                                     COMMAND_LIGHT_OFF_0X13_0X00)
        self._send_method(close_command, self._closed_message_received)
130923
@Override
    public void close() throws IOException {
        if(UndertowLogger.REQUEST_IO_LOGGER.isTraceEnabled()) {
            UndertowLogger.REQUEST_IO_LOGGER.tracef(new ClosedChannelException(), "Channel %s is being closed", this);
        }
        safeClose(channel);
        if(readData != null) {
            readData.close();
            readData = null;
        }
        closeSubChannels();
    }
4253
protected function closeChannels()
    {
        foreach ($this->channels as $key => $channel) {
            // channels[0] is this connection object, so don't close it yet
            if ($key === 0) {
                continue;
            }
            try {
                $channel->close();
            } catch (\Exception $e) {
                /* Ignore closing errors */
            }
        }
    }
864031
def close(self):
        
        if self._protocol is not None:
            self._protocol.processor.close()
            del self._protocol
503727
def channels_close(self, room_id, **kwargs):
        """"""
        return self.__call_api_post('channels.close', roomId=room_id, kwargs=kwargs)
263802
public function close()
    {
        $this->closing = true;
        $this->ws->close(1000, 'discordphp closing...');
        $this->emit('closed', [$this]);
    }
724040
def close(self, reply_code=0, reply_text='', class_id=0, method_id=0):
        '''
        
        '''
        # In the off chance that we call this twice. A good example is if
        # there's an error in close listeners and so we're still inside a
        # single call to process_frames, which will try to close this channel
        # if there's an exception.
        if hasattr(self, 'channel'):
            self.channel.close(reply_code, reply_text, class_id, method_id)
986096
def close(self):
        """"""

        if self.hwman.stream.connected:
            self.hwman.disconnect()

        self.hwman.close()
        self.opened = False
1095731
public void close() {
    if (socketChannel == null) {
      return;
    }

    monitor.remove(socketChannel);
    try {
      socketChannel.close();
    } catch (IOException ignored) {
      /* nothing to be done */
    } finally {
      socketChannel = null;
    }
  }
284134
private void closeChannel() {
        // TODO: race condition between this and the setChannel method.
        Channel c;
        synchronized (channelLock) {
            c = channel;
            channel = null;
            absoluteRemoteFs = null;
            isUnix = null;
        }
        if (c != null) {
            try {
                c.close();
            } catch (IOException e) {
                logger.log(Level.SEVERE, "Failed to terminate channel to " + getDisplayName(), e);
            }
            for (ComputerListener cl : ComputerListener.all())
                cl.onOffline(this, offlineCause);
        }
    }