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

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/call.rb

@@ -0,0 +1,182 @@
+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 = lambda_client.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::S3::Client.new.config.region || ENV["AWS_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 make 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
+
+  def lambda_client
+    opt = {}
+    opt = opt.merge({retry_limit: @options[:retry_limit]}) if @options[:retry_limit].present?
+    opt = opt.merge({http_read_timeout: @options[:read_timeout]}) if @options[:read_timeout].present?
+
+    if opt.empty?
+      aws_lambda
+    else
+      Aws::Lambda::Client.new(opt)
+    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[:yes]
+
+      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,111 @@
+# 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)
+        delete_log_group(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 delete_log_group(log_group_name)
+      logs.delete_log_group(log_group_name: log_group_name)
+    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/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 :yes, 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/configure.rb

@@ -0,0 +1,51 @@
+module Jets::Commands
+  class Configure
+    extend Memoist
+
+    def initialize(options)
+      @options = options
+    end
+
+    def run
+      data = load_yaml
+      data['key'] = token
+      FileUtils.mkdir_p(File.dirname(path))
+      IO.write(path, YAML.dump(data))
+      puts "Updated #{pretty(path)}"
+    end
+
+    def load_yaml
+      if File.exist?(path)
+        YAML.load_file(path)
+      else
+        {}
+      end
+    rescue Psych::SyntaxError => e
+      puts "WARN: There was an error reading #{pretty(path)}".color(:yellow)
+      puts "WARN: #{e.class} #{e.message}".color(:yellow)
+      {}
+    end
+
+    def pretty(path)
+      path.sub(ENV['HOME'], '~')
+    end
+
+    def path
+      "#{ENV['HOME']}/.jets/config.yml"
+    end
+
+    def token
+      @options[:token] || prompt
+    end
+    memoize :token
+
+    def prompt
+      puts <<~EOL
+        You are about to configure your ~/.jets/config.yml
+        You can get a token from serverlessgems.com
+      EOL
+      print "Please provide your token: "
+      $stdin.gets.strip
+    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/environment-task.rake

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

data/lib/jets/commands/db/tasks/dummy/app.rb

@@ -0,0 +1,25 @@
+require "recursive-open-struct"
+
+module Jets::Commands::Db::Tasks::Dummy
+  class App
+    def config
+      Config.new(
+        active_record: {
+          belongs_to_required_by_default: true
+        },
+        paths: {
+          db: ["db"],
+          "db/migrate": ["db/migrate"]
+        }
+      )
+    end
+
+    def paths
+      RecursiveOpenStruct.new(
+        paths: {
+          "db/migrate": ["db/migrate"]
+        }
+      )
+    end
+  end
+end

data/lib/jets/commands/db/tasks/dummy/config.rb

@@ -0,0 +1,14 @@
+require "recursive-open-struct"
+
+module Jets::Commands::Db::Tasks::Dummy
+  class Config < RecursiveOpenStruct
+    def load_database_yaml # :nodoc:
+      require "rails/application/dummy_erb_compiler"
+
+      path = "#{Jets.root}/config/database.yml"
+      yaml = Pathname.new(path)
+      erb = DummyERB.new(yaml.read)
+      YAML.load(erb.result) || {}
+    end
+  end
+end

data/lib/jets/commands/db/tasks.rb

@@ -0,0 +1,34 @@
+class Jets::Commands::Db::Tasks
+  # Ugly but it loads ActiveRecord database tasks
+  def self.load!
+    # Lazy require rails so Rails const is only defined in jets db:* tasks
+    require "rails"
+    require "active_record"
+
+    # Jets.boot # Jets.boot here screws up jets -h, the db_config doesnt seem to match exactly
+    # but seems to be working anyway.
+    db_configs = Jets.application.config.database
+    ActiveRecord::Tasks::DatabaseTasks.database_configuration = db_configs
+    ActiveRecord::Tasks::DatabaseTasks.migrations_paths = ["db/migrate"]
+    ActiveRecord::Tasks::DatabaseTasks.seed_loader = Seeder.new("#{Jets.root}/db/seeds.rb")
+
+    # Need to mock out the usage of Rails.application in:
+    # activerecord-5.1.4/lib/active_record/tasks/database_tasks.rb
+    Rails.application = Dummy::App.new
+    load "active_record/railties/databases.rake"
+    load File.expand_path("../environment-task.rake", __FILE__)
+  end
+
+
+  # Thanks: https://stackoverflow.com/questions/19206764/how-can-i-load-activerecord-database-tasks-on-a-ruby-project-outside-rails/24840749
+  class Seeder
+    def initialize(seed_file)
+      @seed_file = seed_file
+    end
+
+    def load_seed
+      raise "Seed file '#{@seed_file}' does not exist" unless File.file?(@seed_file)
+      load @seed_file
+    end
+  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