jets_bb_fork 0.0.4

data/lib/jets/commands/build.rb

@@ -0,0 +1,234 @@
+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?
+    end
+
+    def full?
+      @options[:templates] || @options[:stack_type] == :full
+    end
+
+    def build_all_templates
+      # CloudFormation templates
+      # 1. Shared templates - child templates needs them
+      build_api_gateway_templates
+      # 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
+      # minimal_template does no longer includes ApiGateway since that is now paged and
+      # at this point we know nothing about the pages.
+      Jets::Cfn::Builders::ParentBuilder.new(@options).build
+    end
+
+    def build_api_gateway_templates
+      @api_gateway_builder = Jets::Cfn::Builders::ApiGatewayBuilder.new(@options).build
+      Jets::Cfn::Builders::ApiDeploymentBuilder.new(@options).build
+    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)
+      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)
+      builder = builder_class.new(app_class)
+      unless Jets.poly_only? && app_class == Jets::PreheatJob
+        builder.build
+      end
+    end
+
+    def build_parent_template
+      options = @options.dup
+      options[:api_gateway_page_range] = @api_gateway_builder.range
+      options[:indexed_paths] = @api_gateway_builder.indexed_paths
+      options[:required_parameters] = @api_gateway_builder.required_parameters
+      Jets::Cfn::Builders::ParentBuilder.new(options).build
+    end
+
+    def clean_templates
+      FileUtils.rm_rf("#{Jets.build_root}/templates")
+    end
+
+    def app_files
+      self.class.app_files
+    end
+
+    # 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.
+    def self.app_files
+      paths = []
+      expression = "#{Jets.root}/app/**/**/*.rb"
+      Dir.glob(expression).each do |path|
+        return false unless File.file?(path)
+        next unless app_file?(path)
+        next if concerns?(path)
+
+        relative_path = path.sub("#{Jets.root}/", '')
+        # Rids of the Jets.root at beginning
+        paths << relative_path
+      end
+      paths += internal_app_files
+      paths
+    end
+
+    def shared_files
+      self.class.shared_files
+    end
+
+    def self.shared_files
+      paths = []
+      expression = "#{Jets.root}/app/**/**/*.rb"
+      Dir.glob(expression).each do |path|
+        return false unless File.file?(path)
+        next unless path.include?("app/shared/resources")
+
+        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 self.poly_only?
+      !app_has_ruby? && !shared_has_ruby?
+    end
+
+    def self.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 self.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 self.internal_app_files
+      paths = []
+      controllers = File.expand_path("../../internal/app/controllers/jets", __FILE__)
+
+      public_catchall = Jets::Router.has_controller?("Jets::PublicController")
+      paths << "#{controllers}/public_controller.rb" if public_catchall
+
+      rack_catchall = Jets::Router.has_controller?("Jets::RackController")
+      paths << "#{controllers}/rack_controller.rb" if rack_catchall
+
+      mailer_controller = Jets::Router.has_controller?("Jets::MailersController")
+      paths << "#{controllers}/mailers_controller.rb" if mailer_controller
+
+      if Jets.config.prewarm.enable
+        jobs = File.expand_path("../../internal/app/jobs/jets", __FILE__)
+        paths << "#{jobs}/preheat_job.rb"
+      end
+
+      paths
+    end
+
+    def self.app_file?(path)
+      return false unless File.extname(path) == ".rb"
+      # Do not define lamda functions for the application_controller.rb or
+      # application_job.rb
+      excludes = %w[
+        application_controller.rb
+        application_job.rb
+      ]
+      return false if excludes.detect { |p| path.include?(p) }
+
+      includes = %w[
+        app/controllers
+        app/jobs
+        app/functions
+        app/rules
+      ]
+      return true if includes.detect { |p| path.include?(p) }
+
+      false
+    end
+
+    def self.concerns?(path)
+      path =~ %r{app/\w+/concerns/}
+    end
+
+    def self.tmp_code(full_build_path=false)
+      full_build_path ? "#{Jets.build_root}/stage/code" : "stage/code"
+    end
+
+  end
+end

data/lib/jets/commands/call.rb

@@ -0,0 +1,169 @@
+require "base64"
+require "json"
+
+class Jets::Commands::Call
+  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 = aws_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/home?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