jets_bb_fork 0.0.4

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

@@ -0,0 +1,52 @@
+module Jets
+  class TmpLoader
+    include AwsServices
+
+    def self.load!
+      new.load
+    end
+
+    def initialize(yaml_path=nil)
+      yaml_path ||= "#{Jets.root}/handlers/data.yml"
+      @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.rb

@@ -0,0 +1,55 @@
+require 'fileutils'
+
+module Jets
+  class Turbo
+    class << self
+      extend Memoist
+
+      # Relies on the cached side-effect since Jets afterburner will switch Jets.root and the result will be different
+      def afterburner?
+        new.rails?
+      end
+      memoize :afterburner?
+    end
+
+    # Turbo charge mode
+    def charge
+      framework = detect
+      case framework
+      when :jets
+        # do nothing
+      when :rails
+        Rails.new.setup
+      else
+        # should never get here
+      end
+    end
+
+    def detect
+      if rails?
+        :rails
+      elsif jets?
+        :jets
+      else
+        :unknown_framework
+      end
+    end
+
+    def rails?
+      config_ru_contains?('run Rails.application')
+    end
+
+    def jets?
+      config_ru_contains?('run Jets.application')
+    end
+
+    def config_ru_contains?(value)
+      root = ENV["JETS_ROOT"] || Dir.pwd # Jets.root is not yet available
+      config_ru = "#{root}/config.ru"
+      return false unless File.exist?(config_ru)
+
+      lines = ::IO.readlines(config_ru)
+      !!lines.detect { |l| l.include?(value) }
+    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