jets_bb_fork 0.0.4

data/lib/jets/stack/definition.rb

@@ -0,0 +1,50 @@
+# Class that include Definition should implement:
+#
+#   template - method should use @definition to build a CloudFormation template section
+#
+class Jets::Stack
+  module Definition
+    extend ActiveSupport::Concern
+
+    # Example of usage that leads here:
+    #
+    #   Parameter.new(self, *definition).register
+    #
+    # Which  is defined in parameter/dsl.rb
+    #
+    # Example subclass: ExampleStack < Jets::Stack
+    def initialize(subclass, *definition)
+      @subclass = subclass.to_s # important to use to_s, dont want the object as keys in @definitions
+      @definition = definition.flatten
+    end
+
+    def register
+      self.class.register(@subclass, *@definition)
+    end
+
+    def camelize(attributes)
+      Jets::Camelizer.transform(attributes)
+    end
+
+    class_methods do
+      def register(subclass, *definition)
+        @definitions ||= {}
+        @definitions[subclass.to_s] ||= []
+        # Create instance of the CloudFormation section class and register it.  Examples:
+        #   Stack::Parameter.new(definition)
+        #   Stack::Resource.new(definition)
+        #   Stack::Output.new(definition)
+        @definitions[subclass.to_s] << new(subclass, definition)
+      end
+
+      def definitions(subclass)
+        @definitions ||= {}
+        @definitions[subclass.to_s]
+      end
+
+      def all_definitions
+        @definitions
+      end
+    end
+  end
+end

data/lib/jets/stack/depends.rb

@@ -0,0 +1,34 @@
+class Jets::Stack
+  class Depends
+    def initialize(items)
+      @items = items
+    end
+
+    def params
+      result = {}
+      @items.each do |item|
+        logical_id = item.stack.to_s.camelize # logical_id
+        dependency_outputs(logical_id).each do |output|
+          dependency_class = logical_id.to_s.camelize
+          output_key = item.options[:class_prefix] ?
+            "#{dependency_class}#{output}" : # already camelized
+            output
+
+          output_value = "!GetAtt #{dependency_class}.Outputs.#{output}"
+          result[output_key] = output_value
+        end
+      end
+      result
+    end
+
+    def stack_list
+      @items.map do |item|
+        item.stack.to_s.camelize # logical_id # logical_id
+      end
+    end
+
+    def dependency_outputs(logical_id)
+      logical_id.to_s.camelize.constantize.output_keys
+    end
+  end
+end

data/lib/jets/stack/depends/item.rb

@@ -0,0 +1,9 @@
+class Jets::Stack::Depends
+  class Item
+    attr_reader :stack, :options
+    def initialize(stack, options={})
+      @stack = stack
+      @options = options
+    end
+  end
+end

data/lib/jets/stack/function.rb

@@ -0,0 +1,69 @@
+class Jets::Stack
+  class Function
+    extend Memoist
+
+    attr_reader :template
+    def initialize(template)
+      @template = template
+    end
+
+    def meth
+      attributes = @template.values.first
+      handler = attributes['Properties']['Handler']
+      handler.split('.').last
+    end
+
+    def lang
+      return if internal?
+
+      if source_file
+        # Detect language from file extension
+        ext = File.extname(source_file).sub(/^\./,'').to_sym
+        lang_map[ext]
+      else
+        puts "WARN: Unable to find a source file for function. Looked at: #{search_expression}".color(:yellow)
+      end
+    end
+
+    def lang_map
+      {
+        rb: :ruby,
+        py: :python,
+        js: :node,
+      }
+    end
+
+    def source_file
+      Dir.glob(search_expression).first
+    end
+    memoize :source_file
+
+    def search_expression
+      base_search_expression.sub('handlers/shared/', "#{Jets.root}/app/shared/")
+    end
+
+    def internal_search_expression
+      internal = File.expand_path("../internal", File.dirname(__FILE__))
+      base_search_expression.sub('handlers/shared/', "#{internal}/app/shared/")
+    end
+
+    def base_search_expression
+      attributes = @template.values.first
+      handler = attributes['Properties']['Handler']
+      handler.split('.')[0..-2].join('.') + '.*' # search_expression
+      # Example: handlers/shared/functions/jets/s3_bucket_config.*
+    end
+
+    # Internal flag is mainly used to disable WARN messages
+    def internal?
+      !!Dir.glob(internal_search_expression).first
+    end
+
+    # Relative path
+    # app/shared/functions/kevin.py => handlers/shared/functions/kevin.py
+    def handler_dest
+      return unless source_file
+      source_file.sub(%r{.*/app/}, "handlers/")
+    end
+  end
+end

data/lib/jets/stack/main.rb

@@ -0,0 +1,4 @@
+class Jets::Stack
+  class Main
+  end
+end

data/lib/jets/stack/main/dsl.rb

@@ -0,0 +1,28 @@
+class Jets::Stack
+  class Main
+    module Dsl
+      extend ActiveSupport::Concern
+
+      class_methods do
+        include Base
+        include Cloudwatch
+        include Iam
+        include Lambda
+        include S3
+        include Sns
+        include Sqs
+      end
+
+      def self.included(base)
+        base_path = "#{Jets.root}/app/shared/extensions"
+        Dir.glob("#{base_path}/**/*.rb").each do |path|
+          next unless File.file?(path)
+
+          class_name = path.sub("#{base_path}/", '').sub(/\.rb/,'').camelize
+          klass = class_name.constantize # autoload
+          base.extend(klass)
+        end
+      end
+    end
+  end
+end

data/lib/jets/stack/main/dsl/base.rb

@@ -0,0 +1,49 @@
+module Jets::Stack::Main::Dsl
+  module Base
+    def ref(value)
+      "!Ref #{value.to_s.camelize}"
+    end
+
+    def getatt(value, attribute=:arn)
+      "!GetAtt #{value.to_s.camelize}.#{attribute.to_s.camelize}"
+    end
+
+    def logical_id(value)
+      value.to_s.camelize
+    end
+
+    def depends_on(*stacks)
+      if stacks == []
+        @depends_on
+      else
+        @depends_on ||= []
+        @depends_on += stacks
+      end
+    end
+
+    # Due to `if Jets::Stack.has_resources?` check early on in the bootstraping process
+    # The code has not been built at that point. So we use a placeholder and will replace
+    # the placeholder as part of the cfn template build process after the code has been built
+    # and the code_s3_key with md5 is available.
+    def code_s3_key
+      "code_s3_key_placeholder"
+    end
+
+    # resource(:hello,
+    #   function_name: "hello",
+    #   code: {
+    #     s3_bucket: "!Ref S3Bucket",
+    #     s3_key: code_s3_key
+    #   },
+    #   description: "Hello world",
+    #   handler: handler_function("hello.lambda_handler"),
+    #   memory_size: 128,
+    #   role: "!Ref IamRole",
+    #   runtime: "python3.6",
+    #   timeout: 20,
+    # )
+    def handler(name)
+      "handlers/shared/functions/#{name}" # generated handler
+    end
+  end
+end

data/lib/jets/stack/main/dsl/cloudwatch.rb

@@ -0,0 +1,19 @@
+module Jets::Stack::Main::Dsl
+  module Cloudwatch
+    def cloudwatch_alarm(id, hash={})
+      if hash.key?(:depends_on)
+        attributes = hash # leave structure alone and add type only
+        attributes[:type] = "AWS::CloudWatch::Alarm"
+      else
+        # the attributes are properties
+        properties = hash
+        attributes = {
+          type: "AWS::CloudWatch::Alarm",
+          properties: properties,
+        }
+      end
+      resource(id, attributes)
+      output(id)
+    end
+  end
+end

data/lib/jets/stack/main/dsl/iam.rb

@@ -0,0 +1,8 @@
+module Jets::Stack::Main::Dsl
+  module Iam
+    def iam_role(id, props={})
+      resource(id, "AWS::IAM::Role", props)
+      output(id) # IAM Arn
+    end
+  end
+end

data/lib/jets/stack/main/dsl/lambda.rb

@@ -0,0 +1,83 @@
+module Jets::Stack::Main::Dsl
+  module Lambda
+    # Example:
+    #
+    #   function(:hello,
+    #     handler: handler("hello.lambda_hander"),
+    #     runtime: "python3.6"
+    #   )
+    #
+    # Defaults to ruby. So:
+    #
+    #   function(:hello)
+    #
+    # is the same as:
+    #
+    #   function(:hello,
+    #     handler: handler("hello.hande"),
+    #     runtime: :ruby
+    #   )
+    #
+    def function(id, props={})
+      # Required: code, handler, role, runtime Docs: https://amzn.to/2pdot7S
+      meth = sanitize_method_name(id)
+      class_namespace = self.to_s.underscore.gsub('/','-') # IE: Jets::Domain => jets-domain
+      description = "#{self.to_s} #{meth}" # not bother adding extension
+      defaults = {
+        code: {
+          s3_bucket: "!Ref S3Bucket",
+          s3_key: code_s3_key
+        },
+        role: "!Ref IamRole",
+        handler: "#{id}.lambda_handler", # default ruby convention
+        runtime: :ruby,
+        timeout: Jets.config.function.timeout,
+        memory_size: Jets.config.function.memory_size,
+        description: description,
+      }
+
+      function_name = "#{Jets.config.project_namespace}-#{class_namespace}-#{meth}"
+      function_name = function_name.size > Jets::MAX_FUNCTION_NAME_SIZE ? nil : function_name
+      defaults[:function_name] = function_name if function_name
+
+      props = defaults.merge(props)
+      props[:runtime] = "ruby2.5" if props[:runtime].to_s == "ruby"
+      props[:handler] = handler(props[:handler])
+
+      logical_id = id.to_s.gsub('/','_')
+      resource(logical_id, "AWS::Lambda::Function", props)
+    end
+    alias_method :ruby_function, :function
+    alias_method :lambda_function, :function
+
+    def python_function(id, props={})
+      meth = sanitize_method_name(id)
+      props[:handler] ||= "#{meth}.lambda_handler" # default python convention
+      props[:runtime] = "python3.6"
+      function(id, props)
+    end
+
+    def node_function(id, props={})
+      meth = sanitize_method_name(id)
+      props[:handler] ||= "#{meth}.handler" # default python convention
+      props[:runtime] = "nodejs8.10"
+      function(id, props)
+    end
+
+    # Usage:
+    #
+    #   permission(:my_permission, principal: "events.amazonaws.com")
+    #
+    def permission(id, props={})
+      defaults = { action: "lambda:InvokeFunction" }
+      props = defaults.merge(props)
+      resource(id, "AWS::Lambda::Permission", props)
+    end
+
+  private
+    # demo-dev-hard_job-dig_me
+    def sanitize_method_name(id)
+      id.to_s.gsub('/','-')
+    end
+  end
+end

data/lib/jets/stack/main/dsl/s3.rb

@@ -0,0 +1,12 @@
+module Jets::Stack::Main::Dsl
+  module S3
+    def s3_bucket(id, props={})
+      resource(id, "AWS::S3::Bucket", props)
+      output(id) # Bucket name
+    end
+
+    def s3_bucket_configuration(id, props={})
+      resource(id, "Custom::S3BucketConfiguration", props)
+    end
+  end
+end

data/lib/jets/stack/main/dsl/sns.rb

@@ -0,0 +1,16 @@
+module Jets::Stack::Main::Dsl
+  module Sns
+    def sns_topic(id, props={})
+      resource(id, "AWS::SNS::Topic", props)
+      output(id) # Topic Arn
+    end
+
+    def sns_topic_policy(id, props={})
+      resource(id, "AWS::SNS::TopicPolicy", props)
+    end
+
+    def sns_subscription(id, props={})
+      resource(id, "AWS::SNS::Subscription", props)
+    end
+  end
+end

data/lib/jets/stack/main/dsl/sqs.rb

@@ -0,0 +1,10 @@
+module Jets::Stack::Main::Dsl
+  module Sqs
+    def sqs_queue(id, props={})
+      # props[:queue_name] ||= id.to_s # comment out to allow CloudFormation to generate name
+      resource(id, "AWS::SQS::Queue", props)
+      output(id, getatt(id, :arn)) # normal !Ref returns the sqs url the ARN is useful for nested stacks depends_on
+      output("#{id}_url", ref(id)) # useful for Stack.lookup method. IE: List.lookup(:waitlist_url)
+    end
+  end
+end

data/lib/jets/stack/output.rb

@@ -0,0 +1,35 @@
+# Implements:
+#
+#   template - uses @definition to build a CloudFormation template section
+#
+class Jets::Stack
+  class Output
+    include Definition
+
+    def template
+      camelize(standarize(@definition))
+    end
+
+    # Value is the only required property: https://amzn.to/2xbhmk3
+    def standarize(definition)
+      first, second, _ = definition
+      if definition.size == 1 && first.is_a?(Hash) # long form
+        first # pass through
+      elsif definition.size == 2 && second.is_a?(Hash) # medium form
+        logical_id, properties = first, second
+        { logical_id => properties }
+      elsif definition.size == 2 && second.is_a?(String) # short form
+        logical_id = first
+        properties = second.is_a?(String) ? { value: second } : {}
+        { logical_id => properties }
+      elsif definition.size == 1
+        logical_id = first.to_s
+        properties = {value: "!Ref #{logical_id.camelize}"}
+        { logical_id => properties }
+      else # I dont know what form
+        raise "Invalid form provided. definition #{definition.inspect}"
+      end
+    end
+  end
+end
+