@ibm-aspera/sdk 0.2.29 → 0.4.12

package/dist/commonjs/helpers/ws.d.ts

@@ -0,0 +1,62 @@
+import { WebsocketTopics } from '../models/models';
+export declare class WebsocketService {
+    /** The main websocket connection to Aspera App*/
+    private globalSocket;
+    /** A map of requested subscription names and the callback for them */
+    private sockets;
+    /** The callback for websocket events */
+    private eventListener;
+    /** Indicator if the websocket is already connected */
+    private isConnected;
+    /** Global promise object that resolves when init completes */
+    private initPromise;
+    /** Log call for not being ready */
+    private handleNotReady;
+    /**
+     * This function handles when a connection is opened
+     */
+    private handleOpen;
+    /**
+     * This function handles completed subscription
+     */
+    private handleClose;
+    /**
+     * This function handles errors received from the websocket
+     */
+    private handleError;
+    /**
+     * This function handles messages received from the websocket
+     */
+    private handleMessage;
+    /**
+     * This function joins the channel to be able to subscribe to events
+     */
+    private joinChannel;
+    /**
+     * This function registers clients to listen to a certain message name. Returns any to allow functions to declare proper type
+     *
+     * @param messageName - the name of messages to listen to (one message name per subscription)
+     * @param callback - the callback function
+     */
+    registerMessage(messageName: WebsocketTopics, callback: Function): void;
+    /**
+     *
+     * @param callback This function registers clients to a certain WebSocket event.
+     *
+     * @param callback - the callback function to call with the event name.
+     */
+    registerEvent(callback: Function): void;
+    /**
+     * This function starts the websocket subscription with the websocket provider
+     *
+     * @returns a promise that resolves when the websocket connection is established
+     */
+    init(): Promise<unknown>;
+    private connect;
+    private reconnect;
+    private getWebSocketConnection;
+    private notifyEvent;
+    private updateRpcPort;
+}
+export declare const websocketService: WebsocketService;
+export default WebsocketService;

package/dist/commonjs/helpers/ws.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.websocketService = exports.WebsocketService = void 0;
+var helpers_1 = require("./helpers");
+var messages_1 = require("../constants/messages");
+var index_1 = require("../index");
+var WebsocketService = /** @class */ (function () {
+    function WebsocketService() {
+        var _this = this;
+        /** A map of requested subscription names and the callback for them */
+        this.sockets = new Map();
+        /** Indicator if the websocket is already connected */
+        this.isConnected = false;
+        /** Global promise object that resolves when init completes */
+        this.initPromise = (0, helpers_1.generatePromiseObjects)();
+        /**
+         * This function handles when a connection is opened
+         */
+        this.handleOpen = function () {
+            if (_this.isConnected || !_this.joinChannel()) {
+                return;
+            }
+            _this.isConnected = true;
+            _this.updateRpcPort();
+            _this.notifyEvent('RECONNECT');
+        };
+        /**
+         * This function handles completed subscription
+         */
+        this.handleClose = function () {
+            if (_this.isConnected) {
+                _this.isConnected = false;
+                _this.notifyEvent('CLOSED');
+            }
+            if (!_this.globalSocket) {
+                _this.handleNotReady();
+                return;
+            }
+            _this.reconnect();
+        };
+        /**
+         * This function handles errors received from the websocket
+         */
+        this.handleError = function () {
+            (0, helpers_1.errorLog)(messages_1.messages.websocketClosedError);
+        };
+        /**
+         * This function handles messages received from the websocket
+         */
+        this.handleMessage = function (message) {
+            var data = (0, helpers_1.safeJsonParse)(message.data);
+            // Message we get on subscription
+            if (data && data.id === 1) {
+                _this.initPromise.resolver(data);
+                return;
+            }
+            var socket = _this.sockets.get(data.method);
+            if (typeof socket === 'function' && data.params) {
+                socket(data.params);
+            }
+        };
+    }
+    /** Log call for not being ready */
+    WebsocketService.prototype.handleNotReady = function () {
+        (0, helpers_1.errorLog)(messages_1.messages.websocketNotReady);
+    };
+    /**
+     * This function joins the channel to be able to subscribe to events
+     */
+    WebsocketService.prototype.joinChannel = function () {
+        if (!this.globalSocket) {
+            this.handleNotReady();
+            return false;
+        }
+        this.globalSocket.send((0, helpers_1.safeJsonString)({ jsonrpc: '2.0', method: 'subscribe_transfer_activity', params: [index_1.asperaSdk.globals.appId], id: 1 }));
+        return true;
+    };
+    /**
+     * This function registers clients to listen to a certain message name. Returns any to allow functions to declare proper type
+     *
+     * @param messageName - the name of messages to listen to (one message name per subscription)
+     * @param callback - the callback function
+     */
+    WebsocketService.prototype.registerMessage = function (messageName, callback) {
+        if (!this.sockets.get(messageName)) {
+            this.sockets.set(messageName, function (data) {
+                callback(data.result);
+            });
+        }
+    };
+    /**
+     *
+     * @param callback This function registers clients to a certain WebSocket event.
+     *
+     * @param callback - the callback function to call with the event name.
+     */
+    WebsocketService.prototype.registerEvent = function (callback) {
+        this.eventListener = callback;
+        this.eventListener(this.isConnected ? 'RECONNECT' : 'CLOSED');
+    };
+    /**
+     * This function starts the websocket subscription with the websocket provider
+     *
+     * @returns a promise that resolves when the websocket connection is established
+     */
+    WebsocketService.prototype.init = function () {
+        this.connect();
+        return this.initPromise.promise;
+    };
+    WebsocketService.prototype.connect = function () {
+        var _this = this;
+        this.getWebSocketConnection(index_1.asperaSdk.globals.rpcPort)
+            .then(function (webSocket) {
+            _this.globalSocket = webSocket;
+            _this.globalSocket.onerror = _this.handleError;
+            _this.globalSocket.onclose = _this.handleClose;
+            _this.globalSocket.onopen = _this.handleOpen;
+            _this.globalSocket.onmessage = _this.handleMessage;
+            _this.handleOpen();
+        }).catch(function () {
+            _this.reconnect();
+        });
+    };
+    WebsocketService.prototype.reconnect = function () {
+        var _this = this;
+        if (this.globalSocket) {
+            this.globalSocket.close();
+        }
+        setTimeout(function () {
+            _this.connect();
+        }, 1000);
+    };
+    WebsocketService.prototype.getWebSocketConnection = function (port) {
+        var webSocketUrl = (0, helpers_1.getWebsocketUrl)(index_1.asperaSdk.globals.asperaAppUrl);
+        return new Promise(function (resolve, reject) {
+            var webSocket = new WebSocket("".concat(webSocketUrl, ":").concat(port));
+            webSocket.onopen = function () {
+                resolve(webSocket);
+            };
+            webSocket.onerror = function () {
+                reject("Connection failed on port ".concat(port));
+            };
+        });
+    };
+    WebsocketService.prototype.notifyEvent = function (event) {
+        if (typeof this.eventListener === 'function') {
+            this.eventListener(event);
+        }
+    };
+    WebsocketService.prototype.updateRpcPort = function () {
+        if (!this.globalSocket) {
+            return;
+        }
+        var url = new URL(this.globalSocket.url);
+        index_1.asperaSdk.globals.rpcPort = Number(url.port);
+    };
+    return WebsocketService;
+}());
+exports.WebsocketService = WebsocketService;
+exports.websocketService = new WebsocketService();
+exports.default = WebsocketService;

package/dist/commonjs/http-gateway/core.d.ts

@@ -0,0 +1,98 @@
+import { FileDialogOptions, DataTransferResponse, TransferSpec, AsperaSdkTransfer, ReadAsArrayBufferResponse, ReadChunkAsArrayBufferResponse } from '../models/models';
+/**
+ * HTTP Gateway Core Logic
+ * - File/Folder picking
+ * - Starting and testing
+ *
+ * @remarks
+ * Most logic is called directly by Desktop SDK functions
+ * You may not need to import anything from this file.
+ */
+/**
+ * Remove a transfer from HTTP Gateway systems
+ * @param id - ID of the transfer
+ *
+ * @returns Promise indicating success
+ */
+export declare const httpRemoveTransfer: (id: string) => Promise<any>;
+/**
+ * Get the list of http gateway transfers
+ *
+ * @returns list of HTTP Gateway
+ */
+export declare const httpGetAllTransfers: () => AsperaSdkTransfer[];
+/**
+ * Get a HTTP Gateway transfer by ID
+ *
+ * @returns a transfer or null
+ */
+export declare const httpGetTransfer: (id: string) => AsperaSdkTransfer | null;
+/**
+ * Create HTML input element for file picking
+ */
+export declare const createHtmlInputElement: () => HTMLInputElement;
+/**
+ * Handle drop events and store files for HTTP Gateway
+ * This works on top of desktop.
+ */
+export declare const handleHttpGatewayDrop: (items: DataTransferItemList, callback: (data: {
+    event: DragEvent;
+    files: DataTransferResponse;
+}) => void, event: DragEvent) => void;
+/**
+ * Open native browser file or folder picker for files
+ *
+ * @param options - File picker options
+ * @param folder - Indicate if choosing folders
+ *
+ * @returns Promise that resolves with info about the files picked
+ */
+export declare const httpGatewaySelectFileFolderDialog: (options?: FileDialogOptions, folder?: boolean) => Promise<DataTransferResponse>;
+/**
+ * Get a generic transfer object for HTTP Gateway transfers.
+ *
+ * @param transferSpec - TransferSpec being provided for the HTTP Gateway transfer
+ *
+ * @returns a transfer object to track status and send to consumers
+ */
+export declare const getSdkTransfer: (transferSpec: TransferSpec) => AsperaSdkTransfer;
+/**
+ * Send a transfer update through the SDK
+ *
+ * @param transfer - Transsfer object to send to consumers
+ */
+export declare const sendTransferUpdate: (transfer: AsperaSdkTransfer) => void;
+/**
+ * Try to parse and get a useful string from API calls for HTTP Gateway
+ *
+ * @param error - Error from API call for Gateway
+ *
+ * @returns a string to use for errors
+ */
+export declare const getMessageFromError: (error: any) => {
+    message: string;
+    code: number;
+};
+export declare const base64Encoding: (jsonString: string) => string;
+/**
+ * Returns the specified file's contents as a base64-encoded string.
+ *
+ * Note: The maximum file size allowed is 50 MiB.
+ *
+ * @param path path to the file to read
+ *
+ * @returns a promise that resolves with the file data as a base64-encoded string and mime type
+ */
+export declare const httpGatewayReadAsArrayBuffer: (path: string) => Promise<ReadAsArrayBufferResponse>;
+/**
+ * Read a chunk of a file as a base64-encoded string.
+ *
+ * Note: The maximum chunk size allowed is 50 MiB.
+ *
+ * @param path path to the file to read. For pure JS this will just be the filename.
+ * @param offset offset to start reading the file, in bytes
+ * @param chunkSize the size of the chunk to read, in bytes
+ *
+ * @returns a promise that resolves with the file chunk data as a base64-encoded string and mime type
+ */
+export declare const httpGatewayReadChunkAsArrayBuffer: (path: string, offset: number, chunkSize: number) => Promise<ReadChunkAsArrayBufferResponse>;