Cut all wires and disconnect all connections established on this link
321514
def disconnect(self):
        

        for name, wire in self.wires():
            self.cut(name, disconnect=True)
369956
private void destroy()
  {
    if (log.isLoggable(Level.FINEST)) {
      log.finest(this + " destroying connection");
    }

    try {
      _socket.forceShutdown();
    } catch (Throwable e) {
    }

    try {
      closeConnection();
    } catch (Throwable e) {
      log.log(Level.FINER, e.toString(), e);
    }

    // XXX:
    _port.removeConnection(this);
  }
33339
function removeConnection(conn) {

  this.emit('disconnect');

  conn.removeAllListeners('input');
  conn.removeAllListeners('output');

  // clean channel subscriptions
  if(conn.client.pubsub) {
    // must slice channels ref
    this._pubsub.unsubscribe(
      conn, conn.client.pubsub.channels.slice(0));
  }

  // clean pattern subscriptions
  // client.pubsub can be null after
  // removing channel subscriptions
  if(conn.client.pubsub) {
    // must slice patterns ref
    this._pubsub.punsubscribe(
      conn, conn.client.pubsub.patterns.slice(0));
  }

  var ind = this._conn.indexOf(conn);
  // remove the connection reference
  // the server disconnect listener is once
  // so we should always have a valid
  // index into the array
  this._conn.splice(ind, 1);
}
887997
function (conn, cb) {

      // TODO: disconnect here
      if (typeof conn == 'function') {
        cb = conn;
        conn = null;
      }
      if (!conn) {
        connections = {};
        return cb();
      }
      if(!connections[conn]) return cb();
      delete connections[conn];
      cb();
    }
317227
def terminate(self):
        

        self.close()

        for conn in list(self._used):
            conn.close()
            self._terminated.add(conn)

        self._used.clear()
506312
def shutdown_connections(self):
        """"""
        if not self.is_shutting_down:
            self.set_state(self.STATE_SHUTTING_DOWN)
        for name in self.connections:
            if self.connections[name].is_running:
                self.connections[name].shutdown()
1301795
public function disconnect()
    {
        if (!is_array($this->conn) || !count($this->conn)) {
            return;
        }

        foreach ($this->conn as $conn) {
            Connection::close($conn);
        }
    }
742199
def drop_networks(self) -> None:
        """"""
        for network in self.session.query(Network).all():
            self.drop_network(network)
177326
def _disconnect(self):
        """"""
        for cluster in self._clusters:
            if 'connection' in cluster:
                connection = cluster.pop('connection')
                connection.close()
        # Remove all attributes that are database names so that next time
        # when they are accessed, __getattr__ will be called and will create
        # new Clients
        for dbname in self._mapped_databases:
            self.__delattr__(dbname)
        self._mapped_databases = []
1274345
def disconnect(self, device):
        """"""
        # self.device.ctrl.sendcontrol(']')
        # self.device.ctrl.sendline('quit')
        self.log("TELNET disconnect")
        try:
            self.device.ctrl.send(chr(4))
        except OSError:
            self.log("Protocol already disconnected")
1259451
def disconnect(self):
        
        if hasattr(self, '_lazy_sftp'):
            if self.sftp is not None:
                self.sftp.close()
            delattr(self, '_lazy_sftp')
        if hasattr(self, '_lazy_channel'):
            if self.channel is not None:
                self.channel.close()
            delattr(self, '_lazy_channel')
        if hasattr(self, '_lazy_cli'):
            if self.cli is not None:
                self.cli.close()
            delattr(self, '_lazy_cli')
        if hasattr(self, '_lazy_pbm'):
            if self.pbm is not None:
                self.pbm.close()
            delattr(self, '_lazy_pbm')
        if hasattr(self, '_lazy_rpyc'):
            if self.rpyc is not None:
                self.rpyc.close()
            delattr(self, '_lazy_rpyc')
915629
def disconnect(self):
        """"""
        if self.pipeline:
            self._send(*self.pipeline)
        self.pipeline = None
977091
def close_all(self):
        """"""
        for host, conns in self._cm.get_all().items():
            for h in conns:
                self._cm.remove(h)
                h.close()
1214137
private void purgeAllConnections() {
        synchronized (m_dbConns) {
            Iterator<DBConn> iter = m_dbConns.iterator();
            while (iter.hasNext()) {
                DBConn dbConn = iter.next();
                dbConn.close();
                iter.remove();
            }
        }
    }
131588
def disconnect(self):
        
        all_conns = chain(
            self._available_connections.values(),
            self._in_use_connections.values(),
        )

        for node_connections in all_conns:
            for connection in node_connections:
                connection.disconnect()
581968
def disconnect_all(self, message=""):
        """"""
        with self.mutex:
            for conn in self.connections:
                conn.disconnect(message)
1130944
def disconnect(self):
        """"""
        if self.pipeline:
            self._send(*self.pipeline)
        self.transport.close()
        self.transport = self.pipeline = None