jets_bb_fork 0.0.4

data/lib/jets/commands/call/autoload_guesser.rb

@@ -0,0 +1,136 @@
+class Jets::Commands::Call
+  class AutoloadGuesser < BaseGuesser
+    def detect_class_name
+      # First guess the class name assuming simple
+      class_name = simple_detect_class_name
+      return class_name if class_name
+
+      guess_classes.each do |class_name_guess|
+        begin
+          class_name_guess.constantize
+          return class_name_guess # if there's no error then the class is found
+        rescue NameError
+          if out_of_guesses(class_name_guess)
+            # puts "Unable to find the class to call. Tried guessing: #{guess_classes[0..-2].join(', ')}."
+            # raise # re-raise NameError for now but maybe better to provide
+              # a custom error class, so we can rescue it and provide a
+              # friendly message to the user
+          else
+            next
+          end
+        end
+      end
+
+      nil
+    end
+
+    # Can guess name by looking at underscore and dashes.
+    #
+    # Example:
+    #
+    #   @provided_function_name: first_module-lost_controller-index
+    #   return: FirstModule::LostController
+    #
+    def simple_detect_class_name
+      parts = @provided_function_name.split('-')
+      namespace = parts[0..-3].join('/')
+      controller = parts[-2..-2] # dont include the action
+      class_name = [namespace, controller].reject {|s| s.empty?}.compact.join('/').camelize
+      begin
+        class_name.constantize
+        return class_name
+      rescue NameError
+        nil
+      end
+    end
+
+    def method_name
+      return @method_name if defined?(@method_name)
+      return nil unless class_name
+
+      underscored_class_name = class_name.underscore.gsub('/','_')
+      underscored_function_name = @provided_function_name.underscore.gsub('/','_')
+      meth = underscored_function_name.sub(underscored_class_name, '')
+      meth = meth.sub(/^[-_]/,'') # remove leading _ or -
+
+      if class_name.constantize.tasks.map(&:meth).include?(meth.to_sym)
+        @method_name = meth
+      else
+        @method_name_error ="#{class_name} class found but #{meth} method not found"
+        @method_name = nil
+      end
+    end
+
+    # Useful to printing out what was attempted to look up
+    def error_message
+      guesses = guess_classes
+      puts "Unable to find the function to call."
+      if class_name and !method_name
+        puts @method_name_error
+      else
+        puts "Tried: #{guesses.join(', ')}"
+      end
+    end
+
+    def process_type
+      if @provided_function_name =~ /[-_]controller/
+        "controller"
+      elsif @provided_function_name =~ /[-_]job/
+        "job"
+      elsif @provided_function_name =~ /[-_]rule/
+        "rule"
+      else
+        "function"
+      end
+    end
+
+    def process_type_pattern
+      Regexp.new("[-_]#{process_type}[-_](.*)")
+    end
+
+    # Strips the action because we dont want it to guess the class name
+    # So:
+    #   admin-related-pages => admin_related_pages_controller
+    def underscored_name
+      # strip action and concidentally the _controller_ string
+      name = @provided_function_name.sub(process_type_pattern,'')
+      # Ensure _controller or _job at the end except for simple functions
+      unless process_type == "function"
+        name = name.gsub('-','_') + "_#{process_type}"
+      end
+      name
+    end
+
+    # Guesses autoload paths.
+    #
+    # underscored_name: admin_related_pages_controller
+    # Returns:
+    #   [
+    #     "admin_related_pages_controller",
+    #     "admin/related_pages_controller",
+    #     "admin_related/pages_controller",
+    #     "admin_related_pages/controller",
+    #   ]
+    def autoload_paths
+      guesses = []
+
+      parts = underscored_name.split('_')
+      parts.size.times do |i|
+        namespace = i == 0 ? nil : parts[0..i-1].join('/')
+        class_path = parts[i..-1].join('_')
+        guesses << [namespace, class_path].compact.join('/')
+      end
+
+      guesses
+    end
+
+    def guess_classes
+      autoload_paths.map(&:classify)
+    end
+
+    def out_of_guesses(guess)
+      guess.include?("::Controller")
+    end
+
+  end
+end

data/lib/jets/commands/call/base_guesser.rb

@@ -0,0 +1,60 @@
+# Subclasses of BaseGuessor must implement interface:
+#   detect_class_name
+#   method_name
+#   error_message
+#
+class Jets::Commands::Call
+  class BaseGuesser
+    include Jets::AwsServices
+
+    # provided_function_name:
+    #   admin/related_pages_controller-list_all
+    #   admin-related-pages-controller-list-all
+    def initialize(provided_function_name)
+      @provided_function_name = provided_function_name
+    end
+
+    def class_name
+      return @class_name if @detection_ran
+
+      @class_name = detect_class_name
+      @detection_ran = true
+      @class_name
+    end
+
+    def function_name
+      # Strip the project namespace if the user has accidentally added it
+      # Since we're going to automatically add it no matter what at the end
+      # and dont want the namespace to be included twice
+      @provided_function_name = @provided_function_name.sub("#{Jets.config.project_namespace}-", "")
+
+      code_path = class_name.underscore.gsub('/','-')
+      function_name = [Jets.config.project_namespace, code_path, method_name].join('-')
+      generated_function_name(function_name)
+    end
+
+    def generated_function_name(function_name)
+      if function_name.size > Jets::MAX_FUNCTION_NAME_SIZE # name generated by CloudFormation
+        logical_id = @class_name.gsub('::','')
+        app_stack_arn = lookup(parent_stack[:outputs], logical_id)
+
+        resources = stack_resources(app_stack_arn)
+        resource = resources.find { |r| r.logical_resource_id == method_name.camelize + "LambdaFunction" } # method_name only contains the method
+        resource.physical_resource_id # actual function name
+      else
+        function_name
+      end
+    end
+
+    # Class variable caches
+    @@stack_resources = {}
+    def stack_resources(stack_name)
+      @@stack_resources[stack_name] ||= cfn.describe_stack_resources(stack_name: stack_name).stack_resources
+    end
+
+    @@parent_stack = nil
+    def parent_stack
+      @@parent_stack ||= cfn.describe_stacks(stack_name: Jets::Naming.parent_stack_name).stacks.first
+    end
+  end
+end

data/lib/jets/commands/call/guesser.rb

@@ -0,0 +1,48 @@
+# Guesser transforms the user provided function name to the actual lambda
+# function name.
+#
+# Allow for variety of different inputs to work:
+# Simple:
+#   admin/pages_controller-index => admin-pages_controller-index
+#   admin-pages_controller-index => admin-pages_controller-index
+#
+# Complex, requires detecting the right class name:
+#   admin/related_pages_controller-list_all
+#   admin-related-pages-controller-list-all
+#
+# All still result in: admin-related_pages_controller-index
+#
+# The detection process follows. Given worse case:
+#   admin-related-pages-controller-list-all
+#
+# Know that the action comes after controller, try:
+#   AdminRelatedPagesController
+#   Admin::RelatedPagesController <= found stop guessing
+#
+# admin/related_pages_controller <= underscored
+# admin/related_pages_controller-list_all <= add action back on
+# admin-related_pages_controller-list_all <= gsub / - DONE
+#
+# Now we're at a point where we can start guessing
+# function_name = detect_function_name(function_name)
+class Jets::Commands::Call
+  class Guesser
+    delegate :class_name, :method_name, :error_message, :function_name,
+      to: :delegate_guesser
+
+    # Example of provided_function_name:
+    #   admin/related_pages_controller-list_all
+    #   admin-related-pages-controller-list-all
+    def initialize(provided_function_name)
+      @provided_function_name = provided_function_name
+    end
+
+    def delegate_guesser
+      @delegate_guesser ||= if @provided_function_name =~ /[-_](controller|job|rule)/
+                              AutoloadGuesser.new(@provided_function_name)
+                            else
+                              AnonymousGuesser.new(@provided_function_name)
+                            end
+    end
+  end
+end

data/lib/jets/commands/clean.rb

@@ -0,0 +1,19 @@
+module Jets::Commands
+  class Clean < Jets::Commands::Base
+    class_option :noop, type: :boolean, desc: "noop or dry-run mode"
+    class_option :mute, type: :boolean, desc: "mute output"
+    class_option :sure, type: :boolean, desc: "bypass are you sure prompt"
+
+    desc "log", "Cleans CloudWatch log groups assocated with app"
+    long_desc Help.text('clean:log')
+    def log
+      Log.new(options).clean
+    end
+
+    desc "build", "Cleans jets build"
+    long_desc Help.text('clean:build')
+    def build
+      Build.new(options).clean
+    end
+  end
+end

data/lib/jets/commands/clean/base.rb

@@ -0,0 +1,24 @@
+class Jets::Commands::Clean
+  class Base
+    def initialize(options={})
+      @options = options
+    end
+
+  private
+    def say(message)
+      prefix = 'NOOP ' if @options[:noop]
+      puts "#{prefix}#{message}" unless @options[:mute]
+    end
+
+    def are_you_sure?(message)
+      return true if @options[:sure]
+
+      puts "Are you sure that you want to #{message}? (y/N)"
+      yes = $stdin.gets.strip
+      unless yes =~ /^y/
+        puts "Phew that was close!"
+        exit 0
+      end
+    end
+  end
+end

data/lib/jets/commands/clean/build.rb

@@ -0,0 +1,13 @@
+require 'fileutils'
+
+class Jets::Commands::Clean
+  class Build < Base
+    def clean
+      are_you_sure?("delete /tmp/jets")
+
+      say "Removing /tmp/jets..."
+      FileUtils.rm_rf("/tmp/jets") unless @options[:noop]
+      say "Removed /tmp/jets"
+    end
+  end
+end

data/lib/jets/commands/clean/log.rb

@@ -0,0 +1,107 @@
+# The thing that limits this implementation is that there needs to be at least
+# one lambda function created from an internal jets function. Example:
+#
+#   /aws/lambda/demo-dev-2-jets-preheat_job-warm
+#   /aws/lambda/demo-dev-2-jets-public_controller-show
+#
+# We're doing this because JETS_ENV_EXTRA environments can create additional matching
+# log groups and we don't want to overly-aggressively delete them.
+#
+# The `keep_prefixes(log_group_names)` method calcuates the log groups to keep.
+class Jets::Commands::Clean
+  class Log < Base
+    extend Memoist
+    include Jets::AwsServices
+
+    def clean
+      are_you_sure?("delete CloudWatch logs")
+
+      say "Removing CloudWatch logs for #{prefix_guess}..."
+      log_groups.each do |g|
+        next if keep_log_group?(g.log_group_name)
+        logs.delete_log_group(log_group_name: g.log_group_name) unless @options[:noop]
+        say "Removed log group: #{g.log_group_name}"
+      end
+      say "Removed CloudWatch logs for #{prefix_guess}"
+    end
+
+    def clean_deploys
+      groups = deploy_log_groups.sort_by do |g|
+        g.log_group_name
+      end
+      # Keep the last 2 recent log groups so we can see the deleted logic
+      groups = groups[0..-3]
+      groups.each do |g|
+        logs.delete_log_group(log_group_name: g.log_group_name) unless @options[:noop]
+      end
+    end
+
+    def deploy_log_groups
+      log_groups.select do |g|
+        !keep_log_group?(g.log_group_name) &&
+        g.log_group_name.include?('jets-base-path')
+      end
+    end
+
+  private
+    def prefix_guess
+      Jets::Naming.parent_stack_name
+    end
+
+    def log_groups
+      groups, next_token = [], true
+      while next_token
+        next_token = nil if next_token == true # just at start the loop
+        resp = logs.describe_log_groups(
+          log_group_name_prefix: "/aws/lambda/#{prefix_guess}-",
+          next_token: next_token,
+        )
+        groups += resp.log_groups
+        next_token = resp.next_token
+      end
+      groups
+    end
+    memoize :log_groups
+
+    def log_group_names
+      log_groups.map(&:log_group_name)
+    end
+
+    def all_prefixes(log_group_names)
+      log_prefixes(log_group_names)
+    end
+    memoize :all_prefixes
+
+    # Check for the prefixes to keep. The slightly tricky thing to watch for is
+    # for the prefix matching addiitonal log groups that belong to other
+    # JETS_ENV_EXTRA=xxx created environments.
+    #
+    # We find and store the prefixes to keep so we don't over aggressively delete
+    # log groups.
+    def keep_prefixes(log_group_names)
+      names = log_group_names.reject do |name|
+        name =~ %r{/aws/lambda/#{prefix_guess}-jets}
+      end
+      log_prefixes(names)
+    end
+    memoize :keep_prefixes
+
+    # Strips -jets.* from the full log group name to leave only the prefix behind
+    def log_prefixes(names)
+      names = names.select do |name|
+        name.match(Regexp.new("#{prefix_guess}-.*jets"))
+      end
+      names.map do |name|
+        name.sub(/-jets.*/,'')
+      end.uniq.sort
+    end
+
+    # Check if it is safe to delete the log group
+    def keep_log_group?(log_group_name)
+      keep_prefixes = keep_prefixes(log_group_names)
+      !!keep_prefixes.detect do |keep_prefix|
+        log_group_name =~ Regexp.new(keep_prefix)
+      end
+    end
+  end
+end

data/lib/jets/commands/console.rb

@@ -0,0 +1,12 @@
+class Jets::Commands::Console
+  def self.run
+    puts Jets::Booter.message
+
+    # Thanks: https://mutelight.org/bin-console
+    require "irb"
+    require "irb/completion"
+
+    ARGV.clear # https://stackoverflow.com/questions/33070092/irb-start-not-starting/33136762
+    IRB.start
+  end
+end

data/lib/jets/commands/db.rb

@@ -0,0 +1,13 @@
+module Jets::Commands
+  class Db < Jets::Commands::Base
+    desc "generate", "Creates a migration to change a db table"
+    long_desc Help.text('db:generate')
+    def generate(*args)
+      require "rails/generators"
+      require "rails/generators/active_record/migration/migration_generator"
+
+      generator = ActiveRecord::Generators::MigrationGenerator.new(args)
+      generator.create_migration_file
+    end
+  end
+end

data/lib/jets/commands/db/environment-task.rake

@@ -0,0 +1,3 @@
+task :environment do
+  Jets.boot
+end