@signiant/media-shuttle-sdk-base
Version:
The base parent sdk behind other media shuttle sdks (e.g. media-shuttle-sdk)
290 lines (289 loc) • 14.5 kB
JavaScript
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
import { CodedError, ConnectionState, ErrorCode, TransferEventType, TransferState, } from '../../external';
import LogManager from '../system/LogManager';
import { mapFromAppTransferEvent } from '../common/utils';
import ErrorMessages from '../../external/common/ErrorMessages';
import TransferOperation from '../../external/enums/TransferOperation';
import { TransferClientEventType, TransferClientState } from '../enums';
import { transferConfigKeyJsId } from '../common/constants';
import { v4 as uuid } from 'uuid';
/**
* An abstract implementation of common functionalities between upload and download transfers
*/
var AbstractTransfer = /** @class */ (function () {
function AbstractTransfer(_transferClient) {
this._transferClient = _transferClient;
this._eventHandlerMap = new Map();
this._originatorId = uuid();
this._handleTransferClientStateChangeBoundInstance = this.handleTransferClientStateChange.bind(this);
this._transferClient.on(TransferClientEventType.STATE_CHANGED, this._handleTransferClientStateChangeBoundInstance);
}
AbstractTransfer.prototype.handleTransferClientStateChange = function (newState) {
return __awaiter(this, void 0, void 0, function () {
var err_1, err_2;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!(newState === TransferClientState.INITIALIZED)) return [3 /*break*/, 9];
this.publishTransferConnectionStatusUpdateEvent(ConnectionState.CONNECTED);
_a.label = 1;
case 1:
_a.trys.push([1, 3, , 4]);
return [4 /*yield*/, this._transferClient.reinitialize()];
case 2:
_a.sent();
return [3 /*break*/, 4];
case 3:
err_1 = _a.sent();
LogManager.error("Failed to reinitialize transfer client for transfer [".concat(this.transferId, "]"), err_1);
/**
* If the reinitialization fails there don't bother taking any further steps because communication
* with the app will not work.
*/
return [2 /*return*/];
case 4:
if (!(this._transferState === TransferState.IN_PROGRESS)) return [3 /*break*/, 8];
_a.label = 5;
case 5:
_a.trys.push([5, 7, , 8]);
this.subscribeToAllTransferEvents();
LogManager.debug('Attempting transfer restart');
return [4 /*yield*/, this.startTransfer()];
case 6:
_a.sent();
LogManager.info("Successfully restarted transfer [".concat(this.transferId, "]"));
return [3 /*break*/, 8];
case 7:
err_2 = _a.sent();
LogManager.error("Problem restarting transfer [".concat(this.transferId, "]"), err_2);
return [3 /*break*/, 8];
case 8: return [3 /*break*/, 10];
case 9:
if (newState === TransferClientState.UNINITIALIZED) {
this.publishTransferConnectionStatusUpdateEvent(ConnectionState.DISCONNECTED);
}
_a.label = 10;
case 10: return [2 /*return*/];
}
});
});
};
AbstractTransfer.prototype.publishTransferConnectionStatusUpdateEvent = function (connectionState) {
this.publishTransferEvent({
type: TransferEventType.TRANSFER_CLIENT_CONNECTION_STATUS_UPDATE,
eventData: {
transferId: this._transferId,
connectionState: connectionState,
},
});
};
AbstractTransfer.prototype.cancel = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!this.isInCancellableState()) {
throw new CodedError({
code: ErrorCode.STATE_TRANSITION_INVALID,
message: ErrorMessages.generatedErrorMessages[ErrorCode.STATE_TRANSITION_INVALID](TransferOperation.CANCEL, this._transferState),
});
}
return [4 /*yield*/, this._transferClient.cancelTransfer(this._originatorId)];
case 1:
_a.sent();
this._transferState = TransferState.CANCELING;
return [2 /*return*/];
}
});
});
};
AbstractTransfer.prototype.isInCancellableState = function () {
return this._transferState === TransferState.IN_PROGRESS || this._transferState === TransferState.STARTING;
};
Object.defineProperty(AbstractTransfer.prototype, "currentTransferState", {
get: function () {
return this._transferState;
},
enumerable: false,
configurable: true
});
AbstractTransfer.prototype.unsubscribeAll = function () {
if (this._eventHandlerMap.size > 0) {
this._eventHandlerMap.clear();
return true;
}
return false;
};
AbstractTransfer.prototype.isInRetryableState = function () {
return this._transferState === TransferState.FAILURE || this._transferState === TransferState.CANCELED;
};
AbstractTransfer.prototype.retry = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!this.isInRetryableState()) {
throw new CodedError({
code: ErrorCode.STATE_TRANSITION_INVALID,
message: ErrorMessages.generatedErrorMessages[ErrorCode.STATE_TRANSITION_INVALID](TransferOperation.RETRY, this._transferState),
});
}
return [4 /*yield*/, this.startTransfer()];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
};
AbstractTransfer.prototype.start = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (this._transferState) {
throw new CodedError({
code: ErrorCode.STATE_TRANSITION_INVALID,
message: 'Transfer is already underway, cannot be started, if retrying, use retry function',
});
}
return [4 /*yield*/, this.startTransfer()];
case 1:
_a.sent();
return [2 /*return*/];
}
});
});
};
AbstractTransfer.prototype.onTransferUpdate = function (_a) {
var type = _a.type, context = _a.context, content = _a.content;
LogManager.debug("onTransferUpdate message received from the transferClient type =[".concat(type, "], context =[").concat(context, "], content=").concat(JSON.stringify(content), " "));
if (type === 'event') {
var _b = this.mapTransferClientEvent({ context: context, content: content }), state = _b.state, transferEvent = _b.transferEvent;
if (transferEvent.type) {
//If there is no state specific info in the event, retain the old state
this._transferState = state ? state : this._transferState;
if ([TransferState.CANCELED, TransferState.SUCCESSFUL, TransferState.FAILURE].includes(this._transferState)) {
this.unsubscribeFromAllTransferEvents();
this._transferClient.off(TransferClientEventType.STATE_CHANGED, this._handleTransferClientStateChangeBoundInstance);
}
this.publishTransferEvent(transferEvent);
}
}
};
AbstractTransfer.prototype.publishTransferEvent = function (event) {
this.onTransferEvent(event).catch(function (err) {
LogManager.warn('Error processing event: ', err);
LogManager.debug(event);
});
if (this._eventHandlerMap.has(event.type)) {
try {
this._eventHandlerMap.get(event.type)(event);
}
catch (err) {
LogManager.warn("Subscription function resulted in error ".concat(err.messge));
}
}
};
AbstractTransfer.prototype.unsubscribeFromAllTransferEvents = function () {
this._transferClient.removeEventHandler(this._originatorId, /.*/);
};
AbstractTransfer.prototype.subscribeToAllTransferEvents = function () {
this._transferClient.setEventHandler(this._originatorId, /.*/, this.onTransferUpdate.bind(this));
};
AbstractTransfer.prototype.mapTransferClientEvent = function (_a) {
var context = _a.context, content = _a.content;
var _b = mapFromAppTransferEvent({
transferId: this._transferId,
eventType: context,
eventData: content,
}), state = _b.state, transferEvent = _b.transferEvent;
return { state: state, transferEvent: transferEvent };
};
AbstractTransfer.prototype.startTransfer = function () {
return __awaiter(this, void 0, void 0, function () {
var error_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 2, , 3]);
this._transferConfig[transferConfigKeyJsId] = this.transferId;
this.subscribeToAllTransferEvents();
return [4 /*yield*/, this.executeTransferCommand()];
case 1:
_a.sent();
this._transferState = TransferState.STARTING;
return [3 /*break*/, 3];
case 2:
error_1 = _a.sent();
this.unsubscribeFromAllTransferEvents();
this._transferState = TransferState.FAILURE;
throw error_1;
case 3: return [2 /*return*/];
}
});
});
};
AbstractTransfer.prototype.subscribeToEvent = function (_a) {
var eventType = _a.eventType, handler = _a.handler;
if (this._eventHandlerMap.has(eventType)) {
LogManager.warn("Replacing an existing subscription for event ".concat(eventType));
}
this._eventHandlerMap.set(eventType, handler);
};
AbstractTransfer.prototype.unsubscribeFromEvent = function (_a) {
var eventType = _a.eventType;
if (this._eventHandlerMap.has(eventType)) {
delete this._eventHandlerMap[eventType];
return true;
}
return false;
};
Object.defineProperty(AbstractTransfer.prototype, "transferId", {
get: function () {
return this._transferId;
},
set: function (transferId) {
this._transferId = transferId;
},
enumerable: false,
configurable: true
});
return AbstractTransfer;
}());
export default AbstractTransfer;