@iotize/tap
Version:
IoTize Device client for Javascript
131 lines • 13.2 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());
});
};
import '../generated/service-container-extension';
import { StepOperations } from '@iotize/common/task-manager';
import { sleep } from '@iotize/common/utility';
import { TapError } from '@iotize/tap';
import { ResultCode } from '@iotize/tap/client/api';
import { CRC } from '@iotize/tap/client/impl';
import { SinglePacketChunk } from '../generated/models';
import { debug } from '../logger';
import { SinglePacketError } from './definitions';
import { SinglePacketBuilder } from './single-packet-builder';
import { SinglePacketSplitter } from './single-packet-splitter';
export class SinglePacketStoreLoader extends StepOperations {
constructor(steps,
// public readonly crc: number,
singlePacketService) {
super(StepOperations.createSequentialContainers(steps));
this.singlePacketService = singlePacketService;
}
static createOperationsFromBytes(data, singlePacketService, options) {
const chunkSize = (options === null || options === void 0 ? void 0 : options.chunkSize) || SinglePacketBuilder.MAX_PART_SIZE;
const offsetFitsOn2Bytes = data.length / chunkSize <= 0xffff;
const singlePacketSplitter = new SinglePacketSplitter({
chunkSize,
format: offsetFitsOn2Bytes
? SinglePacketChunk.Format.OFFSET_ON_2_BYTES
: SinglePacketChunk.Format.OFFSET_ON_4_BYTES,
pad: options && 'pad' in options ? options.pad : true,
});
const packets = singlePacketSplitter.chunk(data);
return SinglePacketStoreLoader.createOperationsFromChunk(packets, singlePacketService, options);
}
static createFromBytes(data, singlePacketService, options) {
const steps = SinglePacketStoreLoader.createOperationsFromBytes(data, singlePacketService, options);
return new SinglePacketStoreLoader(steps,
// expectedCRC,
singlePacketService);
}
/**
* Create single packet loading operations
* @param packets Single packet chunks to load to the Tap
* @param expectedCRC expected CRC sent to the Tap when executing the single packet. if you don't plan to execute single packet, you pass a dummy value
* @param singlePacketService
* @param options
*/
static createOperationsFromChunk(packets, singlePacketService, options, output = {
expectedCRC: 0,
}) {
output.expectedCRC = CRC.FIRST_VALUE;
const operations = packets.map((packet, index) => {
return (observer, context) => __awaiter(this, void 0, void 0, function* () {
if (packet.data.length > SinglePacketBuilder.MAX_PART_SIZE) {
throw SinglePacketError.maxSinglePacketPartSizeExceeded(packet, SinglePacketBuilder.MAX_PART_SIZE);
}
debug('createSinglePacketLoadOperations', `sendSinglePacket`, `sending packet ${index + 1}/${packets.length} offset: ${packet.offset}...${packet.offset + (packet.length || 0)}`);
let retryCount = 0;
const maxRetry = (options === null || options === void 0 ? void 0 : options.maxRetry) || 3;
output.expectedCRC = CRC.fromBytes(packet.data, output.expectedCRC);
while (true) {
retryCount++;
// if (userIncrementalSinglePacketPart) {
// const call = { ...this.tap.service.singlePacket.resources.writeChunk };
// call.bodyEncoder = undefined;
// call.body = encodePartialSinglePacketBig(packet.data, packet.offset * this.singlePacketSplitter.options.sizeMultiplicator);
// response = await this.tap.lwm2m.execute(call);
const response = yield singlePacketService.writeChunk(packet);
// }
// else {
// response = await singlePacketService.writeChunk(packet);
// }
if (retryCount < maxRetry &&
(response.status === ResultCode.SERVICE_UNAVAILABLE ||
response.status === ResultCode.NVM_ERROR)) {
debug('createSinglePacketLoadOperations', `Attempt ${retryCount + 1}/${maxRetry} failed with error ${TapError.reponseStatusError(response).toString()}`);
yield sleep((options === null || options === void 0 ? void 0 : options.retryDelay) || 500);
continue;
}
response.successful();
observer.next({
step: SinglePacketStoreLoader.Step.loadPacketChunk,
progress: {
total: packets.length,
loaded: index + 1,
},
});
return;
}
// debug(TAG, `sendSinglePacket`, `Packet ${index + 1}/${packets.length} SENT!`);
});
});
if (options === null || options === void 0 ? void 0 : options.execute) {
operations.push((observer, context) => __awaiter(this, void 0, void 0, function* () {
observer.next({
step: SinglePacketStoreLoader.Step.executeSinglePacket,
expectedCRC: output.expectedCRC,
});
(yield singlePacketService.executeSinglePacketInStore(output.expectedCRC)).successful();
}));
}
return operations;
}
static createFromChunks(packets, singlePacketService, options) {
return new SinglePacketStoreLoader(SinglePacketStoreLoader.createOperationsFromChunk(packets, singlePacketService, options), singlePacketService);
}
static computeCRC(data) {
if (data instanceof Uint8Array) {
return CRC.mpeg2().compute(data);
}
else {
return data.reduce((crc, packet) => {
return CRC.mpeg2().compute(packet.data, crc);
}, CRC.FIRST_VALUE);
}
}
}
(function (SinglePacketStoreLoader) {
let Step;
(function (Step) {
Step["loadPacketChunk"] = "loadPacketChunk";
Step["executeSinglePacket"] = "executeSinglePacket";
})(Step = SinglePacketStoreLoader.Step || (SinglePacketStoreLoader.Step = {}));
})(SinglePacketStoreLoader || (SinglePacketStoreLoader = {}));
//# sourceMappingURL=data:application/json;base64,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