lam 0.0.1

data/lib/lam/util.rb

@@ -0,0 +1,13 @@
+module Lam::Util
+  # Ensures trailing slash
+  # Useful for appending a './' in front of a path or leaving it alone.
+  # Returns: '/path/with/trailing/slash/' or './'
+  @@root = nil
+  def root
+    return @@root if @@root
+    @@root = ENV['PROJECT_ROOT'].to_s
+    @@root = '.' if @@root == ''
+    @@root = "#{@@root}/" unless @@root.ends_with?('/')
+    @@root
+  end
+end

data/lib/lam/version.rb

@@ -0,0 +1,3 @@
+module Lam
+  VERSION = "0.0.1"
+end

data/notes/design.md

@@ -0,0 +1,43 @@
+## Project Structure
+
+TODO: make this a table
+
+```sh
+app/controllers
+app/workers
+app/functions
+config/project.yml
+config/events.yml
+config/routes.rb
+```
+
+
+## Usage
+
+```sh
+lam build
+lam deploy
+```
+
+## Testing
+
+Testing controller processing without node shim.
+
+```
+lam process controller '{ "we" : "love", "using" : "Lambda" }' '{"test": "1"}' "handlers/controllers/posts.create"
+```
+
+Testing the generated node shim handler and the controller processing.
+
+```
+cd spec/fixtures/project
+lam build # generates the handlers
+node handlers/controllers/posts.js
+```
+
+VS
+
+```sh
+processors/controller_processor.rb '{ "we" : "love", "using" : "Lambda" }' '{"test": "1"}' "handlers/controllers/posts.create" | jq '.'
+```
+

data/notes/traveling-ruby-packaging-lam.md

@@ -0,0 +1,26 @@
+# start off at project root
+
+mkdir -p /tmp/lam_build
+cp Gemfile* /tmp/lam_build/
+cd /tmp/lam_build # cd into there to build TravelingRuby
+
+wget http://d6r77u77i8pq3.cloudfront.net/releases/traveling-ruby-20150715-2.2.2-linux-x86_64.tar.gz .
+mkdir -p bundled/ruby # tmp/lam_build/bundled/ruby
+tar -xvf traveling-ruby-20150715-2.2.2-linux-x86_64.tar.gz -C bundled/ruby
+# ls ruby => bin  bin.real  info  lib
+# bundled/ruby/bin/ruby -v # works now :)
+
+# had to modify Gemfile and update the local path for linux
+bundle install --path bundled/gems
+
+# DONT THINK THAT I NEED TO COPY THE Gemfile into bundled/gems...
+# mv Gemfile* bundled/gems/ # copy Gemfile from the project to bundled/gems
+# IMPORTANT: the Gemfile must be in the same bundled/gems folder
+
+# now we have both bundled/gems bundled/ruby :)
+bundled/gems/ruby/2.2.0/bin/print_ruby_info # should work
+
+
+# Let's move back to the project and test the wrapper, it should work also
+mv bundled ~/lam-test/lam/spec/fixtures/project/
+cd ~/lam-test/lam/spec/fixtures/project # back to project root

data/notes/traveling-ruby-packaging.md

@@ -0,0 +1,103 @@
+### Packaging Gems Info
+
+### Structure
+
+This is the structure that TravelingRuby uses in it's tutorial.
+
+```sh
+PROJECT/YOUR_BINARY_WRAPPER (hello)
+PROJECT/lib/ruby/bin/ruby -> PROJECT/lib/ruby/bin.real/ruby
+PROJECT/lib/vendor/ruby/2.2.0/bin/print_ruby_info # the gem binaries are here
+```
+
+* Instead calling the ruby binary `lam process` command directly.
+* Lam will require 'bundler/setup' so the user's gems will be required properly
+* Skip the overhead of having another wrapper
+
+```sh
+PROJECT/vendor/ruby/2.2.0/bin/lam # the gem binaries are here
+```
+
+### Packaging Gems Commands
+
+```
+mkdir packaging/tmp
+cp Gemfile Gemfile.lock packaging/tmp/ # this are from the user's project
+cd packaging/tmp
+
+# here's where the gems are instaleld into packaging/vendor/
+BUNDLE_IGNORE_CONFIG=1 bundle install --path ../vendor --without development
+# IMPORTANT: Think I'll make the user switch to 2.2.0 and error the build proccess.
+
+##############
+I can call ruby bin files directly.
+I was WRONG. Cannot call gem bin files directly because I need to make sure that
+bundler/setup gets loaded before calling the gem bin.
+Tried moving bundler/setup into the lam library itself but get all sorts of warnings.
+
+hello-1.0.0-linux-x86_64/lib/vendor/ruby/2.2.0/bin/lam help
+BUT the shabang line has: #!/usr/bin/env ruby2.0 .. but only on linux..
+Simply cannot rename the darn ruby version folder.
+#############
+
+
+cd ../..
+rm -rf packaging/tmp # remove working space
+
+# reduce the zip package size!
+rm -f packaging/vendor/*/*/cache/*
+```
+
+Now we can copy over the generated vendored files
+
+##################################
+# clean
+rm -rf packaging/vendor/
+
+bundle update
+rake package:linux:x86_64 DIR_ONLY=1
+
+mkdir packaging/tmp
+cp Gemfile Gemfile.lock packaging/tmp/
+cd packaging/tmp
+BUNDLE_IGNORE_CONFIG=1 bundle install --path ../vendor --without development
+cd ../..
+
+cp -pR packaging/vendor hello-1.0.0-linux-x86_64/lib/
+cp Gemfile Gemfile.lock hello-1.0.0-linux-x86_64/lib/vendor/
+mkdir hello-1.0.0-linux-x86_64/lib/vendor/.bundle
+cp packaging/bundler-config hello-1.0.0-linux-x86_64/lib/vendor/.bundle/config
+
+find . -name print_ruby_info
+
+
+# Wrapper script `lam`
+
+```bash
+#!/bin/bash
+set -e
+
+# Figure out where this script is located.
+SELFDIR="`dirname \"$0\"`"
+SELFDIR="`cd \"$SELFDIR\" && pwd`"
+
+# Tell Bundler where the Gemfile and gems are.
+export BUNDLE_GEMFILE="$SELFDIR/lib/vendor/Gemfile"
+unset BUNDLE_IGNORE_CONFIG
+
+# Run the actual app using the bundled Ruby interpreter, with Bundler activated.
+exec "$SELFDIR/lib/ruby/bin/ruby" -rbundler/setup "$SELFDIR/lib/app/hello.rb"
+```
+
+
+### Building Ruby
+http://cache.ruby-lang.org/pub/ruby/2.2/
+
+```sh
+wget http://cache.ruby-lang.org/pub/ruby/2.2/ruby-2.2.2.tar.gz
+tar xvfvz ruby-2.2.2.tar.gz
+cd ruby-2.2.2
+./configure
+make
+sudo make install
+```

data/notes/traveling-ruby.md

@@ -0,0 +1,82 @@
+## Overview
+
+There are 2 things to point out:
+
+1. What the user's environment contains - cannot control this, can only suggest
+2. What the lambda environment contains - can fully control this
+
+* User can develop with ruby 2.4 and bundle gems and test and be happy. Hopefully they eventually learn to test with ruby 2.2.0 (when they run into bugs).
+* When `lam build` runs it will bundle it in ruby 2.2.0 though.
+* When lambda runs it will call `lam` with ruby 2.2.0. The gems will be installed in 2.2.0
+	* Hope all works
+
+## Download ruby commands
+
+```sh
+# linux 64bit
+wget http://d6r77u77i8pq3.cloudfront.net/releases/traveling-ruby-20150715-2.2.2-linux-x86_64.tar.gz .
+mkdir ruby-linux
+tar -xvf traveling-ruby-20150715-2.2.2-linux-x86_64.tar.gz -C ruby-linux
+# mac
+wget http://d6r77u77i8pq3.cloudfront.net/releases/traveling-ruby-20150715-2.2.2-osx.tar.gz
+mkdir ruby-mac
+tar -xvf traveling-ruby-20150715-2.2.2-osx.tar.gz -C ruby-mac
+
+# another version
+mkdir hello-1.0.0-linux-x86_64/lib/ruby && tar -xzf packaging/traveling-ruby-20150715-2.2.2-linux-x86_64.tar.gz -C hello-1.0.0-linux-x86_64/lib/ruby
+```
+
+## Launch Instance for Testing
+
+```sh
+aws ec2 run-instances --image-id ami-8c1be5f6 --count 1 --instance-type t2.micro --key-name default --security-groups demo
+```
+
+## Tree Structure
+
+```sh
+lib/
+├── app
+│   └── hello.rb
+├── ruby
+│   ├── bin
+│   │   ├── gem
+│   │   ├── irb
+│   │   ├── rake
+│   │   ├── ruby
+│   │   └── ruby_environment
+│   ├── bin.real
+│   │   ├── bundle
+│   │   ├── bundler
+│   │   ├── gem
+│   │   ├── irb
+│   │   ├── rake
+│   │   └── ruby
+│   └── lib
+│       └── ruby
+│           ├── 2.2.0
+...
+│           │   └── yaml.rb
+│           ├── gems
+│           │   └── 2.2.0
+│           │       ├── gems
+│           │       │   ├── attr_extras-5.2.0
+│           │       │   │   ├── attr_extras.gemspec
+...
+│           │       │   ├── bundler-1.9.9
+...
+│           │           └── rake-12.2.1.gemspec
+...
+└── vendor
+    ├── Gemfile
+    ├── Gemfile.lock
+    └── ruby
+        └── 2.2.0 <= IMPORTANT: bundler copies gems to folder with running ruby version
+            ├── gems
+            │   ├── concurrent-ruby-1.0.5
+            │   ├── faker-1.7.3
+            │   └── i18n-0.9.0
+...
+```
+
+* [Full tree](https://gist.github.com/tongueroo/c42f9d35b15b06eb810802243f4e2f6d)

data/spec/fixtures/project/.gitignore

@@ -0,0 +1,3 @@
+vendor
+bundled
+lam.zip

data/spec/fixtures/project/.ruby-version

@@ -0,0 +1 @@
+2.2.2

data/spec/fixtures/project/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gem "lam", path: "/Users/tung/src/tongueroo/lam"
+gem "print_ruby_info" # test

data/spec/fixtures/project/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: /Users/tung/src/tongueroo/lam
+  specs:
+    lam (0.0.1)
+      activesupport
+      colorize
+      hashie
+      thor
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.1.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    colorize (0.8.1)
+    concurrent-ruby (1.0.5)
+    hashie (3.5.6)
+    i18n (0.9.0)
+      concurrent-ruby (~> 1.0)
+    minitest (5.10.3)
+    print_ruby_info (0.0.3)
+    thor (0.20.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.3)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  lam!
+  print_ruby_info

data/spec/fixtures/project/app/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < Lam::BaseController
+end

data/spec/fixtures/project/app/controllers/posts_controller.rb

@@ -0,0 +1,12 @@
+class PostsController < Lam::BaseController
+  def create
+    # render text: "test2" # more consistent for web controllers
+
+    # render returns Lamba Proxy struture for web requests
+    render json: event, status: 200
+  end
+
+  # def update
+  #   render json: event, status: 200
+  # end
+end

data/spec/fixtures/project/bin/lam

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+set -e
+
+# Figure out where this script is located.
+PROJECTDIR="`dirname \"$0\"`"
+PROJECTDIR="`cd \"$PROJECTDIR/..\" && pwd`"
+
+# Tell Bundler where the Gemfile and gems are.
+# IMPORTANT: the Gemfile must be in the same bundled/gems folder
+export BUNDLE_GEMFILE="$PROJECTDIR/Gemfile"
+unset BUNDLE_IGNORE_CONFIG
+
+# Run the actual app using the bundled Ruby interpreter, with Bundler activated.
+os=$(uname)
+if [[ "$os" == 'Darwin' ]]; then
+  # used macosx ruby for development
+  exec lam "$@"
+else
+  # used bundled ruby for Lambda
+  exec "$PROJECTDIR/bundled/ruby/bin/ruby" -rbundler/setup "$PROJECTDIR/bundled/gems/ruby/2.2.0/bin/lam" "$@"
+fi

data/spec/fixtures/project/handlers/controllers/posts.js

@@ -0,0 +1,156 @@
+'use strict';
+
+// handler: handlers/controllers/posts.create
+const spawn = require('child_process').spawn;
+
+// Once hooked up to API Gateway can use the curl command to test:
+// curl -s -X POST -d @event.json https://endpoint | jq .
+
+// Filters out lines so only the error lines remain.
+// Uses the "RubyError: " marker to find the starting error lines.
+//
+// Input: String
+// random line
+// RubyError: RuntimeError: error in submethod
+// line1
+// line2
+// line3
+//
+// Output: String
+// RubyError: RuntimeError: error in submethod
+// line1
+// line2
+// line3
+function filterErrorLines(text) {
+  var lines = text.split("\n")
+  var markerIndex = lines.findIndex(line => line.startsWith("RubyError: ") )
+  lines = lines.filter((line, index) => index >= markerIndex )
+  return lines.join("\n")
+}
+
+// Produces an Error object that displays in the AWS Lambda test console nicely.
+// The backtrace are the ruby lines, not the nodejs shim error lines.
+// The json payload in the Lambda console looks something like this:
+//
+// {
+//   "errorMessage": "RubyError: RuntimeError: error in submethod",
+//   "errorType": "RubyError",
+//   "stackTrace": [
+//     [
+//       "line1",
+//       "line2",
+//       "line3"
+//     ]
+//   ]
+// }
+//
+// Input: String
+// RubyError: RuntimeError: error in submethod
+// line1
+// line2
+// line3
+//
+// Output: Error object
+// { RubyError: RuntimeError: error in submethod
+// line1
+// line2
+// line3 name: 'RubyError' }
+function customError(text) {
+  text = filterErrorLines(text) // filter for error lines only
+  var lines = text.split("\n")
+  var message = lines[0]
+  var error = new Error(message)
+  error.name = message.split(':')[0]
+  error.stack = lines.slice(0, lines.length-1) // drop final empty line
+                  .map(e => e.replace(/^\s+/g,'')) // trim leading whitespaces
+                  .join("\n")
+  return error
+}
+
+module.exports.create = (event, context, callback) => {
+  // To test on mac, set these environment variables:
+  // export RUBY_BIN=$HOME/.rbenv/shims/ruby
+  // export PROCESSOR_COMMAND="lam process controller"
+
+  // Command: lam process controller [event] [context] [handler]
+  const processor_command = process.env.PROCESSOR_COMMAND || "lam"
+  var args = [
+    "process",
+    "controller",
+    JSON.stringify(event),
+    JSON.stringify(context),
+    "handlers/controllers/posts.create"
+  ]
+  // console.log("processor_command %o", processor_command)
+  // console.log("args %o", args)
+
+  var ruby = spawn("bin/lam", args);
+
+  // string concatation in javascript is faster than array concatation
+  // http://bit.ly/2gBMDs6
+  var stdout_buffer = ""; // stdout buffer
+  // In the processor_command we do NOT call puts directly and write to stdout
+  // because it will mess up the eventual response that we want API Gateway to
+  // process.
+  // The Lambda prints out function to whatever the return value the ruby method
+  ruby.stdout.on('data', function(data) {
+    // Not using console.log because it decorates output with a newline.
+    //
+    // Uncomment process.stdout.write to see stdout streamed for debugging.
+    // process.stdout.write(data)
+    stdout_buffer += data;
+  });
+
+  // react to potential errors
+  var stderr_buffer = "";
+  ruby.stderr.on('data', function(data) {
+    // not using console.error because it decorates output with a newline
+    stderr_buffer += data
+    process.stderr.write(data)
+  });
+
+  //finalize when ruby process is done.
+  ruby.on('close', function(exit_code) {
+    // http://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-handler.html#nodejs-prog-model-handler-callback
+
+    // succcess
+    if (exit_code == 0) {
+      var result
+      try {
+        result = JSON.parse(stdout_buffer)
+      } catch(e) {
+        // if json cannot be parse assume simple text output intended
+        process.stderr.write("WARN: error parsing json, assuming plain text is desired.")
+        result = stdout_buffer
+      }
+      callback(null, result);
+
+      // callback(null, stdout_buffer);
+    } else {
+
+      // TODO: if this works, allow a way to not decorate the error in case
+      // it actually errors in javascript land
+      // Customize error object with ruby error info
+      var error = customError(stderr_buffer)
+      callback(error);
+      // console.log("error!")
+    }
+  });
+}
+
+// for local testing
+if (process.platform == "darwin") {
+  // fake event and context
+  var event = {"hello": "world"}
+  // var event = {"body": {"hello": "world"}} // API Gateway wrapper structure
+  var context = {"fake": "context"}
+  module.exports.create(event, context, (error, message) => {
+    console.error("\nLOCAL TESTING OUTPUT")
+    if (error) {
+      console.error("error message: %o", error)
+    } else {
+      console.error("success message %o", message)
+      // console.log(JSON.stringify(message)) // stringify
+    }
+  })
+}