jets_bb_fork 0.0.4

data/lib/jets/commands/db/tasks.rb

@@ -0,0 +1,44 @@
+class Jets::Commands::Db::Tasks
+  # Ugly but it loads ActiveRecord database tasks
+  def self.load!
+    # Lazy require rails so Rails const is only defined in jets db:* tasks
+    require "rails"
+    require "active_record"
+    require "recursive-open-struct"
+
+    # Jets.boot # Jets.boot here screws up jets -h, the db_config doesnt seem to match exactly
+    # but seems to be working anyway.
+    db_configs = Jets.application.config.database
+    ActiveRecord::Tasks::DatabaseTasks.database_configuration = db_configs
+    ActiveRecord::Tasks::DatabaseTasks.migrations_paths = ["db/migrate"]
+    ActiveRecord::Tasks::DatabaseTasks.seed_loader = Seeder.new("#{Jets.root}/db/seeds.rb")
+
+    # Need to mock out the usage of Rails.application in:
+    # activerecord-5.1.4/lib/active_record/tasks/database_tasks.rb
+    Rails.application = RecursiveOpenStruct.new(
+      config: {
+        paths: {
+          db: ["db"],
+        }
+      },
+      paths: {
+        "db/migrate": ["db/migrate"]
+      }
+    )
+    load "active_record/railties/databases.rake"
+
+    load File.expand_path("../environment-task.rake", __FILE__)
+  end
+
+  # Thanks: https://stackoverflow.com/questions/19206764/how-can-i-load-activerecord-database-tasks-on-a-ruby-project-outside-rails/24840749
+  class Seeder
+    def initialize(seed_file)
+      @seed_file = seed_file
+    end
+
+    def load_seed
+      raise "Seed file '#{@seed_file}' does not exist" unless File.file?(@seed_file)
+      load @seed_file
+    end
+  end
+end

data/lib/jets/commands/dbconsole.rb

@@ -0,0 +1,131 @@
+# Thanks: Rails dbconsole_command.rb
+module Jets::Commands
+  class Dbconsole
+    def self.start(*args)
+      new(*args).start
+    end
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def start
+      ENV["RAILS_ENV"] ||= @options[:environment] || environment
+
+      case config["adapter"]
+      when /^(jdbc)?mysql/
+        args = {
+          "host"      => "--host",
+          "port"      => "--port",
+          "socket"    => "--socket",
+          "username"  => "--user",
+          "encoding"  => "--default-character-set",
+          "sslca"     => "--ssl-ca",
+          "sslcert"   => "--ssl-cert",
+          "sslcapath" => "--ssl-capath",
+          "sslcipher" => "--ssl-cipher",
+          "sslkey"    => "--ssl-key"
+        }.map { |opt, arg| "#{arg}=#{config[opt]}" if config[opt] }.compact
+
+        if config["password"] && @options["include_password"]
+          args << "--password=#{config['password']}"
+        elsif config["password"] && !config["password"].to_s.empty?
+          args << "-p"
+        end
+
+        args << config["database"]
+
+        find_cmd_and_exec(["mysql", "mysql5"], *args)
+
+      when /^postgres|^postgis/
+        ENV["PGUSER"]     = config["username"] if config["username"]
+        ENV["PGHOST"]     = config["host"] if config["host"]
+        ENV["PGPORT"]     = config["port"].to_s if config["port"]
+        ENV["PGPASSWORD"] = config["password"].to_s if config["password"] && @options["include_password"]
+        find_cmd_and_exec("psql", config["database"])
+
+      when "sqlite3"
+        args = []
+
+        args << "-#{@options['mode']}" if @options["mode"]
+        args << "-header" if @options["header"]
+        args << File.expand_path(config["database"], Jets.root)
+
+        find_cmd_and_exec("sqlite3", *args)
+
+      when "oracle", "oracle_enhanced"
+        logon = ""
+
+        if config["username"]
+          logon = config["username"]
+          logon << "/#{config['password']}" if config["password"] && @options["include_password"]
+          logon << "@#{config['database']}" if config["database"]
+        end
+
+        find_cmd_and_exec("sqlplus", logon)
+
+      when "sqlserver"
+        args = []
+
+        args += ["-D", "#{config['database']}"] if config["database"]
+        args += ["-U", "#{config['username']}"] if config["username"]
+        args += ["-P", "#{config['password']}"] if config["password"]
+
+        if config["host"]
+          host_arg = "#{config['host']}"
+          host_arg << ":#{config['port']}" if config["port"]
+          args += ["-S", host_arg]
+        end
+
+        find_cmd_and_exec("sqsh", *args)
+
+      else
+        abort "Unknown command-line client for #{config['database']}."
+      end
+    end
+
+    def config
+      @config ||= begin
+        if configurations[environment].blank?
+          raise ActiveRecord::AdapterNotSpecified, "'#{environment}' database is not configured. Available configuration: #{configurations.inspect}"
+        else
+          configurations[environment]
+        end
+      end
+    end
+
+    def environment
+      Jets.env.to_s
+    end
+
+    private
+      def configurations # :doc:
+        db_config = Jets.application.config.database
+        ActiveRecord::Base.configurations = db_config
+        ActiveRecord::Base.configurations
+      end
+
+      def find_cmd_and_exec(commands, *args) # :doc:
+        commands = Array(commands)
+
+        dirs_on_path = ENV["PATH"].to_s.split(File::PATH_SEPARATOR)
+        unless (ext = RbConfig::CONFIG["EXEEXT"]).empty?
+          commands = commands.map { |cmd| "#{cmd}#{ext}" }
+        end
+
+        full_path_command = nil
+        found = commands.detect do |cmd|
+          dirs_on_path.detect do |path|
+            full_path_command = File.join(path, cmd)
+            File.file?(full_path_command) && File.executable?(full_path_command)
+          end
+        end
+
+        if found
+          exec full_path_command, *args
+        else
+          abort("Couldn't find database client: #{commands.join(', ')}. Check your $PATH and try again.")
+        end
+      end
+  end
+end

data/lib/jets/commands/delete.rb

@@ -0,0 +1,143 @@
+class Jets::Commands::Delete
+  include Jets::AwsServices
+
+  def initialize(options)
+    @options = options
+  end
+
+  def run
+    puts("Deleting project...")
+    return if @options[:noop]
+
+    are_you_sure?
+
+    confirm_project_exists
+
+    # Must first remove all objects from s3 bucket in order to delete stack
+    puts "First, deleting objects in s3 bucket #{s3_bucket_name}" if s3_bucket_name
+    empty_s3_bucket
+
+    stack_in_progress?(parent_stack_name)
+
+    cfn.delete_stack(stack_name: parent_stack_name)
+    puts "Deleting #{Jets.config.project_namespace.color(:green)}..."
+
+    wait_for_stack if @options[:wait]
+
+    delete_logs
+
+    puts "Project #{Jets.config.project_namespace.color(:green)} deleted!"
+  end
+
+  def wait_for_stack
+    status = Jets::Cfn::Status.new(@options)
+    start_time = Time.now
+    status.wait
+    took = Time.now - start_time
+    puts "Time took for deletion: #{status.pretty_time(took).color(:green)}."
+  end
+
+  def delete_logs
+    puts "Deleting CloudWatch logs"
+    log = Jets::Commands::Clean::Log.new(mute: true, sure: true)
+    log.clean
+  end
+
+  def confirm_project_exists
+    begin
+      resp = cfn.describe_stacks(stack_name: parent_stack_name)
+    rescue Aws::CloudFormation::Errors::ValidationError
+      # Aws::CloudFormation::Errors::ValidationError is thrown when the stack
+      # does not exist
+      puts "The parent stack #{Jets.config.project_namespace.color(:green)} for the project #{Jets.config.project_name.color(:green)} does not exist. So it cannot be deleted."
+      exit 0
+    end
+  end
+
+  def empty_s3_bucket
+    return unless s3_bucket_name # Happens when minimal stack fails to build
+    return unless bucket_exists?(s3_bucket_name)
+
+    resp = s3.list_objects(bucket: s3_bucket_name)
+    if resp.contents.size > 0
+      # IE: objects = [{key: "objectkey1"}, {key: "objectkey2"}]
+      objects = resp.contents.map { |item| {key: item.key} }
+      s3.delete_objects(
+        bucket: s3_bucket_name,
+        delete: {
+          objects: objects,
+          quiet: false,
+        }
+      )
+      empty_s3_bucket # keep deleting objects until bucket is empty
+    end
+  end
+
+  def s3_bucket_name
+    return @s3_bucket_name if defined?(@s3_bucket_name)
+
+    resp = cfn.describe_stacks(stack_name: parent_stack_name)
+    outputs = resp.stacks[0].outputs
+    if outputs.empty?
+      @s3_bucket_name = false
+    else
+      @s3_bucket_name = outputs.find {|o| o.output_key == 'S3Bucket'}.output_value
+    end
+  end
+
+  # Thanks: https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/s3-example-does-bucket-exist.html
+  def bucket_exists?(bucket_name)
+    bucket_exists = false
+    begin
+      resp = s3.head_bucket(bucket: bucket_name, use_accelerate_endpoint: false)
+      bucket_exists = true
+    rescue
+    end
+    bucket_exists
+  end
+
+  def parent_stack_name
+    Jets::Naming.parent_stack_name
+  end
+
+  def are_you_sure?
+    if @options[:sure]
+      sure = 'y'
+    else
+      puts "Are you sure you want to want to delete the #{Jets.config.project_namespace.color(:green)} project? (y/N)"
+      sure = $stdin.gets
+    end
+
+    unless sure =~ /^y/
+      puts "Phew! Jets #{Jets.config.project_namespace.color(:green)} project was not deleted."
+      exit 0
+    end
+  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 check_deleteable_status
+      return true if !stack_exists?(@parent_stack_name)
+
+      # Assumes stack exists
+      resp = cfn.describe_stacks(stack_name: @parent_stack_name)
+      status = resp.stacks[0].stack_status
+
+      return true if status == 'ROLLBACK_COMPLETE'
+
+      if status =~ /_IN_PROGRESS$/
+        puts "The '#{@parent_stack_name}' stack status is #{status}. " \
+             "It is not in an updateable status. Please wait until the stack is ready and try again.".color(:red)
+        exit 0
+      elsif resp.stacks[0].outputs.empty?
+        # 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
+end

data/lib/jets/commands/deploy.rb

@@ -0,0 +1,141 @@
+module Jets::Commands
+  class Deploy
+    extend Memoist
+    include StackInfo
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      deployment_env = Jets.config.project_namespace.color(:green)
+      puts "Deploying to Lambda #{deployment_env} environment..."
+      return if @options[:noop]
+
+      check_dev_mode
+      validate_routes!
+
+      # deploy full nested stack when stack already exists
+      # Delete existing rollback stack from previous bad minimal deploy
+      delete_minimal_stack if minimal_rollback_complete?
+      exit_unless_updateable! # Stack could be in a weird rollback state or in progress state
+
+      if first_run?
+        ship(stack_type: :minimal)
+        Jets.application.reload_configs!
+      end
+
+      # Build code after the minimal stack because need s3 bucket for assets
+      # on_aws? and s3_base_url logic
+      # TODO: possible deploy hook point: before_build
+      build_code
+
+      # TODO: possible deploy hook point: before_ship
+      create_s3_event_buckets
+      ship(stack_type: :full, s3_bucket: s3_bucket)
+    end
+
+    def create_s3_event_buckets
+      buckets = Jets::Job::Base.s3_events.keys
+      buckets.each do |bucket|
+        Jets::AwsServices::S3Bucket.ensure_exists(bucket)
+      end
+    end
+
+    def delete_minimal_stack
+      puts "Existing stack is in ROLLBACK_COMPLETE state from a previous failed minimal deploy. Deleting stack and continuing."
+      cfn.delete_stack(stack_name: stack_name)
+      status.wait
+      status.reset
+    end
+
+    def check_dev_mode
+      if File.exist?("#{Jets.root}/dev.mode")
+        puts "The dev.mode file exists. Please removed it and run bundle update before you deploy.".color(:red)
+        exit 1
+      end
+    end
+
+    def build_code
+      Jets::Commands::Build.new(@options).build_code
+    end
+
+    def validate_routes!
+      check_route_connected_functions
+    end
+
+    # Checks that all routes are validate and have corresponding lambda functions
+    def check_route_connected_functions
+      return if Jets::Router.all_routes_valid
+
+      puts "Deploy fail: The jets application contain invalid routes.".color(:red)
+      puts "Please double check the routes below map to valid controllers:"
+      Jets::Router.invalid_routes.each do |route|
+        puts "  /#{route.path} => #{route.controller_name}##{route.action_name}"
+      end
+      exit 1
+    end
+
+    def ship(stack_options)
+      options = @options.merge(stack_options) # includes stack_type and s3_bucket
+      Jets::Commands::Build.new(options).build_templates
+      Jets::Cfn::Ship.new(options).run
+    end
+
+    def status
+      Jets::Cfn::Status.new(stack_name)
+    end
+    memoize :status
+
+    def stack_name
+      Jets::Naming.parent_stack_name
+    end
+
+    # Checks for a few things before deciding to delete the parent stack
+    #
+    #   * Parent stack status status is ROLLBACK_COMPLETE
+    #   * Parent resources are in the DELETE_COMPLETE state
+    #
+    def minimal_rollback_complete?
+      stack = find_stack(stack_name)
+      return false unless stack
+
+      return false unless stack.stack_status == 'ROLLBACK_COMPLETE'
+
+      # Finally check if all the minimal resources in the parent template have been deleted
+      resp = cfn.describe_stack_resources(stack_name: stack_name)
+      resource_statuses = resp.stack_resources.map(&:resource_status).uniq
+      resource_statuses == ['DELETE_COMPLETE']
+    end
+
+    def find_stack(stack_name)
+      resp = cfn.describe_stacks(stack_name: stack_name)
+      resp.stacks.first
+    rescue Aws::CloudFormation::Errors::ValidationError => e
+      # example: Stack with id demo-dev does not exist
+      if e.message =~ /Stack with/ && e.message =~ /does not exist/
+        nil
+      else
+        raise
+      end
+    end
+
+    # All CloudFormation states listed here: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html
+    def exit_unless_updateable!
+      stack_name = Jets::Naming.parent_stack_name
+      exists = stack_exists?(stack_name)
+      return unless exists # continue because stack could be updating
+
+      stack = cfn.describe_stacks(stack_name: stack_name).stacks.first
+      status = stack["stack_status"]
+      if status =~ /^ROLLBACK_/ ||
+         status =~ /_IN_PROGRESS$/
+        region = `aws configure get region`.strip rescue "us-east-1"
+        url = "https://console.aws.amazon.com/cloudformation/home?region=#{region}#/stacks"
+        puts "The parent stack of the #{Jets.config.project_name.color(:green)} project is not in an updateable state."
+        puts "Stack name #{stack_name.color(:yellow)} status #{stack["stack_status"].color(:yellow)}"
+        puts "Here's the CloudFormation url to check for more details #{url}"
+        exit 1
+      end
+    end
+  end
+end