Handle kill signal

src/blockstore/fs.ts

@@ -1,18 +1,18 @@
 import fs from 'fs'
-import os from 'os'
 
 import { CID } from 'multiformats'
 import { BaseBlockstore } from 'blockstore-core'
 import { Blockstore } from './index'
+import * as os from "os";
 
 export class FsBlockStore extends BaseBlockstore implements Blockstore {
   path: string
   _opened: boolean
   _opening?: Promise<void>
 
-  constructor () {
+  constructor (path?: string) {
     super()
-    this.path = `${os.tmpdir()}/${(parseInt(String(Math.random() * 1e9), 10)).toString() + Date.now()}`
+    this.path = path ? path : `${os.tmpdir()}/${(parseInt(String(Math.random() * 1e9), 10)).toString() + Date.now()}`
     this._opened = false
   }
 

src/pack/fs.ts

@@ -1,5 +1,4 @@
 import fs from 'fs'
-import os from 'os'
 import path from 'path'
 import moveFile from 'move-file'
 
@@ -13,8 +12,10 @@ export interface PackToFsProperties extends PackProperties {
 }
 
 export async function packToFs ({ input, output, blockstore: userBlockstore, hasher, maxChunkSize, maxChildrenPerNode, wrapWithDirectory, rawLeaves }: PackToFsProperties) {
-  const blockstore = userBlockstore ? userBlockstore : new FsBlockStore()
-  const location = output || `${os.tmpdir()}/${(parseInt(String(Math.random() * 1e9), 10)).toString() + Date.now()}`
+  const realpath = path.basename(await fs.promises.realpath(input as string))
+  const inputBasename = realpath === "/" ? "file" : realpath
+  const blockstore = userBlockstore ? userBlockstore : new FsBlockStore(`/tmp/${inputBasename}.tmp.${process.pid}`)
+  const location = output || `${process.cwd()}/.${inputBasename}.car.tmp.${process.pid}`
   const writable = fs.createWriteStream(location)
 
   const { root } = await packToStream({
@@ -35,7 +36,7 @@ export async function packToFs ({ input, output, blockstore: userBlockstore, has
   // Move to work dir
   if (!output) {
     const basename = typeof input === 'string' ? path.parse(path.basename(input)).name : root.toString()
-    const filename = `${basename}.car`
+    const filename = basename === "/" ? "file.car" : `${basename}.car`
     await moveFile(location, `${process.cwd()}/${filename}`)
 
     return {root, filename}

src/pack/stream.ts

@@ -14,6 +14,8 @@ import { MemoryBlockStore } from '../blockstore/memory'
 import { unixfsImporterOptionsDefault } from './constants'
 
 import type { PackProperties } from './index'
+import {Blockstore} from "../blockstore";
+import {FsBlockStore} from "../blockstore/fs";
 
 export interface PackToStreamProperties extends PackProperties {
   input: string | Iterable<string> | AsyncIterable<string>,
@@ -27,21 +29,32 @@ export async function packToStream ({ input, writable, blockstore: userBlockstor
   }
   input = typeof input === 'string' ? [input] : input
 
-  const blockstore = userBlockstore ? userBlockstore : new MemoryBlockStore()
+  if (userBlockstore) {
+    process.on("SIGINT", async (signal) => await handleSignal(signal, userBlockstore));
+    process.on("SIGTERM", async (signal) => await handleSignal(signal, userBlockstore));
+  }
 
-  // Consume the source
-  const rootEntry = await last(pipe(
-    legacyGlobSource(input),
-    source => normaliseInput(source),
-    (source: any) => importer(source, blockstore, {
-      ...unixfsImporterOptionsDefault,
-      hasher: hasher || unixfsImporterOptionsDefault.hasher,
-      maxChunkSize: maxChunkSize || unixfsImporterOptionsDefault.maxChunkSize,
-      maxChildrenPerNode: maxChildrenPerNode || unixfsImporterOptionsDefault.maxChildrenPerNode,
-      wrapWithDirectory: wrapWithDirectory === false ? false : unixfsImporterOptionsDefault.wrapWithDirectory,
-      rawLeaves: rawLeaves == null ? unixfsImporterOptionsDefault.rawLeaves : rawLeaves
-    })
-  ))
+  const blockstore = userBlockstore ? userBlockstore : new MemoryBlockStore()
+  let rootEntry
+
+  try {
+    // Consume the source
+    rootEntry = await last(pipe(
+      legacyGlobSource(input),
+      source => normaliseInput(source),
+      (source: any) => importer(source, blockstore, {
+        ...unixfsImporterOptionsDefault,
+        hasher: hasher || unixfsImporterOptionsDefault.hasher,
+        maxChunkSize: maxChunkSize || unixfsImporterOptionsDefault.maxChunkSize,
+        maxChildrenPerNode: maxChildrenPerNode || unixfsImporterOptionsDefault.maxChildrenPerNode,
+        wrapWithDirectory: wrapWithDirectory === false ? false : unixfsImporterOptionsDefault.wrapWithDirectory,
+        rawLeaves: rawLeaves == null ? unixfsImporterOptionsDefault.rawLeaves : rawLeaves
+      })
+    ))
+  } catch (err) {
+    // tslint:disable-next-line:no-console
+    console.log("Error while importing")
+  }
 
   if (!rootEntry || !rootEntry.cid) {
     throw new Error('given input could not be parsed correctly')
@@ -52,8 +65,13 @@ export async function packToStream ({ input, writable, blockstore: userBlockstor
   const { writer, out } = await CarWriter.create([root])
   Readable.from(out).pipe(writable)
 
-  for await (const block of blockstore.blocks()) {
-    await writer.put(block)
+  try {
+    for await (const block of blockstore.blocks()) {
+      await writer.put(block)
+    }
+  } catch (err) {
+    // tslint:disable-next-line:no-console
+    console.log("Error while writing blocks")
   }
 
   await writer.close()
@@ -86,3 +104,10 @@ async function * legacyGlobSource (input: Iterable<string> | AsyncIterable<strin
     }
   }
 }
+
+async function handleSignal(signal: NodeJS.Signals, blockstore: Blockstore) {
+  // tslint:disable-next-line:no-console
+  console.log(`Received ${signal} signal, cleaning up...`)
+  fs.rmSync((blockstore as FsBlockStore).path, {recursive: true, force: true})
+  fs.rmSync((blockstore as FsBlockStore).path.replace(".tmp", ".car.tmp").replace("/tmp/", `${process.cwd()}/.`), {recursive: true, force: true})
+}

src/unpack/fs.ts

@@ -12,7 +12,7 @@ import { FsBlockStore } from '../blockstore/fs'
 import toIterable from 'stream-to-it'
 
 import { unpack, unpackStream } from './index'
-import { Blockstore } from '../blockstore/index'
+import { Blockstore } from '../blockstore'
 
 // Node only, read a car from fs, write files to fs
 export async function unpackToFs ({input, roots, output}: {input: string, roots?: CID[], output?: string}) {
@@ -22,7 +22,7 @@ export async function unpackToFs ({input, roots, output}: {input: string, roots?
 
 // Node only, read a stream, write files to fs
 export async function unpackStreamToFs ({input, roots, output, blockstore: userBlockstore}: {input: AsyncIterable<Uint8Array>, roots?: CID[], output?: string, blockstore?: Blockstore}) {
-  const blockstore = userBlockstore ? userBlockstore : new FsBlockStore()
+  const blockstore = userBlockstore ? userBlockstore : new FsBlockStore(output ? output : (roots ? roots[0].toString() : "output"))
   await writeFiles(unpackStream(input, { roots, blockstore }), output)
   if (!userBlockstore) {
     await blockstore.close()