jets 0.8.18 → 0.9.0

data/lib/jets/stack/builder.rb

@@ -0,0 +1,38 @@
+class Jets::Stack
+  class Builder
+    extend Memoist
+
+    def initialize(stack)
+      @stack = stack
+      @template = {} # will build this structure up
+    end
+
+    def template
+      build_section(:parameters)
+      build_section(:resources)
+      build_section(:outputs)
+      Jets::Camelizer.transform(@template)
+    end
+    memoize :template
+
+    def build_section(section)
+      elements = build_elements(section)
+      @template[section] = elements if elements
+    end
+
+    def build_elements(section)
+      # s is a "section element".  Examples:
+      #
+      #   Jets::Stack::Parameter
+      #   Jets::Stack::Resource
+      #   Jets::Stack::Output
+      #
+      section_elements = @stack.send(section)
+      return unless section_elements
+
+      section_elements.inject({}) do |template_section, s|
+        template_section.merge(s.template)
+      end
+    end
+  end
+end

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/function.rb

@@ -0,0 +1,60 @@
+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
+      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}".colorize(: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
+      attributes = @template.values.first
+      handler = attributes['Properties']['Handler']
+      search_expression = handler.split('.')[0..-2].join('.') + '.*'
+      search_expression.sub('handlers/shared/', "#{Jets.root}app/shared/")
+    end
+
+    # Relative path
+    # app/shared/functions/kevin.py => handlers/shared/functions/kevin.py
+    def handler_dest
+      return unless source_file
+
+      dest = source_file.sub(%r{.*/app/}, "handlers/")
+      if lang == :ruby
+        filename = dest.split('.').first
+        filename + '.js' # change extension to .js because ruby uses a node shim
+      else
+        dest
+      end
+    end
+  end
+end

data/lib/jets/stack/main.rb

@@ -0,0 +1,5 @@
+class Jets::Stack
+  class Main
+    autoload :Dsl, "jets/stack/main/dsl"
+  end
+end

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

@@ -0,0 +1,33 @@
+class Jets::Stack
+  class Main
+    module Dsl
+      extend ActiveSupport::Concern
+      autoload :Base, 'jets/stack/main/extensions/base'
+      autoload :Cloudwatch, 'jets/stack/main/extensions/cloudwatch'
+      autoload :Lambda, 'jets/stack/main/extensions/lambda'
+      autoload :Sns, 'jets/stack/main/extensions/sns'
+      autoload :Sqs, 'jets/stack/main/extensions/sqs'
+
+      class_methods do
+        include Base
+        include Cloudwatch
+        include Lambda
+        include Sns
+        include Sqs
+      end
+
+      def self.included(base)
+        base_path = "#{Jets.root}/app/shared/extensions"
+        ActiveSupport::Dependencies.autoload_paths += [base_path]
+
+        Dir.glob("#{base_path}/**/*.rb").each do |path|
+          next unless File.file?(path)
+
+          class_name = path.sub("#{base_path}/", '').sub(/\.rb/,'').classify
+          klass = class_name.constantize # autoload
+          base.extend(klass)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Jets::Stack::Main::Dsl
+  module Base
+    def ref(value)
+      "!Ref #{value.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/extensions/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/extensions/lambda.rb

@@ -0,0 +1,69 @@
+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 = id.to_s.underscore
+      defaults = {
+        function_name: "#{Jets.config.project_namespace}-#{id.to_s.underscore}",
+        code: {
+          s3_bucket: "!Ref S3Bucket",
+          s3_key: code_s3_key
+        },
+        role: "!Ref IamRole",
+        handler: "#{meth}.handle", # default ruby convention
+        runtime: :ruby,
+        timeout: Jets.config.function.timeout,
+        memory_size: Jets.config.function.memory_size,
+      }
+      props = defaults.merge(props)
+      props[:runtime] = "nodejs8.10" if props[:runtime].to_s == "ruby"
+      props[:handler] = handler(props[:handler])
+
+      resource(id, "AWS::Lambda::Function", props)
+    end
+    alias_method :ruby_function, :function
+    alias_method :lambda_function, :function
+
+    def python_function(id, props={})
+      meth = id.to_s.underscore
+      props[:handler] ||= "#{meth}.lambda_handler" # default python convention
+      props[:runtime] = "python3.6"
+      function(id, props)
+    end
+
+    def node_function(id, props={})
+      meth = id.to_s.underscore
+      props[:handler] ||= "#{meth}.handler" # default python convention
+      props[:runtime] = "node8.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
+  end
+end

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

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

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

@@ -0,0 +1,8 @@
+module Jets::Stack::Main::Dsl
+  module Sqs
+    def sqs_queue(id, props={})
+      resource(id, "AWS::SNS::Topic", props)
+      output(id)
+    end
+  end
+end

data/lib/jets/stack/output.rb

@@ -0,0 +1,38 @@
+# Implements:
+#
+#   template - uses @definition to build a CloudFormation template section
+#
+class Jets::Stack
+  class Output
+    autoload :Dsl, "jets/stack/output/dsl"
+    autoload :Lookup, "jets/stack/output/lookup"
+
+    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
+

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

@@ -0,0 +1,19 @@
+class Jets::Stack
+  class Output
+    module Dsl
+      extend ActiveSupport::Concern
+
+      def outputs
+        Output.definitions(self.class)
+      end
+
+      class_methods do
+        def output(*definition)
+          # self is subclass is the stack that inherits from Jets::Stack
+          # IE: ExampleStack < Jets::Stack
+          Output.new(self, *definition).register
+        end
+      end
+    end
+  end
+end

data/lib/jets/stack/output/lookup.rb

@@ -0,0 +1,36 @@
+class Jets::Stack::Output
+  class Lookup
+    include Jets::AwsServices
+
+    def initialize(stack_subclass)
+      @stack_subclass = stack_subclass
+    end
+
+    def output(logical_id)
+      child_stack_id = @stack_subclass.to_s.classify
+
+      stack_arn = shared_stack_arn(child_stack_id)
+      resp = cfn.describe_stacks(stack_name: stack_arn)
+      child = resp.stacks.first
+      return unless child
+
+      output_value(child, logical_id)
+    end
+
+    # Shared child stack arn
+    def shared_stack_arn(logical_id)
+      parent_stack = Jets.config.project_namespace
+      resp = cfn.describe_stacks(stack_name: parent_stack)
+      parent = resp.stacks.first
+      output_value(parent, logical_id)
+    end
+
+    def output_value(stack, key)
+      key = key.to_s.camelize
+      output = stack.outputs.find do |o|
+        o.output_key == key
+      end
+      output&.output_value
+    end
+  end
+end