jets 0.2.0 → 0.5.0

data/lib/jets/commands/base.rb

@@ -0,0 +1,151 @@
+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
+    # 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
+
+    # Useful for help menu when we need to have all the definitions loaded.
+    # Using constantize instead of require so we dont care about
+    # order. The eager load actually uses autoloading.
+    def eager_load!
+      path = File.expand_path("../../", __FILE__)
+      Dir.glob("#{path}/commands/**/*.rb").select do |path|
+        next if !File.file?(path) or path =~ /templates/ or path =~ %r{/markdown/}
+
+        class_name = path
+                      .sub(/\.rb$/,'')
+                      .sub(%r{.*/jets/commands}, 'jets/commands')
+                      .classify
+        class_name.sub!(/Task$/, "Tasks") # special rule here for Tasks class
+        # NOTE: Weird thing where Jets::Commands::Db::Task => Thor::Command
+        # because Task is a class available to Thor I believe.
+        puts "eager_load! loading path: #{path} class_name: #{class_name}" if ENV['DEBUG']
+        class_name.constantize # dont have to worry about order.
+      end
+    end
+
+    # Fully qualifed task names. Examples:
+    #   build
+    #   process:controller
+    #   dynamodb:migrate:down
+    def namespaced_commands
+      eager_load!
+      subclasses.map do |klass|
+        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.classify}"
+        class_name.constantize
+      end
+    end
+
+    # If this fails to match then it'l just 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
+  end
+end

data/lib/jets/commands/build.rb

@@ -0,0 +1,186 @@
+require 'digest'
+
+module Jets::Commands
+  class Build
+    include Jets::Timing
+    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
+    time :run
+
+    def build
+      build_code unless @options[:templates_only]
+      build_templates
+    end
+    time :build
+
+    def build_code
+      Jets::Builders::CodeBuilder.new.build unless @options[:noop]
+    end
+    time :build_code
+
+    def build_templates
+      if @options[:stack_type] == :minimal
+        build_minimal_template
+      else
+        build_all_templates
+      end
+    end
+    time :build_templates
+
+    def build_all_templates
+      clean_templates
+      # TODO: move this build.rb logic to cfn/builder.rb
+      ## CloudFormation templates
+      puts "Building Lambda functions as CloudFormation templates."
+      # 1. Shared templates - child templates needs them
+      build_api_gateway_templates
+      # 2. Child templates - parent template needs them
+      build_child_templates
+      # 3. Finally parent template
+      build_parent_template # must be called at the end
+    end
+
+    def build_minimal_template
+      parent = Jets::Cfn::TemplateBuilders::ParentBuilder.new(@options)
+      parent.build
+    end
+
+    def build_api_gateway_templates
+      gateway = Jets::Cfn::TemplateBuilders::ApiGatewayBuilder.new(@options)
+      gateway.build
+      deployment = Jets::Cfn::TemplateBuilders::ApiGatewayDeploymentBuilder.new(@options)
+      deployment.build
+    end
+
+    def build_child_templates
+      app_files.each do |path|
+        build_child_template(path)
+      end
+    end
+
+    # path: app/controllers/comments_controller.rb
+    # path: app/jobs/easy_job.rb
+    def build_child_template(path)
+      class_path = path.sub(%r{.*app/\w+/},'').sub(/\.rb$/,'')
+      class_name = class_path.classify
+      class_name.constantize # load app/**/* class definition
+
+      md = path.match(%r{app/(.*?)/}) # extract: controller, job or function
+      process_class = md[1].classify
+      builder_class = "Jets::Cfn::TemplateBuilders::#{process_class}Builder".constantize
+
+      # Examples:
+      #   Jets::Cfn::TemplateBuilders::JobBuilder.new(EasyJob)
+      #   Jets::Cfn::TemplateBuilders::ControllerBuilder.new(PostsController)
+      #   Jets::Cfn::TemplateBuilders::FunctionBuilder.new(Hello)
+      #   Jets::Cfn::TemplateBuilders::FunctionBuilder.new(HelloFunction)
+      app_klass = Jets::Klass.from_path(path)
+      builder = builder_class.new(app_klass)
+      builder.build
+    end
+
+    def build_parent_template
+      parent = Jets::Cfn::TemplateBuilders::ParentBuilder.new(@options)
+      parent.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_app_root because for
+    # because Jets.boot set ups autoload_paths and this is how project
+    # classes are loaded.
+    # TODO: rework code so this is not the case.
+    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)
+
+        relative_path = path.sub(Jets.root.to_s, '')
+        # Rids of the Jets.root at beginning
+        paths << relative_path
+      end
+      paths += internal_app_files
+      paths
+    end
+
+    def self.poly_only?
+      # Scans all the app code and look for any methods that are ruby.
+      # If any method is written in ruby then we know the app is not a
+      # soley polymorphic non-ruby app.
+      has_ruby = app_files.detect do |path|
+        # 1. remove app/controllers or app/jobs, etc
+        # 2. remove .rb extension
+        app_file = path.sub(%r{app/\w+/},'').sub(/\.rb$/,'')
+        # Internal jets controllers like Welcome and Public need a different regexp
+        app_file = app_file.sub(%r{.*lib/jets/internal/},'')
+        app_klass = app_file.classify.constantize # IE: PostsController, Jets::PublicController
+        langs = app_klass.tasks.map(&:lang)
+        langs.include?(:ruby)
+      end
+      !has_ruby
+    end
+
+    # Add internal Jets controllers if they are being used
+    def self.internal_app_files
+      paths = []
+      controllers = File.expand_path("../../internal/app/controllers/jets", __FILE__)
+
+      welcome = Jets::Router.has_controller?("Jets::WelcomeController")
+      paths << "#{controllers}/public_controller.rb" if welcome
+
+      public_catchall = Jets::Router.has_controller?("Jets::PublicController")
+      paths << "#{controllers}/welcome_controller.rb" if public_catchall
+
+      jobs = File.expand_path("../../internal/app/jobs/jets", __FILE__)
+      paths << "#{jobs}/preheat_job.rb"
+
+      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.tmp_app_root(full_build_path=false)
+      full_build_path ? "#{Jets.build_root}/app_root" : "app_root"
+    end
+
+  end
+end

data/lib/jets/commands/call.rb

@@ -0,0 +1,175 @@
+require "base64"
+require "json"
+require "active_support/core_ext/string"
+
+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?".colorize(:red)
+      exit
+    end
+
+    if @options[:show_log]
+      puts "Last 4KB of log in the x-amz-log-result header:".colorize(: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.colorize(: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?".colorize(: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
+
+  # Client context must be a valid Base64-encoded JSON object
+  # Example: http://docs.aws.amazon.com/mobileanalytics/latest/ug/PutEvents.html
+  # TODO: figure out how to sign client_context
+  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