jets 0.8.0 → 0.8.1

data/lib/jets/resource/function.rb

@@ -0,0 +1,184 @@
+class Jets::Resource
+  class Function < Jets::Resource::Base
+    def initialize(task)
+      @task = task
+      @app_class = task.class_name.to_s
+    end
+
+    def definition
+      {
+        function_logical_id => {
+          type: "AWS::Lambda::Function",
+          properties: combined_properties
+        }
+      }
+    end
+
+    def function_logical_id
+      "{namespace}_lambda_function".underscore
+    end
+
+    def replacements
+      @task.replacements # has namespace replacement
+    end
+
+    def combined_properties
+      props = env_file_properties
+        .deep_merge(global_properties)
+        .deep_merge(class_properties)
+        .deep_merge(function_properties)
+      finalize_properties!(props)
+    end
+
+    def env_file_properties
+      env_vars = Jets::Dotenv.load!(true)
+      {environment: { variables: env_vars }}
+    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 = 1536
+    #   end
+    def global_properties
+      baseline = {
+        code: {
+          s3_bucket: "!Ref S3Bucket",
+          s3_key: code_s3_key
+        },
+        role: "!Ref IamRole",
+        environment: { variables: environment },
+      }
+
+      appplication_config = Jets.application.config.function.to_h
+      baseline.merge(appplication_config)
+    end
+
+    # Class properties example:
+    #
+    #   class PostsController < ApplicationController
+    #     class_timeout 22
+    #     ...
+    #   end
+    #
+    # Also handles iam policy override at the class level. Example:
+    #
+    #   class_iam_policy("logs:*")
+    #
+    def class_properties
+      # klass is PostsController, HardJob, GameRule, Hello or HelloFunction
+      klass = Jets::Klass.from_task(@task)
+      class_properties = klass.class_properties
+      if klass.build_class_iam?
+        iam_policy = Jets::Resource::Iam::ClassRole.new(klass)
+        class_properties[:role] = "!GetAtt #{iam_policy.logical_id}.Arn"
+      end
+      class_properties
+    end
+
+    # Function properties example:
+    #
+    # class PostsController < ApplicationController
+    #   timeout 18
+    #   def index
+    #     ...
+    #   end
+    #
+    # Also handles iam policy override at the function level. Example:
+    #
+    #   iam_policy("ec2:*")
+    #   def new
+    #     render json: params.merge(action: "new")
+    #   end
+    #
+    def function_properties
+      properties = @task.properties
+      if @task.build_function_iam?
+        iam_policy = Jets::Resource::Iam::FunctionRole.new(@task)
+        properties[:role] = "!GetAtt #{iam_policy.logical_id}.Arn"
+      end
+      properties
+    end
+
+    # Properties managed by Jets with more finality.
+    def finalize_properties!(props)
+      handler = full_handler(props)
+      runtime = get_runtime(props)
+      props.merge!(
+        function_name: function_name,
+        handler: handler,
+        runtime: runtime,
+      )
+    end
+
+    def get_runtime(props)
+      props[:runtime] || default_runtime
+    end
+
+    def default_runtime
+      map = {
+        node: "nodejs8.10",
+        python: "python3.6",
+        ruby: "nodejs8.10", # node shim for ruby support
+      }
+      map[@task.lang]
+    end
+
+    def default_handler
+      map = {
+        node: @task.full_handler(:handler), # IE: handlers/controllers/posts/show.handler
+        python: @task.full_handler(:lambda_handler), # IE: handlers/controllers/posts/show.lambda_handler
+        ruby: handler, # IE: handlers/controllers/posts_controllers.index
+      }
+      map[@task.lang]
+    end
+
+    def handler
+      handler_value(@task.meth)  # IE: handlers/controllers/posts_controllers.index
+    end
+
+    # Used for node-shim also
+    def handler_value(meth)
+      "handlers/#{@task.type.pluralize}/#{@app_class.underscore}.#{meth}"
+    end
+
+    # Ensure that the handler path is normalized.
+    def full_handler(props)
+      if props[:handler]
+        handler_value(props[:handler])
+      else
+        default_handler
+      end
+    end
+
+    def code_s3_key
+      Jets::Naming.code_s3_key
+    end
+
+    # Examples:
+    #   "#{Jets.config.project_namespace}-sleep_job-perform"
+    #   "demo-dev-sleep_job-perform"
+    def function_name
+      # Example values:
+      #   @app_class: admin/pages_controller
+      #   @task.meth: index
+      #   method: admin/pages_controller
+      #   method: admin-pages_controller-index
+      method = @app_class.underscore
+      method = method.sub('/','-') + "-#{@task.meth}"
+      "#{Jets.config.project_namespace}-#{method}"
+    end
+
+    def environment
+      env = Jets.config.environment ? Jets.config.environment.to_h : {}
+      jets_env_options = {JETS_ENV: Jets.env.to_s}
+      jets_env_options[:JETS_ENV_EXTRA] = Jets.config.env_extra if Jets.config.env_extra
+      env.deep_merge(jets_env_options)
+    end
+  end
+end

data/lib/jets/resource/iam.rb

@@ -0,0 +1,8 @@
+module Jets::Resource::Iam
+  autoload :BaseRoleDefinition, 'jets/resource/iam/base_role_definition'
+  autoload :ApplicationRole, 'jets/resource/iam/application_role'
+  autoload :ClassRole, 'jets/resource/iam/class_role'
+  autoload :FunctionRole, 'jets/resource/iam/function_role'
+  autoload :PolicyDocument, 'jets/resource/iam/policy_document'
+  autoload :ManagedPolicy, 'jets/resource/iam/managed_policy'
+end

data/lib/jets/resource/iam/application_role.rb

@@ -0,0 +1,27 @@
+module Jets::Resource::Iam
+  class ApplicationRole < Jets::Resource::Base
+    include BaseRoleDefinition
+
+    def initialize
+      @policy_definitions = Jets.config.iam_policy # config.iam_policy contains definitions
+      @policy_definitions = [@policy_definitions].flatten if @policy_definitions
+
+      @managed_policy_definitions = Jets.config.managed_iam_policy # config.managed_iam_policy contains definitions
+      @managed_policy_definitions = [@managed_policy_definitions].flatten if @managed_policy_definitions
+    end
+
+    def role_logical_id
+      "iam_role"
+    end
+
+    def role_name
+      "ApplicationRole" # camelized because used as template value
+    end
+
+    def outputs
+      {
+        logical_id => "!Ref #{logical_id}",
+      }
+    end
+  end
+end

data/lib/jets/resource/iam/base_role_definition.rb

@@ -0,0 +1,44 @@
+module Jets::Resource::Iam
+  module BaseRoleDefinition
+    def definition
+      logical_id = role_logical_id
+
+      definition = {
+        logical_id => {
+          type: "AWS::IAM::Role",
+          properties: {
+            role_name: role_name,
+            path: "/",
+            assume_role_policy_document: {
+              version: "2012-10-17",
+              statement: [{
+                effect: "Allow",
+                principal: {service: ["lambda.amazonaws.com"]},
+                action: ["sts:AssumeRole"]}
+              ]
+            }
+          }
+        }
+      }
+
+      definition[logical_id][:properties][:policies] = [
+        policy_name: "#{role_name}Policy",
+        policy_document: policy_document,
+      ] if policy_document
+
+      # if managed_iam_policy.arns
+      #   definition[logical_id][:properties][:managed_policy_arns] = managed_iam_policy.arns
+      # end
+
+      definition
+    end
+
+    def policy_document
+      PolicyDocument.new(@policy_definitions).policy_document
+    end
+
+    def managed_iam_policy
+      ManagedPolicy.new(@managed_policy_definitions).arns
+    end
+  end
+end

data/lib/jets/resource/iam/class_role.rb

@@ -0,0 +1,25 @@
+module Jets::Resource::Iam
+  class ClassRole < Jets::Resource::Base
+    include BaseRoleDefinition
+
+    def initialize(app_class)
+      @app_class = app_class.to_s # IE: PostsController, HardJob, Hello, HelloFunction
+      @policy_definitions = app_class.class_iam_policy || [] # class_iam_policy contains definitions
+      @managed_policy_definitions = app_class.class_managed_iam_policy || [] # class_managed_iam_policy contains definitions
+    end
+
+    def role_logical_id
+      "{namespace}_iam_role".underscore
+    end
+
+    def role_name
+      "{namespace}Role" # camelized because used as template value
+    end
+
+    def replacements
+      {
+        namespace: @app_class.gsub('::','').camelize, # camelized because can be used as value
+      }
+    end
+  end
+end

data/lib/jets/resource/iam/function_role.rb

@@ -0,0 +1,25 @@
+module Jets::Resource::Iam
+  class FunctionRole < Jets::Resource::Base
+    include BaseRoleDefinition
+
+    def initialize(task)
+      @task = task
+      @policy_definitions = task.iam_policy || [] # iam_policy contains policy definitions
+      @managed_policy_definitions = task.managed_iam_policy || [] # managed_iam_policy contains policy definitions
+    end
+
+    def role_logical_id
+      "{namespace}_iam_role".underscore
+    end
+
+    def role_name
+      "{namespace}Role" # camelized because used as template value
+    end
+
+    def replacements
+      {
+        namespace: "#{@task.class_name.gsub('::','')}#{@task.meth.to_s.camelize}", # camelized because can be used as value
+      }
+    end
+  end
+end

data/lib/jets/{cfn/template_builders/managed_iam_policy/base_policy.rb → resource/iam/managed_policy.rb}

@@ -1,11 +1,11 @@
-# Classes that inherit this Base class should implement:
-#
-#   initialize - each initializer has a different signature
-#
-module Jets::Cfn::TemplateBuilders::ManagedIamPolicy
-  class BasePolicy
+module Jets::Resource::Iam
+  class ManagedPolicy
     extend Memoist
+
     attr_reader :definitions
+    def initialize(*definitions)
+      @definitions = definitions.flatten
+    end
 
     def arns
       definitions.map { |definition| standardize(definition) }

data/lib/jets/resource/iam/policy_document.rb

@@ -0,0 +1,43 @@
+module Jets::Resource::Iam
+  class PolicyDocument
+    extend Memoist
+
+    attr_reader :definitions
+    def initialize(*definitions)
+      @definitions = definitions.flatten
+      # empty starting policy that will be altered
+      @policy = {
+        version: "2012-10-17",
+        statement: []
+      }
+      # https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_sid.html
+      @sid = 0 # counter
+    end
+
+    def policy_document
+      definitions.map { |definition| standardize(definition) }
+      Jets::Pascalize.pascalize(@policy)
+    end
+    memoize :policy_document # only process policy_document once
+
+    def standardize(definition)
+      @sid += 1
+      case definition
+      when String
+        @policy[:statement] << {
+          sid: "Stmt#{@sid}",
+          action: [definition],
+          effect: "Allow",
+          resource: "*",
+        }
+      when Hash
+        definition = definition.stringify_keys
+        if definition.key?("Version") # special case where we replace the policy entirely
+          @policy = definition
+        else
+          @policy[:statement] << definition
+        end
+      end
+    end
+  end
+end

data/lib/jets/resource/permission.rb

@@ -1,43 +1,60 @@
-module Jets::Resource
+class Jets::Resource
   class Permission
     extend Memoist
 
-    def initialize(task, resource)
-      @task = task
-      @resource_attributes = resource
+    def initialize(replacements, associated_resource)
+      @replacements = replacements
+      # puts caller
+      # puts "replacements #{replacements.inspect}"
+      @associated_resource = associated_resource
     end
 
-    def attributes
+    def logical_id
       logical_id = "{namespace}Permission"
-      md = @resource_attributes.logical_id.match(/(\d+)/)
-      if md
-        counter = md[1]
-      end
+      md = @associated_resource.logical_id.match(/(\d+)/)
+      counter = md[1] if md
       logical_id = [logical_id, counter].compact.join('')
+      # replace possible {namespace} in the logical id
+      logical_id = replacer.replace_value(logical_id)
+      Jets::Pascalize.pascalize_string(logical_id)
+    end
 
+    def type
+      attributes['Type']
+    end
+
+    def properties
+      attributes['Properties']
+    end
+
+    def attributes
       attributes = {
-        logical_id => {
-          type: "AWS::Lambda::Permission",
-          properties: {
-            function_name: "!GetAtt {namespace}LambdaFunction.Arn",
-            action: "lambda:InvokeFunction",
-            principal: principal,
-            source_arn: source_arn,
-          }
+        type: "AWS::Lambda::Permission",
+        properties: {
+          function_name: "!GetAtt {namespace}LambdaFunction.Arn",
+          action: "lambda:InvokeFunction",
+          principal: principal,
+          source_arn: source_arn,
         }
       }
-      Attributes.new(attributes, @task)
+      attributes = replacer.replace_placeholders(attributes)
+      Jets::Pascalize.pascalize(attributes)
     end
     memoize :attributes
 
     # Auto-detect principal from the associated resources.
     def principal
-      Replacer.principal_map(@resource_attributes.type)
+      Replacer.principal_map(@associated_resource.type)
     end
 
     def source_arn
-      default_arn = "!GetAtt #{@resource_attributes.logical_id}.Arn"
-      Replacer.source_arn_map(@resource_attributes.type) || default_arn
+      default_arn = "!GetAtt #{@associated_resource.logical_id}.Arn"
+      Replacer.source_arn_map(@associated_resource.type) || default_arn
+    end
+
+    def replacer
+      Replacer.new(@replacements)
     end
+    memoize :replacer
   end
 end