js/Thread.alt.js

  1. /**=====LICENSE STATEMENT START=====
  2.     Translator++ 
  3.     CAT (Computer-Assisted Translation) tools and framework to create quality
  4.     translations and localizations efficiently.
  5.         
  6.     Copyright (C) 2018  Dreamsavior<dreamsavior@gmail.com>
  8.     This program is free software: you can redistribute it and/or modify
  9.     it under the terms of the GNU General Public License as published by
  10.     the Free Software Foundation, either version 3 of the License, or
  11.     (at your option) any later version.
  13.     This program is distributed in the hope that it will be useful,
  14.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.     GNU General Public License for more details.
  18.     You should have received a copy of the GNU General Public License
  19.     along with this program.  If not, see <https://www.gnu.org/licenses/>.
  20. =====LICENSE STATEMENT END=====*/
  21. // Alternative thread. using HTTP server instead
  23. const { resolve } = require('path');
  25. class WSv {
  26.     constructor(options) {
  27.         this.options = options || {};
  28.     }
  29. }
  31. WSv.actions = {
  32.     echo: async function(data, req, res) {
  33.         console.log("response back:", data.post.msg);
  34.         res.write(data.post.msg);
  35.     },
  36.     run: async function(data, req, res) {
  37.         try {
  38.             if (data.post.type == "function") data.post.msg = `return (${data.post.msg})()`
  39.             let AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
  40.             var thisVal = new AsyncFunction(data.post.msg);
  41.             var result = await thisVal() || ""
  42.             res.write(result);
  43.         } catch (e) {
  44.             res.write("Error executing "+data.post.msg+"\n"+e.toString());
  45.         }
  46.     },
  47.     close: async function(data, req, res) {
  48.         window.close(true);
  49.     }
  50. }
  52. WSv.prototype.action = async function(action, data, req, res) {
  53.     if (!ThreadHost.actions[action]) return;
  54.     return await ThreadHost.actions[action].call(this, data, req, res)
  55. }
  57. WSv.prototype.closeServer = function() {
  58.     this.server.close();
  59. }
  61. WSv.prototype.startServer = function() {
  62. 	var http        = require('http');
  63. 	var url         = require('url');
  64. 	var querystring = require('querystring');
  65. 	var hostname    = '127.0.0.1';
  66. 	//this.port        = 29942;
  68.     var collectRequestData = async function(request, callback) {
  69.         callback = callback || async function() {}
  70.         return new Promise(async (resolve, reject) => {
  71.             const FORM_URLENCODED = 'application/x-www-form-urlencoded';
  72.             if(request.headers['content-type'].includes(FORM_URLENCODED)) {
  73.                 let body = '';
  74.                 request.on('data', chunk => {
  75.                     body += chunk.toString();
  76.                 });
  77.                 request.on('end', async () => {
  78.                     await callback(querystring.parse(body));
  79.                     resolve(querystring.parse(body));
  80.                 });
  81.             }
  82.             else {
  83.                 await callback(null);
  84.                 resolve(null);
  85.             }
  86.         })
  88.     }
  90. 	this.server = http.createServer(async (req, res) => {
  91. 		console.log("Incoming connection:");
  92. 		console.log("Request:", req);
  93. 		console.log("response:", res);
  96. 		
  97. 		var query;
  98.         var postData;
  99. 		if (req.url.includes("?")) {
  100. 			var queryStr = req.url.substring(req.url.indexOf("?")+1);
  101. 			query = querystring.parse(queryStr);
  102. 			console.log("query", query);
  103. 			// close server if success
  104. 			//this.server.close();
  105. 		}
  106.         if (req.method === 'POST') {
  107.             postData = await collectRequestData(req);
  108.             console.log("Post data:", postData);
  109.         }
  112. 		res.statusCode = 200;
  113. 		res.setHeader("Access-Control-Allow-Origin", "*");
  114. 		res.setHeader('Content-Type', 'text/plain');
  115.         if (query.action) {
  116.             await this.action(query.action, {post:postData, get:query}, req, res);
  117.         }
  119. 		// end the response
  120. 		res.end();
  121. 	});
  123. 	this.server.listen(this.port, hostname, () => {
  124. 	   this.setStatus(`Server running at http://${hostname}:${this.port}/`);
  125. 	});
  126. }
  128. WSv.prototype.setStatus = function(str) {
  129.     $('[data-window="thread"] .status').html(str);
  130.     console.log(str);
  131. }
  137. /**
  138.  * @class
  139.  */
  140. class Thread {
  141.     constructor(options) {
  142.         this.options = options || {};
  143.         this.port = this.options.port || common.rand(30000, 40000);
  144.         
  145.         while (Thread.list[this.port]) {
  146.             this.port = common.rand(30000, 40000);
  147.         }
  148.         Thread.list[this.port] = this;
  149.     }
  150. }
  151. Thread.list = [];
  153. Thread.close = function() {
  154.     delete Thread.list[this.port];
  155. }
  157. Thread.prototype.setReadyState = function(state) {
  158.     this.isReady = state;
  159. }
  161. Thread.prototype.getReadyState = function(state) {
  162.     this.isReady = state;
  163. }
  165. Thread.prototype.openThreadWindow = async function() {
  166.     return new Promise((resolve, reject) => {
  167.         nw.Window.open("www/thread.html?port="+this.port, {new_instance:true}, (win) => {
  168.             console.log(arguments);
  169.             resolve();
  170.         });  
  171.     })
  172. }
  174. Thread.prototype.send = async function(command, msg, options) {
  175.     options         = options || {};
  176.     options.msg     = msg || options.msg;
  177.     options.type    = typeof options.msg;
  178.     if (options.type == "function") {
  179.         options.msg =  options.msg.toString();
  180.     }
  181.     this.setReadyState(false);
  182.     return new Promise((resolve, reject) => {
  183.         $.post(`http://127.0.0.1:${this.port}/?action=${command}`, options, function(data) {
  184.             resolve(data);
  185.         })
  186.         .fail(function() {
  187.            reject();
  188.         })
  189.         .always(()=> {
  190.             this.setReadyState(true);
  191.         })
  192.     })
  193. }
  195. Thread.prototype.init = async function() {
  197. }
  203. /**
  204.  * Handle socket as a server
  205.  * @class
  206.  */
  207. var ThreadServer = function() {
  208.     this.threadList = Thread.list;
  209. }
  211. ThreadServer.prototype.distributeTask = async function(tasks=[]) {
  212.     if (Array.isArray(tasks) == false) tasks = [tasks]
  214. }
  216. /**
  217.  * Add task to the iddle process.
  218.  * If none is iddle, will wait until there is iddle process
  219.  */
  220. ThreadServer.prototype.addTask = async function() {
  221.     
  222. }
  224. ThreadServer.actions = {
  225.     echo: async function(data, req, res) {
  226.         console.log("response back:", data.post.msg);
  227.         res.write(data.post.msg);
  228.     }
  229. }
  231. ThreadServer.prototype.action = async function(action, data, req, res) {
  232.     if (!ThreadServer.actions[action]) return;
  233.     return await ThreadServer.actions[action].call(this, data, req, res)
  234. }
  236. ThreadServer.prototype.startServer = function() {
  237. 	var http        = require('http');
  238. 	var url         = require('url');
  239. 	var querystring = require('querystring');
  240. 	var hostname    = '127.0.0.1';
  241. 	this.port        = 41014;
  243.     var collectRequestData = async function(request, callback) {
  244.         callback = callback || async function() {}
  245.         return new Promise(async (resolve, reject) => {
  246.             const FORM_URLENCODED = 'application/x-www-form-urlencoded';
  247.             if(request.headers['content-type'].includes(FORM_URLENCODED)) {
  248.                 let body = '';
  249.                 request.on('data', chunk => {
  250.                     body += chunk.toString();
  251.                 });
  252.                 request.on('end', async () => {
  253.                     await callback(querystring.parse(body));
  254.                     resolve(querystring.parse(body));
  255.                 });
  256.             }
  257.             else {
  258.                 await callback(null);
  259.                 resolve(null);
  260.             }
  261.         })
  263.     }
  265. 	this.server = http.createServer(async (req, res) => {
  266. 		console.log("Incoming connection:");
  267. 		console.log("Request:", req);
  268. 		console.log("response:", res);
  271. 		
  272. 		var query;
  273.         var postData;
  274. 		if (req.url.includes("?")) {
  275. 			var queryStr = req.url.substring(req.url.indexOf("?")+1);
  276. 			query = querystring.parse(queryStr);
  277. 			console.log("query", query);
  278. 			// close server if success
  279. 			//this.server.close();
  280. 		}
  281.         if (req.method === 'POST') {
  282.             postData = await collectRequestData(req);
  283.             console.log("Post data:", postData);
  284.         }
  287. 		res.statusCode = 200;
  288. 		res.setHeader("Access-Control-Allow-Origin", "*");
  289. 		res.setHeader('Content-Type', 'text/plain');
  290.         if (query.action) {
  291.             await this.action(query.action, {post:postData, get:query}, req, res);
  292.         }
  294. 		// end the response
  295. 		res.end();
  296. 	});
  298. 	this.server.listen(this.port, hostname, () => {
  299. 	   this.setStatus(`Server running at http://${hostname}:${this.port}/`);
  300. 	});
  301. }
  307. /**
  308.  * Handle socket as a client
  309.  * @class
  310.  */
  311.  class ThreadHost extends WSv {
  312. 	constructor(options) {
  313. 		super(options);
  314. 		this.init();
  315. 	}
  316. }
  318. ThreadHost.prototype.init = function() {
  319.     this.query = window.location.search.substr(1)
  320.     var searchparam = new URLSearchParams(this.query);
  321.     this.port = searchparam.get("port")
  322. }
  325. $(document).ready(function() {
  326. 	if ($('body').is('[data-window="thread"]') == false) return;
  327.     window.threadHost = new ThreadHost();
  328.     threadHost.startServer();
  330. })