Transform serverless-wsgi into serverless-python-requirements!

Removes all but an even simpler version of automatic requirement packing and
adds a utility function to add deps to sys.path

Author: dschep

README.md

@@ -1,171 +1,33 @@
-# Serverless WSGI
+# Serverless Python Requirements
 
 [![serverless](http://public.serverless.com/badges/v3.svg)](http://www.serverless.com)
 
-A Serverless v1.0 plugin to build your deploy Python WSGI applications using Serverless. Compatible
-WSGI application frameworks include Flask, Django and Pyramid - for a complete list, see:
-[http://wsgi.readthedocs.io/en/latest/frameworks.html](http://wsgi.readthedocs.io/en/latest/frameworks.html).
-
-### Features
-
-* Transparently converts API Gateway requests to and from standard WSGI requests
-* Supports anything you'd expect from WSGI such as redirects, cookies, file uploads etc.
-* Automatically downloads Python packages that you specify in `requirements.txt` and deploys them along with your application
-* Convenient `wsgi serve` command for serving your application locally during development
+A Serverless v1.0 plugin to automatically bundle dependencies from 
+`requirements.txt`.
 
 
 ## Install
 
 ```
-npm install --save serverless-wsgi
+npm install --save serverless-python-requirements
 ```
 
-Add the plugin to your `serverless.yml` file and set the WSGI application:
+Add the plugin to your `serverless.yml`:
 
 ```yaml
 plugins:
-  - serverless-wsgi
-```
-
-
-## Flask configuration example
-
-This example assumes that you have intialized your application as `app` inside `api.py`.
-
-```
-project
-├── api.py
-├── requirements.txt
-└── serverless.yml
+  - serverless-python-requirements
 ```
 
-### api.py
 
-A regular Flask application.
+## Adding the dependencies to `sys.path`
 
+`serverless-python-requirements` adds a module called `requirements` to your
+puck. To easily make the bundled dependencies available, simply import it. Eg.
+add this to the top of any file using dependencies specified in your
+`requirements.txt`:
 ```python
-from flask import Flask
-app = Flask(__name__)
-
-
-@app.route("/cats")
-def cats():
-    return "Cats"
-
-
-@app.route("/dogs/<id>")
-def dog(id):
-    return "Dog"
-```
-
-### serverless.yml
-
-Load the plugin and set the `custom.wsgi.app` configuration in `serverless.yml` to the
-module path of your Flask application.
-
-All functions that will use WSGI need to have `wsgi.handler` set as the Lambda handler and
-use the `lambda-proxy` integration for API Gateway.
-
-```yaml
-service: example
-
-provider:
-  name: aws
-  runtime: python2.7
-
-plugins:
-  - serverless-wsgi
-
-functions:
-  api:
-    handler: wsgi.handler
-    events:
-      - http:
-          path: cats
-          method: get
-          integration: lambda-proxy
-      - http:
-          path: dogs/{id}
-          method: get
-          integration: lambda-proxy
-
-custom:
-  wsgi:
-    app: api.app
-```
-
-### requirements.txt
-
-Add Flask to the application bundle.
-
-```
-Flask==0.11.1
-```
-
-
-## Deployment
-
-Simply run the serverless deploy command as usual:
-
-```
-$ sls deploy
-Serverless: Packaging Python WSGI handler...
-Serverless: Packaging required Python packages...
-Serverless: Packaging service...
-Serverless: Removing old service versions...
-Serverless: Uploading CloudFormation file to S3...
-Serverless: Uploading service .zip file to S3...
-Serverless: Updating Stack...
-Serverless: Checking Stack update progress...
-..........
-Serverless: Stack update finished...
-```
-
-
-## Other frameworks
-
-Set `custom.wsgi.app` in `serverless.yml` according to your WSGI callable:
-
-* For Pyramid, use [make_wsgi_app](http://docs.pylonsproject.org/projects/pyramid/en/latest/api/config.html#pyramid.config.Configurator.make_wsgi_app) to intialize the callable
-* Django is configured for WSGI by default, set the callable to `<project_name>.wsgi.application`. See [https://docs.djangoproject.com/en/1.10/howto/deployment/wsgi/](https://docs.djangoproject.com/en/1.10/howto/deployment/wsgi/) for more information.
-
-
-## Usage
-
-### Automatic requirement packaging
-
-You'll need to include any packages that your application uses in the bundle
-that's deployed to AWS Lambda. This plugin helps you out by doing this automatically,
-as long as you specify your required packages in a `requirements.txt` file in the root
-of your Serverless service path:
-
-```
-Flask==0.11.1
-requests==2.11.1
-```
-
-For more information, see [https://pip.readthedocs.io/en/1.1/requirements.html](https://pip.readthedocs.io/en/1.1/requirements.html).
-
-### Local server
-
-For convenience, a `sls wsgi serve` command is provided to run your WSGI application
-locally. This command requires the `werkzeug` Python package to be installed,
-and acts as a simple wrapper for starting werkzeug's built-in HTTP server.
-
-By default, the server will start on port 5000.
-
-```
-$ sls wsgi serve
- * Running on http://localhost:5000/ (Press CTRL+C to quit)
- * Restarting with stat
- * Debugger is active!
-```
-
-Configure the port using the `-p` parameter:
-
-```
-$ sls wsgi serve -p 8000
- * Running on http://localhost:8000/ (Press CTRL+C to quit)
- * Restarting with stat
- * Debugger is active!
+import requirements
+# Now you can use deps you specified in requirements.txt!
+import requests
 ```

index.js

@@ -9,27 +9,13 @@ const child_process = require('child_process');
 
 BbPromise.promisifyAll(fse);
 
-class ServerlessWSGI {
-  validate() {
-    if (this.serverless.service.custom && this.serverless.service.custom.wsgi && this.serverless.service.custom.wsgi.app) {
-      this.wsgiApp = this.serverless.service.custom.wsgi.app;
-    } else {
-      throw new this.serverless.classes.Error(
-        'Missing WSGI app, please specify custom.wsgi.app. For instance, if you have a Flask application "app" in "api.py", set the Serverless custom.wsgi.app configuration option to: api.app');
-    }
-  };
+class ServerlessPythonRequirements {
+  packVendorHelper() {
+    this.serverless.cli.log('Packaging Python requirements helper...');
 
-  packWsgiHandler() {
-    this.serverless.cli.log('Packaging Python WSGI handler...');
-
-    return BbPromise.all([
-      fse.copyAsync(
-        path.resolve(__dirname, 'wsgi.py'),
-        path.join(this.serverless.config.servicePath, 'wsgi.py')),
-      fse.writeFileAsync(
-        path.join(this.serverless.config.servicePath, '.wsgi_app'),
-        this.wsgiApp)
-    ]);
+    return fse.copyAsync(
+      path.resolve(__dirname, 'requirements.py'),
+      path.join(this.serverless.config.servicePath, 'requirements.py'));
   };
 
   packRequirements() {
@@ -42,11 +28,12 @@ class ServerlessWSGI {
     this.serverless.cli.log('Packaging required Python packages...');
 
     return new BbPromise((resolve, reject) => {
-      const res = child_process.spawnSync('python', [
-        path.resolve(__dirname, 'requirements.py'),
-        path.resolve(__dirname, 'requirements.txt'),
+      const res = child_process.spawnSync('pip', [
+        'install',
+        '-t',
+        path.join(this.serverless.config.servicePath, '.requirements'),
+        '-r',
         requirementsFile,
-        path.join(this.serverless.config.servicePath, '.requirements')
       ]);
       if (res.error) {
         return reject(res.error);
@@ -59,7 +46,7 @@ class ServerlessWSGI {
   };
 
   cleanup() {
-    const artifacts = ['wsgi.py', '.wsgi_app', '.requirements'];
+    const artifacts = ['requirements.py', '.requirements'];
 
     return BbPromise.all(_.map(artifacts, (artifact) =>
       fse.removeAsync(path.join(this.serverless.config.servicePath, artifact))));;
@@ -83,39 +70,15 @@ class ServerlessWSGI {
     this.serverless = serverless;
     this.options = options;
 
-    this.commands = {
-      wsgi: {
-        commands: {
-          serve: {
-            usage: 'Serve the WSGI application locally.',
-            lifecycleEvents: [
-              'serve',
-            ],
-            options: {
-              port: {
-                usage: 'The local server port, defaults to 5000.',
-                shortcut: 'p',
-              },
-            },
-          },
-        },
-      },
-    };
-
     this.hooks = {
       'before:deploy:createDeploymentArtifacts': () => BbPromise.bind(this)
-        .then(this.validate)
-        .then(this.packWsgiHandler)
+        .then(this.packVendorHelper)
         .then(this.packRequirements),
 
       'after:deploy:createDeploymentArtifacts': () => BbPromise.bind(this)
         .then(this.cleanup),
-
-      'wsgi:serve:serve': () => BbPromise.bind(this)
-        .then(this.validate)
-        .then(this.serve)
     };
   }
 }
 
-module.exports = ServerlessWSGI;
+module.exports = ServerlessPythonRequirements;

package.json

@@ -1,20 +1,21 @@
 {
-  "name": "serverless-wsgi",
+  "name": "serverless-python-requirements",
   "version": "1.0.0",
   "engines": {
     "node": ">=4.0"
   },
-  "description": "Serverless WSGI Plugin",
-  "author": "logan.dk",
+  "description": "Serverless Python Requirements Plugin",
+  "author": "United Income <[email protected]>",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/logandk/serverless-wsgi"
+    "url": "https://github.com/UnitedIncome/serverless-python-requirements"
   },
   "keywords": [
     "serverless",
-    "wsgi",
-    "flask",
+    "python",
+    "requirements",
+    "pip",
     "serverless framework plugin",
     "serverless applications",
     "serverless plugins",
@@ -30,11 +31,8 @@
     "index.js",
     "LICENSE",
     "package.json",
-    "README.md",
     "requirements.py",
-    "requirements.txt",
-    "serve.py",
-    "wsgi.py"
+    "README.md"
   ],
   "main": "index.js",
   "bin": {},