Deploy functions with zip-it-and-ship-it

Author: biilmann

src/deploy/hash-fns.js

@@ -35,10 +35,6 @@ async function hashFns(dir, opts) {
   const fnShaMap = {} //hash: [fileObj, fileObj, fileObj]
   const manifestCollector = manifestCollectorCtor(functions, fnShaMap, opts)
 
-  // TODO: Zip up functions, hash then send.
-  // This is totally wrong right now.
-  // See https://github.com/netlify/open-api/blob/master/go/porcelain/deploy.go#L544
-
   await pump(fileStream, fnStat, fnFilter, hasher, manifestCollector)
 
   return { functions, fnShaMap }

src/deploy/hasher-segments.js

@@ -1,20 +1,20 @@
 const objFilterCtor = require('through2-filter').objCtor
 const objWriter = require('flush-write-stream').obj
-const { isExe, normalizePath } = require('./util')
+const { normalizePath } = require('./util')
 const transform = require('parallel-transform')
 const hasha = require('hasha')
 const path = require('path')
 const fs = require('fs')
 const map = require('through2-map').obj
-const pump = require('pump')
-const archiver = require('archiver')
+const zipIt = require('zip-it-and-ship-it')
 
 // a parallel transform stream segment ctor that hashes fileObj's created by folder-walker
 exports.hasherCtor = ({ concurrentHash, hashAlgorithm = 'sha1' }) => {
+  const hashaOpts = { algorithm: hashAlgorithm }
   if (!concurrentHash) throw new Error('Missing required opts')
   return transform(concurrentHash, { objectMode: true }, (fileObj, cb) => {
     hasha
-      .fromFile(fileObj.filepath, { algorithm: hashAlgorithm })
+      .fromFile(fileObj.filepath, hashaOpts)
       // insert hash and asset type to file obj
       .then(hash => cb(null, Object.assign({}, fileObj, { hash })))
       .catch(err => cb(err))
@@ -59,64 +59,42 @@ exports.fileFilterCtor = objFilterCtor(fileObj => {
 
 exports.fnFilterCtor = objFilterCtor(fileObj => {
   // filter additional files out of our fn pipeline
-  return fileObj.type === 'file' && !!fileObj.runtime
+  return fileObj && fileObj.type === 'file' && !!fileObj.runtime
 })
 
-// Zip a file into a temporary directory
-function zipFunction(item, tmpDir, cb) {
-  const zipPath = path.join(tmpDir, item.normalizedPath + '.zip')
-  const output = fs.createWriteStream(zipPath)
-  const archive = archiver('zip')
-
-  archive.file(item.filepath, { name: item.basename })
-  archive.finalize()
-
-  pump(archive, output, err => {
-    if (err) return cb(err)
-
-    item.filepath = zipPath
-    cb(null, item)
-  })
-}
-
 // parallel stream ctor similar to folder-walker but specialized for netlify functions
 // Stream in names of files that may be functions, and this will stat the file and return a fileObj
 exports.fnStatCtor = ({ root, concurrentStat, tmpDir }) => {
   if (!concurrentStat || !root || !tmpDir) throw new Error('Missing required opts')
   return transform(concurrentStat, { objectMode: true }, (name, cb) => {
-    const filepath = path.join(root, name)
+    const filepath = path.resolve(path.join(root, name))
     fs.stat(filepath, (err, stat) => {
       if (err) return cb(err)
-
-      const item = {
-        root,
-        filepath,
-        stat,
-        relname: path.relative(root, filepath),
-        basename: path.basename(name),
-        extname: path.extname(name),
-        type: stat.isFile() ? 'file' : stat.isDirectory() ? 'directory' : null,
-        assetType: 'function',
-        normalizedPath: path.basename(name, path.extname(name))
-      }
-
-      if (['.zip'].some(ext => item.extname === ext)) {
-        item.runtime = 'js'
-        return cb(null, item)
-      }
-
-      if (['.js'].some(ext => item.extname === ext)) {
-        item.runtime = 'js'
-
-        return zipFunction(item, tmpDir, cb)
-      }
-
-      if (isExe(item.stat)) {
-        item.runtime = 'go'
-        return zipFunction(item, tmpDir, cb)
-      }
-
-      return cb(null, item)
+      zipIt
+        .zipFunction(filepath, tmpDir)
+        .then(functionZip => {
+          if (functionZip === null) {
+            return cb(null, null)
+          }
+
+          const item = {
+            root,
+            filepath: functionZip.path,
+            stat,
+            relname: path.relative(root, filepath),
+            basename: path.basename(name),
+            extname: path.extname(name),
+            type: 'file',
+            assetType: 'function',
+            normalizedPath: path.basename(name, path.extname(name)),
+            runtime: functionZip.runtime
+          }
+
+          cb(null, item)
+        })
+        .catch(err => {
+          cb(err, null)
+        })
     })
   })
 }

src/deploy/util.js

@@ -115,18 +115,4 @@ function getUploadList(required, shaMap) {
   return flatten(required.map(sha => shaMap[sha]))
 }
 
-// given a Stat object, return if its executable or not
-// https://github.com/jokeyrhyme/is-executable.js without the io
-exports.isExe = stat => {
-  const { mode, gid, uid } = stat
-  if (process.platform === 'win32') {
-    return true
-  }
-
-  const isGroup = gid ? process.getgid && gid === process.getgid() : true
-  const isUser = uid ? process.getuid && uid === process.getuid() : true
-
-  return Boolean(mode & 0o0001 || (mode & 0o0010 && isGroup) || (mode & 0o0100 && isUser))
-}
-
 exports.retry = async (fn, errHandler, opts) => {}