jets 0.2.0 → 0.5.0

data/lib/jets/cfn/template_builders/api_gateway_deployment_builder.rb

@@ -0,0 +1,38 @@
+class Jets::Cfn::TemplateBuilders
+  class ApiGatewayDeploymentBuilder
+    include Interface
+    include Jets::AwsServices
+
+    def initialize(options={})
+      @options = options
+      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
+    end
+
+    # compose is an interface method
+    def compose
+      return if @options[:stack_type] == :minimal
+
+      puts "Building API Gateway Deployment template."
+      add_parameter("RestApi", Description: "RestApi")
+
+      map = Jets::Cfn::TemplateMappers::ApiGatewayDeploymentMapper.new(path=nil,s3_bucket=nil)
+      add_resource(map.logical_id, "AWS::ApiGateway::Deployment",
+        Description: "Version #{map.timestamp} deployed by jets",
+        RestApiId: "!Ref RestApi",
+        StageName: map.stage_name,
+      )
+
+      add_output("RestApiUrl", Value: "!Sub 'https://${RestApi}.execute-api.${AWS::Region}.amazonaws.com/#{map.stage_name}/'")
+    end
+
+    # template_path is an interface method
+    def template_path
+      Jets::Naming.api_gateway_deployment_template_path
+    end
+
+    # do not bother writing a template if routes are empty
+    def write
+      super unless Jets::Router.routes.empty?
+    end
+  end
+end

data/lib/jets/cfn/template_builders/base_child_builder.rb

@@ -0,0 +1,38 @@
+class Jets::Cfn::TemplateBuilders
+  class BaseChildBuilder
+    include Interface
+
+    # The app_klass is can be a controller, job or anonymous function class.
+    # IE: PostsController, HardJob
+    def initialize(app_klass)
+      @app_klass = app_klass
+      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
+    end
+
+    # template_path is an interface method for Interface module
+    def template_path
+      Jets::Naming.template_path(@app_klass)
+    end
+
+    def add_common_parameters
+      add_parameter("IamRole", Description: "Iam Role that Lambda function uses.")
+      add_parameter("S3Bucket", Description: "S3 Bucket for source code.")
+    end
+
+    def add_functions
+      @app_klass.tasks.each do |task|
+        add_function(task)
+      end
+    end
+
+    def add_function(task)
+      # Examples:
+      #   FunctionProperties::RubyBuilder
+      #   FunctionProperties::PythonBuilder
+      builder_class = "Jets::Cfn::TemplateBuilders::FunctionProperties::#{task.lang.to_s.classify}Builder".constantize
+      builder = builder_class.new(task)
+      logical_id = builder.map.logical_id
+      add_resource(logical_id, "AWS::Lambda::Function", builder.properties)
+    end
+  end
+end

data/lib/jets/cfn/template_builders/controller_builder.rb

@@ -0,0 +1,107 @@
+class Jets::Cfn::TemplateBuilders
+  class ControllerBuilder < BaseChildBuilder
+    # compose is an interface method for Interface module
+    def compose
+      add_common_parameters
+      add_api_gateway_parameters
+      add_functions
+      add_routes
+    end
+
+    def add_api_gateway_parameters
+      return if Jets::Router.routes.empty?
+
+      add_parameter("RestApi", Description: "RestApi")
+      scoped_routes.each do |route|
+        map = Jets::Cfn::TemplateMappers::GatewayResourceMapper.new(route.path)
+        add_parameter(map.logical_id, Description: map.desc)
+      end
+    end
+
+    def add_routes
+      scoped_routes.each_with_index do |route, i|
+        map = Jets::Cfn::TemplateMappers::GatewayMethodMapper.new(route)
+        add_route(route, map)
+        add_cors(map)
+        add_permission(map)
+      end
+    end
+
+    def add_route(route, map)
+      # AWS::ApiGateway::Method
+      # Example map.logical_id: ApiGatewayMethodPostsControllerIndex
+      add_resource(map.logical_id, "AWS::ApiGateway::Method",
+        HttpMethod: route.method,
+        RequestParameters: {},
+        ResourceId: "!Ref #{map.gateway_resource_logical_id}",
+        RestApiId: "!Ref RestApi",
+        AuthorizationType: "NONE",
+        Integration: {
+          IntegrationHttpMethod: "POST",
+          Type: "AWS_PROXY",
+          Uri: "!Sub arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${#{map.lambda_function_logical_id}.Arn}/invocations"
+        },
+        MethodResponses:[]
+      )
+    end
+
+    def add_cors(map)
+      # TODO: provide a way to allow specify CORs domains
+      return unless Jets.config.cors
+
+      add_resource(map.cors_logical_id, "AWS::ApiGateway::Method",
+        AuthorizationType: "NONE",
+        HttpMethod: "OPTIONS",
+        MethodResponses: [
+          {
+            StatusCode: "200",
+            ResponseParameters: {
+              "method.response.header.Access-Control-AllowOrigin" => true,
+              "method.response.header.Access-Control-AllowHeaders" => true,
+              "method.response.header.Access-Control-AllowMethods" => true,
+              "method.response.header.Access-Control-AllowCredentials" => true
+            },
+            ResponseModels: {}
+          }
+        ],
+        RequestParameters: {},
+        Integration: {
+          Type: "MOCK",
+          RequestTemplates: {
+            "application/json" => "{statusCode:200}"
+          },
+          IntegrationResponses: [
+            {
+              StatusCode: "200",
+              ResponseParameters: {
+                "method.response.header.Access-Control-AllowOrigin" => "'*'",
+                "method.response.header.Access-Control-AllowHeaders" => "'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token,X-Amz-User-Agent'",
+                "method.response.header.Access-Control-AllowMethods" => "'OPTIONS,GET'",
+                "method.response.header.Access-Control-AllowCredentials" => "'false'"
+              },
+              ResponseTemplates: {"application/json" => ""}
+            }
+          ]
+        },
+        ResourceId: "!Ref #{map.gateway_resource_logical_id}",
+        RestApiId: "!Ref RestApi",
+      )
+    end
+
+    def add_permission(map)
+      add_resource(map.permission_logical_id, "AWS::Lambda::Permission",
+        FunctionName: "!GetAtt #{map.lambda_function_logical_id}.Arn",
+        Action: "lambda:InvokeFunction",
+        Principal: "apigateway.amazonaws.com",
+        SourceArn: "!Sub arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${RestApi}/*/*"
+      )
+    end
+
+    # routes scoped to this controller template.
+    def scoped_routes
+      @routes ||= Jets::Router.routes.select do |route|
+        route.controller_name == @app_klass.to_s
+      end
+    end
+  end
+end

data/lib/jets/cfn/template_builders/function_builder.rb

@@ -0,0 +1,20 @@
+class Jets::Cfn::TemplateBuilders
+  class FunctionBuilder < BaseChildBuilder
+    # compose is an interface method for Interface module
+    def compose
+      add_common_parameters
+      add_functions
+    end
+
+    # For function stacks, ensure there's a _function.yml at the end of the
+    # template_path name for easy identification.
+    def template_path
+      path = super
+      unless path.include?("function.yml")
+        path = path.sub(".yml", "_function.yml")
+      end
+      path
+    end
+
+  end
+end

data/lib/jets/cfn/template_builders/function_properties.rb

@@ -0,0 +1,6 @@
+module Jets::Cfn::TemplateBuilders::FunctionProperties
+  autoload :BaseBuilder, 'jets/cfn/template_builders/function_properties/base_builder'
+  autoload :RubyBuilder, 'jets/cfn/template_builders/function_properties/ruby_builder'
+  autoload :PythonBuilder, 'jets/cfn/template_builders/function_properties/python_builder'
+  autoload :NodeBuilder, 'jets/cfn/template_builders/function_properties/node_builder'
+end

data/lib/jets/cfn/template_builders/function_properties/base_builder.rb

@@ -0,0 +1,106 @@
+# Jets::Cfn::TemplateBuilders does not stick to the TemplateBuilders::Interface.
+# It builds the properties of a function. Usage:
+#
+#   builder = FunctionProperties::PythonBuilder.new(task)
+#   buider.properties
+#   buider.map.logical_id # to access Function's logical id
+#
+module Jets::Cfn::TemplateBuilders::FunctionProperties
+  class BaseBuilder
+    def initialize(task)
+      @task = task
+    end
+
+    def map
+      @map ||= Jets::Cfn::TemplateMappers::LambdaFunctionMapper.new(@task)
+    end
+
+    def properties
+      props = env_file_properties
+        .deep_merge(global_properties)
+        .deep_merge(class_properties)
+        .deep_merge(function_properties)
+      finalize_properties!(props)
+    end
+
+    # Add properties managed by Jets.
+    def finalize_properties!(props)
+      handler = full_handler(props)
+      runtime = get_runtime(props)
+      props.merge!(
+        "FunctionName" => map.function_name,
+        "Handler" => handler,
+        "Runtime" => runtime,
+      )
+    end
+
+    def get_runtime(props)
+      props["Runtime"] || default_runtime
+    end
+
+    # Ensure that the handler path is normalized.
+    def full_handler(props)
+      if props["Handler"]
+        map.handler_value(props["Handler"])
+      else
+        default_handler
+      end
+    end
+
+    # Global properties example:
+    # jets defaults are in jets/default/application.rb.
+    # Your application's default config/application.rb then get used. Example:
+    #
+    #   Jets.application.configure do
+    #     config.function = ActiveSupport::OrderedOptions.new
+    #     config.function.timeout = 10
+    #     config.function.runtime = "nodejs8.10"
+    #     config.function.memory_size = 3008
+    #   end
+    def global_properties
+      baseline = {
+        Code: {
+          S3Bucket: {Ref: "S3Bucket"}, # from child stack
+          S3Key: map.code_s3_key
+        },
+        Role: { Ref: "IamRole" },
+        Environment: { Variables: map.environment },
+      }.deep_stringify_keys
+
+      app_config_props = Jets.application.config.function.to_h
+      app_config_props = Pascalize.pascalize(app_config_props.deep_stringify_keys)
+
+      baseline.deep_merge(app_config_props)
+    end
+
+    # Class properties example:
+    #
+    #   class PostsController < ApplicationController
+    #     class_timeout 22
+    #     ...
+    #   end
+    def class_properties
+      # klass is PostsController, HardJob, GameRule, Hello or HelloFunction
+      klass = Jets::Klass.from_task(@task)
+      class_properties = klass.class_properties
+      Pascalize.pascalize(class_properties.deep_stringify_keys)
+    end
+
+    # Function properties example:
+    #
+    # class PostsController < ApplicationController
+    #   timeout 18
+    #   def index
+    #     ...
+    #   end
+    def function_properties
+      Pascalize.pascalize(@task.properties.deep_stringify_keys)
+    end
+
+    def env_file_properties
+      env_vars = Jets::Dotenv.load!(true)
+      Pascalize.pascalize(environment: { variables: env_vars })
+    end
+  end
+end
+

data/lib/jets/cfn/template_builders/function_properties/node_builder.rb

@@ -0,0 +1,12 @@
+module Jets::Cfn::TemplateBuilders::FunctionProperties
+  class NodeBuilder < BaseBuilder
+    def default_handler
+      @task.full_handler(:handler) # IE: handlers/controllers/posts/show.handler
+    end
+
+    # https://docs.aws.amazon.com/lambda/latest/dg/API_CreateFunction.html#SSS-CreateFunction-request-Runtime
+    def default_runtime
+      "nodejs8.10"
+    end
+  end
+end

data/lib/jets/cfn/template_builders/function_properties/python_builder.rb

@@ -0,0 +1,12 @@
+module Jets::Cfn::TemplateBuilders::FunctionProperties
+  class PythonBuilder < BaseBuilder
+    def default_handler
+      @task.full_handler(:lambda_handler) # IE: handlers/controllers/posts/show.lambda_handler
+    end
+
+    # https://docs.aws.amazon.com/lambda/latest/dg/API_CreateFunction.html#SSS-CreateFunction-request-Runtime
+    def default_runtime
+      "python3.6"
+    end
+  end
+end

data/lib/jets/cfn/template_builders/function_properties/ruby_builder.rb

@@ -0,0 +1,13 @@
+module Jets::Cfn::TemplateBuilders::FunctionProperties
+  class RubyBuilder < BaseBuilder
+    def default_runtime
+      "nodejs8.10" # using node shim for ruby support
+    end
+
+    # Override this in subclasses like PythonBuilder.
+    # Dynamically generated handler.
+    def default_handler
+      map.handler # IE: handlers/controllers/posts_controllers.index
+    end
+  end
+end

data/lib/jets/cfn/template_builders/interface.rb

@@ -0,0 +1,91 @@
+# The class including this module should implement these methods:
+#
+#   * compose
+#   * template_path
+class Jets::Cfn::TemplateBuilders
+  module Interface
+    def build
+      return if @app_klass && @app_klass.tasks.empty? # do not bother building
+        #or writing the template unless there are functions defined
+
+      compose # must be implemented by subclass
+      write
+    end
+
+    def write
+      FileUtils.mkdir_p(File.dirname(template_path))
+      IO.write(template_path, text)
+    end
+
+    def template
+      # need the to_hash or the YAML dump has
+      #  !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+      @template.to_hash
+    end
+
+    def text
+      text = YAML.dump(template)
+      post_process_template(text)
+    end
+
+    # post process the text so that
+    # "!Ref IamRole" => !Ref IamRole
+    # We strip the surrounding quotes
+    def post_process_template(text)
+      results = text.split("\n").map do |line|
+        if line.include?(': "!') # IE: IamRole: "!Ref IamRole",
+           # IamRole: "!Ref IamRole" => IamRole: !Ref IamRole
+          line.sub(/: "(.*)"/, ': \1')
+        else
+          line
+        end
+      end
+      results.join("\n") + "\n"
+    end
+
+    # add_resource handles an options Hash with both only Rroperties
+    # and also one with a nested Properties.
+
+    # Example:
+    #
+    # Simple options with properties only:
+    # add_resource("MyId", "AWS::CloudFormationStack",
+    #   TemplateURL: "template_url",
+    #   Parameters: {},
+    # )
+    #
+    # More complicated options:
+    # add_resource("MyId", "AWS::ApiGateway::RestApi",
+    #   Properties: {
+    #     Name: "my-api"
+    #   },
+    #   DependsOn: ["AnotherResource"]
+    # )
+    def add_resource(logical_id, type, options)
+      base = { Type: type }
+
+      options = if options.include?(:Properties)
+                  base.merge(options)
+                else
+                  {
+                    Type: type,
+                    Properties: options # options are properties
+                  }
+                end
+
+      @template[:Resources][logical_id] = options
+    end
+
+    def add_parameter(name, options={})
+      defaults = { Type: "String" }
+      options = defaults.merge(options)
+      @template[:Parameters] ||= {}
+      @template[:Parameters][name.camelize] = options
+    end
+
+    def add_output(name, options={})
+      @template[:Outputs] ||= {}
+      @template[:Outputs][name.camelize] = options
+    end
+  end
+end