botframework-streaming/lib/payloadTransport/payloadSender.js

Streaming library for the Microsoft Bot Framework

"use strict";
/**
 * @module botframework-streaming
 */
/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License.
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.PayloadSender = void 0;
const headerSerializer_1 = require("../payloads/headerSerializer");
const payloadConstants_1 = require("../payloads/payloadConstants");
const transportDisconnectedEvent_1 = require("./transportDisconnectedEvent");
/**
 * Streaming payload sender.
 */
class PayloadSender {
    /**
     * Get current connected state
     *
     * @returns true if connected to a transport sender.
     */
    get isConnected() {
        return this._sender != null;
    }
    /**
     * Connects to the given transport sender.
     *
     * @param sender The transport sender to connect this payload sender to.
     */
    connect(sender) {
        this._sender = sender;
    }
    /**
     * Sends a payload out over the connected transport sender.
     *
     * @param header The header to attach to the outgoing payload.
     * @param payload The stream of buffered data to send.
     * @param sentCallback The function to execute when the send has completed.
     */
    sendPayload(header, payload, sentCallback) {
        const packet = { header, payload, sentCallback };
        this.writePacket(packet);
    }
    /**
     * Disconnects this payload sender.
     *
     * @param event The disconnected event arguments to include in the disconnected event broadcast.
     */
    disconnect(event = transportDisconnectedEvent_1.TransportDisconnectedEvent.Empty) {
        var _a, _b;
        if (!this.isConnected) {
            return;
        }
        try {
            this._sender.close();
            (_a = this.disconnected) === null || _a === void 0 ? void 0 : _a.call(this, this, event);
        }
        catch (err) {
            (_b = this.disconnected) === null || _b === void 0 ? void 0 : _b.call(this, this, new transportDisconnectedEvent_1.TransportDisconnectedEvent(err.message));
        }
        finally {
            this._sender = null;
        }
    }
    writePacket(packet) {
        try {
            if (packet.header.payloadLength > 0 && packet.payload) {
                let leftOver = packet.header.payloadLength;
                while (leftOver > 0) {
                    const count = leftOver <= payloadConstants_1.PayloadConstants.MaxPayloadLength ? leftOver : payloadConstants_1.PayloadConstants.MaxPayloadLength;
                    const chunk = packet.payload.read(count);
                    const header = packet.header;
                    header.payloadLength = count;
                    header.end = leftOver <= payloadConstants_1.PayloadConstants.MaxPayloadLength;
                    const sendHeaderBuffer = Buffer.alloc(payloadConstants_1.PayloadConstants.MaxHeaderLength);
                    headerSerializer_1.HeaderSerializer.serialize(header, sendHeaderBuffer);
                    this._sender.send(sendHeaderBuffer);
                    this._sender.send(chunk);
                    leftOver -= chunk.length;
                }
                if (packet.sentCallback) {
                    packet.sentCallback();
                }
            }
        }
        catch (err) {
            this.disconnect(new transportDisconnectedEvent_1.TransportDisconnectedEvent(err.message));
        }
    }
}
exports.PayloadSender = PayloadSender;
//# sourceMappingURL=payloadSender.js.map