jets-fs 1.6.10

data/lib/jets/commands/call.rb

@@ -0,0 +1,174 @@
+require "base64"
+require "json"
+
+class Jets::Commands::Call
+  autoload :BaseGuesser, "jets/commands/call/base_guesser"
+  autoload :AutoloadGuesser, "jets/commands/call/autoload_guesser"
+  autoload :AnonymousGuesser, "jets/commands/call/anonymous_guesser"
+  autoload :Guesser, "jets/commands/call/guesser"
+
+  include Jets::AwsServices
+
+  def initialize(provided_function_name, event, options={})
+    @options = options
+    @guess = @options[:guess].nil? ? true : @options[:guess]
+
+    @provided_function_name = provided_function_name
+    @event = event
+
+    @invocation_type = options[:invocation_type] || "RequestResponse"
+    @log_type = options[:log_type] || "Tail"
+    @qualifier = @qualifier
+  end
+
+  def function_name
+    if @guess
+      ensure_guesses_found! # possibly exits here
+      guesser.function_name # guesser adds namespace already
+    else
+      [Jets.config.project_namespace, @provided_function_name].join('-')
+    end
+  end
+
+  def run
+    @options[:local] ? local_run : remote_run
+  end
+
+  # With local mode there is no way to bypass the guesser
+  def local_run
+    puts "Local mode enabled!"
+    ensure_guesses_found! # possibly exits here
+    klass = guesser.class_name.constantize
+    # Example:
+    #   PostsController.process(event, context, meth)
+    event = JSON.load(transformed_event) || {} # transformed_event is JSON text String
+
+    fun = Jets::PolyFun.new(klass, guesser.method_name)
+    result = fun.run(event) # check the logs for polymorphic function errors
+    # Note: even though data might not always be json, the JSON.dump does a
+    # good job of not bombing, so always calling it to simplify code.
+
+    text = Jets::Util.normalize_result(result)
+    STDOUT.puts text
+  end
+
+  def remote_run
+    puts "Calling lambda function #{function_name} on AWS" unless @options[:mute]
+    return if @options[:noop]
+
+    options = {
+      # client_context: client_context,
+      function_name: function_name,
+      invocation_type: @invocation_type, # "Event", # RequestResponse
+      log_type: @log_type, # pretty sweet
+      payload: transformed_event, # "fileb://file-path/input.json", <= JSON
+      qualifier: @qualifier, # "1",
+    }
+    begin
+      resp = lambda.invoke(options)
+    rescue Aws::Lambda::Errors::ResourceNotFoundException
+      puts "The function #{function_name} was not found.  Maybe check the spelling or the AWS_PROFILE?".color(:red)
+      return
+    end
+
+    if @options[:show_log]
+      puts "Last 4KB of log in the x-amz-log-result header:".color(:green)
+      puts Base64.decode64(resp.log_result)
+    end
+
+    add_console_link_to_clipboard
+    result = resp.payload.read # already been normalized/JSON.dump by AWS
+    unless @options[:mute_output]
+      STDOUT.puts result # only thing that goes to stdout
+    end
+  end
+
+  def guesser
+    @guesser ||= Guesser.new(@provided_function_name)
+  end
+
+  def ensure_guesses_found!
+    unless guesser.class_name and guesser.method_name
+      puts guesser.error_message
+      exit
+    end
+  end
+
+  # @event is String because it can be the file:// notation
+  # Returns text String for the lambda.invoke payload.
+  def transformed_event
+    text = @event
+    if text && text.include?("file://")
+      text = load_event_from_file(text)
+    end
+
+    check_valid_json!(text)
+
+    puts "Function name: #{function_name.color(:green)}" unless @options[:mute]
+    return text unless function_name.include?("_controller-")
+    return text if @options[:lambda_proxy] == false
+
+    event = JSON.load(text)
+    lambda_proxy = {"queryStringParameters" => event}
+    JSON.dump(lambda_proxy)
+  end
+
+  def load_event_from_file(text)
+    path = text.gsub('file://','')
+    path = "#{Jets.root}/#{path}" unless path[0..0] == '/'
+    unless File.exist?(path)
+      puts "File #{path} does not exist.  Are you sure the file exists?".color(:red)
+      exit
+    end
+    text = IO.read(path)
+  end
+
+  # Exits with friendly error message when user provides bad just
+  def check_valid_json!(text)
+    JSON.load(text)
+  rescue JSON::ParserError => e
+    puts "Invalid json provided:\n  '#{text}'"
+    puts "Exiting... Please try again and provide valid json."
+    exit 1
+  end
+
+  # So use can quickly paste this into their browser if they want to see the function
+  # via the Lambda console
+  def add_console_link_to_clipboard
+    return unless RUBY_PLATFORM =~ /darwin/
+    return unless system("type pbcopy > /dev/null")
+
+    # TODO: for add_console_link_to_clipboard get the region from the ~/.aws/config and AWS_PROFILE setting
+    region = Aws.config[:region] || 'us-east-1'
+    link = "https://console.aws.amazon.com/lambda/homepage?region=#{region}#/functions/#{function_name}?tab=configuration"
+    system("echo #{link} | pbcopy")
+    puts "Pro tip: The Lambda Console Link to the #{function_name} function has been added to your clipboard." unless @options[:mute]
+  end
+
+  # TODO: Hook client_context up and maek sure it works. Think I've figure out how to sign client_context below.
+  # Client context must be a valid Base64-encoded JSON object
+  # Example: http://docs.aws.amazon.com/mobileanalytics/latest/ug/PutEvents.html
+  def client_context
+    context = {
+      "client" => {
+        "client_id" => "Jets",
+        "app_title" => "jets call cli",
+        "app_version_name" => Jets::VERSION,
+      },
+      "custom" => {},
+      "env" =>{
+        "platform" => RUBY_PLATFORM,
+        "platform_version" => RUBY_VERSION,
+      }
+    }
+    Base64.encode64(JSON.dump(context))
+  end
+
+  # For this class redirect puts to stderr so user can pipe output to tools like
+  # jq. Example:
+  #   jets call posts_controller-index '{"test":1}' | jq .
+  def puts(text)
+    $stderr.puts(text)
+  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,112 @@
+class Jets::Commands::Call
+  class AutoloadGuesser < BaseGuesser
+    def detect_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
+
+    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,33 @@
+# Subclasses of BaseGuessor must implement interface:
+#   detect_class_name
+#   method_name
+#   error_message
+#
+class Jets::Commands::Call
+  class BaseGuesser
+    # 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('-')
+    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