core-3nweb-client-lib 0.43.9 → 0.43.12

package/build/lib-client/objs-on-disk/obj-on-disk.js

@@ -16,41 +16,54 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjOnDisk = void 0;
+exports.DownloadsRunner = exports.Download = exports.ObjOnDisk = void 0;
+exports.splitSegsDownloads = splitSegsDownloads;
+exports.generateSectionsFrom = generateSectionsFrom;
 const buffer_utils_1 = require("../../lib-common/buffer-utils");
 const wrapping_1 = require("../../lib-common/byte-streaming/wrapping");
 const assert_1 = require("../../lib-common/assert");
 const file_writing_proc_1 = require("./file-writing-proc");
 const operators_1 = require("rxjs/operators");
-const obj_file_1 = require("../../lib-common/objs-on-disk/obj-file");
+const obj_version_file_1 = require("../../lib-common/objs-on-disk/obj-version-file");
 const utils_for_observables_1 = require("../../lib-common/utils-for-observables");
+const types_1 = require("util/types");
+const deferred_1 = require("../../lib-common/processes/deferred");
 class ObjOnDisk {
-    constructor(objId, version, objFile, downloader, readable, getBaseSegsOnDisk) {
+    constructor(objId, version, objFile, downloader, readable, getBaseSegsOnDisk, downloadsInProgress = undefined) {
         this.objId = objId;
         this.version = version;
         this.objFile = objFile;
         this.downloader = downloader;
         this.readable = readable;
         this.getBaseSegsOnDisk = getBaseSegsOnDisk;
+        this.downloadsInProgress = downloadsInProgress;
         this.proxiedHeader = undefined;
+        if (this.downloadsInProgress) {
+            this.downloadsInProgress.saveSegs = this.objFile.saveSegs.bind(this.objFile);
+            this.downloadsInProgress.segsThatNeedDownload = this.segsThatNeedDownload.bind(this);
+        }
         Object.seal(this);
     }
     static async forExistingFile(objId, version, path, downloader, getBase) {
-        const objFile = await obj_file_1.ObjVersionFile.forExisting(path);
+        const objFile = await obj_version_file_1.ObjVersionFile.forExisting(path);
         return new ObjOnDisk(objId, version, objFile, downloader, true, getBase);
     }
     static async createFileForExistingVersion(objId, version, path, downloader, getBase, initDownload) {
+        let download;
         if (!initDownload) {
-            initDownload =
-                await downloader.getLayoutWithHeaderAndFirstSegs(objId, version);
+            download = new Download(objId, version, downloader);
+            initDownload = await download.getInitParts();
+        }
+        else {
+            download = undefined;
         }
-        const { layout, header, segs } = initDownload;
+        const { header, layout, segs } = initDownload;
         if (layout.base !== undefined) {
             // XXX with diff-ed downloads can't assume segs' offset to be 0
             throw new Error(`Current implementation cannot consume diff-ed downloads`);
         }
-        const objFile = await obj_file_1.ObjVersionFile.createNew(path);
-        const obj = new ObjOnDisk(objId, version, objFile, downloader, true, getBase);
+        const objFile = await obj_version_file_1.ObjVersionFile.createNew(path);
+        const obj = new ObjOnDisk(objId, version, objFile, downloader, true, getBase, download);
         await objFile.setSegsLayout(layout, false);
         await objFile.saveHeader(header, !segs);
         if (segs) {
@@ -59,7 +72,7 @@ class ObjOnDisk {
         return obj;
     }
     static async createFileForWriteOfNewVersion(objId, version, path, encSub, downloader, getBase) {
-        const objFile = await obj_file_1.ObjVersionFile.createNew(path);
+        const objFile = await obj_version_file_1.ObjVersionFile.createNew(path);
         const obj = new ObjOnDisk(objId, version, objFile, downloader, false, getBase);
         const write$ = file_writing_proc_1.FileWritingProc.makeFor(objFile, encSub)
             .pipe((0, operators_1.tap)({
@@ -104,12 +117,21 @@ class ObjOnDisk {
                 bytes.push(chunk);
             }
             else {
-                const chunkBytes = await this.downloadAndSaveSegsChunk(chunk);
+                const chunkBytes = await this.downloads().downloadAndSaveSegsChunk(chunk);
                 bytes.push(chunkBytes);
             }
         }
         return (0, buffer_utils_1.joinByteArrs)(bytes);
     }
+    downloads() {
+        if (!this.downloadsInProgress) {
+            if (!this.downloader) {
+                throw new Error(`Object ${this.objId}, version ${this.version}, is not on a disk.`);
+            }
+            this.downloadsInProgress = new Download(this.objId, this.version, this.downloader, this.objFile.saveSegs.bind(this.objFile), this.segsThatNeedDownload.bind(this));
+        }
+        return this.downloadsInProgress;
+    }
     async readSegsOnlyFromDisk(offset, len) {
         const segsLocations = this.objFile.segsLocations(offset, len);
         const bytesAndChunks = [];
@@ -158,26 +180,13 @@ class ObjOnDisk {
         }
         return bytesAndChunks;
     }
-    async downloadAndSaveSegsChunk(chunk) {
-        if (!this.downloader) {
-            throw new Error(`Object ${this.objId}, version ${this.version}, segments section ofs=${chunk.thisVerOfs}, len=${chunk.len} is not on a disk.`);
-        }
-        const chunkBytes = await this.downloader.getSegs(this.objId, this.version, chunk.thisVerOfs, chunk.thisVerOfs + chunk.len);
-        if (chunkBytes.length !== chunk.len) {
-            throw new Error(`Download yielded a different length of a segment section`);
-        }
-        const baseVerOfs = ((chunk.type === 'base') ?
-            chunk.baseVerOfs : undefined);
-        await this.objFile.saveSegs(chunkBytes, chunk.thisVerOfs, baseVerOfs, true);
-        return chunkBytes;
-    }
     getSrc() {
         if (!this.readable) {
             throw new Error(`Version ${this.version} of obj ${this.objId} is not readable, yet`);
         }
-        const segSrc = (0, wrapping_1.wrapAndSyncSource)(new ByteSourceFromObjOnDisk((ofs, len) => this.readSegs(ofs, len), () => this.objFile.getTotalSegsLen()));
+        const segSrc = (0, wrapping_1.wrapAndSyncSource)(new ByteSourceFromObjOnDisk(this.readSegs.bind(this), this.objFile.getTotalSegsLen.bind(this.objFile)));
         const objSrc = {
-            readHeader: () => this.readHeader(),
+            readHeader: this.readHeader.bind(this),
             segSrc,
             version: this.version
         };
@@ -195,10 +204,10 @@ class ObjOnDisk {
     segsThatNeedDownload() {
         const totalLen = this.objFile.getTotalSegsLen();
         const allSegs = this.objFile.segsLocations(0, totalLen);
-        return allSegs.filter(({ type }) => (type === 'new'));
+        return allSegs.filter(({ type }) => ((type === 'new') || (type === 'base')));
     }
     doesFileNeedDownload() {
-        return (this.segsThatNeedDownload().length === 0);
+        return (this.segsThatNeedDownload().length !== 0);
     }
     numOfBytesNeedingDownload() {
         let totalLen = 0;
@@ -207,16 +216,387 @@ class ObjOnDisk {
         }
         return totalLen;
     }
-    async downloadMissingSections() {
-        const needDownload = this.segsThatNeedDownload();
-        for (const chunk of needDownload) {
-            await this.downloadAndSaveSegsChunk(chunk);
-        }
+    startDownloadInBackground(eventSink) {
+        return this.downloads().downloadAllInBackground(eventSink);
     }
 }
 exports.ObjOnDisk = ObjOnDisk;
 Object.freeze(ObjOnDisk.prototype);
 Object.freeze(ObjOnDisk);
+class Download {
+    constructor(objId, version, downloader, saveSegs, segsThatNeedDownload) {
+        this.objId = objId;
+        this.version = version;
+        this.downloader = downloader;
+        this.saveSegs = saveSegs;
+        this.segsThatNeedDownload = segsThatNeedDownload;
+        this.segsAsapRequest = [];
+        this.initDataRequest = undefined;
+        this.inBkgrnd = undefined;
+        Object.seal(this);
+    }
+    getInitParts() {
+        if (!this.initDataRequest) {
+            this.initDataRequest = (0, deferred_1.defer)();
+        }
+        this.downloader.schedule(this);
+        return this.initDataRequest.promise;
+    }
+    downloadAndSaveSegsChunk(chunk) {
+        if (!this.saveSegs) {
+            throw new Error(`saveSegs is not initialized`);
+        }
+        // XXX
+        //  - check existing requests for overlaps and if there 
+        //     - overlaps are cut out into promise only section
+        //  - resulting sections' deferred/promised bytes are all awaited, and combined in returned promise
+        const segments = [];
+        const deferred = (0, deferred_1.defer)();
+        this.segsAsapRequest.push({
+            chunk,
+            deferred,
+            chunkBytes: [],
+            segments: segments
+        });
+        const { thisVerOfs: ofs, len } = chunk;
+        const generator = generateSectionsFrom(this.downloader.splitSegsDownloads(ofs, ofs + len));
+        const next = generator.next();
+        segments.push({
+            deferred: (0, deferred_1.defer)(),
+            sectionBytes: [],
+            generator,
+            nextSection: next.value
+        });
+        this.downloader.schedule(this);
+        return deferred.promise;
+    }
+    downloadAllInBackground(eventSink) {
+        if (!this.segsThatNeedDownload) {
+            throw new Error(`segsThatNeedDownload is not initialized`);
+        }
+        if (this.inBkgrnd) {
+            return this.inBkgrnd.downloadTaskId;
+        }
+        const chunks = this.segsThatNeedDownload();
+        if (chunks.length === 0) {
+            return;
+        }
+        this.inBkgrnd = {
+            downloadTaskId: Math.floor(Math.random() * Number.MAX_SAFE_INTEGER),
+            eventSink,
+            totalBytesToDownload: chunks.reduce((total, chunk) => (total + chunk.len), 0)
+        };
+        eventSink({
+            type: 'download-started',
+            downloadTaskId: this.inBkgrnd.downloadTaskId,
+            path: '',
+            version: this.version,
+            totalBytesToDownload: this.inBkgrnd.totalBytesToDownload
+        });
+        if (this.segsAsapRequest.length === 0) {
+            this.inBkgrnd.chunks = chunks;
+        }
+        this.downloader.schedule(this);
+        return this.inBkgrnd.downloadTaskId;
+    }
+    nextActionType() {
+        if (this.initDataRequest) {
+            return { runASAP: true };
+        }
+        else if (this.segsAsapRequest.length > 0) {
+            return { runASAP: true };
+        }
+        else if (this.inBkgrnd) {
+            return { runASAP: false };
+        }
+        else {
+            return;
+        }
+    }
+    startNextAction() {
+        if (this.initDataRequest) {
+            return this.processInitDataRequest();
+        }
+        else if (this.segsAsapRequest.length > 0) {
+            return this.processSomeAsapSegs();
+        }
+        else if (this.inBkgrnd) {
+            return this.processBkgrnd();
+        }
+        else {
+            return;
+        }
+    }
+    async processInitDataRequest() {
+        var _a, _b;
+        try {
+            const parts = await this.downloader.getLayoutWithHeaderAndFirstSegs(this.objId, this.version);
+            (_a = this.initDataRequest) === null || _a === void 0 ? void 0 : _a.resolve(parts);
+        }
+        catch (exc) {
+            (_b = this.initDataRequest) === null || _b === void 0 ? void 0 : _b.reject(exc);
+        }
+        finally {
+            this.initDataRequest = undefined;
+        }
+    }
+    async processSomeAsapSegs() {
+        var _a;
+        if ((_a = this.inBkgrnd) === null || _a === void 0 ? void 0 : _a.runData) {
+            this.inBkgrnd.runData = undefined;
+            this.inBkgrnd.chunks = undefined;
+        }
+        const { chunk, chunkBytes, deferred, segments } = this.segsAsapRequest[0];
+        const segment = segments[0];
+        try {
+            if ((0, types_1.isPromise)(segment)) {
+                chunkBytes.push(await segment);
+                segments.shift();
+            }
+            else if (segment.nextSection) {
+                const baseVerOfs = ((chunk.type === 'base') ? chunk.baseVerOfs : undefined);
+                const { ofs, len } = segment.nextSection;
+                const bytes = await this.downloader.getSegs(this.objId, this.version, ofs, ofs + len);
+                await this.saveSegs(bytes, ofs, baseVerOfs, true);
+                segment.sectionBytes.push(bytes);
+                const next = segment.generator.next();
+                if (next.done) {
+                    chunkBytes.push(...segment.sectionBytes);
+                    segments.shift();
+                }
+                else {
+                    segment.nextSection = next.value;
+                }
+            }
+            else {
+                chunkBytes.push(...segment.sectionBytes);
+                segments.shift();
+            }
+        }
+        catch (err) {
+            deferred.reject(err);
+            this.segsAsapRequest.shift();
+        }
+        if (segments.length === 0) {
+            deferred.resolve((0, buffer_utils_1.joinByteArrs)(chunkBytes));
+            this.segsAsapRequest.shift();
+        }
+    }
+    async processBkgrnd() {
+        if (!this.inBkgrnd) {
+            return;
+        }
+        if (!this.inBkgrnd.chunks) {
+            this.inBkgrnd.chunks = this.segsThatNeedDownload();
+            if (this.inBkgrnd.chunks.length === 0) {
+                this.completeBkgrnd();
+                return;
+            }
+        }
+        else if (this.inBkgrnd.chunks.length === 0) {
+            this.completeBkgrnd();
+            return;
+        }
+        const chunk = this.inBkgrnd.chunks[0];
+        if (!this.inBkgrnd.runData) {
+            const { thisVerOfs: ofs, len } = chunk;
+            this.inBkgrnd.runData = {
+                generator: generateSectionsFrom(this.downloader.splitSegsDownloads(ofs, ofs + len))
+            };
+        }
+        const next = this.inBkgrnd.runData.generator.next();
+        if (next.done) {
+            this.inBkgrnd.chunks.shift();
+            return;
+        }
+        const baseVerOfs = ((chunk.type === 'base') ? chunk.baseVerOfs : undefined);
+        const { len, ofs } = next.value;
+        this.inBkgrnd.runData.currentDownload = { ofs, len, deferred: (0, deferred_1.defer)() };
+        this.inBkgrnd.runData.currentDownload.deferred.promise.catch(noop);
+        try {
+            const bytes = await this.downloader.getSegs(this.objId, this.version, ofs, ofs + len);
+            await this.saveSegs(bytes, ofs, baseVerOfs, true);
+            this.emitDownloadEvent('download-progress', {
+                totalBytesToDownload: this.inBkgrnd.totalBytesToDownload,
+                bytesLeftToDownload: this.inBkgrnd.chunks.slice(1).reduce((total, chunk) => (total + chunk.len), 0) + (chunk.len - (ofs + len - chunk.thisVerOfs))
+            });
+            this.inBkgrnd.runData.currentDownload.deferred.resolve(bytes);
+        }
+        catch (exc) {
+            this.inBkgrnd.runData.currentDownload.deferred.reject(exc);
+        }
+        finally {
+            this.inBkgrnd.runData.currentDownload = undefined;
+        }
+    }
+    completeBkgrnd() {
+        this.emitDownloadEvent('download-done', {});
+        this.inBkgrnd = undefined;
+    }
+    emitDownloadEvent(type, field) {
+        var _a;
+        (_a = this.inBkgrnd) === null || _a === void 0 ? void 0 : _a.eventSink({
+            type,
+            path: '',
+            version: this.version,
+            downloadTaskId: this.inBkgrnd.downloadTaskId,
+            ...field
+        });
+    }
+}
+exports.Download = Download;
+Object.freeze(Download.prototype);
+Object.freeze(Download);
+class DownloadsRunner {
+    constructor(asapPoolMax = 5, longPoolMax = 1) {
+        this.downloads = new Map();
+        this.asapPool = makeExecPool(asapPoolMax);
+        this.longRunsPool = makeExecPool(longPoolMax);
+        Object.seal(this);
+    }
+    schedule(download) {
+        const found = this.downloads.get(download);
+        if (found) {
+            if (found.isRunning) {
+                return;
+            }
+            else {
+                const next = download.nextActionType();
+                if (!next) {
+                    this.removeDownload(download);
+                    return;
+                }
+                const pool = (next.runASAP ? this.asapPool : this.longRunsPool);
+                if (found.pool !== pool) {
+                    removeFromArray(found.pool.queue, download);
+                    found.pool = pool;
+                    found.pool.queue.push(download);
+                }
+            }
+        }
+        else {
+            const next = download.nextActionType();
+            if (!next) {
+                this.removeDownload(download);
+                return;
+            }
+            const pool = (next.runASAP ? this.asapPool : this.longRunsPool);
+            this.downloads.set(download, { isRunning: false, pool });
+            pool.queue.push(download);
+        }
+        this.triggerRuns();
+    }
+    removeDownload(download) {
+        const found = this.downloads.get(download);
+        if (found) {
+            this.downloads.delete(download);
+            removeFromArray(found.pool.queue, download);
+        }
+    }
+    triggerRuns() {
+        this.triggerRunsInPool(this.asapPool);
+        this.triggerRunsInPool(this.longRunsPool);
+    }
+    triggerRunsInPool(pool) {
+        while ((pool.queue.length > 0) && (pool.numOfRunning < pool.max)) {
+            const download = pool.queue.shift();
+            const info = this.downloads.get(download);
+            if (!info) {
+                continue;
+            }
+            let promise = download.startNextAction();
+            if (!promise) {
+                this.removeDownload(download);
+                continue;
+            }
+            info.isRunning = true;
+            pool.numOfRunning += 1;
+            if (pool === this.asapPool) {
+                promise = promise.then(() => {
+                    const next = download.nextActionType();
+                    if (!next) {
+                        this.removeDownload(download);
+                        return;
+                    }
+                    if (next.runASAP) {
+                        this.asapPool.queue.unshift(download);
+                    }
+                    else {
+                        this.longRunsPool.queue.push(download);
+                        info.pool = this.longRunsPool;
+                    }
+                });
+            }
+            else {
+                promise = promise.then(() => {
+                    const next = download.nextActionType();
+                    if (!next) {
+                        this.removeDownload(download);
+                        return;
+                    }
+                    if (next.runASAP) {
+                        this.asapPool.queue.push(download);
+                        info.pool = this.asapPool;
+                    }
+                    else {
+                        this.longRunsPool.queue.unshift(download);
+                    }
+                }, (_exc) => {
+                    this.longRunsPool.queue.unshift(download);
+                });
+            }
+            promise.finally(() => {
+                info.isRunning = false;
+                pool.numOfRunning -= 1;
+                this.triggerRuns();
+            });
+        }
+    }
+}
+exports.DownloadsRunner = DownloadsRunner;
+Object.freeze(DownloadsRunner.prototype);
+Object.freeze(DownloadsRunner);
+function makeExecPool(max) {
+    return { queue: [], max, numOfRunning: 0 };
+}
+function removeFromArray(arr, elem) {
+    const ind = arr.indexOf(elem);
+    if (ind >= 0) {
+        arr.splice(ind, 1);
+    }
+}
+function splitSegsDownloads(start, end, max) {
+    const parts = [];
+    let ofs = start;
+    const repeatCount = Math.floor((end - start) / max);
+    if (repeatCount > 1) {
+        const repeatLen = max * repeatCount;
+        parts.push({ ofs, len: max, repeatCount, repeatLen });
+        ofs += repeatLen;
+    }
+    else if (repeatCount === 1) {
+        parts.push({ ofs, len: max });
+        ofs += max;
+    }
+    const tailLen = end - ofs;
+    if (tailLen > 0) {
+        parts.push({ ofs, len: tailLen });
+    }
+    return parts;
+}
+function* generateSectionsFrom(sections) {
+    for (const { ofs, len, repeatCount, repeatLen } of sections) {
+        if (repeatCount) {
+            for (let i = 0; i < repeatCount; i += 1) {
+                yield { ofs: ofs + (i * len), len };
+            }
+        }
+        else {
+            yield { ofs, len };
+        }
+    }
+}
+function noop() { }
 class ByteSourceFromObjOnDisk {
     constructor(readSegs, totalSegsLen) {
         this.readSegs = readSegs;
@@ -225,7 +605,7 @@ class ByteSourceFromObjOnDisk {
         Object.seal(this);
     }
     async readNext(len) {
-        (0, assert_1.assert)((Number.isInteger(len) && (len >= 0)) || (len === undefined), 'Illegal length parameter given: ' + len);
+        (0, assert_1.assert)((len === undefined) || (Number.isInteger(len) && (len >= 0)), 'Illegal length parameter given: ' + len);
         const start = this.segsPointer;
         if (len === undefined) {
             const segsLen = this.totalSegsLen();

package/build/lib-client/request-utils.d.ts

@@ -1,4 +1,3 @@
-import { HTTPException } from '../lib-common/exceptions/http';
 import * as https from 'https';
 import { ClientRequest } from 'http';
 export declare const SESSION_ID_HEADER = "X-Session-Id";
@@ -30,12 +29,6 @@ export type ContentType = 'application/json' | 'application/octet-stream' | 'tex
 export type RequestFn<T> = (opts: RequestOpts, contentType?: ContentType, reqBody?: Uint8Array) => Promise<Reply<T>>;
 export declare function processRequest<T>(requester: (opts: https.RequestOptions) => ClientRequest, httpsOpts: https.RequestOptions, opts: RequestOpts, reqBody: Uint8Array | undefined, attempt?: number): Promise<Reply<T>>;
 export declare function formHttpsReqOpts(opts: RequestOpts, contentType?: ContentType, reqBody?: Uint8Array): https.RequestOptions;
-/**
- * @param rep
- * @param errMsg
- * @return http exception based on given reply, with an optional message
- */
-export declare function makeException(rep: Reply<any>, errMsg?: string): HTTPException;
 export declare function extractIntHeader(rep: Reply<any>, headerName: string): number;
 export interface NetClient {
     /**

package/build/lib-client/request-utils.js

@@ -18,7 +18,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONTENT_TYPE_HEADER = exports.SESSION_ID_HEADER = void 0;
 exports.processRequest = processRequest;
 exports.formHttpsReqOpts = formHttpsReqOpts;
-exports.makeException = makeException;
 exports.extractIntHeader = extractIntHeader;
 exports.makeNetClient = makeNetClient;
 const http_1 = require("../lib-common/exceptions/http");
@@ -134,7 +133,11 @@ function formReply(res, resBody, reqOpts) {
         }
         catch (err) {
             if (resContentType === 'application/json') {
-                throw (0, http_1.makeHTTPException)(reqOpts.url, reqOpts.method, status, `Cannot parse received bytes`, err);
+                throw (0, http_1.makeHTTPException)(reqOpts.url, reqOpts.method, status, {
+                    message: `Cannot parse received bytes as json`,
+                    cause: err,
+                    malformedResponse: true
+                });
             }
         }
     }
@@ -168,18 +171,20 @@ function makeHeaders(headers) {
         }
     };
 }
-/**
- * @param rep
- * @param errMsg
- * @return http exception based on given reply, with an optional message
- */
-function makeException(rep, errMsg) {
-    return (0, http_1.makeHTTPException)(rep.url, rep.method, rep.status, errMsg);
-}
+// /**
+//  * @param rep
+//  * @param errMsg
+//  * @return http exception based on given reply, with an optional message
+//  */
+// export function makeException(rep: Reply<any>, message?: string): HTTPException {
+// 	return makeHTTPException(rep.url, rep.method, rep.status, { message });
+// }
 function extractIntHeader(rep, headerName) {
     const intHeader = parseInt(rep.headers.get(headerName));
     if (isNaN(intHeader)) {
-        throw makeException(rep, `Malformed response: header ${headerName} is missing or malformed`);
+        throw (0, http_1.makeMalformedReplyHTTPException)(rep, {
+            message: `Malformed response: header ${headerName} is missing or malformed`
+        });
     }
     return intHeader;
 }

package/build/lib-client/service-locator.js

@@ -23,8 +23,8 @@ exports.makeServiceLocator = makeServiceLocator;
 exports.getMailerIdInfoFor = getMailerIdInfoFor;
 const jwkeys_1 = require("../lib-common/jwkeys");
 const url_1 = require("url");
-const request_utils_1 = require("./request-utils");
 const runtime_1 = require("../lib-common/exceptions/runtime");
+const http_1 = require("../lib-common/exceptions/http");
 async function readJSONLocatedAt(client, url) {
     if ((0, url_1.parse)(url).protocol !== 'https:') {
         throw new Error("Url protocol must be https.");
@@ -36,12 +36,12 @@ async function readJSONLocatedAt(client, url) {
     });
     if (rep.status === 200) {
         if (!rep.data) {
-            throw (0, request_utils_1.makeException)(rep, 'Malformed reply');
+            throw (0, http_1.makeMalformedReplyHTTPException)(rep);
         }
         return rep;
     }
     else {
-        throw (0, request_utils_1.makeException)(rep, 'Unexpected status');
+        throw (0, http_1.makeUnexpectedStatusHTTPException)(rep);
     }
 }
 function transformPathToCompleteUri(url, path, rep) {
@@ -49,7 +49,7 @@ function transformPathToCompleteUri(url, path, rep) {
     const protoAndHost = `${uInit.protocol}//${uInit.host}`;
     const uPath = (0, url_1.parse)(path);
     if (!uPath.path || !uPath.href || !uPath.href.startsWith(uPath.path)) {
-        throw (0, request_utils_1.makeException)(rep, `Malformed path parameter ${path}`);
+        throw (0, http_1.makeMalformedReplyHTTPException)(rep, { message: `Malformed path parameter ${path}` });
     }
     if (uPath.href.startsWith('/')) {
         return `${protoAndHost}${uPath.href}`;
@@ -92,7 +92,7 @@ async function mailerIdInfoAt(client, url) {
         transform.provisioning = transformPathToCompleteUri(url, json.provisioning, rep);
     }
     else {
-        throw (0, request_utils_1.makeException)(rep, 'Malformed reply');
+        throw (0, http_1.makeMalformedReplyHTTPException)(rep);
     }
     if ((0, jwkeys_1.isLikeSignedKeyCert)(json["current-cert"])) {
         transform.currentCert = json["current-cert"];
@@ -100,7 +100,7 @@ async function mailerIdInfoAt(client, url) {
             json["previous-certs"].filter(jwkeys_1.isLikeSignedKeyCert) : []);
     }
     else {
-        throw (0, request_utils_1.makeException)(rep, 'Malformed reply');
+        throw (0, http_1.makeMalformedReplyHTTPException)(rep);
     }
     Object.freeze(transform);
     return transform;
@@ -224,7 +224,8 @@ const DNS_ERR_CODE = {
     NODATA: 'ENODATA',
     NOTFOUND: 'ENOTFOUND',
     ESERVFAIL: 'ESERVFAIL',
-    ECONNREFUSED: 'ECONNREFUSED'
+    ECONNREFUSED: 'ECONNREFUSED',
+    ETIMEOUT: 'ETIMEOUT'
 };
 Object.freeze(DNS_ERR_CODE);
 function makeServiceLocator(resolver) {
@@ -244,7 +245,9 @@ function makeServiceLocator(resolver) {
             if (code === DNS_ERR_CODE.NODATA) {
                 throw noServiceRecordExc(address);
             }
-            else if ((code === DNS_ERR_CODE.ESERVFAIL) || (code === DNS_ERR_CODE.ECONNREFUSED)) {
+            else if ((code === DNS_ERR_CODE.ESERVFAIL)
+                || (code === DNS_ERR_CODE.ECONNREFUSED)
+                || (code === DNS_ERR_CODE.ETIMEOUT)) {
                 throw noConnectionExc({ code, hostname, message });
             }
             else if (hostname) {