@muze-nl/simplystore 0.4.7 → 0.5.0

package/src/statusCodes.mjs

@@ -0,0 +1,70 @@
+const httpStatusCodes = {
+	'100': 'Continue',
+	'101': 'Switching Protocols',
+	'102': 'Processing',
+	'103': 'Early Hints',
+	'200': 'OK',
+	'201': 'Created',
+	'200': 'OK',
+	'201': 'Created',
+	'202': 'Accepted',
+	'203': 'Non-Authoritative Information',
+	'204': 'No Content',
+	'205': 'Reset Content',
+	'206': 'Partial Content',
+	'207': 'Multi-Status',
+	'208': 'Already Reported',
+	'226': 'IM Used',
+	'300': 'Multiple Choices',
+	'301': 'Moved Permanently',
+	'302': 'Found',
+	'303': 'See Other',
+	'304': 'Not Modified',
+	'305': 'Use Proxy',
+	'306': '(Unused)',
+	'307': 'Temporary Redirect',
+	'308': 'Permanent Redirect (experimental)',
+ 	'400': 'Bad Request',
+	'401': 'Unauthorized',
+	'402': 'Payment Required',
+	'403': 'Forbidden',
+	'404': 'Not Found',
+	'405': 'Method Not Allowed',
+	'406': 'Not Acceptable',
+	'407': 'Proxy Authentication Required',
+	'408': 'Request Timeout',
+	'409': 'Conflict',
+	'410': 'Gone',
+	'411': 'Length Required',
+	'412': 'Precondition Failed',
+	'413': 'Request Entity Too Large',
+	'414': 'Request-URI Too Long',
+	'415': 'Unsupported Media Type',
+	'416': 'Requested Range Not Satisfiable',
+	'417': 'Expectation Failed',
+	'418': 'I\'m a teapot (RFC 2324)',
+	'420': 'Enhance Your Calm (Twitter)',
+	'422': 'Unprocessable Entity (WebDAV)',
+	'423': 'Locked (WebDAV)',
+	'424': 'Failed Dependency (WebDAV)',
+	'425': 'Reserved for WebDAV',
+	'426': 'Upgrade Required',
+	'428': 'Precondition Required',
+	'429': 'Too Many Requests',
+	'431': 'Request Header Fields Too Large',
+	'451': 'Unavailable For Legal Reasons',
+	'500': 'Internal Server Error',
+	'501': 'Not Implemented',
+	'502': 'Bad Gateway',
+	'503': 'Service Unavailable',
+	'504': 'Gateway Timeout',
+	'505': 'HTTP Version Not Supported',
+	'506': 'Variant Also Negotiates (Experimental)',
+	'507': 'Insufficient Storage (WebDAV)',
+	'508': 'Loop Detected (WebDAV)',
+	'509': 'Bandwidth Limit Exceeded (Apache)',
+	'510': 'Not Extended',
+	'511': 'Network Authentication Required',
+}
+
+export default httpStatusCodes

package/src/symbols.mjs

@@ -0,0 +1,6 @@
+export const source = Symbol('source')
+export const isProxy = Symbol('isProxy')
+export const getBuffer = Symbol('getBuffer')
+export const getIndex = Symbol('getIndex')
+export const isChanged = Symbol('isChanged')
+export const getString = Symbol('getString')

package/src/util.mjs

@@ -33,14 +33,14 @@ export function joinArgs(args) {
  * @return {void}
  */
 export async function appendFile(filename, data) {
-	console.log('appending command')
 	let handle;
 	try {
-		handle = await fs.open(filename, 'a')
+		handle = await fs.open(filename, 'a+')
 		await handle.appendFile(data+"\n")
 		await handle.datasync()
 		return true
 	} finally {
 		await handle.close()
 	}
-}
+}
+

package/src/workerPool.mjs

@@ -0,0 +1,99 @@
+import { AsyncResource } from 'async_hooks'
+import { EventEmitter } from 'events'
+import path from 'path'
+import { Worker } from 'worker_threads'
+
+const kTaskInfo = Symbol('kTaskInfo');
+const kWorkerFreedEvent = Symbol('kWorkerFreedEvent');
+
+class WorkerPoolTaskInfo extends AsyncResource {
+  constructor(callback) {
+    super('WorkerPoolTaskInfo');
+    this.callback = callback;
+  }
+
+  done(err, result) {
+    this.runInAsyncScope(this.callback, null, err, result);
+    this.emitDestroy();  // `TaskInfo`s are used only once.
+  }
+}
+
+//@TODO: only create new workers when needed, not immediately
+//@TODO: allow initialization of newly created workers
+
+export default class WorkerPool extends EventEmitter {
+  constructor(numThreads, workerFile, initTask) {
+    super()
+    this.numThreads  = numThreads
+    this.workerFile  = workerFile
+    this.initTask    = initTask
+    this.workers     = []
+    this.freeWorkers = []
+
+    for (let i = 0; i < numThreads; i++)
+      this.addNewWorker();
+  }
+
+  addNewWorker() {
+    const worker = new Worker(path.resolve(this.workerFile));
+    worker.on('message', (result) => {
+      // In case of success: Call the callback that was passed to `runTask`,
+      // remove the `TaskInfo` associated with the Worker, and mark it as free
+      // again.
+      if (worker[kTaskInfo]) {
+        worker[kTaskInfo].done(null, result);
+        worker[kTaskInfo] = null;
+      }
+      this.freeWorkers.push(worker);
+      this.emit(kWorkerFreedEvent);
+    });
+    worker.on('error', (err) => {
+      // In case of an uncaught exception: Call the callback that was passed to
+      // `runTask` with the error.
+      if (worker[kTaskInfo])
+        worker[kTaskInfo].done(err, null);
+      else
+        this.emit('error', err);
+      // Remove the worker from the list and start a new Worker to replace the
+      // current one.
+      this.workers.splice(this.workers.indexOf(worker), 1);
+      this.addNewWorker();
+    });
+    this.workers.push(worker);
+    worker.postMessage(this.initTask);
+  }
+
+  async run(name, req) {
+    return new Promise((resolve, reject) => {
+      this.runTask({name,req}, (error, result) => {
+        if (error) {
+          return reject(error)
+        }
+        return resolve(result)
+      })
+    })
+  }
+
+  runTask(task, callback) {
+    if (this.freeWorkers.length === 0) {
+      // No free threads, wait until a worker thread becomes free.
+      console.log('no free worker.. waiting')
+      this.once(kWorkerFreedEvent, () => this.runTask(task, callback));
+      return;
+    }
+    const worker = this.freeWorkers.pop();
+    worker[kTaskInfo] = new WorkerPoolTaskInfo(callback);
+    worker.postMessage(task);
+  }
+
+  memoryUsage() {
+    for (let worker of this.freeWorkers) {
+      worker[kTaskInfo] = new WorkerPoolTaskInfo((result) => {})
+      worker.postMessage({name:'memoryUsage'})
+    }
+  }
+
+  close() {
+    for (const worker of this.workers) worker.terminate();
+  }
+}

package/data.jsontag

@@ -1,20 +0,0 @@
-{
-	"persons": [
-		<object id="john" class="Person">{
-			"name": "John",
-			"lastName": "Doe",
-			"dob": <date>"1972-09-20",
-			"foaf": [
-				<link>"jane"
-			]
-		},
-		<object id="jane" class="Person">{
-			"name": "Jane",
-			"lastName": "Doe",
-			"dob": <date>"1986-01-01",
-			"foaf": [
-				<link>"john"
-			]
-		}
-	]
-}

package/src/share.mjs

@@ -1,142 +0,0 @@
-import JSONTag from '@muze-nl/jsontag'
-
-const handler = function(root, index, buffer) 
-{
-	return {
-		get(target, key, receiver) 
-		{
-			let keyNumber = index.key[key]
-			if (root[keyNumber]) {
-				let keyStart = root[keyNumber].s + root.s
-				let keyEnd = root[keyNumber].e + root.s
-				subobjecten hoeven niet geparsed...
-				if (root[keyNumber].c) {
-					// object
-					return new jsontagProxy(root[keyNumber], index, buffer)
-				}
-				return JSON.parse(buffer.slice(keyStart,keyEnd))
-			}
-		}
-
-		has(target, key)
-		{
-			let keyNumber = index.key[key]
-			return typeof root[keyNumber] !== 'undefined'
-		}
-
-		ownKeys(target)
-		{
-			return root.c.map(n => index.reverse[n])
-		}
-	}
-}
-
-export class jsontagProxy extends proxy
-{
-	constructor(root, index, buffer) 
-	{
-		super({}, handler(root, index, buffer))
-	}
-
-}
-
-export default function share(data)
-{
-	let jsontag = JSONTag.stringify(data)
-	let buffer = new SharedArrayBuffer(jsontag.length)
-	let dv = new DataView(buffer)
-	let encode = new TextEncoder('utf-8')
-	let root = {}
-	let index = {
-		key: {},
-		reverse: [],
-		types: {}
-	}
-	let current = 0
-
-	function getKey(key) {
-		let l;
-		if (typeof index.key[key] == 'undefined') {
-			l = Object.keys(index.key)
-			index.key[key] = l
-			index.reverse[l] = key
-		}
-		return index.key[key]
-	}
-
-	function getType(type) {
-		if (typeof index.types[type] == 'undefined') {
-			l = Object.keys(index.types);
-			index.types[type] = l
-		}
-
-	}
-
-	function store(container, key, value) {
-		let l = getKey(key)
-		container[l] = {
-			s: current
-		}
-		container = container[l]
-		let attributes = JSONTag.getAttributes(value)
-		if (attributes) {
-			container.a = {
-				s: current,
-				c: {}
-			}
-			attributes.forEach((v,k) => {
-				let l = getKey(k)
-				let t = getType('string')
-				container.a.c[k] = {
-					s: current,
-					t
-				}
-				let v = JSON.stringify(value)
-				let (r,w) = encoder.encodeInto(v, dv, current)
-				current += w
-				container.a.c[k].e = current
-			})
-		}
-		let type = JSONTag.getType(node)
-		let t = getType(type)
-		container.t = t
-		let v = JSON.stringify(value)
-		let (r,w) = encoder.encodeInto(v, dv, current)
-		current+= w
-		container.e = current
-	}
-
-
-	function walk(node, parentKey, parent, save) 
-	{
-		let type = JSONTag.getType(node)
-		let t = getType(type)
-		switch (type) {
-			case 'array':
-				save.s = current
-				save.t = t
-				save.c = []
-				node.forEach((v,k) => walk(v, k, node, save.c))
-				save.e = current
-				break
-			case 'object':
-				save.s = current
-				save.c = []
-				save.t = t
-				Object.entries(node).forEach((k,v) => walk(v, k, node, save.c))
-				save.e = current
-				break
-			default:
-				store(save, parentKey, node)
-				break
-		}
-	}
-
-	walk(data, null, null, root)
-
-	return {
-		root: new jsontagProxy(root, index, buffer),
-		index,
-		buffer
-	}
-}

package/src/worker-query-init.mjs

@@ -1,14 +0,0 @@
-import JSONTag from '@muze-nl/jsontag';
-import worker_threads from 'node:worker_threads';
-import * as queryWorker from './worker-query.mjs';
-
-async function initialize() {
-	let meta = {}
-	let dataspace = JSONTag.parse(worker_threads.workerData, null, meta)
-	//console.log('starting')
-	await queryWorker.initialize(dataspace,meta)
-	//console.log('initialized')
-	return queryWorker.runQuery
-}
-
-export default initialize()