jets 0.2.0 → 0.5.0

data/lib/jets/cfn/base.rb

@@ -1,17 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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/help.rb

@@ -1,19 +0,0 @@
-module Jets
-  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/jets/command.rb

@@ -1,25 +0,0 @@
-require "thor"
-
-module Jets
-  class Command < Thor
-    class << self
-      def dispatch(m, args, options, config)
-        # Allow calling for help via:
-        #   jets command help
-        #   jets command -h
-        #   jets command --help
-        #   jets command -D
-        #
-        # as well thor's normal way:
-        #
-        #   jets 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/jets/process.rb

@@ -1,18 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

data/notes/design.md

@@ -1,107 +0,0 @@
-## What is Jets?
-
-Jet's is a Lambda Framework that allows you to create AWS Lambda serverless applications with ruby.  It includes everything required to build a web application and deploy it to AWS Lambda.  It also can be used as a cost-effective worker system. For example, it can be used to write "cron" jobs.
-
-It is key to conceptually understand AWS Lambda and API Gateway to understand Jets.  Jets maps your code to Lambda functions and API Gatway.
-
-* **AWS Lambda** is Functions as a Service. It allows you to upload and run functions without worrying about the underlying infrastructure.
-* **API Gateway** is a routing layer for Lambda. You can use it to route url endpoints to your Lambda functions.
-
-## How It Works
-
-With Jets, you focus on your business logic and Jet's does the mechanical work. You write controllers, workers and functions and Jets automatically wire these up to Lambda and API Gateway for you.
-
-### What is a Jets controller?
-
-A Jets controller handles a web request and rendering a response back to the user.  Here's an example
-
-`app/controllers/posts_controller.rb`:
-
-```ruby
-class PostsController < Jets::BaseController
-  def create
-    # event and context is automatically available as a Hash
-    # render returns Lambda Proxy struture for web requests
-    render json: event, status: 200
-  end
-
-  def update
-    render json: event.merge(a: "update"), status: 200
-  end
-end
-```
-
-Jets creates up lambda functions for each of the controller public methods above when you run the `jets deploy` command.
-
-### How do I connect API Gateway to the Lambda functions?
-
-You can hook the Lambda functions to url endpoints via API Gateway.  To route an API Gateway endpoint to the controller action, add the following to your routes file:
-
-`config/routes.rb`:
-
-```ruby
-# API Gateway resources are only created if the controller action exists.
-get  "posts", to: "posts#index"
-get  "posts/:id", to: "posts#show"
-post "posts", to: "posts#create"
-get  "posts/:id/edit", to: "posts#edit"
-put  "posts", to: "posts#update"
-delete  "posts", to: "posts#destroy"
-
-resources :posts # macro that will creaet all the routes above
-
-any "posts/hot", to: "posts#hot" # GET, POST, PUT, etc request all work
-```
-
-Run the `jets deploy` command to add the routes to API Gateway.
-
-### Project Structure
-
-Here's an overview of the project structure.
-
-File / Directory  | Description
-------------- | -------------
-app/controllers  | controllers code
-app/workers  | workers code
-app/functions  | functions code
-config/project.yml  | project configs
-config/events.yml  | events configs
-config/routes.rb  | routes
-
-
-## Usage
-
-### Quick Start
-
-```sh
-jets deploy
-
-jets deploy
-jets deploy function xxx
-jets deploy controller xxx
-jets deploy worker xxx
-```
-
-### Scaffolding
-
-
-
-## Under the hood
-
-Lambda does not yet support ruby. So Jets uses a node shim and a bundled version of ruby to add support.
-
-## Test
-
-Testing controller processing without node shim.
-
-```
-jets 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
-jets build # generates the handlers
-node handlers/controllers/posts.js
-```

data/notes/faq.md

@@ -1,3 +0,0 @@
-Q: Is it slower using a node shim?
-Yes, the node shim adds a little bit of overhead. The overhead is of the node shim is about 500ms with a function configured to use 1.5GB of RAM. If your application requires faster response times than than then you will have to wait for official ruby support from AWS.
-

data/notes/lambda_ruby_info.md

@@ -1,34 +0,0 @@
-```sh
-RUBY_VERSION 2.2.2
-/var/task/bundled/gems/ruby/2.2.0/gems/bin/print_ruby_info
-LOAD_PATH:
-/var/task/bundled/gems/ruby/2.2.0/gems/print_ruby_info-0.0.3/lib
-/var/task/bundled/gems/ruby/2.2.0/gems/jets-0.1.1/lib
-/var/task/bundled/gems/ruby/2.2.0/gems/thor-0.20.0/lib
-/var/task/bundled/gems/ruby/2.2.0/gems/hashie-3.5.6/lib
-/var/task/bundled/gems/ruby/2.2.0/gems/colorize-0.8.1/lib
-/var/task/bundled/ruby/lib/ruby/gems/2.2.0/gems/bundler-1.9.9/lib/gems/bundler-1.9.9/lib
-/var/task/bundled/gems/ruby/2.2.0/gems/activesupport-5.1.4/lib
-/var/task/bundled/gems/ruby/2.2.0/gems/tzinfo-1.2.3/lib
-/var/task/bundled/gems/ruby/2.2.0/gems/thread_safe-0.3.6/lib
-/var/task/bundled/gems/ruby/2.2.0/gems/minitest-5.10.3/lib
-/var/task/bundled/gems/ruby/2.2.0/gems/i18n-0.9.0/lib
-/var/task/bundled/gems/ruby/2.2.0/gems/concurrent-ruby-1.0.5/lib
-/var/task/bundled/ruby/lib/ruby/gems/2.2.0/gems/bundler-1.9.9/lib
-/var/task/bundled/ruby/lib/ruby/site_ruby/2.2.0
-/var/task/bundled/ruby/lib/ruby/site_ruby/2.2.0/x86_64-linux
-/var/task/bundled/ruby/lib/ruby/site_ruby
-/var/task/bundled/ruby/lib/ruby/vendor_ruby/2.2.0
-/var/task/bundled/ruby/lib/ruby/vendor_ruby/2.2.0/x86_64-linux
-/var/task/bundled/ruby/lib/ruby/vendor_ruby
-/var/task/bundled/ruby/lib/ruby/2.2.0
-/var/task/bundled/ruby/lib/ruby/2.2.0/x86_64-linux
-/tmp/ruby/lib/ruby/site_ruby/2.2.0
-/tmp/ruby/lib/ruby/site_ruby/2.2.0/x86_64-linux
-/tmp/ruby/lib/ruby/site_ruby
-/tmp/ruby/lib/ruby/vendor_ruby/2.2.0
-/tmp/ruby/lib/ruby/vendor_ruby/2.2.0/x86_64-linux
-/tmp/ruby/lib/ruby/vendor_ruby
-/tmp/ruby/lib/ruby/2.2.0
-/tmp/ruby/lib/ruby/2.2.0/x86_64-linux
-```