}
	if debugPrint {
		fmt.Println("Connecting Mux", m.MuxID, ",to", m.parent.Remote)
	}

	// Space for one message and an error.
	responseCh := make(chan Response, 1)

	// Spawn simple disconnect
	if requests == nil {
		go m.handleOneWayStream(responseCh, responses)
		return &Stream{responses: responseCh, Requests: nil, ctx: m.ctx, cancel: m.cancelFn, muxID: m.MuxID}, nil
	}

        nonPooledConnections.offer(nonPooledSpy);

        // Mock disconnect behavior
        when(pooledSpy.disconnect(false, false)).thenReturn(true); // In use
        when(nonPooledSpy.disconnect(false, false)).thenReturn(false); // Not in use

        // When: Close the pool
        boolean inUse = pool.close();

        // Then: Should report in-use and call disconnect on all
        assertTrue(inUse, "Should report connections in use");

	OpConnectMux

	// OpMuxConnectError is an  error while connecting a mux.
	OpMuxConnectError

	// OpDisconnectClientMux instructs a client to disconnect a mux
	OpDisconnectClientMux

	// OpDisconnectServerMux instructs a server to disconnect (cancel) a server mux
	OpDisconnectServerMux

	// OpMuxClientMsg contains a message to a client Mux
	OpMuxClientMsg

                     * Someone removed the share while we were
                     * connected. Bastards! Disconnect this tree
                     * so that it reconnects cleanly should the share
                     * reappear in this client's lifetime.
                     */
                    log.debug("Disconnect tree on NT_STATUS_NETWORK_NAME_DELETED");
                    treeDisconnect(true, true);
                }

        self.active_connections: list[WebSocket] = []

    async def connect(self, websocket: WebSocket):
        await websocket.accept()
        self.active_connections.append(websocket)

    def disconnect(self, websocket: WebSocket):
        self.active_connections.remove(websocket)

    async def send_personal_message(self, message: str, websocket: WebSocket):
        await websocket.send_text(message)

        return delegate.hasCapability(cap);
    }

    @Override
    public boolean isDisconnected() {
        return delegate.isDisconnected();
    }

    @Override
    public boolean disconnect(boolean hard, boolean inuse) throws IOException {
        synchronized (connectionLock) {
            if (rdmaConnection != null) {
                try {
                    rdmaConnection.close();

    }

    private void attemptRecovery(ChannelInfo channel, FailoverState state) {
        try {
            log.info("Attempting to recover channel {}", channel.getChannelId());

            // Disconnect existing transport
            SmbTransport oldTransport = channel.getTransport();
            if (oldTransport != null) {
                try {
                    oldTransport.close();

	biggerBufMax = maxBufferSize

	// If there is a queue, merge up to this many messages.
	maxMergeMessages = 50

	// clientPingInterval will ping the remote handler every 15 seconds.
	// Clients disconnect when we exceed 2 intervals.
	clientPingInterval = 15 * time.Second

	// Deadline for single (non-streaming) requests to complete.
	// Used if no deadline is provided on context.
	defaultSingleRequestTimeout = time.Minute

/**
 * SMB1 COM_TREE_DISCONNECT command implementation.
 *
 * This command disconnects from a tree connection (share) on the server.
 * It releases the tree ID and terminates access to the share.
 */
public class SmbComTreeDisconnect extends ServerMessageBlock {

    /**
     * Constructs a tree disconnect request to close a connection to a shared resource.
     *
     * @param config the configuration to use

                default:
                    disconnect(true);
                    throw new NbtException(NbtException.ERR_SSN_SRVC, errorCode);
                }
                break;
            case -1:
                disconnect(true);
                throw new NbtException(NbtException.ERR_SSN_SRVC, NbtException.CONNECTION_REFUSED);
            default:
                disconnect(true);