jets.benforeva 3.0.17.pre.mount.pre.fix

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] = Jets.ruby_runtime 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, value: get_att("#{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/main/dsl.rb

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

data/lib/jets/stack/main.rb

@@ -0,0 +1,4 @@
+class Jets::Stack
+  class Main
+  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.camelize
+
+      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

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
+

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

@@ -0,0 +1,42 @@
+class Jets::Stack
+  class Parameter
+    module Dsl
+      extend ActiveSupport::Concern
+      extend Memoist
+
+      def parameters
+        add_common_parameters
+        add_depends_on_parameters
+        Parameter.definitions(self.class)
+      end
+
+      def add_common_parameters
+        self.class.parameter(:iam_role)
+        self.class.parameter(:s3_bucket)
+      end
+
+      def add_depends_on_parameters
+        depends_on = self.class.depends_on
+        depends_on.each do |dependency|
+          dependency_outputs(dependency).each do |output|
+            self.class.parameter(output)
+          end
+        end if depends_on
+      end
+      memoize :add_depends_on_parameters # only run once
+
+      # Returns output keys associated with the stack.  They are the resource logical ids.
+      def dependency_outputs(dependency)
+        dependency.to_s.camelize.constantize.output_keys
+      end
+
+      class_methods do
+        def parameter(*definition)
+          # self is subclass is the stack that inherits from Jets::Stack
+          # IE: ExampleStack < Jets::Stack
+          Parameter.new(self, *definition).register
+        end
+      end
+    end
+  end
+end

data/lib/jets/stack/parameter.rb

@@ -0,0 +1,37 @@
+# Implements:
+#
+#   template - uses @definition to build a CloudFormation template section
+#
+class Jets::Stack
+  class Parameter
+    include Definition
+
+    def template
+      camelize(add_required(standarize(@definition)))
+    end
+
+    # Type is the only required property: https://amzn.to/2x8W5aD
+    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
+            definition.size == 1
+        logical_id = first
+        properties = second.is_a?(String) ? { default: second } : {}
+        { logical_id => properties }
+      else # I dont know what form
+        raise "Invalid form provided. definition #{definition.inspect}"
+      end
+    end
+
+    def add_required(attributes)
+      properties = attributes.values.first
+      properties[:type] ||= 'String'
+      attributes
+    end
+  end
+end

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

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

data/lib/jets/stack/resource.rb

@@ -0,0 +1,31 @@
+# Implements:
+#
+#   template - uses @definition to build a CloudFormation template section
+#
+class Jets::Stack
+  class Resource
+    include Definition
+
+    def template
+      template = camelize(standarize(@definition))
+      template = replace_placeholers(template)
+      template
+    end
+
+    # CloudFormation Resources reference: https://amzn.to/2NKg6ip
+    def standarize(definition)
+      Jets::Resource::Standardizer.new(definition).template
+    end
+
+    def replace_placeholers(template)
+      attributes = template.values.first
+      s3_key = attributes.dig('Properties','Code','S3Key')
+      if s3_key == "code_s3_key_placeholder"
+        checksum = Jets::Builders::Md5.checksums["stage/code"]
+        code_zip = "code-#{checksum}.zip"
+        attributes['Properties']['Code']['S3Key'] = "jets/code/#{code_zip}"
+      end
+      template
+    end
+  end
+end

data/lib/jets/stack/s3_event.rb

@@ -0,0 +1,87 @@
+class Jets::Stack
+  class S3Event
+    def initialize(bucket_name)
+      @bucket_name = bucket_name
+    end
+
+    # Stack names can only contain alpha numeric chars.
+    # Bucket names are limit to 64 chars: https://amzn.to/2SIzvme
+    # Stack names are limit to 128 chars: https://amzn.to/2SFkrG0
+    # This gsub should handle this.
+    def stack_name
+      @bucket_name.gsub(/[^0-9a-z\-_]/i, '').gsub('-','_').camelize
+    end
+
+    def build_stack
+      # assign to local variable so its available in the block
+      bucket = @bucket_name
+
+      Jets::Stack.new_class(stack_name) do
+        s3_bucket_configuration(:s3_bucket_configuration,
+          service_token: "!GetAtt JetsS3BucketConfig.Arn", # Cannot change this w/o changing the logical id
+          # These properties correspond to the ruby aws-sdk s3.put_bucket_notification_configuration
+          # in jets/s3_bucket_config.rb, not the CloudFormation Bucket properties. The CloudFormation
+          # bucket properties have a similiar structure but is slightly different so it can be confusing.
+          #
+          #   Ruby aws-sdk S3 Docs: https://amzn.to/2N7m5Lr
+          bucket: bucket,
+          notification_configuration: Jets.config.s3_event.notification_configuration,
+        ) if Jets.config.s3_event.configure_bucket
+
+        # Important note: If we change the name of this function we should also change the
+        # logical id of the s3_bucket_configuration custom resource or we'll get this error:
+        #   Modifying service token is not allowed.
+        function("jets/s3_bucket_config",
+          role: "!GetAtt BucketConfigIamRole.Arn",
+          layers: ["!Ref GemLayer"],
+        )
+
+        sns_topic(:sns_topic)
+        sns_topic_policy(:sns_topic_policy,
+          policy_document: {
+            version: "2012-10-17",
+            statement: {
+              effect: "Allow",
+              principal: { service: "s3.amazonaws.com"},
+              action: "sns:Publish",
+              resource: "!Ref SnsTopic",
+              condition: {
+                arn_like: {
+                  "aws:SourceArn" => "!Sub arn:aws:s3:*:*:#{bucket}"
+                }
+              }
+            }
+          },
+          topics: ["!Ref SnsTopic"],
+        )
+
+        iam_role(:bucket_config_iam_role,
+          assume_role_policy_document: {
+            version: '2012-10-17',
+            statement: [
+              effect: "Allow",
+              principal: {service: ["lambda.amazonaws.com"]},
+              action: ['sts:AssumeRole'],
+            ]
+          },
+          path: "/",
+          managed_policy_arns: ["arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"],
+          policies: [
+            policy_name: "S3Policy",
+            policy_document: {
+              version: '2012-10-17',
+              statement: [
+                effect: "Allow",
+                action: [
+                  's3:GetBucketNotification',
+                  's3:PutBucketNotification',
+                ],
+                resource: "*"
+              ]
+            }
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/jets/stack.rb

@@ -0,0 +1,88 @@
+module Jets
+  class Stack
+    include Main::Dsl
+    include Parameter::Dsl
+    include Output::Dsl
+    include Resource::Dsl
+
+    class << self
+      extend Memoist
+
+      # Track all command subclasses.
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def inherited(base)
+        super
+        self.subclasses << base if base.name
+      end
+
+      # klass = Jets::Stack.new_class("Bucket3")
+      def new_class(class_name, &block)
+        # https://stackoverflow.com/questions/4113479/dynamic-class-definition-with-a-class-name
+        # Defining the constant this way gets around: SyntaxError: dynamic constant assignment error
+        klass = Class.new(Jets::Stack) # First klass is an anonymous class. IE: class.name is nil
+        klass = Object.const_set(class_name, klass) # now klass is a named class
+        Jets::Stack.subclasses << klass # mimic inherited hook because
+
+        # Must run class_eval after adding to subclasses in order for the resource declarations in the
+        # so that the resources get registered to the right subclass.
+        klass.class_eval(&block)
+        klass # return klass
+      end
+
+      # Build it to figure out if we need to build the stack for the SharedBuilder
+      def build?
+        empty = template == {"Parameters"=>{"IamRole"=>{"Type"=>"String"}, "S3Bucket"=>{"Type"=>"String"}}}
+        !empty
+      end
+
+      def functions
+        stack = new
+        # All the & because resources might be nil
+        templates = stack.resources&.map(&:template)&.select do |t|
+          attributes = t.values.first
+          attributes['Type'] == 'AWS::Lambda::Function'
+        end
+        templates ||= []
+        templates.map { |t| Function.new(t) }
+      end
+
+      def template
+        # Pretty funny looking, creating an instance of stack to be passed to the Builder.
+        # Another way of looking at it:
+        #
+        #   stack = new # MyStack.new
+        #   builder = Jets::Stack::Builder.new(stack)
+        #
+        builder = Jets::Stack::Builder.new(new)
+        builder.template
+      end
+      memoize :template
+
+      # Eager loading the app/shared resources to ensure shared resources have been registered.
+      # Not being used anymore but keeping around just in case for now.
+      def eager_load_shared_resources!
+        Dir.glob("#{Jets.root}/app/shared/**").each do |path|
+          next if path.include?("app/shared/functions")
+          Jets::Autoloaders.main.preload(path)
+        end
+      end
+
+      def lookup(logical_id)
+        looker.output(logical_id)
+      end
+
+      def looker
+        Jets::Stack::Output::Lookup.new(self)
+      end
+      memoize :looker
+
+      def output_keys
+        outputs = new.outputs || []
+        outputs.map(&:template).map {|o| o.keys.first}
+      end
+    end
+  end
+end

data/lib/jets/tmp_loader.rb

@@ -0,0 +1,53 @@
+module Jets
+  class TmpLoader
+    include AwsServices
+
+    def self.load!
+      new.load
+    end
+
+    def initialize(yaml_path=nil)
+      yaml_path ||= "#{Jets.root}/handlers/data.yml"
+      return unless File.exist?(yaml_path)
+      @data = YAML.load_file(yaml_path)
+      @s3_bucket = @data['s3_bucket']
+      @rack_zip = @data['rack_zip']
+    end
+
+    def load
+      rack
+    end
+
+    def rack
+      return unless @rack_zip
+      download_and_extract(@rack_zip, '/tmp/rack')
+    end
+
+    def download_and_extract(zip_file, folder_dest)
+      s3_key = "jets/code/#{zip_file}" # jets/code/rack-checksum.zip
+      download_path = "/tmp/#{zip_file}" # /tmp/rack-checksum.zip
+
+      download(s3_key, download_path)
+      unzip(download_path, folder_dest)
+    end
+
+    def download(key, dest)
+      # https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#get_object-instance_method
+      # stream object directly to disk
+      s3.get_object(response_target: dest,
+                    bucket: @s3_bucket,
+                    key: key)
+    end
+
+    def unzip(zipfile, folder_dest)
+      sh "unzip -qo #{zipfile} -d #{folder_dest}"
+    end
+
+    def sh(command)
+      puts "=> #{command}"
+      success = system(command)
+      raise "Command #{command} failed" unless success
+      success
+    end
+  end
+end

data/lib/jets/turbine.rb

@@ -0,0 +1,41 @@
+module Jets
+  class Turbine
+    class_attribute :after_initializers
+    class_attribute :initializers
+    class_attribute :on_exceptions
+
+    class << self
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def inherited(base)
+        subclasses << base
+      end
+
+      def after_initializer(label, &block)
+        self.after_initializers ||= {}
+        self.after_initializers[label] = block
+      end
+
+      def initializer(label, &block)
+        self.initializers ||= {}
+        self.initializers[label] = block
+      end
+
+      def on_exception(label, &block)
+        self.on_exceptions ||= {}
+        self.on_exceptions[label] = block
+      end
+
+      def exception_reporter(label, &block)
+        on_exception(label, &block)
+      end
+
+      # Make config available in Turbine. Note only available outside of hooks like initializers.
+      def config
+        Jets.application.config
+      end
+    end
+  end
+end

data/lib/jets/turbo/database_yaml.rb

@@ -0,0 +1,41 @@
+class Jets::Turbo
+  class DatabaseYaml
+    def reconfigure
+      current_yaml = "#{Jets.root}/rack/config/database.yml"
+      return unless File.exist?(current_yaml)
+
+      vars = {}
+      current_database = YAML.load_file(current_yaml)
+      database_names = infer_database_name(current_database)
+      vars.merge!(database_names)
+      vars['adapter'] = current_database['development']['adapter']
+
+      path = File.expand_path("templates/config/database.yml", File.dirname(__FILE__))
+      content = Jets::Erb.result(path, vars)
+      IO.write(current_yaml, content)
+      # puts "Reconfigured #{current_yaml}" # uncomment to inspect and debug
+    rescue Exception => e
+      puts "WARNING: Was not able to generate a database.yml. Leaving your current one in place"
+      puts e.message
+      # If unable to copy the database.yml settings just slightly fail.
+      # Do this because really unsure what is in the current database.yml
+    end
+
+    def infer_database_name(current_database)
+      vars = {}
+      %w[development test production].each do |env|
+        if !current_database[env]['database'].include?('<%') # already has ERB
+          vars["database_#{env}"] = current_database[env]['database']
+        else
+          lines = IO.readlines("#{Jets.root}/rack/config/application.rb")
+          module_line = lines.find { |l| l =~ /^module / }
+          app_module = module_line.gsub(/^module /,'').strip
+          app_name = app_module.underscore
+          vars["database_#{env}"] = "#{app_name}_#{env}"
+        end
+      end
+
+      vars
+    end
+  end
+end