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

data/lib/jets/commands/base.rb

@@ -0,0 +1,145 @@
+require "thor"
+
+# Override thor's long_desc identation behavior
+# https://github.com/erikhuda/thor/issues/398
+class Thor
+  module Shell
+    class Basic
+      def print_wrapped(message, options = {})
+        message = "\n#{message}" unless message.starts_with?("\n")
+        stdout.puts message
+      end
+    end
+  end
+end
+
+class Jets::Commands::Base < Thor
+  class << self
+    extend Memoist
+
+    # thor_args is an array of commands. Examples:
+    #   ["help"]
+    #   ["dynamodb:migrate"]
+    #
+    # Same signature as RakeCommand.perform.  Not using full_command.
+    def perform(full_command, thor_args)
+      config = {} # doesnt seem like config is used
+      dispatch(nil, thor_args, nil, config)
+    end
+
+    # Hacky way to handle error for 'jets new' when no project name is passed in to avoid
+    # this error:
+    #
+    #   required arguments 'project_name' (Thor::RequiredArgumentMissingError)
+    def dispatch(command, given_args, given_opts, config)
+      if given_args.reject{|s| s =~ /^-/} == ['new'] # user forgot to pass a project name
+        given_args = ['help', 'new']
+      end
+      super
+    end
+
+    # Track all command subclasses.
+    def subclasses
+      @subclasses ||= []
+    end
+
+    def inherited(base)
+      super
+
+      if base.name
+        self.subclasses << base
+      end
+    end
+
+    # Fully qualifed task names. Examples:
+    #   build
+    #   process:controller
+    #   dynamodb:migrate:down
+    def namespaced_commands
+      eager_load!
+      subclasses.map do |klass|
+        # This all_tasks is part of Thor not the lambda/dsl.rb
+        klass.all_tasks.keys.map do |task_name|
+          klass = klass.to_s.sub('Jets::Commands::','')
+          namespace = klass =~ /^Main/ ? nil : klass.underscore.gsub('/',':')
+          [namespace, task_name].compact.join(':')
+        end
+      end.flatten.sort
+    end
+
+    # Use Jets banner instead of Thor to account for namespaces in commands.
+    def banner(command, namespace = nil, subcommand = false)
+      namespace = namespace_from_class(self)
+      command_name = command.usage # set with desc when defining tht Thor class
+      namespaced_command = [namespace, command_name].compact.join(':')
+
+      "jets #{namespaced_command}"
+    end
+
+    def namespace_from_class(klass)
+      namespace = klass.to_s.sub('Jets::Commands::', '').underscore.gsub('/',':')
+      namespace unless namespace == "main"
+    end
+
+    def help_list(all=false)
+      # hack to show hidden comands when requested
+      Thor::HiddenCommand.class_eval do
+        def hidden?; false; end
+      end if all
+
+      list = []
+      eager_load!
+      subclasses.each do |klass|
+        commands = klass.printable_commands(true, false)
+        commands.reject! { |array| array[0].include?(':help') }
+        list += commands
+      end
+
+      list.sort_by! { |array| array[0] }
+    end
+
+    def klass_from_namespace(namespace)
+      if namespace.nil?
+        Jets::Commands::Main
+      else
+        class_name = namespace.gsub(':','/')
+        class_name = "Jets::Commands::#{class_name.camelize}"
+        class_name.constantize
+      end
+    end
+
+    # If this fails to find a match then return the original full command
+    def autocomplete(full_command)
+      return nil if full_command.nil? # jets help
+
+      eager_load!
+
+      words = full_command.split(':')
+      namespace = words[0..-2].join(':') if words.size > 1
+      command = words.last
+
+      # Thor's normalize_command_name autocompletes the command but then we need to add the namespace back
+      begin
+        thor_subclass = klass_from_namespace(namespace) # could NameError
+        command = thor_subclass.normalize_command_name(command) # could Thor::AmbiguousCommandError
+        [namespace, command].compact.join(':')
+      rescue NameError
+        full_command # return original full_command
+      rescue Thor::AmbiguousCommandError => e
+        puts "Unable to autodetect the command name. #{e.message}."
+        full_command # return original full_command
+      end
+    end
+
+    # For help menu to list all commands, we must eager load the command classes.
+    #
+    # There is special eager_load logic here because this is called super early as part of the CLI start.
+    # We cannot assume we have full access to to the project yet.
+    def eager_load!
+      return if Jets::Turbo.afterburner?
+
+      Jets::Autoloaders.cli.eager_load
+    end
+    memoize :eager_load!
+  end
+end

data/lib/jets/commands/build.rb

@@ -0,0 +1,252 @@
+require 'digest'
+
+module Jets::Commands
+  class Build
+    include StackInfo
+
+    def initialize(options)
+      @options = options.dup
+    end
+
+    def run
+      puts "Building project for Lambda..."
+
+      return if @options[:noop]
+      # run gets called from the CLI and does not have all the stack_options yet.
+      # We compute it and change the options early here.
+      @options.merge!(stack_type: stack_type, s3_bucket: s3_bucket)
+      build
+    end
+
+    def build
+      build_code unless @options[:templates]
+      build_templates
+    end
+
+    def build_code
+      Jets::Builders::CodeBuilder.new.build unless @options[:noop]
+    end
+
+    def build_templates
+      puts "Building CloudFormation templates."
+      clean_templates
+      build_minimal_template
+      build_all_templates if full?
+      puts "Generated CloudFormation templates at #{Jets.build_root}/templates"
+    end
+
+    def full?
+      @options[:templates] || @options[:stack_type] == :full
+    end
+
+    def build_all_templates
+      # CloudFormation templates
+      # 1. Shared and authorizer templates - child templates needs them
+      build_api_gateway_templates
+      build_authorizer_templates # controllers can use these
+      # 2. Child templates - parent template needs them
+      build_app_child_templates
+      # 2. Child templates - parent template needs them
+      build_shared_resources_templates
+      # 4. Finally parent template
+      build_parent_template # must be called at the end
+    end
+
+    def build_minimal_template
+      Jets::Cfn::Builders::ParentBuilder.new(@options).build(parent=true)
+    end
+
+    def build_api_gateway_templates
+      Jets::Cfn::Builders::ApiGatewayBuilder.new(@options).build
+      Jets::Cfn::Builders::ApiDeploymentBuilder.new(@options).build
+    end
+
+    def build_authorizer_templates
+      authorizer_files.each do |path|
+        Jets::Cfn::Builders::AuthorizerBuilder.new(path).build
+      end
+    end
+
+    def build_app_child_templates
+      app_files.each do |path|
+        build_child_template(path)
+      end
+    end
+
+    def build_shared_resources_templates
+      Jets::Stack.subclasses.each do |subclass|
+        Jets::Cfn::Builders::SharedBuilder.new(subclass).build
+      end
+    end
+
+    # path: app/controllers/comments_controller.rb
+    # path: app/jobs/easy_job.rb
+    def build_child_template(path)
+      return if authorizer?(path) # AuthorizerBuilder is built earlier
+
+      md = path.match(%r{app/(.*?)/}) # extract: controller, job or function
+      process_class = md[1].classify
+      builder_class = "Jets::Cfn::Builders::#{process_class}Builder".constantize
+
+      # Examples:
+      #   Jets::Cfn::Builders::ControllerBuilder.new(PostsController)
+      #   Jets::Cfn::Builders::JobBuilder.new(EasyJob)
+      #   Jets::Cfn::Builders::RuleBuilder.new(CheckRule)
+      #   Jets::Cfn::Builders::FunctionBuilder.new(Hello)
+      #   Jets::Cfn::Builders::FunctionBuilder.new(HelloFunction)
+      app_class = Jets::Klass.from_path(path)
+      if Jets.poly_only? && app_class == Jets::PreheatJob
+        return # No prewarm when there's only poly functions
+      end
+
+      builder = builder_class.new(app_class)
+      builder.build
+    end
+
+    def authorizer?(path)
+      path.include?("app/authorizers")
+    end
+
+    def build_parent_template
+      Jets::Cfn::Builders::ParentBuilder.new(@options).build(parent=true)
+    end
+
+    def clean_templates
+      FileUtils.rm_rf("#{Jets.build_root}/templates")
+    end
+
+    def app_files
+      self.class.app_files
+    end
+
+    def shared_files
+      self.class.shared_files
+    end
+
+    def authorizer_files
+      self.class.authorizer_files
+    end
+
+    class << self
+      # Crucial that the Dir.pwd is in the tmp_code because for because Jets.boot set ups autoload_paths and this is
+      # how project classes are loaded.
+      # TODO: rework code so that Dir.pwd does not have to be in tmp_code for build to work.
+      #
+      # app_files used to determine what CloudFormation templates to build.
+      # app_files also used to determine what handlers to build.
+      def app_files
+        paths = []
+        expression = "#{Jets.root}/app/**/**/*.rb"
+        Dir.glob(expression).each do |path|
+          next unless app_file?(path)
+          relative_path = path.sub("#{Jets.root}/", '') # rid of the Jets.root at beginning
+          paths << relative_path
+        end
+        paths += internal_app_files
+        paths
+      end
+
+      APP_FOLDERS = %w[authorizers controllers functions jobs rules]
+      def app_file?(path)
+        return false unless File.extname(path) == ".rb"
+        return false unless File.file?(path) unless Jets.env.test?
+        return false if application_abstract_classes.detect { |p| path.include?(p) }
+        return false if concerns?(path)
+        return true if APP_FOLDERS.detect { |p| path.include?("app/#{p}") }
+        false
+      end
+
+      # Do not define lamda functions for abstract application parent classes. Examples:
+      #
+      #   application_controller.rb
+      #   application_job.rb
+      #   application_authorizer.rb
+      def application_abstract_classes
+        APP_FOLDERS.map { |a| "application_#{a.singularize}.rb" }
+      end
+
+      def concerns?(path)
+        path =~ %r{app/\w+/concerns/}
+      end
+
+      def authorizer_files
+        app_files.select { |p| p.include?("app/authorizers") }
+      end
+
+      def shared_files
+        find_app_paths("shared/resources")
+      end
+
+      def find_app_paths(app_path)
+        paths = []
+        expression = "#{Jets.root}/app/#{app_path}/**/*.rb"
+        Dir.glob(expression).each do |path|
+          return false unless File.file?(path)
+
+          relative_path = path.sub("#{Jets.root}/", '')
+          # Rids of the Jets.root at beginning
+          paths << relative_path
+        end
+        paths
+      end
+
+      # Finds out of the app has polymorphic functions only and zero ruby functions.
+      # In this case, we can skip a lot of the ruby related building and speed up the
+      # deploy process.
+      def poly_only?
+        !app_has_ruby? && !shared_has_ruby?
+      end
+
+      def app_has_ruby?
+        has_ruby = app_files.detect do |path|
+          app_class = Jets::Klass.from_path(path)  # IE: PostsController, Jets::PublicController
+          langs = app_class.tasks.map(&:lang)
+          langs.include?(:ruby) && app_class != Jets::PreheatJob
+        end
+        !!has_ruby
+      end
+
+      def shared_has_ruby?
+        has_ruby = false
+        Jets::Stack.subclasses.each do |klass|
+          klass.functions.each do |fun|
+            if fun.lang == :ruby
+              has_ruby = true
+              break
+            end
+          end
+        end
+        has_ruby
+      end
+
+      # Add internal Jets controllers if they are being used
+      # TODO: Interesting, this eventually just used to generate handlers and controllers only.
+      # Maybe rename to make that clear.
+      # The copying of other internal files like views is done in builders/code_builder.rb copy_internal_jets_code
+      def internal_app_files
+        paths = []
+        internal = File.expand_path("../internal", __dir__)
+
+        controllers = "#{internal}/app/controllers/jets"
+        paths << "#{controllers}/public_controller.rb" if router_has?("Jets::PublicController")
+        paths << "#{controllers}/rack_controller.rb" if router_has?("Jets::RackController")
+        paths << "#{controllers}/mailers_controller.rb" if router_has?("Jets::MailersController")
+        paths << "#{controllers}/mount_controller.rb" if router_has?("Jets::MountController")
+
+        if Jets.config.prewarm.enable
+          paths << "#{internal}/app/jobs/jets/preheat_job.rb"
+        end
+
+        paths
+      end
+
+      def router_has?(controller)
+        Jets::Router.has_controller?(controller)
+      end
+
+      def tmp_code(full_build_path=false)
+        full_build_path ? "#{Jets.build_root}/stage/code" : "stage/code"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+class Jets::Commands::Call
+  class AnonymousGuesser < BaseGuesser
+    def detect_class_name
+      found_path = function_paths.find do |path|
+        File.exist?("#{Jets.root}/#{path}")
+      end
+
+      klass = Jets::Klass.from_path(found_path) if found_path
+      klass.to_s
+    end
+
+    def method_name
+      return @method_name if defined?(@method_name)
+
+      full_function_name = @provided_function_name.underscore
+      underscored_class_name = class_name.underscore
+      meth = full_function_name.sub("#{underscored_class_name}_","")
+
+      if meth == class_name.constantize.handler.to_s
+        @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
+      guess_paths = function_paths
+      puts "Unable to find the function to call."
+      if class_name and !method_name
+        puts @method_name_error
+      else
+        puts "Tried: #{guess_paths.join(', ')}"
+      end
+    end
+
+    def function_filenames(meth=nil, primary_namespace=nil)
+      guesses = []
+      parts = meth.split('_')
+
+      if primary_namespace.nil?
+        guesses << meth
+
+        if parts.size == 1 # already on final_primary_namespace
+          return guesses # end of recursion
+        else
+          next_primary_namespace =  parts.first
+          guesses += function_filenames(meth, next_primary_namespace) # start of recursion
+          return guesses # return early
+        end
+      end
+
+      next_meth = meth.sub("#{primary_namespace}_", '')
+      next_parts = next_meth.split('_')
+
+      # Takes the next_parts and creates guesses with the parts joined by '/'
+      # with the primary_namespace prepended.  So if next_parts is
+      # ["long", "name", "function"] and primary_namespace is "complex"
+      #
+      # guesses that get added:
+      #
+      #   [
+      #     "complex/long_name_function",
+      #     "complex/long/name_function",
+      #     "complex/long/name/function",
+      #   ]
+      n = next_parts.size + 1
+      next_parts.size.times do |i|
+        namespace = i == 0 ? nil : next_parts[0..i-1].join('/')
+        class_path = next_parts[i..-1].join('_')
+        guesses << [primary_namespace, namespace, class_path].compact.join('/')
+      end
+
+      final_primary_namespace = parts[0..-2].join('_')
+      if primary_namespace == final_primary_namespace
+        return guesses # end of recursion
+      else
+        namespace_size = parts.size - next_parts.size
+        next_primary_namespace = parts[0..namespace_size].join('_')
+        guesses += function_filenames(meth, next_primary_namespace)
+        return guesses
+      end
+    end
+
+    def function_paths
+      # drop the last word for starting filename
+      starting_filename = @provided_function_name.underscore.split('_')[0..-2].join('_')
+      filenames = function_filenames(starting_filename)
+      filenames.map do |name|
+        "app/functions/#{name}.rb"
+      end
+    end
+
+  end
+end

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,62 @@
+# 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('::','')
+
+        parent_resources = stack_resources(parent_stack.stack_id)
+        app_stack = parent_resources.find { |s| s.logical_resource_id == logical_id }
+
+        resources = stack_resources(app_stack.physical_resource_id)
+        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