jets-fs 1.6.10

data/lib/jets/aws_info.rb

@@ -0,0 +1,111 @@
+
+module Jets
+  class AwsInfo
+    extend Memoist
+    include AwsServices
+
+    def region
+      return 'us-east-1' if test?
+
+      return ENV['JETS_AWS_REGION'] if ENV['JETS_AWS_REGION'] # highest precedence
+      return ENV['AWS_REGION'] if ENV['AWS_REGION']
+
+      region = nil
+
+      # First if aws binary is available
+      # try to get it from the ~/.aws/config
+      if which('aws')
+        region = `aws configure get region 2>&1`.strip rescue nil
+        exit_code = $?.exitstatus
+        if exit_code != 0
+          exception_message = region.split("\n").grep(/botocore\.exceptions/).first
+          if exception_message
+            puts "WARN: #{exception_message}".color(:yellow)
+          else
+            # show full message as warning
+            puts region.color(:yellow)
+          end
+          puts "You can also get rid of this message by setting AWS_REGION or configuring ~/.aws/config with the region"
+          region = nil
+        end
+        region = nil if region == ''
+        return region if region
+      end
+
+      # Second try the metadata endpoint, should be available on AWS Lambda environment
+      # https://stackoverflow.com/questions/4249488/find-region-from-within-an-ec2-instance
+      begin
+        az = `curl -s --max-time 3 --connect-timeout 5 http://169.254.169.254/latest/meta-data/placement/availability-zone`
+        region = az.strip.chop # remove last char
+        region = nil if region == ''
+      rescue
+      end
+      return region if region
+
+      'us-east-1' # default if all else fails
+    end
+    memoize :region
+
+    # aws sts get-caller-identity
+    def account
+      return '123456789' if test?
+      # ensure region set, required for sts.get_caller_identity.account to work
+      ENV['AWS_REGION'] ||= region
+      begin
+        sts.get_caller_identity.account
+      rescue Aws::Errors::MissingCredentialsError
+        puts "INFO: You're missing AWS credentials. Only local services are currently available"
+      end
+    end
+    memoize :account
+
+    # If bucket does not exist, do not use the cache value and check for the bucket again.
+    # This is because we can build the app before deploying it for the first time.
+    # The deploy sequence ensure an minimal stack exists and will return a s3 bucket
+    # value for real deployments though, just not for the `jets build` only command.
+    BUCKET_DOES_NOT_YET_EXIST = "bucket-does-not-yet-exist" # use const to save from misspellings
+    @@s3_bucket = BUCKET_DOES_NOT_YET_EXIST
+    def s3_bucket
+      return "fake-test-s3-bucket" if ENV['TEST']
+      return @@s3_bucket unless @@s3_bucket == BUCKET_DOES_NOT_YET_EXIST
+
+      resp = cfn.describe_stacks(stack_name: Jets::Naming.parent_stack_name)
+      stack = resp.stacks.first
+      output = stack["outputs"].find { |o| o["output_key"] == "S3Bucket" }
+      @@s3_bucket = output["output_value"] # s3_bucket
+    rescue Exception => e
+      # When user uses Jets::Application.default_iam_policy in their config/application.rb
+      # it looks up the s3 bucket for the iam policy, but the project name has
+      # not been loaded in the config yet.  We do some trickery with loading
+      # the config twice in Application#load_app_config
+      # The first load will result in a Aws::CloudFormation::Errors::ValidationError
+      # since the Jets::Naming.parent_stack_name has not been properly set yet.
+      #
+      # Rescuing all exceptions in case there are other exceptions dont know about yet
+      # Here are the known ones: Aws::CloudFormation::Errors::ValidationError, Aws::CloudFormation::Errors::InvalidClientTokenId
+      BUCKET_DOES_NOT_YET_EXIST
+    end
+
+    def test?
+      ENV['TEST'] || ENV['CIRCLECI']
+    end
+
+    private
+
+    # Cross-platform way of finding an executable in the $PATH.
+    #
+    #   which('ruby') #=> /usr/bin/ruby
+    #
+    # source: https://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby
+    def which(cmd)
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each { |ext|
+          exe = File.join(path, "#{cmd}#{ext}")
+          return exe if File.executable?(exe) && !File.directory?(exe)
+        }
+      end
+      return nil
+    end
+  end
+end

data/lib/jets/aws_services.rb

@@ -0,0 +1,60 @@
+require "aws-sdk-apigateway"
+require "aws-sdk-cloudformation"
+require "aws-sdk-cloudwatchlogs"
+require "aws-sdk-lambda"
+require "aws-sdk-s3"
+require "aws-sdk-sts"
+# Not used in Jets internally but convenient for shared resources
+require "aws-sdk-sns"
+require "aws-sdk-sqs"
+
+module Jets::AwsServices
+  autoload :StackStatus, 'jets/aws_services/stack_status'
+  include StackStatus
+  extend Memoist
+
+  def apigateway
+    Aws::APIGateway::Client.new
+  end
+  memoize :apigateway
+
+  def cfn
+    Aws::CloudFormation::Client.new
+  end
+  memoize :cfn
+
+  def lambda
+    Aws::Lambda::Client.new
+  end
+  memoize :lambda
+
+  def logs
+    Aws::CloudWatchLogs::Client.new
+  end
+  memoize :logs
+
+  def s3
+    Aws::S3::Client.new
+  end
+  memoize :s3
+
+  def s3_resource
+    Aws::S3::Resource.new
+  end
+  memoize :s3_resource
+
+  def sns
+    Aws::SNS::Client.new
+  end
+  memoize :sns
+
+  def sqs
+    Aws::SQS::Client.new
+  end
+  memoize :sqs
+
+  def sts
+    Aws::STS::Client.new
+  end
+  memoize :sts
+end

data/lib/jets/aws_services/stack_status.rb

@@ -0,0 +1,59 @@
+module Jets::AwsServices
+  module StackStatus
+    def stack_exists?(stack_name)
+      return false if ENV['TEST']
+
+      exist = nil
+      begin
+        # When the stack does not exist an exception is raised. Example:
+        # Aws::CloudFormation::Errors::ValidationError: Stack with id blah does not exist
+        resp = cfn.describe_stacks(stack_name: stack_name)
+        exist = true
+      rescue Aws::CloudFormation::Errors::ValidationError => e
+        if e.message =~ /does not exist/
+          exist = false
+        elsif e.message.include?("'stackName' failed to satisfy constraint")
+          # Example of e.message when describe_stack with invalid stack name
+          # "1 validation error detected: Value 'instance_and_route53' at 'stackName' failed to satisfy constraint: Member must satisfy regular expression pattern: [a-zA-Z][-a-zA-Z0-9]*|arn:[-a-zA-Z0-9:/._+]*"
+          puts "Invalid stack name: #{stack_name}"
+          puts "Full error message: #{e.message}"
+          exit 1
+        else
+          raise # re-raise exception  because unsure what other errors can happen
+        end
+      end
+      exist
+    end
+
+    # All CloudFormation states listed here: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html
+    #
+    # Returns resp so we can use it to grab data about the stack without calling api again.
+    def stack_in_progress?(stack_name)
+      return true if !stack_exists?(stack_name)
+
+      # Assumes stack exists
+      resp = cfn.describe_stacks(stack_name: stack_name)
+      status = resp.stacks[0].stack_status
+      if status =~ /_IN_PROGRESS$/
+        puts "The '#{stack_name}' stack status is #{status}. " \
+             "Please wait until the stack is ready and try again.".color(:red)
+        exit 0
+      elsif resp.stacks[0].outputs.empty? && status != 'ROLLBACK_COMPLETE'
+        # This Happens when the miminal stack fails at the very beginning.
+        # There is no s3 bucket at all.  User should delete the stack.
+        puts "The minimal stack failed to create. Please delete the stack first and try again. " \
+        "You can delete the CloudFormation stack or use the `jets delete` command"
+        exit 0
+      else
+        true
+      end
+    end
+
+    # Lookup output value.
+    # Used in Jets::Resource::ApiGateway::RestApi::* andJets::Commands::Url
+    def lookup(outputs, key)
+      out = outputs.find { |o| o.output_key == key }
+      out&.output_value
+    end
+  end
+end

data/lib/jets/booter.rb

@@ -0,0 +1,130 @@
+class Jets::Booter
+  class << self
+    @booted = false
+    def boot!(options={})
+      return if @booted
+
+      turbo_charge
+      confirm_jets_project!
+      require_bundle_gems unless bypass_bundler_setup?
+      Jets::Dotenv.load!
+
+      Jets.application.setup!
+      app_initializers
+      turbine_initializers
+      Jets.application.finish!
+
+      Jets.eager_load!
+      setup_db
+      # build_middleware_stack # TODO: figure out how to build middleware during Jets.boot without breaking jets new and webpacker:install
+
+      @booted = true
+    end
+
+    def bypass_bundler_setup?
+      command = ARGV.first
+      %w[build delete deploy url].include?(command)
+    end
+
+    def turbo_charge
+      turbo = Jets::Turbo.new
+      turbo.charge
+    end
+
+    # Builds and memoize stack so it only gets built on bootup
+    def build_middleware_stack
+      Jets.application.build_stack
+    end
+
+    def turbine_initializers
+      Jets::Turbine.subclasses.each do |subclass|
+        subclass.initializers.each do |label, block|
+          block.call(Jets.application)
+        end
+      end
+    end
+
+    def app_initializers
+      Dir.glob("#{Jets.root}/config/initializers/**/*").each do |path|
+        load path
+      end
+    end
+
+    # require_bundle_gems called when environment boots up via Jets.boot.  It
+    # also useful for when to loading Rake tasks in
+    # Jets::Commands::RakeTasks.load!
+    #
+    # For example, some gems like webpacker that load rake tasks are specified
+    # with a git based source:
+    #
+    #   gem "webpacker", git: "https://github.com/tongueroo/webpacker.git"
+    #
+    # This results in the user having to specific bundle exec in front of
+    # jets for those rake tasks to show up in jets help.
+    #
+    # Instead, when the user is within the project folder, jets automatically
+    # requires bundler for the user. So the rake tasks show up when calling
+    # jets help.
+    #
+    # When the user calls jets help from outside the project folder, bundler
+    # is not used and the load errors get rescued gracefully.  This is done in
+    # Jets::Commands::RakeTasks.load!  In the case when there are in another
+    # project with another Gemfile, the load errors will still be rescued.
+    def require_bundle_gems
+      # NOTE: Dont think ENV['BUNDLE_GEMFILE'] is quite working right.  We still need
+      # to be in the project directory.  Leaving logic in here for when it gets fix.
+      if ENV['BUNDLE_GEMFILE'] || File.exist?("Gemfile")
+        require "bundler/setup"
+        Bundler.require(*bundler_groups)
+      end
+    end
+
+    # Only connects connect to database for ActiveRecord and when
+    # config/database.yml exists.
+    # Dynomite handles connecting to the clients lazily.
+    def setup_db
+      return unless File.exist?("#{Jets.root}/config/database.yml")
+
+      db_configs = Jets.application.config.database
+      # DatabaseTasks.database_configuration for db:create db:migrate tasks
+      # Documented in DatabaseTasks that this is the right way to set it when
+      # using ActiveRecord rake tasks outside of Rails.
+      ActiveRecord::Tasks::DatabaseTasks.database_configuration = db_configs
+
+      current_config = db_configs[Jets.env]
+      if current_config.empty?
+        abort("ERROR: config/database.yml exists but no environment section configured for #{Jets.env}")
+      end
+      # Using ActiveRecord rake tasks outside of Rails, so we need to set up the
+      # db connection ourselves
+      ActiveRecord::Base.establish_connection(current_config)
+    end
+
+    def bundler_groups
+      [:default, Jets.env.to_sym]
+    end
+
+    # Cannot call this for the jets new
+    def confirm_jets_project!
+      unless File.exist?("#{Jets.root}/config/application.rb")
+        puts "It does not look like you are running this command within a jets project.  Please confirm that you are in a jets project and try again.".color(:red)
+        exit 1
+      end
+    end
+
+    def message
+      "Jets booting up in #{Jets.env.color(:green)} mode!"
+    end
+
+    def check_config_ru!
+      config_ru = File.read("#{Jets.root}/config.ru")
+      unless config_ru.include?("Jets.boot")
+        puts 'The config.ru file is missing Jets.boot.  Please add Jets.boot after require "jets"'.color(:red)
+        puts "This was changed as made in Jets v1.1.0."
+        puts "To have Jets update the config.fu file for you, you can run:\n\n"
+        puts "  jets upgrade"
+        exit 1
+      end
+    end
+  end
+end

data/lib/jets/builders.rb

@@ -0,0 +1,16 @@
+class Jets::Builders
+  autoload :CodeBuilder, "jets/builders/code_builder"
+  autoload :CodeSize, "jets/builders/code_size"
+  autoload :GemReplacer, "jets/builders/gem_replacer"
+  autoload :HandlerGenerator, "jets/builders/handler_generator"
+  autoload :LambdaLayer, "jets/builders/lambda_layer"
+  autoload :Md5, "jets/builders/md5"
+  autoload :Md5Zip, "jets/builders/md5_zip"
+  autoload :Purger, "jets/builders/purger"
+  autoload :RackPackager, "jets/builders/rack_packager"
+  autoload :ReconfigureRails, "jets/builders/reconfigure_rails"
+  autoload :RubyPackager, "jets/builders/ruby_packager"
+  autoload :ShimVars, "jets/builders/shim_vars"
+  autoload :Tidy, "jets/builders/tidy"
+  autoload :Util, "jets/builders/util"
+end

data/lib/jets/builders/code_builder.rb

@@ -0,0 +1,379 @@
+require "action_view"
+require "fileutils"
+require "net/http"
+require "open-uri"
+require "socket"
+
+# Some important folders to help understand how jets builds a project:
+#
+# /tmp/jets: build root where different jets projects get built.
+# /tmp/jets/project: each jets project gets built in a different subdirectory.
+#
+# The rest of the folders are subfolders under /tmp/jets/project.
+#
+class Jets::Builders
+  class CodeBuilder
+    include Jets::AwsServices
+    include Util
+    extend Memoist
+
+    attr_reader :full_project_path
+    def initialize
+      # Expanding to the full path and capture now.
+      # Dir.chdir gets called later and we'll lose this info.
+      @full_project_path = File.expand_path(Jets.root) + "/"
+      @version_purger = Purger.new
+    end
+
+    def build
+      check_ruby_version
+      @version_purger.purge
+      cache_check_message
+
+      clean_start
+      compile_assets # easier to do before we copy the project because node and yarn has been likely setup in the that dir
+      compile_rails_assets
+      copy_project
+      Dir.chdir("#{stage_area}/code") do
+        # These commands run from project root
+        code_setup
+        package_ruby
+        code_finish
+      end
+    end
+
+    # Resolves the chicken-and-egg problem with md5 checksums. The handlers need
+    # to reference files with the md5 checksum.  The files are the:
+    #
+    #   jets/code/rack-checksum.zip
+    #   jets/code/opt-checksum.zip
+    #
+    # We compute the checksums before we generate the node shim handlers.
+    def calculate_md5s
+      Md5.compute! # populates Md5.checksums hash
+    end
+
+    def generate_node_shims
+      headline "Generating shims in the handlers folder."
+      # Crucial that the Dir.pwd is in the tmp_code because for
+      # Jets::Builders::app_files because Jets.boot set ups
+      # autoload_paths and this is how project classes are loaded.
+      Jets::Builders::HandlerGenerator.build!
+    end
+
+    def create_zip_files
+      folders = Md5.stage_folders
+      # Md5.stage_folders ["stage/bundled", "stage/code"]
+      folders.each do |folder|
+        zip = Md5Zip.new(folder)
+        if exist_on_s3?(zip.md5_name)
+          puts "Already exists: s3://#{s3_bucket}/jets/code/#{zip.md5_name}"
+        else
+          zip = Md5Zip.new(folder)
+          zip.create
+        end
+      end
+    end
+
+    def exist_on_s3?(filename)
+      s3_key = "jets/code/#{filename}"
+      begin
+        s3.head_object(bucket: s3_bucket, key: s3_key)
+        true
+      rescue Aws::S3::Errors::NotFound
+        false
+      end
+    end
+
+    def code_setup
+      reconfigure_development_webpacker
+    end
+
+    def code_finish
+      # Reconfigure code
+      store_s3_base_url
+      disable_webpacker_middleware
+      copy_internal_jets_code
+
+      # Code prep and zipping
+      check_code_size!
+      calculate_md5s # must be called before generate_node_shims and create_zip_files
+      generate_node_shims
+      create_zip_files
+    end
+
+    def check_code_size!
+      CodeSize.check!
+    end
+
+    # We copy the files into the project because we cannot require simple functions
+    # directly since they are wrapped by an anonymous class.
+    # TODO: Do this with the other files we required the same way.
+    def copy_internal_jets_code
+      files = []
+      files.each do |relative_path|
+        src = File.expand_path("../internal/#{relative_path}", File.dirname(__FILE__))
+        dest = "#{"#{stage_area}/code"}/#{relative_path}"
+        FileUtils.mkdir_p(File.dirname(dest))
+        FileUtils.cp(src, dest)
+      end
+    end
+
+    # Thanks https://stackoverflow.com/questions/9354595/recursively-getting-the-size-of-a-directory
+    # Seems to overestimate a little bit but close enough.
+    def dir_size(folder)
+      Dir.glob(File.join(folder, '**', '*'))
+        .select { |f| File.file?(f) }
+        .map{ |f| File.size(f) }
+        .inject(:+)
+    end
+
+    # Store s3 base url is needed for asset serving from s3 later. Need to package this
+    # as part of the code so we have a reference to it.
+    # At this point the minimal stack exists, so we can grab it with the AWS API.
+    # We do not want to grab this as part of the live request because it is slow.
+    def store_s3_base_url
+      write_s3_base_url("#{stage_area}/code/config/s3_base_url.txt")
+      write_s3_base_url("#{stage_area}/rack/config/s3_base_url.txt") if Jets.rack?
+    end
+
+    def write_s3_base_url(full_path)
+      FileUtils.mkdir_p(File.dirname(full_path))
+      IO.write(full_path, s3_base_url)
+    end
+
+    def s3_base_url
+      # Allow user to set assets.base_url
+      #
+      #   Jets.application.configure do
+      #     config.assets.base_url = "https://cloudfront.com/my/base/path"
+      #   end
+      #
+      return Jets.config.assets.base_url if Jets.config.assets.base_url
+
+      region = Jets.aws.region
+
+      asset_base_url = region == 'us-east-1' ?
+        "https://s3.amazonaws.com" :
+        "https://s3-#{region}.amazonaws.com"
+      "#{asset_base_url}/#{s3_bucket}/jets" # s3_base_url
+    end
+
+    def s3_bucket
+      Jets.aws.s3_bucket
+    end
+
+    def disable_webpacker_middleware
+      full_path = "#{"#{stage_area}/code"}/config/disable-webpacker-middleware.txt"
+      FileUtils.mkdir_p(File.dirname(full_path))
+      FileUtils.touch(full_path)
+    end
+
+    # This happens in the current app directory not the tmp code for simplicity.
+    # This is because the node and yarn has likely been set up correctly there.
+    def compile_assets
+      if ENV['JETS_SKIP_ASSETS']
+        puts "Skip compiling assets".color(:yellow) # useful for debugging
+        return
+      end
+
+      headline "Compling assets in current project directory"
+      return unless webpacker_included?
+
+      sh("yarn install")
+      webpack_command = File.exist?("#{Jets.root}/bin/webpack") ?
+          "bin/webpack" :
+          `which webpack`.strip
+      sh "JETS_ENV=#{Jets.env} #{webpack_command}"
+    end
+
+    def webpacker_included?
+      # Old code, leaving around for now:
+      # Thanks: https://stackoverflow.com/questions/4195735/get-list-of-gems-being-used-by-a-bundler-project
+      # webpacker_loaded = Gem.loaded_specs.keys.include?("webpacker")
+      # return unless webpacker_loaded
+
+      # Checking this way because when using jets standalone for Afterburner mode we don't want to run into
+      # bundler gem collisions.  TODO: figure out the a better way to handle the collisions.
+      lines = IO.readlines("#{Jets.root}/Gemfile")
+      lines.detect { |l| l =~ /webpacker/ }
+    end
+
+    # This happens in the current app directory not the tmp code for simplicity
+    # This is because the node likely been set up correctly there.
+    def compile_rails_assets
+      return unless Jets.rack? && rails? && !rails_api?
+
+      if ENV['JETS_SKIP_ASSETS']
+        puts "Skip compiling rack assets".color(:yellow) # useful for debugging
+        return
+      end
+
+      # Need to capture JETS_ROOT since can be changed by Turbo mode
+      jets_root = Jets.root
+      Bundler.with_clean_env do
+        # Switch gemfile for Afterburner mode
+        gemfile = ENV['BUNDLE_GEMFILE']
+        ENV['BUNDLE_GEMFILE'] = "#{jets_root}/rack/Gemfile"
+        sh "cd #{jets_root} && bundle install"
+        ENV['BUNDLE_GEMFILE'] = gemfile
+
+        rails_assets(:clobber, jets_root: jets_root)
+        rails_assets(:precompile, jets_root: jets_root)
+      end
+    end
+
+    def rails_assets(cmd, jets_root:)
+      # rake is available in both rails 4 and 5. rails command only in 5
+      command = "bundle exec rake assets:#{cmd} --trace"
+      command = "RAILS_ENV=#{Jets.env} #{command}" unless Jets.env.development?
+      sh("cd #{jets_root}/rack && #{command}")
+    end
+
+    # Rudimentary rails detection
+    # Duplicated in builders/reconfigure_rails.rb
+    def rails?
+      config_ru = "#{Jets.root}/rack/config.ru"
+      return false unless File.exist?(config_ru)
+      !IO.readlines(config_ru).grep(/Rails.application/).empty?
+    end
+
+    # Rudimentary rails api detection
+    # Duplicated in builders/reconfigure_rails.rb
+    # Another way of checking is loading a rails console and checking Rails.application.config.api_only
+    # Using this way for simplicity.
+    def rails_api?
+      config_app = "#{Jets.root}/rack/config/application.rb"
+      return false unless File.exist?(config_app)
+      !IO.readlines(config_app).grep(/config.api_only.*=.*true/).empty?
+    end
+
+    # Cleans out non-cached files like code-*.zip in Jets.build_root
+    # for a clean start. Also ensure that the /tmp/jets/project build root exists.
+    #
+    # Most files are kept around after the build process for inspection and
+    # debugging. So we have to clean out the files. But we only want to clean out
+    # some of the files.
+    def clean_start
+      Dir.glob("#{Jets.build_root}/code/code-*.zip").each { |f| FileUtils.rm_f(f) }
+      FileUtils.mkdir_p(Jets.build_root) # /tmp/jets/demo
+    end
+
+    # Copy project into temporary directory. Do this so we can keep the project
+    # directory untouched and we can also remove a bunch of unnecessary files like
+    # logs before zipping it up.
+    def copy_project
+      headline "Copying current project directory to temporary build area: #{"#{stage_area}/code"}"
+      FileUtils.rm_rf("#{build_area}/stage") # clear out from previous build's stage area
+      FileUtils.mkdir_p("#{build_area}/stage")
+      FileUtils.rm_rf("#{stage_area}/code") # remove current code folder
+      move_node_modules(Jets.root, Jets.build_root)
+      begin
+        # puts "cp -r #{@full_project_path} #{"#{stage_area}/code"}".color(:yellow) # uncomment to debug
+        Jets::Util.cp_r(@full_project_path, "#{stage_area}/code")
+      ensure
+        move_node_modules(Jets.build_root, Jets.root) # move node_modules directory back
+      end
+    end
+
+    # Move the node modules to the tmp build folder to speed up project copying.
+    # A little bit risky because a ctrl-c in the middle of the project copying
+    # results in a missing node_modules but user can easily rebuild that.
+    #
+    # Tesing shows 6.623413 vs 0.027754 speed improvement.
+    def move_node_modules(source_folder, dest_folder)
+      source = "#{source_folder}/node_modules"
+      dest = "#{dest_folder}/node_modules"
+      if File.exist?(source)
+        FileUtils.mv(source, dest)
+      end
+    end
+
+    # Bit hacky but this saves the user from accidentally forgetting to change this
+    # when they deploy a jets project in development mode
+    def reconfigure_development_webpacker
+      return unless Jets.env.development?
+      headline "Reconfiguring webpacker development settings for AWS Lambda."
+
+      webpacker_yml = "#{"#{stage_area}/code"}/config/webpacker.yml"
+      return unless File.exist?(webpacker_yml)
+
+      config = YAML.load_file(webpacker_yml)
+      config["development"]["compile"] = false # force this to be false for deployment
+      new_yaml = YAML.dump(config)
+      IO.write(webpacker_yml, new_yaml)
+    end
+
+    def ruby_packager
+      RubyPackager.new(tmp_code)
+    end
+    memoize :ruby_packager
+
+    def rack_packager
+      RackPackager.new("#{tmp_code}/rack")
+    end
+    memoize :rack_packager
+
+    def package_ruby
+      return if Jets.poly_only?
+
+      check_agree
+      ruby_packager.install
+      reconfigure_rails # call here after "#{stage_area}/code" is available
+      rack_packager.install
+      ruby_packager.finish # by this time we have a /tmp/jets/demo/stage/code/vendor/gems
+      rack_packager.finish
+
+      build_lambda_layer
+    end
+
+    def check_agree
+      agree = Jets::Gems::Agree.new
+      agree.prompt
+    end
+
+    def build_lambda_layer
+      return if Jets.poly_only?
+      lambda_layer = LambdaLayer.new
+      lambda_layer.build
+    end
+
+    # TODO: Move logic into plugin instead
+    def reconfigure_rails
+      ReconfigureRails.new("#{"#{stage_area}/code"}/rack").run
+    end
+
+    def cache_check_message
+      if File.exist?("#{Jets.build_root}/cache")
+        puts "The #{Jets.build_root}/cache folder exists. Incrementally re-building the jets using the cache.  To clear the cache: rm -rf #{Jets.build_root}/cache"
+      end
+    end
+
+    def check_ruby_version
+      unless ruby_version_supported?
+        puts "You are using Ruby version #{RUBY_VERSION} which is not supported by Jets."
+        ruby_variant = Jets::RUBY_VERSION.split('.')[0..1].join('.') + '.x'
+        abort("Jets uses Ruby #{Jets::RUBY_VERSION}.  You should use a variant of Ruby #{ruby_variant}".color(:red))
+      end
+    end
+
+    def ruby_version_supported?
+      pattern = /(\d+)\.(\d+)\.(\d+)/
+      md = RUBY_VERSION.match(pattern)
+      ruby = {major: md[1], minor: md[2]}
+      md = Jets::RUBY_VERSION.match(pattern)
+      jets = {major: md[1], minor: md[2]}
+
+      ruby[:major] == jets[:major] && ruby[:minor] == jets[:minor]
+    end
+
+    # Group all the path settings together here
+    def self.tmp_code
+      Jets::Commands::Build.tmp_code
+    end
+
+    def tmp_code
+      self.class.tmp_code
+    end
+  end
+end