467 lines
17 KiB
JavaScript
467 lines
17 KiB
JavaScript
'use strict';
|
|
const os = require('os');
|
|
const path = require('path');
|
|
const fs = require('fs');
|
|
const child_process = require('child_process');
|
|
const { ipcRenderer } = require('electron');
|
|
|
|
// import psList from 'ps-list';
|
|
// const ps_list = require('ps-list');
|
|
|
|
let home_directory = require('os').homedir();
|
|
console.log('Home: '+home_directory);
|
|
|
|
let tmp_directory = require('os').tmpdir();
|
|
console.log('Temporary: '+tmp_directory);
|
|
|
|
let config = null;
|
|
|
|
exports.load_config = function () {
|
|
console.log('*** Electron framework: load_config() ***');
|
|
console.log('CWD: '+process.cwd());
|
|
|
|
// let home_directory = require('os').homedir();
|
|
// console.log('Home: '+home_directory);
|
|
|
|
// let tmp_directory = require('os').tmpdir();
|
|
// console.log('Temporary: '+tmp_directory);
|
|
|
|
// let config = null;
|
|
let config_directory = null;
|
|
let default_config_path = path.join(process.cwd(),'config.json.default');
|
|
console.log(default_config_path);
|
|
let config_path = null;
|
|
|
|
// Set the config path for macOS or Linux
|
|
if (os.platform == 'darwin') {
|
|
config_directory = path.join(home_directory, 'Library/Application Support/OSIT');
|
|
console.log('macOS config directory: '+config_directory);
|
|
} else if (os.platform == 'linux') {
|
|
config_directory = path.join(home_directory, '.config/OSIT');
|
|
console.log('Linux config directory: '+config_directory);
|
|
}
|
|
|
|
// Look for the config file and copy the default if not found.
|
|
if (fs.existsSync(config_directory)) {
|
|
console.log('Config directory found: '+config_directory);
|
|
} else {
|
|
fs.mkdirSync(config_directory);
|
|
console.log('Config directory created: '+config_directory);
|
|
|
|
//default_config_path = path.join(process.cwd(),'config.json.default');
|
|
// config_path = path.join(config_directory, 'config.json');
|
|
// fs.copyFileSync(default_config_path, config_path);
|
|
// console.log('Default config file copied: '+config_directory);
|
|
}
|
|
|
|
config_path = path.join(config_directory, 'config.json');
|
|
|
|
// Attempt to open the config file. The preferred location is based on the OS's config directory.
|
|
if (fs.existsSync(config_path)) {
|
|
console.log(`Config file (config.json) found under ${config_directory}`);
|
|
} else if (!fs.existsSync(config_path) && fs.existsSync(default_config_path)) {
|
|
fs.copyFileSync(default_config_path, config_path);
|
|
console.log('Default config file copied: '+config_directory);
|
|
|
|
// config = JSON.parse(fs.readFileSync(config_path));
|
|
// console.log('Config file read.');
|
|
} else if (fs.existsSync('config.json')) {
|
|
//fs.copyFileSync(default_config_path, config_path);
|
|
//console.log('Default config file copied: '+config_directory);
|
|
|
|
console.log(`Config file (config.json) not found under ${config_directory}. Using config in CWD. ${process.cwd()}`);
|
|
config_path = 'config.json';
|
|
|
|
// config = JSON.parse(fs.readFileSync('config.json'));
|
|
// console.log('Config file read.');
|
|
|
|
//console.log('Config file (config.json) not found under '+config_directory+'. Using config in CWD.');
|
|
//config = JSON.parse(fs.readFileSync('config.json'));
|
|
} else {
|
|
console.log('Unknown');
|
|
//close();
|
|
|
|
return false;
|
|
}
|
|
|
|
config = JSON.parse(fs.readFileSync(config_path));
|
|
console.log('Config file read.');
|
|
|
|
config.home_directory = home_directory; // From the OS platform
|
|
config.tmp_directory = tmp_directory; // From the OS platform
|
|
|
|
config.host_file_cache_path = config.host_file_cache_path.replace('[home]', home_directory);
|
|
config.host_file_cache_path = config.host_file_cache_path.replace('[tmp]', tmp_directory);
|
|
console.log(config.host_file_cache_path);
|
|
// if (fs.existsSync(config.host_file_cache_path)) {
|
|
// } else {
|
|
// fs.mkdirSync(config.host_file_cache_path);
|
|
// console.log(`Host file cache directory created: ${config.host_file_cache_path}`);
|
|
// }
|
|
|
|
config.host_file_temp_path = config.host_file_temp_path.replace('[home]', home_directory);
|
|
config.host_file_temp_path = config.host_file_temp_path.replace('[tmp]', tmp_directory);
|
|
console.log(config.host_file_temp_path);
|
|
// if (fs.existsSync(config.host_file_temp_path)) {
|
|
// } else {
|
|
// fs.mkdirSync(config.host_file_temp_path);
|
|
// console.log(`Host file temp directory created: ${config.host_file_temp_path}`);
|
|
// }
|
|
|
|
let import_config_to_ipc_result = ipcRenderer.invoke('import_config', config).then((result) => {
|
|
console.log('IPC import config finished');
|
|
console.log(result);
|
|
return true;
|
|
})
|
|
|
|
//console.log(config);
|
|
return config;
|
|
}
|
|
|
|
|
|
// Check for local file
|
|
// Updated 2022-05-06
|
|
exports.check_local_file = async function ({local_file_path, filename}) {
|
|
console.log('*** Electron framework export: check_local_file() ***');
|
|
// console.log('Check for local file');
|
|
console.log(`Local File Path: ${local_file_path}; Filename: ${filename}`);
|
|
|
|
let full_local_file_path = path.join(local_file_path, filename);
|
|
console.log(full_local_file_path);
|
|
|
|
if (fs.existsSync(full_local_file_path)) {
|
|
console.log(`Local file exists: ${full_local_file_path}`);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
// Check local hash file cache
|
|
// Updated 2022-05-06
|
|
exports.check_hash_file_cache = async function ({host_file_cache_path, hash}) {
|
|
console.log('*** Electron framework export: check_hash_file_cache() ***');
|
|
// console.log('Check local hash file cache');
|
|
console.log(`Host File Cache Path: ${host_file_cache_path}; Hash: ${hash}`);
|
|
|
|
let hash_filename = `${hash}.file`;
|
|
|
|
let subdirectory = hash_filename.substring(0,2);
|
|
let subdirectory_path = path.join(host_file_cache_path, subdirectory);
|
|
if (fs.existsSync(subdirectory_path)) {
|
|
} else {
|
|
console.log(`Hashed file subdirectory not found in cache: ${subdirectory_path}`);
|
|
return false;
|
|
}
|
|
|
|
let hash_file_cache_path = path.join(subdirectory_path, hash_filename);
|
|
// console.log(hash_file_cache_path);
|
|
|
|
if (fs.existsSync(hash_file_cache_path)) {
|
|
console.log(`Hashed file exists in cache: ${hash_file_cache_path}`);
|
|
return true;
|
|
} else {
|
|
console.log(`Hashed file not found in cache: ${hash_file_cache_path}`);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
// Download hash file to cache
|
|
// Updated 2022-05-06
|
|
exports.download_hash_file_to_cache = async function ({host_file_cache_path, event_file_id=null, hash=null}) {
|
|
console.log('*** Electron framework export: download_hash_file_to_cache() ***');
|
|
// console.log('Download hash file to cache');
|
|
console.log(`Host File Cache Path: ${host_file_cache_path}; Event File ID: ${event_file_id}; Hash: ${hash}`);
|
|
|
|
let endpoint = `/event/file/${event_file_id}/download`;
|
|
|
|
let hash_filename = `${hash}.file`;
|
|
|
|
let subdirectory = hash_filename.substring(0,2);
|
|
let subdirectory_path = path.join(host_file_cache_path, subdirectory);
|
|
if (fs.existsSync(subdirectory_path)) {
|
|
} else {
|
|
fs.mkdirSync(subdirectory_path);
|
|
console.log(`Subdirectory directory created: ${subdirectory_path}`);
|
|
}
|
|
|
|
let hash_file_cache_path = path.join(subdirectory_path, hash_filename);
|
|
// console.log(hash_file_cache_path);
|
|
|
|
let download_file_result = await ipcRenderer.invoke('download_file', api_server_base_url, endpoint, hash_file_cache_path).then((result) => {
|
|
console.log('IPC download file process finished');
|
|
console.log(result);
|
|
return true;
|
|
});
|
|
|
|
// console.log(download_file_result);
|
|
// console.log('End: download_hash_file_to_cache()');
|
|
if (download_file_result) {
|
|
console.log('File downloaded successfully');
|
|
return true;
|
|
} else {
|
|
console.log('File was not downloaded successfully');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
// Open cached hash file after copying to temp directory
|
|
// Updated 2022-05-06
|
|
exports.open_hash_file_to_temp = async function ({host_file_cache_path, hash, host_file_temp_path, filename}) {
|
|
console.log('*** Electron framework export: open_hash_file_to_temp() ***');
|
|
// console.log('Open cached hash file after copying to temp directory');
|
|
console.log(`Host File Cache Path: ${host_file_cache_path}; Hash: ${hash}; Host File Temp Path: ${host_file_temp_path}; Filename: ${filename}`);
|
|
|
|
let subdirectory = hash.substring(0,2);
|
|
let subdirectory_path = path.join(host_file_cache_path, subdirectory);
|
|
if (fs.existsSync(subdirectory_path)) {
|
|
} else {
|
|
console.log(`Hashed file subdirectory not found in cache: ${subdirectory_path}`);
|
|
return false;
|
|
}
|
|
|
|
let open_hash_file_to_temp_result = await ipcRenderer.invoke('open_hash_file_to_temp', subdirectory_path, hash, host_file_temp_path, filename).then((result) => {
|
|
console.log('IPC open hash file to temp finished');
|
|
console.log(result);
|
|
return true;
|
|
})
|
|
|
|
// let result = await ipcRenderer.send('open_local_file', host_file_cache_path, hash, host_file_temp_path, filename);
|
|
// console.log(result);
|
|
|
|
console.log(open_hash_file_to_temp_result);
|
|
console.log('End: open_hash_file_to_temp()');
|
|
if (open_hash_file_to_temp_result) {
|
|
console.log('File opened successfully');
|
|
return true;
|
|
} else {
|
|
console.log('File was not opened successfully');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
// Open local file
|
|
// Updated 2022-03-10
|
|
exports.open_local_file = async function ({local_file_path, filename}) {
|
|
console.log('*** Electron framework export: open_local_file() ***');
|
|
// console.log('Open local file');
|
|
console.log(`Local File Path: ${local_file_path}; Filename: ${filename}`);
|
|
|
|
// let full_local_file_path = path.join(local_file_path, filename);
|
|
// console.log(full_local_file_path);
|
|
|
|
// if (fs.existsSync(full_local_file_path)) {
|
|
// console.log(`Local file exists: ${full_local_file_path}`);
|
|
// // return true;
|
|
// } else {
|
|
// return false;
|
|
// }
|
|
|
|
let open_local_file_result = await ipcRenderer.invoke('open_local_file', local_file_path, filename).then((result) => {
|
|
console.log('IPC open local file finished');
|
|
console.log(result);
|
|
return true;
|
|
})
|
|
|
|
console.log(open_local_file_result);
|
|
console.log('End: open_local_file()');
|
|
if (open_local_file_result) {
|
|
console.log('File opened successfully');
|
|
return true;
|
|
} else {
|
|
console.log('File was not opened successfully');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
// Check local file cache and download from server if needed.
|
|
// Updated 2022-03-09
|
|
// exports.check_file_cache = async function ({host_file_cache_path, event_file_id, hash}) {
|
|
exports.check_file_cache = async function ({host_file_cache_path, event_file_id, hash}) {
|
|
console.log('*** Electron framework export: check_file_cache() ***');
|
|
// console.log('Check local file cache and download from server if needed.');
|
|
console.log(`Host File Cache Path: ${host_file_cache_path}; Event File ID: ${event_file_id}; Hash: ${hash}`);
|
|
|
|
// NOTE: event_file_id is the event_file.id_random or event_file.event_file_id_random
|
|
let hash_filename = hash+'.file';
|
|
|
|
let save_path = path.join(host_file_cache_path, hash_filename);
|
|
console.log(save_path);
|
|
|
|
if (fs.existsSync(save_path)) {
|
|
console.log('Hashed file cache already exists: '+save_path);
|
|
return true;
|
|
} else {
|
|
console.log('Hashed file not found in local cache. Downloading file: '+save_path);
|
|
let endpoint = `/event/file/${event_file_id}/download`;
|
|
let result = await ipcRenderer.send('download_file', api_server_base_url, endpoint, save_path); // Must download file using main node.js thread.
|
|
console.log(result);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
ipcRenderer.once('download_file_reply', function(event, response){
|
|
console.log(response);
|
|
return response;
|
|
})
|
|
resolve(true);
|
|
});
|
|
|
|
// await ipcRenderer.once('download_file_reply', function(event, response){
|
|
// console.log(response);
|
|
// return response;
|
|
// });
|
|
|
|
// result.then(function (response) {
|
|
// console.log('Downloaded!!!???');
|
|
// return true;
|
|
// }).catch(function (error) {
|
|
// console.log(error);
|
|
// return false;
|
|
// });
|
|
|
|
// return result;
|
|
|
|
// console.log(result);
|
|
// if (result) {
|
|
// return true;
|
|
// } else {
|
|
// return false;
|
|
// }
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Check local file cache and download from server if needed. Must use IPC to Main to download file. Set a Promise to wait for download_file_reply.
|
|
// Updated 2022-03-09
|
|
async function check_file_cache({host_file_cache_path, event_file_id, hash}) {
|
|
console.log('*** Electron framework: check_file_cache() ***');
|
|
// console.log('Check local file cache and download from server if needed.');
|
|
console.log(`Host File Cache Path: ${host_file_cache_path}; Event File ID: ${event_file_id}; Hash: ${hash}`);
|
|
|
|
// NOTE: event_file_id is the event_file.id_random or event_file.event_file_id_random
|
|
let hash_filename = hash+'.file';
|
|
|
|
let save_path = path.join(host_file_cache_path, hash_filename);
|
|
console.log(save_path);
|
|
|
|
if (fs.existsSync(save_path)) {
|
|
console.log('Hashed file cache already exists: '+save_path);
|
|
return true;
|
|
} else {
|
|
console.log('Hashed file not found in local cache. Downloading file: '+save_path);
|
|
let endpoint = `/event/file/${event_file_id}/download`;
|
|
let result = await ipcRenderer.send('download_file', api_server_base_url, endpoint, save_path); // Must download file using main node.js thread.
|
|
console.log(result);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
ipcRenderer.once('download_file_reply', function(event, response){
|
|
console.log(response);
|
|
return response;
|
|
})
|
|
resolve(true);
|
|
});
|
|
|
|
// await ipcRenderer.once('download_file_reply', function(event, response){
|
|
// console.log(response);
|
|
// return response;
|
|
// });
|
|
|
|
// result.then(function (response) {
|
|
// console.log('Downloaded!!!???');
|
|
// return true;
|
|
// }).catch(function (error) {
|
|
// console.log(error);
|
|
// return false;
|
|
// });
|
|
|
|
// return result;
|
|
|
|
// console.log(result);
|
|
// if (result) {
|
|
// return true;
|
|
// } else {
|
|
// return false;
|
|
// }
|
|
}
|
|
}
|
|
|
|
// IPC to Main: Open local file cache if available. Copy to temp directory with given filename first.
|
|
// Updated 2022-03-09
|
|
async function open_local_file({host_file_cache_path, hash, host_file_temp_path, filename}) {
|
|
console.log('*** Electron framework: open_local_file() ***');
|
|
// console.log('Open local file cache if available. Copy to temp directory with given filename first.');
|
|
console.log(`Host File Cache Path: ${host_file_cache_path}; Hash: ${hash}; Host File Temp Path: ${host_file_temp_path}; Filename: ${filename}`);
|
|
|
|
console.log(host_file_cache_path);
|
|
console.log(hash);
|
|
console.log(filename);
|
|
|
|
let result = await ipcRenderer.send('open_local_file', host_file_cache_path, hash, host_file_temp_path, filename);
|
|
console.log(result);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
exports.check_file_cache_and_open_local_file = async function ({host_file_cache_path, event_file_id, hash, host_file_temp_path, filename}) {
|
|
console.log('*** Electron framework: check_file_cache_and_open_local_file() ***');
|
|
console.log('Checking the local file cache against the remote server and then opening the local file.');
|
|
|
|
let check_file_cache_result = check_file_cache({host_file_cache_path: host_file_cache_path, event_file_id: event_file_id, hash: hash});
|
|
console.log(check_file_cache_result);
|
|
|
|
if (check_file_cache_result) {
|
|
let open_local_file_result = open_local_file({host_file_cache_path: host_file_cache_path, hash: hash, host_file_temp_path: host_file_temp_path, filename: filename});
|
|
console.log(open_local_file_result);
|
|
|
|
return open_local_file_result;
|
|
}
|
|
|
|
ipcRenderer.once('download_file_reply', function(event, response){
|
|
console.log(response);
|
|
|
|
let open_local_file_result = open_local_file({host_file_cache_path: host_file_cache_path, hash: hash, host_file_temp_path: host_file_temp_path, filename: filename});
|
|
console.log(open_local_file_result);
|
|
|
|
return open_local_file_result;
|
|
})
|
|
}
|
|
|
|
|
|
|
|
// Kill processes
|
|
// Updated 2022-05-06
|
|
exports.kill_processes = async function ({process_name = null}) {
|
|
console.log('*** Electron framework export: kill_processes() ***');
|
|
console.log(process_name); // process_name or grep pattern
|
|
|
|
let command = `pkill ${process_name}`;
|
|
child_process.exec(command, (err, stdout, stdin) => {
|
|
if (err) throw err;
|
|
console.log(stdout);
|
|
});
|
|
console.log('Killed processes?');
|
|
|
|
// let command = `ps -aux | grep ${process_name}`;
|
|
// child_process.exec(command, (err, stdout, stdin) => {
|
|
// if (err) throw err;
|
|
// console.log(stdout);
|
|
// });
|
|
|
|
// console.log(await psList());
|
|
// console.log(await ps_list());
|
|
|
|
// let signal = 'SIGTERM'; // 'SIGTERM', 'SIGINT', 'SIGHUP'
|
|
|
|
// process.kill(pid, signal);
|
|
|
|
// process.kill(pid, 0); // Special case test if process exists
|
|
return true;
|
|
} |