jets 0.0.1 → 0.2.0

data/lib/jets/build/traveling_ruby.rb

@@ -0,0 +1,133 @@
+require "fileutils"
+require "open-uri"
+require "colorize"
+
+class Jets::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/jets_build'.freeze
+
+  class TravelingRuby
+    def build
+      if File.exist?("#{Jets.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
+        vendor_gemfiles
+      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("#{Jets.root}Gemfile", "#{TEMP_BUILD_DIR}/")
+      FileUtils.cp("#{Jets.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
+
+    # The wrapper script doesnt work unless you move the gem files in the
+    # bundled/gems folder and export it to BUNDLE_GEMFILE in the
+    # wrapper script.
+    def vendor_gemfiles
+      puts "Moving gemfiles into #{bundled_gems_dest}/"
+      FileUtils.mv("Gemfile", "#{bundled_gems_dest}/")
+      FileUtils.mv("Gemfile.lock", "#{bundled_gems_dest}/")
+
+      bundle_config_path = "#{bundled_gems_dest}/.bundle/config"
+      puts "Generating #{bundle_config_path}"
+      FileUtils.mkdir_p(File.dirname(bundle_config_path))
+      bundle_config =<<-EOL
+BUNDLE_PATH: .
+BUNDLE_WITHOUT: development
+BUNDLE_DISABLE_SHARED_GEMS: '1'
+EOL
+      IO.write(bundle_config_path, bundle_config)
+
+    end
+
+    def move_bundled_to_project
+      if File.exist?("#{Jets.root}bundled")
+        puts "Removing current bundled folder"
+        FileUtils.rm_rf("#{Jets.root}bundled")
+      end
+      puts "Moving bundled ruby to your project."
+      FileUtils.mv("#{TEMP_BUILD_DIR}/bundled", Jets.root)
+    end
+
+    def bundled_ruby_dest
+      "bundled/ruby"
+    end
+
+    def bundled_gems_dest
+      "bundled/gems"
+    end
+
+    def traveling_ruby_url
+      TRAVELING_RUBY_VERSION
+    end
+
+    def traveling_ruby_tar_file
+      File.basename(traveling_ruby_url)
+    end
+  end
+end

data/lib/jets/cfn.rb

@@ -0,0 +1,5 @@
+class Jets::Cfn
+  autoload :Base, "jets/cfn/base"
+  autoload :Builder, "jets/cfn/builder"
+  autoload :Namer, "jets/cfn/namer"
+end

data/lib/jets/cfn/base.rb

@@ -0,0 +1,17 @@
+class Jets::Cfn
+  class Base
+    def add_resource(logical_id, type, properties)
+      @template[:Resources][logical_id] = {
+        Type: type,
+        Properties: properties
+      }
+    end
+
+    def add_parameter(name, options={})
+      defaults = { Type: "String" }
+      options = defaults.merge(options)
+      @template[:Parameters] ||= {}
+      @template[:Parameters][name.camelize] = options
+    end
+  end
+end

data/lib/jets/cfn/builder.rb

@@ -0,0 +1,53 @@
+require 'active_support/core_ext/hash'
+require 'yaml'
+
+class Jets::Cfn
+  class Builder < Base
+    def initialize(controller_class)
+      @controller_class = controller_class
+      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
+    end
+
+    def compose!
+      add_parameters
+      add_functions
+    end
+
+    def add_parameters
+      add_parameter("LambdaIamRole", Description: "Iam Role that Lambda function uses.")
+      add_parameter("S3Bucket", Description: "S3 Bucket for source code.")
+      add_s3_bucket
+    end
+
+    def add_functions
+      @controller_class.lambda_functions.each do |name|
+        add_function(name)
+      end
+    end
+
+    def add_function(name)
+      namer = Namer.new(@controller_class, name)
+
+      add_resource(namer.logical_id, "AWS::Lambda::Function",
+        Code: {
+          S3Bucket: {Ref: "S3Bucket"}, # from child stack
+          S3Key: namer.s3_key
+        },
+        FunctionName: namer.function_name,
+        Handler: namer.handler,
+        Role: { Ref: "LambdaIamRole" },
+        MemorySize: Jets::Project.memory_size,
+        Runtime: Jets::Project.runtime,
+        Timeout: Jets::Project.timeout
+      )
+    end
+
+    def template
+      @template
+    end
+
+    def text
+      YAML.dump(@template.to_hash)
+    end
+  end
+end

data/lib/jets/cfn/namer.rb

@@ -0,0 +1,30 @@
+class Jets::Cfn
+  class Namer
+    def initialize(controller_class, method_name)
+      @controller_class, @method_name = controller_class, method_name
+    end
+
+    def handler
+      controller_name = @controller_class.to_s.sub('Controller', '').underscore
+      "handlers/controllers/#{controller_name}.#{@method_name}"
+    end
+
+    def logical_id
+      "#{@controller_class}_#{@method_name}".camelize
+    end
+
+    def function_name
+      "#{Jets::Project.project_name}-#{Jets::Project.env}-#{logical_id.underscore.dasherize}"
+    end
+
+    def s3_key
+      self.class.s3_key
+    end
+
+    # @@s3_key = "jets/cfn-templates/dev/#{Time.now.strftime("%Y%m%dT%H%M%S")}/jets-app-code.zip"
+    @@s3_key = "jets/cfn-templates/code.zip" # hardcode to test
+    def self.s3_key
+      @@s3_key
+    end
+  end
+end

data/lib/jets/cli.rb

@@ -7,13 +7,17 @@ module Jets
     class_option :verbose, type: :boolean
     class_option :noop, type: :boolean
 
-    desc "hello NAME", "say hello to NAME"
-    long_desc Help.hello
-    option :from, desc: "from person"
-    def hello(name)
-      puts "from: #{options[:from]}" if options[:from]
-      puts "Hello #{name}"
+    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
+      Jets::Build.new(options).run
     end
 
+    desc "process TYPE", "process subcommand tasks"
+    long_desc Help.process
+    subcommand "process", Jets::Process
   end
 end

data/lib/jets/cli/help.rb

@@ -2,9 +2,15 @@ module Jets
   class CLI < Command
     class Help
       class << self
-        def hello
+        def build
 <<-EOL
-Hello world example
+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

data/lib/jets/process.rb

@@ -0,0 +1,18 @@
+class Jets::Process < Jets::Command
+  autoload :Help, 'jets/process/help'
+  autoload :ProcessorDeducer, 'jets/process/processor_deducer'
+  autoload :BaseProcessor, 'jets/process/base_processor'
+  autoload :ControllerProcessor, 'jets/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/jets/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 Jets::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

data/lib/jets/process/controller_processor.rb

@@ -0,0 +1,36 @@
+require_relative "base_processor"
+
+class Jets::Process
+  class ControllerProcessor < Jets::Process::BaseProcessor
+    def run
+      # Use the handler value (ie: posts.create) to deduce the user's business
+      # code to require and run.
+      deducer = ProcessorDeducer.new(handler)
+      path = deducer.controller[:path]
+      code = deducer.controller[:code]
+
+      begin
+        require path  # require "app/controllers/posts_controller.rb"
+        # Puts the return value of user's code to stdout because this is
+        # what eventually gets used by API Gateway.
+        # Explicitly using $stdout since puts redirected to $stderr.
+
+        # result = PostsController.new(event, context).create
+        result = instance_eval(code, path)
+
+        # JSON.dump is pretty robust.  If it cannot dump the structure into a
+        # json string, it just dumps it to a plain text string.
+        $stdout.puts JSON.dump(result) # only place where we write to stdout.
+      rescue Exception => e
+        # Customize error message slightly so nodejs shim can process the
+        # returned error message.
+        # The "RubyError: " is a marker that the javascript shim scans for.
+        $stderr.puts("RubyError: #{e.class}: #{e.message}") # js needs this as the first line
+        backtrace = e.backtrace.map {|l| "  #{l}" }
+        $stderr.puts(backtrace)
+        # $stderr.puts("END OF RUBY OUTPUT")
+        exit 1 # instead of re-raising to control the error backtrace output
+      end
+    end
+  end
+end

data/lib/jets/process/help.rb

@@ -0,0 +1,11 @@
+class Jets::Process::Help
+  class << self
+    def controller
+<<-EOL
+Examples:
+
+jets process controller '{ "we" : "love", "using" : "Lambda" }' '{"test": "1"}' "handlers/controllers/posts.create"
+EOL
+    end
+  end
+end

data/lib/jets/process/processor_deducer.rb

@@ -0,0 +1,51 @@
+class Jets::Process::ProcessorDeducer
+  def initialize(handler)
+    @handler = handler
+  end
+
+  # Deduces the path and method from the handler. Example:
+  #
+  #   ProcessorDeducer.new("handlers/functions/posts.create").function
+  #     => {path: "app/functions/posts.rb", code: "create(event, context)"}
+  #
+  # Summary:
+  #
+  # Input:
+  #   handler: handlers/functions/posts.create
+  # Output:
+  #   path: app/functions/posts.rb
+  #   code: create(event, context) # code to instance_eval
+  #
+  # Returns: {path: path, code: code}
+  def function
+    path, meth = @handler.split('.')
+    path = Jets.root + path.sub("handlers", "app") + ".rb"
+    code = "#{meth}(event, context)"
+    {path: path, code: code}
+  end
+
+  # Deduces the path and method from the handler. Example:
+  #
+  #   ProcessorDeducer.new("handlers/controllers/posts.create").controller
+  #     => {path: "controllers/posts_controller.rb", code: "create"}
+  #
+  # Summary:
+  #
+  # Input:
+  #   handler: handlers/controllers/posts.create
+  # Output:
+  #   path: app/controllers/posts_controller.rb
+  #   code: create # code to instance_eval
+  #
+  # Returns: {path: path, code: code}
+  def controller
+    handler_path, meth = @handler.split('.')
+
+    path = Jets.root + handler_path.sub("handlers", "app") + "_controller.rb"
+    controller_name = handler_path.sub(%r{.*handlers/controllers/}, "") + "_controller" # posts_controller
+    controller_class = controller_name.split('_').collect(&:capitalize).join # PostsController
+    code = "#{controller_class}.new(event, context).#{meth}" # PostsController.new(event, context).create
+
+    {path: path, code: code, class_name: controller_class}
+  end
+end

data/lib/jets/project.rb

@@ -0,0 +1,23 @@
+require 'ostruct'
+
+# The Project default options.
+# Overriden with config/project.yml
+class Jets::Project
+  class << self
+    def method_missing(method_name)
+      options = Jets::Project.new.options
+      options[method_name.to_sym]
+    end
+  end
+
+  # Defaults
+  def options
+    OpenStruct.new(
+      project_name: "proj", # shouldnt really be a default here
+      env: ENV['JETS_ENV'] || 'dev', # shouldnt really be a default here
+      timeout: 30,
+      runtime: "nodejs6.10",
+      memory_size: 1536
+    )
+  end
+end