apache-iggy 0.10.0 → 0.10.1-edge.2

package/dist/client/client.connection.js

@@ -21,7 +21,8 @@ import { readFileSync } from 'node:fs';
 import { debug } from './client.debug.js';
 import { DEFAULT_MAX_RESPONSE_FRAME_SIZE } from './client.config.js';
 import { ProtocolFrameError, ResponseFrameDecoder } from './client.frame.js';
-import { Command, peekCommand } from '../wire/vsr/header.js';
+import { Command, EvictionReason, peekCommand, readEviction, readStatus, REQUEST_OFFSET, REPLY_OFFSET } from '../wire/vsr/header.js';
+import { ChangeSignal, PermitPool, OPERATION_TIMEOUT_MS, VsrResponseTimeoutError, waitWithin } from './client.operation.js';
 import { evictionError } from '../wire/vsr/reply.js';
 /**
  * Creates a TCP socket connection.
@@ -75,506 +76,242 @@ const getTransport = (config) => {
             return createTcpSocket(options);
     }
 };
-/**
- * Bound on one dial while other endpoints are queued behind it. Neither the
- * connect nor the TLS handshake has a deadline of its own, so a node whose syns
- * are dropped -- or one that accepts TCP and never answers the ClientHello --
- * would hold the whole pass. Matches the Rust SDK.
- */
-const FAILOVER_DIAL_TIMEOUT_MS = 2_000;
-/**
- * Default reconnection settings.
- *
- * One retry is one full pass over every endpoint the client knows, so this is
- * twelve passes rather than twelve dials, waiting 5 seconds between them. The
- * first pass runs at once when more than one endpoint is known: the node just
- * lost may be gone for good, and pausing before dialing a survivor only pushes
- * the failover past the interval a caller is willing to wait.
- */
-const DefaultReconnectOption = {
-    enabled: true,
-    interval: 5 * 1000,
-    maxRetries: 12
-};
-/**
- * Waits before a reconnection attempt.
- *
- * The timer is unref'd: a queued command fails fast on 'disconnected', so
- * the retry loop is background work that must not keep the process alive.
- *
- * @param interval - Delay in milliseconds before dialing again
- */
-const waitForReconnect = (interval) => new Promise((resolve) => {
-    const timeout = setTimeout(resolve, interval);
-    timeout.unref();
-});
-/**
- * Manages the low-level TCP/TLS connection to the Iggy server.
- * Handles connection lifecycle, reconnection, and data buffering.
- */
+export const DIAL_TIMEOUT_MS = 2_000;
+export const LINK_WRITE_QUEUE = 32;
+export const MAX_PENDING_PER_LINK = 256;
+const STALE_CLIENT = 30;
+/** A connected socket was lost; a later bootstrap can bind it again. */
+export class ConnectionClosedError extends Error {
+    constructor(cause) {
+        super(cause?.message ?? 'replica connection closed', { cause });
+        this.name = 'ConnectionClosedError';
+    }
+}
+/** One physical endpoint, with independent reader framing and a bounded writer. */
 export class IggyConnection extends EventEmitter {
-    /** Client configuration */
     config;
-    /** Underlying socket connection */
     socket;
-    /** Whether the connection is established */
-    connected;
-    /** Whether a connection attempt is in progress */
-    connecting;
-    /** Whether the connection is being intentionally closed */
-    ending;
-    /**
-     * Whether the socket is being replaced by a deliberate leader redirect
-     * rather than lost. The drop looks the same from the outside, but nothing a
-     * caller submitted is in doubt: work waiting to be sent belongs on the node
-     * the client moves to, not in an error.
-     */
-    redirecting;
-    /** Reconnection configuration */
-    reconnectOption;
-    /**
-     * Number of passes made over the known endpoints. One pass dials the
-     * endpoint the client is on, the endpoint it was configured with, and every
-     * node the roster named.
-     */
-    reconnectCount;
-    /** Shared promise for concurrent callers waiting on one connection attempt */
+    connected = false;
+    ending = false;
+    failure;
+    closed;
+    close;
     connectPromise;
-    /** Shared promise for callers waiting on automatic reconnection */
-    reconnectPromise;
-    /** Endpoint the client was configured with, kept across leader redirects */
-    seedOptions;
-    /**
-     * Every node the roster named on the last read, kept as redial candidates.
-     * A node dies together with its address, and the roster is unreachable
-     * exactly when it is needed, so it has to have been remembered while the
-     * connection was still healthy.
-     */
-    rosterEndpoints;
-    /** Incremental response frame decoder */
-    responseDecoder;
-    /**
-     * Creates a new IggyConnection.
-     *
-     * @param config - Client configuration
-     */
+    decoder;
+    pending = new Map();
+    writes = [];
+    changed = new ChangeSignal();
+    admissions = new PermitPool(MAX_PENDING_PER_LINK);
+    writing = false;
+    frameTimer;
+    failed = false;
     constructor(config) {
         super();
         this.config = config;
-        this.connected = false;
-        this.connecting = false;
-        this.ending = false;
-        this.redirecting = false;
-        this.reconnectOption = { ...DefaultReconnectOption, ...config.reconnect };
-        this.seedOptions = { ...config.options };
-        this.rosterEndpoints = [];
-        this.reconnectCount = 0;
-        this.connectPromise = undefined;
-        this.reconnectPromise = undefined;
-        this.responseDecoder = new ResponseFrameDecoder(config.maxResponseFrameSize ?? DEFAULT_MAX_RESPONSE_FRAME_SIZE);
-        this.socket = this._installSocket(getTransport(config));
+        this.decoder = new ResponseFrameDecoder(config.maxResponseFrameSize ?? DEFAULT_MAX_RESPONSE_FRAME_SIZE);
+        this.closed = new Promise((resolve) => { this.close = resolve; });
     }
-    /**
-     * Attaches the lifecycle listeners exactly once per socket instance.
-     * Attaching them in `connect()` would stack duplicate handlers whenever a
-     * failed attempt is retried on the same socket.
-     */
-    _installSocket(socket) {
-        socket.on('data', (data) => {
-            if (this.socket !== socket)
-                return;
-            if (!Buffer.isBuffer(data)) {
-                this.emit('error', new ProtocolFrameError('socket returned text instead of binary data'));
-                socket.destroy();
-                return;
-            }
-            this._onData(data);
-        });
-        socket.on('error', (err) => {
-            if (this.socket !== socket)
-                return;
-            debug('socket/error event', err, err.code, this.ending);
-            if (this.ending && (err?.code === 'ECONNRESET' || err?.code === 'EPIPE'))
-                return;
-            this.emit('error', err);
-        });
-        // The readiness event, not 'connect': on TLS the socket is only usable
-        // once the handshake completes, and writing a request before that would
-        // announce a connection the peer has not agreed to yet.
-        socket.once(this._readyEvent(), () => {
-            if (this.socket !== socket)
-                return;
-            debug('socket/connect event');
-            this.connected = true;
-            this.connecting = false;
-            this.reconnectCount = 0;
-            this.emit('connect');
-        });
-        socket.once('close', (hadError) => {
-            if (this.socket !== socket)
-                return;
-            debug('socket/close event', hadError);
-            this.connected = false;
-            this.connecting = false;
-            this.connectPromise = undefined;
-            this._endResponseWait();
-            this.emit('disconnected', hadError);
-            if (!this.ending)
-                void this.reconnect().catch(() => undefined);
-        });
-        return socket;
-    }
-    /**
-     * Establishes the connection to the server.
-     *
-     * @returns Promise that resolves when connected
-     */
-    connect(boundDial = false) {
-        if (this.ending)
-            return Promise.reject(new Error('connection is closed'));
+    connect(signal) {
+        if (this.ending || this.failed)
+            return Promise.reject(this.failure ?? new Error('connection is closed'));
         if (this.connected)
             return Promise.resolve(this);
-        if (this.reconnectPromise)
-            return this.reconnectPromise;
         if (this.connectPromise)
             return this.connectPromise;
-        if (this.socket.destroyed)
-            this.socket = this._installSocket(getTransport(this.config));
-        this.connecting = true;
-        const socket = this.socket;
-        // Bounded here too when the client knows somewhere else to go: this dial
-        // is not part of a pass, so an endpoint that never becomes usable would
-        // hold it with no timer of its own and the redial pass would never start.
-        const connectPromise = this._dialWithin(socket, boundDial || this._redialCandidates().length > 1);
-        this.connectPromise = connectPromise;
-        const clearConnectPromise = () => {
-            if (this.connectPromise === connectPromise)
-                this.connectPromise = undefined;
-        };
-        void connectPromise.then(clearConnectPromise, clearConnectPromise);
-        return connectPromise;
+        this.connectPromise = this.dial(signal);
+        return this.connectPromise;
     }
-    /**
-     * Waits for one dial, bounded while other endpoints are queued behind it.
-     *
-     * A socket has no connect deadline of its own and there is no 'timeout'
-     * listener on it, so a node whose syns are dropped holds the pass for the
-     * whole OS connect timeout -- and it leads every pass, because the current
-     * endpoint only moves on success. The bound covers the TLS handshake too,
-     * which is what `_readyEvent()` waits for and has no deadline of its own
-     * either. It matches the Rust, Go and C# SDKs'.
-     */
-    async _dialWithin(socket, bounded) {
-        if (!bounded)
-            return this._waitForConnection(socket);
-        let expire;
-        const bound = new Promise((_resolve, reject) => {
-            expire = setTimeout(() => {
-                // Destroying it makes the pending dial settle and releases the handle;
-                // left alone it would keep the event loop alive.
-                socket.destroy();
-                reject(new Error(`dial exceeded ${FAILOVER_DIAL_TIMEOUT_MS}ms`));
-            }, FAILOVER_DIAL_TIMEOUT_MS);
-            expire.unref?.();
-        });
+    async dial(signal) {
         try {
-            return await Promise.race([this._waitForConnection(socket), bound]);
+            signal?.throwIfAborted();
+            const socket = getTransport(this.config);
+            this.socket = socket;
+            const ready = this.config.transport === 'TLS' ? 'secureConnect' : 'connect';
+            socket.on('data', (data) => this.onData(data));
+            socket.on('error', (error) => this.fail(this.connected ? new ConnectionClosedError(error) : error));
+            socket.once('close', () => this.fail(this.failure ?? new ConnectionClosedError()));
+            await waitWithin(new Promise((resolve, reject) => {
+                const cleanup = () => {
+                    socket.removeListener(ready, established);
+                    socket.removeListener('error', rejected);
+                    socket.removeListener('close', closed);
+                };
+                const established = () => { cleanup(); resolve(); };
+                const rejected = (error) => { cleanup(); reject(error); };
+                const closed = () => rejected(new Error('connection closed before establishment'));
+                socket.once(ready, established);
+                socket.once('error', rejected);
+                socket.once('close', closed);
+            }), Date.now() + DIAL_TIMEOUT_MS, signal);
+            if (this.failed || this.ending)
+                throw this.failure ?? new Error('connection is closed');
+            this.connected = true;
+            this.emit('connect');
+            return this;
         }
-        finally {
-            clearTimeout(expire);
+        catch (error) {
+            this.fail(error);
+            throw error;
         }
     }
-    /**
-     * The event that says a socket can carry a request.
-     *
-     * On TLS that is 'secureConnect', not 'connect': the latter fires as soon as
-     * the TCP handshake completes, so waiting on it would treat a peer that
-     * never answers the ClientHello as connected and leave the handshake with no
-     * deadline at all.
-     */
-    _readyEvent() {
-        return this.config.transport === 'TLS' ? 'secureConnect' : 'connect';
-    }
-    _waitForConnection(socket) {
-        const ready = this._readyEvent();
-        return new Promise((resolve, reject) => {
-            const cleanup = () => {
-                socket.removeListener(ready, resolveConnect);
-                socket.removeListener('error', rejectConnect);
-                socket.removeListener('close', rejectClosed);
-            };
-            const rejectConnect = (error) => {
-                cleanup();
-                reject(error);
-            };
-            const rejectClosed = () => {
-                rejectConnect(new Error('connection closed before it was established'));
-            };
-            const resolveConnect = () => {
-                cleanup();
-                resolve(this);
-            };
-            socket.once('error', rejectConnect);
-            socket.once('close', rejectClosed);
-            socket.once(ready, resolveConnect);
-        });
-    }
-    /**
-     * Attempts to reconnect to the server.
-     * Respects maxRetries limit and emits error when exceeded.
-     *
-     * @param err - Optional error that triggered the reconnection
-     */
-    async reconnect(err) {
-        if (this.ending || this.connected)
-            return;
-        if (this.reconnectPromise)
-            return this.reconnectPromise;
-        const { enabled, interval, maxRetries } = this.reconnectOption;
-        debug('reconnect# event/reconnect?', {
-            reconnect: { enabled, interval, maxRetries },
-            count: this.reconnectCount,
-            lastError: err
-        });
-        const reconnectPromise = this._reconnectUntilConnected(enabled, interval, maxRetries, err);
-        this.reconnectPromise = reconnectPromise;
+    async exchange(frame, deadline, signal, owner) {
+        let release;
+        let pending;
         try {
-            return await reconnectPromise;
+            release = await this.admissions.acquire(deadline, signal);
+            signal.throwIfAborted();
+            if (Date.now() >= deadline)
+                throw new VsrResponseTimeoutError(0);
+            if (!this.connected || this.failed)
+                throw this.failure ?? new Error('replica connection is not ready');
+            const bytes = frame();
+            const id = bytes.readBigUInt64LE(REQUEST_OFFSET.request);
+            if (this.pending.has(id))
+                throw new Error('request id already has an active exchange');
+            let resolve;
+            const response = new Promise((complete) => { resolve = complete; });
+            pending = { id, frame: bytes, owner, resolve, done: false, started: false };
+            this.pending.set(id, pending);
+            while (this.writes.length >= LINK_WRITE_QUEUE && !pending.done) {
+                await waitWithin(this.changed.promise, deadline, signal);
+            }
+            signal.throwIfAborted();
+            if (!pending.done) {
+                owner?.retain();
+                this.writes.push(pending);
+                void this.writeFrames();
+            }
+            return await waitWithin(response, deadline, signal);
         }
         catch (error) {
-            if (!this.ending)
-                this.emit('error', error);
-            return;
+            if (pending)
+                this.finish(pending, { error, started: pending.started });
+            return { error, started: pending?.started ?? false };
         }
         finally {
-            if (this.reconnectPromise === reconnectPromise)
-                this.reconnectPromise = undefined;
-            this.connecting = false;
+            release?.();
         }
     }
-    async _reconnectUntilConnected(enabled, interval, maxRetries, initialError) {
-        let lastError = initialError;
-        let expectedSocket = this.socket;
-        let firstPass = true;
-        // Reconnection settings bound the retries, not the endpoints. With them off
-        // and several endpoints known - the address the client was configured with,
-        // the nodes the roster named - those endpoints were made known in order to
-        // be tried, so they get one pass and no backoff, as in the other SDKs. A
-        // client that knows one endpoint and turned reconnection off redials
-        // nothing, which is what it asked for.
-        // Counted rather than tracked within this call: every dial the pass fails
-        // closes a socket, and a close starts a reconnect of its own. Bounded by
-        // `firstPass` alone, each of those closes would open another sweep and the
-        // pass would repeat for as long as the endpoints stay down. The count is
-        // reset when a connection is established, so a later loss sweeps again.
-        const sweepOnce = !enabled && this._redialCandidates().length > 1;
-        while ((enabled && this.reconnectCount < maxRetries) ||
-            (sweepOnce && this.reconnectCount < 1)) {
-            this.connecting = true;
-            this.reconnectCount += 1;
-            const candidates = this._redialCandidates();
-            // The backoff paces retries against a single endpoint. With other
-            // endpoints known there is somewhere else to go, and pausing first only
-            // pushes the failover past the interval a caller is willing to wait;
-            // later passes still back off.
-            if (enabled && (!firstPass || candidates.length === 1))
-                await waitForReconnect(interval);
-            firstPass = false;
-            if (this.ending)
-                throw new Error('connection is closed', { cause: lastError });
-            // A redirect may replace the socket at any point. Defer to the active
-            // connection instead of dialing the superseded endpoint.
-            if (this.connected || this.socket !== expectedSocket)
-                return this.connect();
-            // Every endpoint gets its turn inside one attempt, so a full pass over
-            // the cluster costs one retry rather than one per endpoint: a pass that
-            // stopped at the first refusal would never reach the survivors of a
-            // client configured for a single retry.
-            for (const options of candidates) {
-                // Re-checked every iteration, not once above the loop: a destroy or a
-                // redirect mid-pass has to stop the pass. Left running, the next
-                // endpoint that answers would leave an open socket nobody closes, a
-                // 'connect' event after the destroy, and the process alive.
-                if (this.ending)
-                    throw new Error('connection is closed', { cause: lastError });
-                if (this.socket !== expectedSocket)
-                    return this.connect();
-                const socket = this._installSocket(getTransport({ ...this.config, options }));
-                this.socket = socket;
-                expectedSocket = socket;
+    async writeFrames() {
+        if (this.writing)
+            return;
+        this.writing = true;
+        try {
+            while (this.writes.length > 0) {
+                const pending = this.writes.shift();
+                this.changed.pulse();
                 try {
-                    await this._dialWithin(socket, candidates.length > 1);
-                    if (this.ending) {
-                        socket.destroy();
-                        throw new Error('connection is closed', { cause: lastError });
+                    if (pending.done)
+                        continue;
+                    pending.started = true;
+                    const written = new Promise((resolve, reject) => {
+                        this.socket.write(pending.frame, (error) => error ? reject(new ConnectionClosedError(error)) : resolve());
+                    });
+                    try {
+                        await waitWithin(written, Date.now() + OPERATION_TIMEOUT_MS);
+                    }
+                    catch (error) {
+                        this.fail(error);
+                        await written.catch(() => undefined);
                     }
-                    if (this.socket !== socket)
-                        return this.connect();
-                    this.config.options = options;
-                    return this;
                 }
-                catch (error) {
-                    lastError = error instanceof Error
-                        ? error
-                        : new Error(String(error));
-                    debug('reconnect attempt failed', lastError);
+                finally {
+                    pending.owner?.release();
                 }
             }
         }
-        debug(`reconnect reached maxRetries of ${maxRetries}`, lastError);
-        throw new Error(`reconnect maxRetries exceeded (count: ${this.reconnectCount})`, { cause: lastError });
-    }
-    /**
-     * Records the cluster roster as redial candidates.
-     *
-     * Replaced wholesale rather than merged: the roster is the cluster's own
-     * answer about where its nodes are, so a node it dropped stops being
-     * dialed. The configured seed is kept separately and outlives it.
-     */
-    rememberRoster(endpoints) {
-        if (endpoints.length === 0)
-            return;
-        this.rosterEndpoints = endpoints;
-    }
-    /**
-     * The roster endpoint after the one this connection is on, for a request
-     * the current node keeps refusing to admit. Metadata and partition
-     * consensus groups elect independently, so the metadata leader can hold a
-     * follower replica of the partition a request targets, and only walking
-     * the roster reaches that group's primary. `undefined` when the roster
-     * names nowhere else to go.
-     */
-    nextRosterEndpoint(visited) {
-        const roster = this.rosterEndpoints;
-        if (roster.length === 0)
-            return undefined;
-        const index = roster.findIndex((endpoint) => this.isConnectedTo(endpoint.host, endpoint.port));
-        if (index >= 0)
-            visited.add(endpointKey(roster[index]));
-        const start = index < 0 ? 0 : (index + 1) % roster.length;
-        for (let offset = 0; offset < roster.length; offset += 1) {
-            const candidate = roster[(start + offset) % roster.length];
-            const key = endpointKey(candidate);
-            if (visited.has(key) || this.isConnectedTo(candidate.host, candidate.port))
-                continue;
-            visited.add(key);
-            return candidate;
+        catch (error) {
+            this.fail(error);
         }
-        return undefined;
-    }
-    /**
-     * Endpoints a redial rotates through, likeliest first: where the client
-     * currently is, the endpoint it was configured with, then the roster it
-     * learned while connected. After a leader redirect the current endpoint may
-     * die with the leader, and the rest of the list is the way back to the
-     * cluster.
-     *
-     * Duplicates are dropped by spelling: the loopback aliases and an
-     * IPv4-mapped IPv6 address collapse onto one endpoint. Names are not
-     * resolved, so a seed given as a DNS name and the roster's IP for the same
-     * node still count as two candidates -- one wasted dial per pass, not a
-     * correctness problem.
-     */
-    _redialCandidates() {
-        const candidates = [this.config.options];
-        const known = [
-            this.seedOptions,
-            ...this.rosterEndpoints.map(({ host, port }) => ({ ...this.config.options, host, port }))
-        ];
-        for (const candidate of known) {
-            const duplicate = candidates.some((existing) => existing.port === candidate.port &&
-                normalizeHost(existing.host) === normalizeHost(candidate.host));
-            if (!duplicate)
-                candidates.push(candidate);
+        finally {
+            this.writing = false;
         }
-        return candidates;
     }
-    async redirect(host, port) {
-        const redirectedOptions = { ...this.config.options, host, port };
-        const redirectedConfig = {
-            ...this.config,
-            options: redirectedOptions
-        };
-        this.redirecting = true;
+    onData(data) {
         try {
-            // Destroying the old socket settles any dial still waiting on it. Its
-            // lifecycle listeners stay attached but go inert once the socket is
-            // replaced below, so surface the drop to in-flight exchanges ourselves.
-            this.socket.destroy();
-            this.connected = false;
-            this.connecting = false;
-            this.connectPromise = undefined;
-            this.reconnectPromise = undefined;
-            this._endResponseWait();
-            this.socket = this._installSocket(getTransport(redirectedConfig));
-            this.emit('disconnected', false);
-            await this.connect();
-            this.config.options = redirectedOptions;
+            if (!Buffer.isBuffer(data))
+                throw new ProtocolFrameError('socket returned text instead of binary data');
+            const frames = this.decoder.push(data);
+            if (!this.decoder.hasBufferedData) {
+                clearTimeout(this.frameTimer);
+                this.frameTimer = undefined;
+            }
+            else if (!this.frameTimer || frames.length > 0) {
+                clearTimeout(this.frameTimer);
+                this.frameTimer = setTimeout(() => this.fail(new ProtocolFrameError('incomplete consensus frame timed out')), OPERATION_TIMEOUT_MS);
+            }
+            for (const response of frames) {
+                if (peekCommand(response) === Command.Eviction) {
+                    const error = evictionError(response);
+                    this.emit('eviction', error);
+                    // The server keeps the session of a stale client and drops only this
+                    // link, so it fails as a lost link and the client rebinds the session.
+                    this.fail(readEviction(response).reason === EvictionReason.StaleClient
+                        ? new Error('replica link evicted as a stale client', { cause: error }) : error);
+                    return;
+                }
+                if (peekCommand(response) !== Command.Reply)
+                    throw new ProtocolFrameError('unexpected consensus frame');
+                const id = response.readBigUInt64LE(REPLY_OFFSET.request);
+                const pending = this.pending.get(id);
+                if (pending)
+                    this.finish(pending, { response, started: pending.started });
+                // A 30 refusal says that the server no longer attaches this link to the
+                // session. A replica that replaced its client table says so of a live
+                // session too, so the link fails as a lost link and the bind decides.
+                if (readStatus(response) === STALE_CLIENT) {
+                    this.fail(new Error('replica link detached from its session'));
+                    return;
+                }
+            }
         }
-        finally {
-            this.redirecting = false;
+        catch (error) {
+            this.fail(error);
         }
     }
-    abort() {
-        this._endResponseWait();
-        this.socket.destroy();
+    finish(pending, result) {
+        if (pending.done)
+            return;
+        pending.done = true;
+        if (this.pending.get(pending.id) === pending)
+            this.pending.delete(pending.id);
+        pending.resolve(result);
+        this.changed.pulse();
+    }
+    fail(error) {
+        if (this.failed)
+            return;
+        this.failed = true;
+        this.failure = error;
+        this.connected = false;
+        clearTimeout(this.frameTimer);
+        this.decoder.clear();
+        for (const pending of this.pending.values())
+            this.finish(pending, { error, started: pending.started });
+        for (const pending of this.writes.splice(0))
+            pending.owner?.release();
+        this.socket?.destroy();
+        this.close();
+        this.changed.pulse();
+        if (this.listenerCount('error') > 0)
+            this.emit('error', error);
+        this.emit('disconnected');
+        debug('replica link closed', error);
     }
     isConnectedTo(host, port) {
         const target = normalizeHost(host);
-        if (this.socket.remotePort === port &&
-            normalizeHost(this.socket.remoteAddress) === target)
+        if (this.socket?.remotePort === port && normalizeHost(this.socket.remoteAddress) === target)
             return true;
-        // A roster may advertise a DNS name while the socket reports a resolved
-        // address; falling back to the configured endpoint avoids a redirect to
-        // the peer the client is already connected to.
-        return this.config.options.port === port &&
-            normalizeHost(this.config.options.host) === target;
+        return this.config.options.port === port && normalizeHost(this.config.options.host) === target;
     }
-    /**
-     * Destroys the connection and marks it as ending.
-     */
     _destroy() {
         this.ending = true;
-        this._endResponseWait();
-        this.socket.destroy();
-    }
-    /**
-     * Clears the response buffer and resets the waiting state.
-     */
-    _endResponseWait() {
-        this.responseDecoder.clear();
-    }
-    /**
-     * Handles incoming data from the socket.
-     * Buffers incomplete responses and emits complete ones.
-     *
-     * @param data - Incoming data buffer
-     */
-    _onData(data) {
-        debug('ONDATA', typeof data, Buffer.isBuffer(data), data?.length, this.responseDecoder.hasBufferedData);
-        try {
-            for (const response of this.responseDecoder.push(data)) {
-                if (peekCommand(response) === Command.Eviction)
-                    this.emit('eviction', evictionError(response));
-                else
-                    this.emit('response', response);
-            }
-        }
-        catch (error) {
-            this._endResponseWait();
-            this.emit('error', error instanceof Error ? error : new Error(String(error)));
-            this.socket.destroy();
-        }
-    }
-    writeFrame(frame) {
-        this.socket.write(frame);
+        this.fail(new Error('connection destroyed'));
     }
 }
 const normalizeHost = (host) => {
     const normalized = (host ?? '').toLowerCase().replace(/^::ffff:/, '');
-    return normalized === 'localhost' || normalized === '::1'
-        ? '127.0.0.1'
-        : normalized;
+    return normalized === 'localhost' || normalized === '::1' ? '127.0.0.1' : normalized;
 };
 export const endpointKey = (endpoint) => `${normalizeHost(endpoint.host)}:${endpoint.port}`;
 //# sourceMappingURL=client.connection.js.map