#252645661

Committed 15 Nov 2023 09:37PM UTC coverage: 70.514% (-1.8%) from 72.267%

Build Type

Committed by

Commit Message

from 10 failures, expect fixes - removing noise to focus on real issues (invalid URL, headers already sent by... who?)

Pull Request Pull Request #456: staging version 1.9.2491

Run Details

1730 of 3418 branches covered (0.0%)

Branch coverage included in aggregate %.

114 of 255 new or added lines in 17 files covered. (44.71%)

109 existing lines in 16 files now uncovered.

8032 of 10426 relevant lines covered (77.04%)

7.83 hits per line

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

40.17

/lib/thinx/globals.js

// Prefix equals static globals

let Globals = (function () {

  let Rollbar = require("rollbar");
  let fs = require("fs-extra");
  let crypto = require("crypto");

  let CONFIG_ROOT = "/mnt/data/conf";

  if (process.env.ENVIRONMENT == "development") {
    CONFIG_ROOT = __dirname + "/../../spec/mnt/data/conf";
  }

  let CONFIG_PATH = CONFIG_ROOT + "/config.json";

  if (!fs.existsSync(CONFIG_PATH)) {
    throw new Error(`Config not found in ${CONFIG_PATH} in environment ${process.env.ENVIRONMENT}`);
  }

  // all cached
  let _prefix = "";
  let _app_config = null;
  let _github_ocfg = null;
  let _google_ocfg = null;
  let _rollbar = null;

  const redis_reconnect_strategy = function (options) {

    let max_attempts = 10;
    let retry_time = 5 * 60 * 1000;

    // for test environment, limits are much shorter.
    if (typeof (process.env.CIRCLE_USERNAME) !== "undefined") {
      max_attempts = 5;
      retry_time = 1000 * 60;
    }

    if (options.error) {
      if (options.error.code === 'ECONNREFUSED') {
        // End reconnecting on a specific error and flush all commands with a individual error
        return new Error('The server refused the connection');
      }
      if (options.error.code === 'ECONNRESET') {
        return new Error('The server reset the connection');
      }
      if (options.error.code === 'ETIMEDOUT') {
        return new Error('The server timeouted the connection');
      }
    }
    if (options.total_retry_time > retry_time) {
      // End reconnecting after a specific timeout and flush all commands with a individual error
      return new Error('Retry time exhausted');
    }
    if (options.attempt > max_attempts) {
      // End reconnecting with built in error
      return new Error('Retry attempts ended');
    }
    // reconnect after
    return 1000;
  };

  let _public = {

    redis_options: function () {

      let config = {};

      if ((typeof (_app_config) === "undefined") || (_app_config === null)) {
        console.log("CRITICAL CONFIGURATION ERROR: missing conf/config.json");
        return config;
      }

      if ((typeof (_app_config.redis) === "undefined") || (_app_config.redis === null)) {
        console.log("CRITICAL CONFIGURATION ERROR: `redis` block missing in conf/config.json");
        return config;
      }

      config = _app_config.redis;
      config.retry_strategy = redis_reconnect_strategy;

      // Take the Redis password from environment variable to make sure it's in sync
      if (typeof (process.env.REDIS_PASSWORD) !== "undefined") {
        config.password = process.env.REDIS_PASSWORD;
      }

      config.legacyMode = true;

      return config;
    },

    load: function () {

      if (fs.existsSync(CONFIG_ROOT + '/google-oauth.json')) {
        _google_ocfg = require(CONFIG_ROOT + '/google-oauth.json');
      }

      if (fs.existsSync(CONFIG_ROOT + '/github-oauth.json')) {
        _github_ocfg = require(CONFIG_ROOT + '/github-oauth.json');
      }

      let path = null;

      if ((path == null) && fs.existsSync(CONFIG_ROOT + '/config.override.json')) {
        path = CONFIG_ROOT + '/config.override.json';
        console.log("Configuration loaded from:", path);
        _app_config = require(path);
      }

      if ((path == null) && fs.existsSync(CONFIG_ROOT + '/config.json')) {
        path = CONFIG_ROOT + '/config.json';
        console.log("Configuration loaded from:", path);
        _app_config = require(path);
      }

      if ((typeof (process.env.ROLLBAR_ACCESS_TOKEN) !== "undefined") && (process.env.ROLLBAR_ACCESS_TOKEN !== null)) {
        _rollbar = new Rollbar({
          accessToken: process.env.ROLLBAR_ACCESS_TOKEN,
          handleUncaughtExceptions: true,
          handleUnhandledRejections: true,
          revision: process.env.REVISION || "latest"
        });
      }

      _public.load_or_create_prefix();

    },

    load_or_create_prefix: function () {
      let pfx_path = CONFIG_ROOT + '/.thx_prefix'; // old
      if (!fs.existsSync(pfx_path)) {
        console.log("[globals.js] Prefix file not found at (1)", pfx_path);
        pfx_path = _app_config.data_root + '/conf/.thx_prefix'; // new
        if (!fs.existsSync(pfx_path)) {
          console.log("[globals.js] Prefix file not found at (2)", pfx_path);
          _prefix = null;
        }
      }
      if (fs.existsSync(pfx_path)) {
        _prefix = (fs.readFileSync(pfx_path).toString()).replace("\n", "");
        return;
      }
      console.log("[globals.js] Prefix file not found...");
      _public.save_new_prefix(pfx_path);
    },

    save_new_prefix: function (pfx_path) {
      fs.ensureFile(pfx_path, function (e) {
        if (e) {
          console.log(`☣️ [error] creating thx_prefix: ${e}`);
          return;
        }
        crypto.randomBytes(12, function (_cerr, buffer) {
          _prefix = buffer.toString('hex');
          fs.writeFile(pfx_path, _prefix, "", function (werr) {
            if (werr) {
              console.log(`☣️ [error] writing thx_prefix: ${werr}`);
            } else {
              console.log(`ℹ️ [info] [globals.js] Created new prefix ${_prefix}`);
            }
          });
        });
      });
    },

    generate_prefix: function () {
      let pfx_path = _app_config.data_root + '/conf/.thx_prefix';
      console.log("Generating prefix at " + pfx_path);
      fs.ensureFile(pfx_path, function (e) {
        if (e) {
          console.log("error creating thx_prefix: " + e);
          return null;
        } else {
          crypto.randomBytes(12, function (_cerr, buffer) {
            let prefix = buffer.toString('hex');
            fs.writeFile(prefix, "", function (werr) {
              if (werr) {
                console.log("error writing thx_prefix: " + werr);
                return null;
              } else {
                console.log("Returning new prefix: " + _prefix);
                return _prefix;
              }
            });
          });
        }
      });
    },

    prefix: function () {

      if (_prefix === null) {
        console.log("prefix:_prefix==null; loading");
        _public.load();
      } else {
        return _prefix;
      }

      let pfx_path;
      pfx_path = CONFIG_ROOT + '/.thx_prefix';
      if (!fs.existsSync(pfx_path)) {
        pfx_path = _app_config.data_root + '/conf/.thx_prefix';
        if (!fs.existsSync(pfx_path)) {
          _prefix = null;
        }
      }

      try {
        console.log("Re-loading " + pfx_path);
        if (fs.existsSync(pfx_path)) {
          console.log("xists");
          _prefix = (fs.readFileSync(pfx_path).toString()).replace("\n", "");
          return _prefix; // allow empty prefix as well
        } else {
          console.log("does not exist " + pfx_path);
          _prefix = null;
        }
      } catch (e) {
        // create .thx_prefix with random key on first run!
        console.log("[globals] thx_prefix_exception (2) skipped " + e);
        _prefix = _public.generate_prefix(); // may cause loop, investigate...
      }

      if (_prefix === null) {
        console.log("No prefix found(!), generating...");
        _prefix = _public.generate_prefix();
      } else {
        console.log("Expected empty prefix: " + _prefix);
      }

      console.log("Globals returning prefix '" + _prefix + "'");
      return _prefix;
    },

    app_config: function () {

      if (_app_config === null) {
        console.log("re-ladung publik konfigurazion");
        _public.load();
      }

      if (_app_config === null) {
        console.log("_public.load still failed, hardkernfixoperazione...");
        _app_config = require(CONFIG_ROOT + '/config.json'); // not compatible with test!
      }

      if (process.env.ENVIRONMENT == "development") {
        _app_config.ssh_keys = process.env.HOME + "/.ssh";
      }

      return _app_config;
    },

    google_ocfg: function () {
      if (_prefix === null) {
        _public.load();
      }
      return _google_ocfg;
    },

    github_ocfg: function () {
      if (_prefix === null) {
        _public.load();
      }
      return _github_ocfg;
    },

    rollbar: function () {
      if (_prefix === null) {
        _public.load();
      }
      return _rollbar;
    }

  };

  _public.load();

  return _public;

})();

exports.prefix = Globals.prefix;
exports.save_new_prefix = Globals.save_new_prefix;
exports.load_or_create_prefix = Globals.load_or_create_prefix;
exports.app_config = Globals.app_config;
exports.google_ocfg = Globals.google_ocfg;
exports.github_ocfg = Globals.github_ocfg;
exports.rollbar = Globals.rollbar;
exports.redis_options = Globals.redis_options;

1	// Prefix equals static globals
2
3	let Globals = (function () {	1✔
4
5	let Rollbar = require("rollbar");	1✔
6	let fs = require("fs-extra");	1✔
7	let crypto = require("crypto");	1✔
8
9	let CONFIG_ROOT = "/mnt/data/conf";	1✔
10
11	if (process.env.ENVIRONMENT == "development") {	1!
12	CONFIG_ROOT = __dirname + "/../../spec/mnt/data/conf";	×
13	}
14
15	let CONFIG_PATH = CONFIG_ROOT + "/config.json";	1✔
16
17	if (!fs.existsSync(CONFIG_PATH)) {	1!
18	throw new Error(`Config not found in ${CONFIG_PATH} in environment ${process.env.ENVIRONMENT}`);	×
19	}
20
21	// all cached
22	let _prefix = "";	1✔
23	let _app_config = null;	1✔
24	let _github_ocfg = null;	1✔
25	let _google_ocfg = null;	1✔
26	let _rollbar = null;	1✔
27
28	const redis_reconnect_strategy = function (options) {	1✔
29
30	let max_attempts = 10;	×
31	let retry_time = 5 * 60 * 1000;	×
32
33	// for test environment, limits are much shorter.
34	if (typeof (process.env.CIRCLE_USERNAME) !== "undefined") {	×
35	max_attempts = 5;	×
36	retry_time = 1000 * 60;	×
37	}
38
39	if (options.error) {	×
40	if (options.error.code === 'ECONNREFUSED') {	×
41	// End reconnecting on a specific error and flush all commands with a individual error
42	return new Error('The server refused the connection');	×
43	}
44	if (options.error.code === 'ECONNRESET') {	×
45	return new Error('The server reset the connection');	×
46	}
47	if (options.error.code === 'ETIMEDOUT') {	×
48	return new Error('The server timeouted the connection');	×
49	}
50	}
51	if (options.total_retry_time > retry_time) {	×
52	// End reconnecting after a specific timeout and flush all commands with a individual error
53	return new Error('Retry time exhausted');	×
54	}
55	if (options.attempt > max_attempts) {	×
56	// End reconnecting with built in error
57	return new Error('Retry attempts ended');	×
58	}
59	// reconnect after
60	return 1000;	×
61	};
62
63	let _public = {	1✔
64
65	redis_options: function () {
66
67	let config = {};	29✔
68
69	if ((typeof (_app_config) === "undefined") \|\| (_app_config === null)) {	29!
70	console.log("CRITICAL CONFIGURATION ERROR: missing conf/config.json");	×
NEW 71	return config;	×
72	}
73
74	if ((typeof (_app_config.redis) === "undefined") \|\| (_app_config.redis === null)) {	29!
75	console.log("CRITICAL CONFIGURATION ERROR: `redis` block missing in conf/config.json");	×
NEW 76	return config;	×
77	}
78
79	config = _app_config.redis;	29✔
80	config.retry_strategy = redis_reconnect_strategy;	29✔
81
82	// Take the Redis password from environment variable to make sure it's in sync
83	if (typeof (process.env.REDIS_PASSWORD) !== "undefined") {	29!
84	config.password = process.env.REDIS_PASSWORD;	29✔
85	}
86
87	config.legacyMode = true;	29✔
88
89	return config;	29✔
90	},
91
92	load: function () {
93
94	if (fs.existsSync(CONFIG_ROOT + '/google-oauth.json')) {	1!
95	_google_ocfg = require(CONFIG_ROOT + '/google-oauth.json');	1✔
96	}
97
98	if (fs.existsSync(CONFIG_ROOT + '/github-oauth.json')) {	1!
99	_github_ocfg = require(CONFIG_ROOT + '/github-oauth.json');	1✔
100	}
101
102	let path = null;	1✔
103
104	if ((path == null) && fs.existsSync(CONFIG_ROOT + '/config.override.json')) {	1!
105	path = CONFIG_ROOT + '/config.override.json';	×
106	console.log("Configuration loaded from:", path);	×
107	_app_config = require(path);	×
108	}
109
110	if ((path == null) && fs.existsSync(CONFIG_ROOT + '/config.json')) {	1!
111	path = CONFIG_ROOT + '/config.json';	1✔
112	console.log("Configuration loaded from:", path);	1✔
113	_app_config = require(path);	1✔
114	}
115
116	if ((typeof (process.env.ROLLBAR_ACCESS_TOKEN) !== "undefined") && (process.env.ROLLBAR_ACCESS_TOKEN !== null)) {	1!
117	_rollbar = new Rollbar({	1✔
118	accessToken: process.env.ROLLBAR_ACCESS_TOKEN,
119	handleUncaughtExceptions: true,
120	handleUnhandledRejections: true,
121	revision: process.env.REVISION \|\| "latest"	1!
122	});
123	}
124
125	_public.load_or_create_prefix();	1✔
126
127	},
128
129	load_or_create_prefix: function () {
130	let pfx_path = CONFIG_ROOT + '/.thx_prefix'; // old	1✔
131	if (!fs.existsSync(pfx_path)) {	1!
132	console.log("[globals.js] Prefix file not found at (1)", pfx_path);	×
133	pfx_path = _app_config.data_root + '/conf/.thx_prefix'; // new	×
134	if (!fs.existsSync(pfx_path)) {	×
135	console.log("[globals.js] Prefix file not found at (2)", pfx_path);	×
136	_prefix = null;	×
137	}
138	}
139	if (fs.existsSync(pfx_path)) {	1!
140	_prefix = (fs.readFileSync(pfx_path).toString()).replace("\n", "");	1✔
141	return;	1✔
142	}
143	console.log("[globals.js] Prefix file not found...");	×
144	_public.save_new_prefix(pfx_path);	×
145	},
146
147	save_new_prefix: function (pfx_path) {
148	fs.ensureFile(pfx_path, function (e) {	×
149	if (e) {	×
150	console.log(`☣️ [error] creating thx_prefix: ${e}`);	×
151	return;	×
152	}
153	crypto.randomBytes(12, function (_cerr, buffer) {	×
154	_prefix = buffer.toString('hex');	×
155	fs.writeFile(pfx_path, _prefix, "", function (werr) {	×
156	if (werr) {	×
157	console.log(`☣️ [error] writing thx_prefix: ${werr}`);	×
158	} else {
159	console.log(`ℹ️ [info] [globals.js] Created new prefix ${_prefix}`);	×
160	}
161	});
162	});
163	});
164	},
165
166	generate_prefix: function () {
167	let pfx_path = _app_config.data_root + '/conf/.thx_prefix';	×
168	console.log("Generating prefix at " + pfx_path);	×
169	fs.ensureFile(pfx_path, function (e) {	×
170	if (e) {	×
171	console.log("error creating thx_prefix: " + e);	×
172	return null;	×
173	} else {
174	crypto.randomBytes(12, function (_cerr, buffer) {	×
175	let prefix = buffer.toString('hex');	×
176	fs.writeFile(prefix, "", function (werr) {	×
177	if (werr) {	×
178	console.log("error writing thx_prefix: " + werr);	×
179	return null;	×
180	} else {
181	console.log("Returning new prefix: " + _prefix);	×
182	return _prefix;	×
183	}
184	});
185	});
186	}
187	});
188	},
189
190	prefix: function () {
191
192	if (_prefix === null) {	495!
193	console.log("prefix:_prefix==null; loading");	×
194	_public.load();	×
195	} else {
196	return _prefix;	495✔
197	}
198
199	let pfx_path;
200	pfx_path = CONFIG_ROOT + '/.thx_prefix';	×
201	if (!fs.existsSync(pfx_path)) {	×
202	pfx_path = _app_config.data_root + '/conf/.thx_prefix';	×
203	if (!fs.existsSync(pfx_path)) {	×
204	_prefix = null;	×
205	}
206	}
207
208	try {	×
209	console.log("Re-loading " + pfx_path);	×
210	if (fs.existsSync(pfx_path)) {	×
211	console.log("xists");	×
212	_prefix = (fs.readFileSync(pfx_path).toString()).replace("\n", "");	×
213	return _prefix; // allow empty prefix as well	×
214	} else {
215	console.log("does not exist " + pfx_path);	×
216	_prefix = null;	×
217	}
218	} catch (e) {
219	// create .thx_prefix with random key on first run!
220	console.log("[globals] thx_prefix_exception (2) skipped " + e);	×
221	_prefix = _public.generate_prefix(); // may cause loop, investigate...	×
222	}
223
224	if (_prefix === null) {	×
225	console.log("No prefix found(!), generating...");	×
226	_prefix = _public.generate_prefix();	×
227	} else {
228	console.log("Expected empty prefix: " + _prefix);	×
229	}
230
231	console.log("Globals returning prefix '" + _prefix + "'");	×
232	return _prefix;	×
233	},
234
235	app_config: function () {
236
237	if (_app_config === null) {	119!
238	console.log("re-ladung publik konfigurazion");	×
239	_public.load();	×
240	}
241
242	if (_app_config === null) {	119!
243	console.log("_public.load still failed, hardkernfixoperazione...");	×
244	_app_config = require(CONFIG_ROOT + '/config.json'); // not compatible with test!	×
245	}
246
247	if (process.env.ENVIRONMENT == "development") {	119!
248	_app_config.ssh_keys = process.env.HOME + "/.ssh";	×
249	}
250
251	return _app_config;	119✔
252	},
253
254	google_ocfg: function () {
255	if (_prefix === null) {	1!
256	_public.load();	×
257	}
258	return _google_ocfg;	1✔
259	},
260
261	github_ocfg: function () {
262	if (_prefix === null) {	1!
263	_public.load();	×
264	}
265	return _github_ocfg;	1✔
266	},
267
268	rollbar: function () {
269	if (_prefix === null) {	15!
270	_public.load();	×
271	}
272	return _rollbar;	15✔
273	}
274
275	};
276
277	_public.load();	1✔
278
279	return _public;	1✔
280
281	})();
282
283	exports.prefix = Globals.prefix;	1✔
284	exports.save_new_prefix = Globals.save_new_prefix;	1✔
285	exports.load_or_create_prefix = Globals.load_or_create_prefix;	1✔
286	exports.app_config = Globals.app_config;	1✔
287	exports.google_ocfg = Globals.google_ocfg;	1✔
288	exports.github_ocfg = Globals.github_ocfg;	1✔
289	exports.rollbar = Globals.rollbar;	1✔
290	exports.redis_options = Globals.redis_options;	1✔

suculent / thinx-device-api / #252645661

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