@sjcrh/proteinpaint-rust 2.31.0 → 2.33.0

package/index.js

@@ -1,8 +1,9 @@
 const path = require('path'),
 	spawn = require('child_process').spawn,
-	Readable = require('stream').Readable
+	Readable = require('stream').Readable,
+	Transform = require('stream').Transform
 
-exports.run_rust = function(binfile, input_data) {
+exports.run_rust = function (binfile, input_data) {
 	return new Promise((resolve, reject) => {
 		const binpath = path.join(__dirname, '/target/release/', binfile)
 		const ps = spawn(binpath)
@@ -41,3 +42,31 @@ exports.run_rust = function(binfile, input_data) {
 		})
 	})
 }
+
+exports.run_rust_stream = function (binfile, input_data) {
+	const binpath = path.join(__dirname, '/target/release/', binfile)
+	const ps = spawn(binpath)
+	try {
+		Readable.from(input_data).pipe(ps.stdin)
+	} catch (error) {
+		ps.kill()
+		let errmsg = error
+		if (stderr.length) errmsg += `killed run_rust('${binfile}'), stderr: ${stderr.join('').trim()}`
+		reject(errmsg)
+	}
+
+	const childStream = new Transform({
+		transform(chunk, encoding, callback) {
+			this.push(chunk)
+			callback()
+		}
+	})
+	ps.stdout.pipe(childStream)
+	childStream.on('error', err => {
+		reject(err)
+	})
+	childStream.on('close', code => {
+		childStream.end()
+	})
+	return childStream
+}

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.31.0",
+  "version": "2.33.0",
   "name": "@sjcrh/proteinpaint-rust",
   "description": "Rust-based utilities for proteinpaint",
   "main": "index.js",

package/src/gdcmaf.rs

@@ -4,8 +4,7 @@ use flate2::Compression;
 use serde_json::Value;
 use std::path::Path;
 use futures::StreamExt;
-use std::io;
-use std::io::{Read,Write};
+use std::io::{self,Read,Write};
 use std::sync::mpsc;
 
 
@@ -45,8 +44,7 @@ fn gen_vec(d:String) -> (Vec<String>,Vec<Vec<u8>>) {
                 }
             };
             maf_out_lst.push("\n".to_string());
-            let maf_compress_data = gen_gzip_vec(maf_out_lst);
-            maf_bit.push(maf_compress_data);
+            maf_bit.push(maf_out_lst.join("\t").as_bytes().to_vec());
             lst_chrom_pos.push(chrom+"\t"+&pos);
         }
     };
@@ -62,14 +60,6 @@ fn get_sorted_indices(lst: &Vec<String>) -> Vec<usize>{
     indices
 }
 
-// convert vector (maf row) to GZIP encoded format
-fn gen_gzip_vec(s:Vec<String>) -> Vec<u8> {
-    let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
-    let _ = encoder.write_all(s.join("\t").as_bytes());
-    let compress_data = encoder.finish().unwrap();
-    compress_data
-}
-
 // GDC MAF columns (96)
 const MAF_COL: [&str;96] = ["Hugo_Symbol", "Entrez_Gene_Id", "Center", "NCBI_Build", "Chromosome", 
                             "Start_Position", "End_Position", "Strand", "Variant_Classification", 
@@ -112,18 +102,15 @@ async fn main() -> Result<(),Box<dyn std::error::Error>> {
         url.into_iter().map(|url|{
             let txt = tx.clone();
             async move {
-                match reqwest::get(&url).await{
-                    Ok(resp) => {
-                        let content = resp.bytes().await.unwrap();
-                        let mut decoder = GzDecoder::new(&content[..]);
-                        let mut decompressed_content = Vec::new();
-                        if let Ok(_) = decoder.read_to_end(&mut decompressed_content) {
-                            let text = String::from_utf8_lossy(&decompressed_content);
-                            let (lst_chrom_pos,maf_bit) = gen_vec(text.to_string());
-                            txt.send((lst_chrom_pos,maf_bit)).unwrap();
-                        }
+                if let Ok(resp) = reqwest::get(&url).await {
+                    let content = resp.bytes().await.unwrap();
+                    let mut decoder = GzDecoder::new(&content[..]);
+                    let mut decompressed_content = Vec::new();
+                    if let Ok(_) = decoder.read_to_end(&mut decompressed_content) {
+                        let text = String::from_utf8_lossy(&decompressed_content);
+                        let (lst_chrom_pos,maf_bit) = gen_vec(text.to_string());
+                        txt.send((lst_chrom_pos,maf_bit)).unwrap();
                     }
-                    Err(_) => println!("ERROR downloading {}", url),
                 }
             }
         })
@@ -145,17 +132,11 @@ async fn main() -> Result<(),Box<dyn std::error::Error>> {
     // output
     // maf_out_bit: A vector of GZIPPED maf
     // compress_header: output header
-    let mut maf_out_bit: Vec<u8> = Vec::new();
-    let compress_header = gen_gzip_vec(MAF_COL.iter().map(|s| s.to_string()).collect());
-    maf_out_bit.extend(compress_header);
-    let compress_header_line_break = gen_gzip_vec(["\n".to_string()].to_vec());
-    maf_out_bit.extend(compress_header_line_break);
+    let mut encoder = GzEncoder::new(io::stdout(), Compression::default());
+    let _ = encoder.write_all(&MAF_COL.join("\t").as_bytes().to_vec()).expect("Failed to write header");
+    let _ = encoder.write_all(b"\n").expect("Failed to write newline");
     for i in idx_sorted.iter() {
-        maf_out_bit.extend(&maf_bit[*i]);
+        let _ = encoder.write_all(&maf_bit[*i]).expect("Failed to write file");
     };
-
-    // standard output
-    println!("{:?}",maf_out_bit);
-    std::io::stdout().flush().expect("Failed to flush stdout");
     Ok(())
 }