lam 0.1.0 → 0.1.1

data/lib/lam/build/handler_generator.rb

@@ -0,0 +1,34 @@
+require "fileutils"
+require "erb"
+
+class Lam::Build
+  class HandlerGenerator
+    # handler_info:
+    #   {:handler=>"handlers/controllers/posts.create",
+    #    :js_path=>"handlers/controllers/posts.js",
+    #    :js_method=>"create"}
+    def initialize(handler_info)
+      @handler_info = handler_info
+      @handler = handler_info[:handler]
+      @js_path = handler_info[:js_path]
+      @js_method = handler_info[:js_method]
+    end
+
+    def generate
+      js_path = "#{Lam.root}#{@js_path}"
+      FileUtils.mkdir_p(File.dirname(js_path))
+
+      template_path = File.expand_path('../templates/handler.js', __FILE__)
+      template = IO.read(template_path)
+
+      # Important ERB variables with examples:
+      #   @handler - handlers/controllers/posts.create
+      #   @process_type - controller
+      @process_type = @handler.split('/')[1].singularize
+      result = ERB.new(template, nil, "-").result(binding)
+      puts "generating #{js_path}"
+      IO.write(js_path, result)
+      # FileUtils.cp(template_path, js_path)
+    end
+  end
+end

data/lib/lam/build/lambda_deducer.rb

@@ -0,0 +1,47 @@
+class Lam::Build
+  class LambdaDeducer
+    attr_reader :handlers
+    def initialize(path)
+      @path = path
+    end
+
+    def run
+      deduce
+    end
+
+    def deduce
+      # Example: require "./app/controllers/posts_controller.rb"
+      require_path = @path.starts_with?('/') ? @path : "#{Lam.root}#{@path}"
+      require require_path
+
+      # Example: @klass_name = "PostsController"
+      @klass_name = File.basename(@path, '.rb').classify
+      klass = @klass_name.constantize
+      @handlers = klass.lambda_functions.map { |fn| handler_info(fn) }
+      self
+    end
+
+    # Transform the method to the handler info
+    def handler_info(function_name)
+      handler = get_handler(function_name)
+      js_path = get_js_path(function_name)
+      {
+        handler: handler,
+        js_path: js_path,
+        js_method: function_name.to_s
+      }
+    end
+
+    def get_handler(function_name)
+      "handlers/controllers/#{module_name}.create"
+    end
+
+    def get_js_path(function_name)
+      "handlers/controllers/#{module_name}.js"
+    end
+
+    def module_name
+      @klass_name.sub(/Controller$/,'').underscore
+    end
+  end
+end

data/lib/lam/build/templates/handler.js

@@ -0,0 +1,156 @@
+'use strict';
+
+// handler: <%= @handler %>
+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.<%= @js_method %> = (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",
+    "<%= @process_type %>",
+    JSON.stringify(event),
+    JSON.stringify(context),
+    "<%= @handler %>"
+  ]
+  // 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.<%= @js_method %>(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
+    }
+  })
+}

data/lib/lam/build/traveling_ruby.rb

@@ -0,0 +1,108 @@
+require "fileutils"
+require "open-uri"
+require "colorize"
+
+class Lam::Build
+  TRAVELING_RUBY_VERSION = 'http://d6r77u77i8pq3.cloudfront.net/releases/traveling-ruby-20150715-2.2.2-linux-x86_64.tar.gz'.freeze
+  TEMP_BUILD_DIR = '/tmp/lam_build'.freeze
+
+  class TravelingRuby
+    def build
+      if File.exist?("#{Lam.root}bundled")
+        puts "Ruby bundled already exists."
+        puts "To force rebundling: rm -rf bundled"
+        return
+      end
+
+      check_ruby_version
+
+      FileUtils.mkdir_p(TEMP_BUILD_DIR)
+      copy_gemfiles
+
+      Dir.chdir(TEMP_BUILD_DIR) do
+        download_traveling_ruby
+        unpack_traveling_ruby
+        bundle_install
+      end
+
+      move_bundled_to_project
+    end
+
+    def check_ruby_version
+      return if ENV['LAM_SKIP_RUBY_CHECK'] # only use if you absolutely need to
+      traveling_version = TRAVELING_RUBY_VERSION.match(/-((\d+)\.(\d+)\.(\d+))-/)[1]
+      if RUBY_VERSION != traveling_version
+        puts "You are using ruby version #{RUBY_VERSION}."
+        abort("You must use ruby #{traveling_version} to build the project because it's what Traveling Ruby uses.".colorize(:red))
+      end
+    end
+
+    def copy_gemfiles
+      FileUtils.cp("#{Lam.root}Gemfile", "#{TEMP_BUILD_DIR}/")
+      FileUtils.cp("#{Lam.root}Gemfile.lock", "#{TEMP_BUILD_DIR}/")
+    end
+
+    def download_traveling_ruby
+      puts "Downloading traveling ruby from #{traveling_ruby_url}."
+
+      FileUtils.rm_rf("#{TEMP_BUILD_DIR}/#{bundled_ruby_dest}")
+      File.open(traveling_ruby_tar_file, 'wb') do |saved_file|
+        # the following "open" is provided by open-uri
+        open(traveling_ruby_url, 'rb') do |read_file|
+          saved_file.write(read_file.read)
+        end
+      end
+
+      puts 'Download complete.'
+    end
+
+    def unpack_traveling_ruby
+      puts 'Unpacking traveling ruby.'
+
+      FileUtils.mkdir_p(bundled_ruby_dest)
+
+      success = system("tar -xzf #{traveling_ruby_tar_file} -C #{bundled_ruby_dest}")
+      abort('Unpacking traveling ruby failed') unless success
+      puts 'Unpacking traveling ruby successful.'
+
+      puts 'Removing tar.'
+      FileUtils.rm_rf(traveling_ruby_tar_file)
+    end
+
+    def bundle_install
+      puts 'Installing bundle.'
+      require "bundler" # dynamicaly require bundler so user can use any bundler
+      Bundler.with_clean_env do
+        success = system(
+          "cd #{TEMP_BUILD_DIR} && " \
+          'env BUNDLE_IGNORE_CONFIG=1 bundle install --path bundled/gems --without development'
+        )
+
+        abort('Bundle install failed, exiting.') unless success
+      end
+
+      puts 'Bundle install success.'
+    end
+
+    def move_bundled_to_project
+      if File.exist?("#{Lam.root}bundled")
+        puts "Removing current bundled folder"
+        FileUtils.rm_rf("#{Lam.root}bundled")
+      end
+      puts "Moving bundled ruby to your project."
+      FileUtils.mv("#{TEMP_BUILD_DIR}/bundled", Lam.root)
+    end
+
+    def bundled_ruby_dest
+      "bundled/ruby"
+    end
+
+    def traveling_ruby_url
+      TRAVELING_RUBY_VERSION
+    end
+
+    def traveling_ruby_tar_file
+      File.basename(traveling_ruby_url)
+    end
+  end
+end

data/lib/lam/cli.rb

@@ -0,0 +1,23 @@
+require "thor"
+require "lam/cli/help"
+
+module Lam
+
+  class CLI < Command
+    class_option :verbose, type: :boolean
+    class_option :noop, type: :boolean
+
+    desc "build", "Builds and prepares project for Lambda"
+    long_desc Help.build
+    option :force, type: :boolean, aliases: "-f", desc: "override existing starter files"
+    option :quiet, type: :boolean, aliases: "-q", desc: "silence the output"
+    option :format, type: :string, default: "yaml", desc: "starter project template format: json or yaml"
+    def build
+      Lam::Build.new(options).run
+    end
+
+    desc "process TYPE", "process subcommand tasks"
+    long_desc Help.process
+    subcommand "process", Lam::Process
+  end
+end

data/lib/lam/cli/help.rb

@@ -0,0 +1,19 @@
+module Lam
+  class CLI < Command
+    class Help
+      class << self
+        def build
+<<-EOL
+Builds and prepares project for AWS Lambda.  Generates a node shim and vendors Traveling Ruby.  Creates a zip file to be uploaded to Lambda for each handler.
+EOL
+        end
+
+        def process
+<<-EOL
+TODO: update process help menu
+EOL
+        end
+      end
+    end
+  end
+end

data/lib/lam/command.rb

@@ -0,0 +1,25 @@
+require "thor"
+
+module Lam
+  class Command < Thor
+    class << self
+      def dispatch(m, args, options, config)
+        # Allow calling for help via:
+        #   lam command help
+        #   lam command -h
+        #   lam command --help
+        #   lam command -D
+        #
+        # as well thor's normal way:
+        #
+        #   lam help command
+        help_flags = Thor::HELP_MAPPINGS + ["help"]
+        if args.length > 1 && !(args & help_flags).empty?
+          args -= help_flags
+          args.insert(-2, "help")
+        end
+        super
+      end
+    end
+  end
+end

data/lib/lam/process.rb

@@ -0,0 +1,18 @@
+class Lam::Process < Lam::Command
+  autoload :Help, 'lam/process/help'
+  autoload :ProcessorDeducer, 'lam/process/processor_deducer'
+  autoload :BaseProcessor, 'lam/process/base_processor'
+  autoload :ControllerProcessor, 'lam/process/controller_processor'
+
+  class_option :verbose, type: :boolean
+  class_option :noop, type: :boolean
+  class_option :project_root, desc: "Project folder.  Defaults to current directory", default: "."
+  class_option :region, desc: "AWS region"
+
+  desc "create STACK", "create a CloudFormation stack"
+  option :randomize_stack_name, type: :boolean, desc: "tack on random string at the end of the stack name", default: nil
+  long_desc Help.controller
+  def controller(event, context, handler)
+    ControllerProcessor.new(event, context, handler).run
+  end
+end

data/lib/lam/process/base_processor.rb

@@ -0,0 +1,23 @@
+require 'json'
+require_relative 'processor_deducer'
+
+# Global overrides for Lambda processing
+$stdout.sync = true
+# This might seem weird but we want puts to write to stderr which is set in
+# the node shim to write to stderr.  This directs the output to Lambda logs.
+# Printing to stdout can managle up the payload returned from Lambda function.
+# This is not desired if you want to return say a json payload to API Gateway
+# eventually.
+def puts(text)
+  $stderr.puts(text)
+end
+
+class Lam::Process::BaseProcessor
+  attr_reader :event, :context, :handler
+  def initialize(event, context, handler)
+    # assume valid json from Lambda
+    @event = JSON.parse(event)
+    @context = JSON.parse(context)
+    @handler = handler
+  end
+end