6997892404

Committed 26 Nov 2023 08:40PM UTC coverage: 94.161%. Remained the same

Build # 6997892404

Build Type

push

github

Committed by

icebob

Commit Message

fix file logger test

Run Details

5314 of 5865 branches covered (0.0%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

7199 of 7424 relevant lines covered (96.97%)

1498.47 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.65

/src/middlewares/transmit/compression.js

/*
 * moleculer
 * Copyright (c) 2019 MoleculerJS (https://github.com/moleculerjs/moleculer)
 * MIT Licensed
 */

"use strict";

const { defaultsDeep } = require("lodash");
const { parseByteString } = require("../../utils");
const zlib = require("zlib");
const { promisify } = require("util");

/**
 * This is a transmission compression middleware. It supports
 * the `deflate`, `deflateRaw` & `gzip` compression methods.
 *
 * @param {object} opts
 * @param {String?} opts.method
 * @param {String|Number} opts.threshold
 */
module.exports = function CompressionMiddleware(opts) {
        opts = defaultsDeep(opts, { method: "deflate", threshold: "1kb" });

        let compress, decompress;
        const threshold = parseByteString(opts.threshold);

        switch (opts.method) {
                case "deflate":
                        compress = promisify(zlib.deflate);
                        decompress = promisify(zlib.inflate);
                        break;
                case "deflateRaw":
                        compress = promisify(zlib.deflateRaw);
                        decompress = promisify(zlib.inflateRaw);
                        break;
                case "gzip":
                        compress = promisify(zlib.gzip);
                        decompress = promisify(zlib.gunzip);
                        break;
                default:
                        /* istanbul ignore next */
                        throw new Error("Unknow compression method: " + opts.method);
        }

        let logger;

        return {
                name: "Compression",

                created(broker) {
                        logger = broker.getLogger("TX-COMPRESS");
                        /* istanbul ignore next */
                        logger.info(
                                `The transmission is COMPRESSED by '${opts.method}'. Threshold: ${
                                        threshold != null ? opts.threshold : "none"
                                }`
                        );
                },

                transporterSend(next) {
                        return (topic, data, meta) => {
                                if (threshold != null && data.length < threshold) {
                                        logger.debug(
                                                `Packet '${topic}' is small and not compressed. Size: ${data.length}`
                                        );
                                        return next(topic, Buffer.concat([Buffer.from([0x00]), data]), meta);
                                }
                                return compress(data).then(res => {
                                        logger.debug(
                                                `Packet '${topic}' compressed. Saving: ${Number(
                                                        (1 - res.length / data.length) * 100
                                                ).toFixed(0)}%`,
                                                data.length,
                                                res.length
                                        );
                                        return next(topic, Buffer.concat([Buffer.from([0x01]), res]), meta);
                                });
                        };
                },

                transporterReceive(next) {
                        return (cmd, data, s) => {
                                const isCompressed = data.readInt8(0);
                                if (isCompressed === 0) {
                                        logger.debug(
                                                `Packet '${cmd}' is small and not compressed. Size: ${data.length}`
                                        );
                                        return next(cmd, data.slice(1), s);
                                } else {
                                        return decompress(data.slice(1))
                                                .then(res => {
                                                        logger.debug(
                                                                `Packet '${cmd}' decompressed. Saving: ${Number(
                                                                        (1 - data.length / res.length) * 100
                                                                ).toFixed(0)}%`,
                                                                res.length,
                                                                data.length
                                                        );
                                                        return next(cmd, res, s);
                                                })
                                                .catch(err => {
                                                        logger.error("Received packet decompression error.", err);
                                                });
                                }
                        };
                }
        };
};

1	/*
2	* moleculer
3	* Copyright (c) 2019 MoleculerJS (https://github.com/moleculerjs/moleculer)
4	* MIT Licensed
5	*/
6
7	"use strict";
8
9	const { defaultsDeep } = require("lodash");	606✔
10	const { parseByteString } = require("../../utils");	606✔
11	const zlib = require("zlib");	606✔
12	const { promisify } = require("util");	606✔
13
14	/**
15	* This is a transmission compression middleware. It supports
16	* the `deflate`, `deflateRaw` & `gzip` compression methods.
17	*
18	* @param {object} opts
19	* @param {String?} opts.method
20	* @param {String\|Number} opts.threshold
21	*/
22	module.exports = function CompressionMiddleware(opts) {	606✔
23	opts = defaultsDeep(opts, { method: "deflate", threshold: "1kb" });	48✔
24
25	let compress, decompress;
26	const threshold = parseByteString(opts.threshold);	48✔
27
28	switch (opts.method) {	48!
29	case "deflate":
30	compress = promisify(zlib.deflate);	24✔
31	decompress = promisify(zlib.inflate);	24✔
32	break;	24✔
33	case "deflateRaw":
34	compress = promisify(zlib.deflateRaw);	12✔
35	decompress = promisify(zlib.inflateRaw);	12✔
36	break;	12✔
37	case "gzip":
38	compress = promisify(zlib.gzip);	12✔
39	decompress = promisify(zlib.gunzip);	12✔
40	break;	12✔
41	default:
42	/* istanbul ignore next */
43	throw new Error("Unknow compression method: " + opts.method);
44	}
45
46	let logger;
47
48	return {	48✔
49	name: "Compression",
50
51	created(broker) {
52	logger = broker.getLogger("TX-COMPRESS");	48✔
53	/* istanbul ignore next */
54	logger.info(
55	`The transmission is COMPRESSED by '${opts.method}'. Threshold: ${
56	threshold != null ? opts.threshold : "none"
57	}`
58	);
59	},
60
61	transporterSend(next) {
62	return (topic, data, meta) => {	30✔
63	if (threshold != null && data.length < threshold) {	30✔
64	logger.debug(	6✔
65	`Packet '${topic}' is small and not compressed. Size: ${data.length}`
66	);
67	return next(topic, Buffer.concat([Buffer.from([0x00]), data]), meta);	6✔
68	}
69	return compress(data).then(res => {	24✔
70	logger.debug(	24✔
71	`Packet '${topic}' compressed. Saving: ${Number(
72	(1 - res.length / data.length) * 100
73	).toFixed(0)}%`,
74	data.length,
75	res.length
76	);
77	return next(topic, Buffer.concat([Buffer.from([0x01]), res]), meta);	24✔
78	});
79	};
80	},
81
82	transporterReceive(next) {
83	return (cmd, data, s) => {	30✔
84	const isCompressed = data.readInt8(0);	30✔
85	if (isCompressed === 0) {	30✔
86	logger.debug(	6✔
87	`Packet '${cmd}' is small and not compressed. Size: ${data.length}`
88	);
89	return next(cmd, data.slice(1), s);	6✔
90	} else {
91	return decompress(data.slice(1))	24✔
92	.then(res => {
93	logger.debug(	24✔
94	`Packet '${cmd}' decompressed. Saving: ${Number(
95	(1 - data.length / res.length) * 100
96	).toFixed(0)}%`,
97	res.length,
98	data.length
99	);
100	return next(cmd, res, s);	24✔
101	})
102	.catch(err => {
UNCOV 103	logger.error("Received packet decompression error.", err);	×
104	});
105	}
106	};
107	}
108	};
109	};

moleculerjs / moleculer / 6997892404

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous