@sjcrh/proteinpaint-rust 2.192.0 → 2.195.0

package/Cargo.toml

@@ -75,10 +75,6 @@ path="src/sv.rs"
 name="cluster"
 path="src/cluster.rs"
 
-[[bin]]
-name="gdcmaf"
-path="src/gdcmaf.rs"
-
 [[bin]]
 name="wilcoxon"
 path="src/wilcoxon.rs"
@@ -103,10 +99,6 @@ path="src/readHDF5.rs"
 name="validateHDF5"
 path="src/validateHDF5.rs"
 
-[[bin]]
-name="gdcGRIN2"
-path="src/gdcGRIN2.rs"
-
 [[bin]]
 name="cerno"
 path="src/cerno.rs"

package/index.js

@@ -13,14 +13,11 @@ Standard output of the rust binary is returned.
 // Import necessary modules
 import fs from 'fs'
 import path from 'path'
-import { spawn, exec } from 'child_process'
-import { Readable, Transform } from 'stream'
-import { promisify } from 'util'
+import { spawn } from 'child_process'
+import { Readable } from 'stream'
 
 const __dirname = import.meta.dirname // set __dirname for consistency with cjs code
 
-const execPromise = promisify(exec)
-
 // Check if rust binary directory exists and is not empty
 const binaryDir = path.join(__dirname, '/target/release/')
 if (!fs.existsSync(binaryDir)) throw `missing rust binary directory='${binaryDir}'`
@@ -82,162 +79,3 @@ export function run_rust(binfile, input_data, args = [], { signal } = {}) {
 		})
 	})
 }
-
-// May need to add an abort signal as argument like in run_rust above.
-// Or it's likely not needed since a closed stream connection from a web browser
-// will already trigger an error. `stream_rust()` was heavily tested manually
-// while troubleshooting and fixing the idle rust processes the led to memory leaks
-// as part of `/gdc/mafBuild` handler code, leave this code as-is for now.
-export function stream_rust(binfile, input_data, emitJson) {
-	const binpath = path.join(__dirname, '/target/release/', binfile)
-
-	const ps = spawn(binpath)
-	const childStream = new Transform({
-		transform(chunk, encoding, callback) {
-			this.push(chunk)
-			callback()
-		}
-	})
-	// we only want to run this interval loop inside a container, not in dev/test CI
-	if (binfile == 'gdcmaf') trackByPid(ps.pid, binfile)
-	const stderr = []
-	try {
-		// from route handler -> input_data -> ps.stdin -> ps.stdout -> transformed stream -> express response.pipe()
-		Readable.from(input_data)
-			.pipe(ps.stdin)
-			.on('error', err => {
-				emitErrors({ error: `error piping input data to spawned ${binfile} process` })
-			})
-	} catch (error) {
-		console.log(`Error piping input_data into ${binfile}`, error)
-		return
-	}
-
-	// uncomment to trigger childStream.destroy()
-	// setTimeout(() => { console.log(74, 'childStream.destroy()'); childStream.destroy();}, 1000)
-	// childStream.destroy() does not seem to trigger ps.stdout.pipe('...').on('error') callback,
-	// which is okay as long as the server doesn't crash and ps get's killed eventually
-	ps.stdout.pipe(childStream).on('error', err => console.log('ps.stdout.pipe(childStream) error', err))
-
-	ps.stderr.on('data', data => stderr.push(data))
-
-	ps.on('close', code => {
-		if (trackedPids.has(ps.pid)) trackedPids.delete(ps.pid)
-		if (stderr.length || killedPids.has(ps.pid) || code !== 0) {
-			emitErrors(null, ps.pid, code)
-		} else {
-			emitJson()
-		}
-	})
-	ps.on('error', err => {
-		if (trackedPids.has(ps.pid)) trackedPids.delete(ps.pid)
-		// console.log(74, `stream_rust().on('error')`, err)
-		emitErrors(null, ps.pid)
-	})
-	ps.on('SIGTERM', err => {
-		console.log(err)
-	})
-
-	function emitErrors(error, pid, code = 0) {
-		// concatenate stderr uint8arr into a string
-		let errors = stderr.join('').trim()
-		if (error) errors += `\n` + error
-		if (pid && killedPids.has(ps.pid) && !trackedPids.has(ps.pid)) {
-			errors += '\n' + JSON.stringify({ error: `server error: MAF file processing terminated (expired process)` })
-			killedPids.delete(pid)
-		} else if (pid && code !== 0) {
-			// may result from errors in spawned process code, or external signal (like `kill -9` in terminal)
-			errors += '\n' + JSON.stringify({ error: `server error: MAF file processing terminated (code=${code})` })
-		}
-		emitJson(errors)
-	}
-
-	// on('end') will duplicate ps.on('close') event above
-	// childStream.on('end', () => console.log(`childStream.on(end)`))
-
-	// this may duplicate ps.on('error'), unless the error happened within the transform
-	childStream.on('error', err => {
-		console.log('stream_rust childStream.on(error)', err)
-		try {
-			childStream.destroy(err)
-		} catch (e) {
-			console.log(e)
-		}
-	})
-
-	function endStream() {
-		try {
-			if (!childStream.writableEnded) {
-				console.log('trigger childStream.destroy() in endStream()')
-				childStream.destroy()
-			}
-		} catch (e) {
-			console.log('error triggering childStream.destroy()', e)
-		}
-		try {
-			if (!ps.killed) {
-				console.log('trigger ps.kill() in endStream()')
-				ps.kill()
-			}
-			if (trackedPids.has(ps.pid)) trackedPids.delete(ps.pid)
-		} catch (e) {
-			console.log('error triggering ps.kill()', e)
-		}
-	}
-
-	return { rustStream: childStream, endStream }
-}
-
-const trackedPids = new Map() // will be used to monitor expired processes
-const killedPids = new Set() // will be used to detect killed processes, to help with error detection
-const PSKILL_INTERVAL_MS = 30000 // every 30 seconds
-let psKillInterval
-
-// default maxElapsed = 5 * 60 * 1000 millisecond = 300000 or 5 minutes, change to 0 to test
-// may allow configuration of maxElapsed by dataset/argument
-function trackByPid(pid, name, maxElapsed = 300000) {
-	if (!pid) return
-	// only track by value (integer, string), not reference object
-	// NOTE: a reused/reassigned process.pid will be replaced by the most recent process
-	trackedPids.set(pid, { name, expires: Date.now() + maxElapsed })
-	if (!psKillInterval) psKillInterval = setInterval(killExpiredProcesses, PSKILL_INTERVAL_MS)
-	// uncomment below to test
-	// console.log([...trackedPids.entries()])
-	// if (maxElapsed < 10000) setTimeout(killExpiredProcesses, 1000) // uncomment for testing only
-}
-
-//
-// Use one setInterval() to monitor >= 1 process,
-// instead of a separate setTimeout() for each process.
-// This is more reliable as setTimeout would use spawned ps.kill(),
-// which may not exist when the timeout callback is executed and
-// thus would require clearTimeout(closured_variable). Tracking by
-// pid does not rely on a usable 'ps' variable to kill itself.
-//
-function killExpiredProcesses() {
-	//console.log(149, 'killExpiredProcesses()')
-	killedPids.clear()
-	const time = Date.now()
-	for (const [pid, info] of trackedPids.entries()) {
-		if (info.expires > time) continue
-		try {
-			// true if process exists
-			process.kill(pid, 0)
-		} catch (_) {
-			// no need to kill, but remove from tracking
-			trackedPids.delete(pid)
-			// prevent misleading logs of 'unable to kill ...'
-			continue
-		}
-		const label = `rust process ${info.name} (pid=${pid})`
-		try {
-			// detect if process exists before killing it
-			process.kill(pid, 'SIGTERM')
-			trackedPids.delete(pid)
-			killedPids.add(pid)
-			console.log(`killed ${label}`)
-		} catch (err) {
-			console.log(`unable to kill ${label}`, err)
-		}
-	}
-}

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "2.192.0",
+	"version": "2.195.0",
 	"name": "@sjcrh/proteinpaint-rust",
 	"type": "module",
 	"description": "Rust-based utilities for proteinpaint",