Adding support for pre-compiled Swift binary handlers.

Author: James Thomas

README.md

@@ -264,7 +264,7 @@ In the `serverless.yaml` file, the `handler` property is used to denote the sour
 ```yaml
 functions:
   my_function:
-    handler: index.greeting
+    handler: index.main
     runtime: swift
 ```
 
@@ -291,6 +291,42 @@ func main(args: [String:Any]) -> [String:Any] {
 
 If you want to return an error message, return an object with an `error` property with the message. 
 
+## Writing Functions - Pre-Compiled Swift Binaries
+
+OpenWhisk supports creating Swift actions from a pre-compiled binary. This reduces startup time for Swift actions by removing the need for a dynamic compilation step.
+
+In the `serverless.yaml` file, the `handler` property can refer to the compiled binary file produced by the build. 
+
+```yaml
+functions:
+  hello:
+    handler: .build/release/Hello
+```
+
+This configuration will generate the deployment package for that function containing only this binary file. It will not include other local files, e.g. Swift source files.
+
+Pre-compiled Swift actions must be compatible with the platform runtime and architecture. There is an [open-source Swift package](https://packagecatalog.com/package/jthomas/OpenWhiskAction) (`OpenWhiskAction`) that handles wrapping functions within a shim to support runtime execution.
+
+```
+import OpenWhiskAction
+
+func hello(args: [String:Any]) -> [String:Any] {
+    if let name = args["name"] as? String {
+      return [ "greeting" : "Hello \(name)!" ]
+    } else {
+      return [ "greeting" : "Hello stranger!" ]
+    }
+}
+
+OpenWhiskAction(main: hello)
+```
+
+Binaries produced by the Swift build process must be generated for the correct platform architecture. This Docker command will compile Swift sources files using the relevant Swift environment.
+
+```
+docker run --rm -it -v $(pwd):/swift-package openwhisk/swift3action bash -e -c "cd /swift-package && swift build -v -c release"
+```
+
 ## Writing Functions - Binary
 
 OpenWhisk supports executing a compiled binary for the function handler. Using a Python wrapper, the file will be invoked within the `openwhisk/dockerskeleton` Docker container. 

compile/functions/runtimes/swift.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const BaseRuntime = require('./base')
+const JSZip = require("jszip")
 
 class Swift extends BaseRuntime {
   constructor (serverless) {
@@ -9,8 +10,27 @@ class Swift extends BaseRuntime {
     this.extension = '.swift'
   }
 
+  convertHandlerToPath (functionHandler) {
+    if (this.isBuildPath(functionHandler)) {
+      return functionHandler
+    }
+
+    return super.convertHandlerToPath(functionHandler)
+  }
+
+  isBuildPath (path) {
+    return path.startsWith('.build/')
+  }
+
+  // Ensure zip package used to deploy action has the correct artifacts for the runtime.
+  // Swift source actions must have the function code in `main.swift`.
+  // Swift binary actions must have the binary as `./build/release/Action`.
   processActionPackage (handlerFile, zip) {
     return zip.file(handlerFile).async('nodebuffer').then(data => {
+      if (this.isBuildPath(handlerFile)) {
+        zip = new JSZip()
+        return zip.file('.build/release/Action', data)
+      }
       zip.remove(handlerFile)
       return zip.file('main.swift', data)
     })

compile/functions/runtimes/tests/swift.js

@@ -83,6 +83,16 @@ describe('Swift', () => {
     })
   });
 
+  describe('#convertHandlerToPath()', () => {
+    it('should return file path for swift function handlers', () => {
+      expect(node.convertHandlerToPath('file.func')).to.be.equal('file.swift')
+    })
+
+    it('should return file path for build binaries', () => {
+      expect(node.convertHandlerToPath('.build/release/Action')).to.be.equal('.build/release/Action')
+    })
+  })
+
   describe('#generateActionPackage()', () => {
     it('should throw error for missing handler file', () => {
       expect(() => node.generateActionPackage({handler: 'does_not_exist.main'}))
@@ -134,5 +144,28 @@ describe('Swift', () => {
         })
       });
     })
+
+    it('should create zip file with binary action', () => {
+      node.serverless.service.package = {artifact: '/path/to/zip_file.zip'};
+      node.isValidFile = () => true
+      const zip = new JSZip();
+      const source = 'binary file contents' 
+      zip.file(".build/release/foo/bar", source);
+      return zip.generateAsync({type:"nodebuffer"}).then(zipped => {
+        sandbox.stub(fs, 'readFile', (path, cb) => {
+          expect(path).to.equal('/path/to/zip_file.zip');
+          cb(null, zipped);
+        });
+        return node.generateActionPackage({handler: '.build/release/foo/bar'}).then(data => {
+          return JSZip.loadAsync(new Buffer(data, 'base64')).then(zip => {
+            return zip.file(".build/release/Action").async("string").then(contents => {
+              expect(contents).to.be.equal(source)
+            })
+          })
+        })
+      });
+    })
+
+
   })
 });