jets 3.1.0 → 5.0.0

data/lib/jets/cfn/builders/interface.rb

@@ -1,133 +0,0 @@
-# The class including this module should implement these methods:
-#
-#   * compose
-#   * template_path
-module Jets::Cfn::Builders
-  module Interface
-    extend Memoist
-
-    def build(parent=false)
-      # Do not bother building or writing the template unless there are functions defined
-      return if @app_class && !@app_class.build?
-
-      if @options.nil? || @options[:templates] || @options[:stack_type] != :minimal || parent
-        compose # must be implemented by subclass
-      end
-      write
-    end
-
-    def write
-      FileUtils.mkdir_p(File.dirname(template_path))
-      IO.write(template_path, text)
-    end
-
-    def template
-      # need the to_hash or the YAML dump has
-      #  !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-      @template.to_hash
-    end
-
-    def text
-      text = YAML.dump(template)
-      post_process_template(text)
-    end
-
-    # post process the text so that
-    # "!Ref IamRole" => !Ref IamRole
-    # We strip the surrounding quotes
-    def post_process_template(text)
-      results = text.split("\n").map do |line|
-        if line.include?(': "!') # IE: IamRole: "!Ref IamRole",
-           # IamRole: "!Ref IamRole" => IamRole: !Ref IamRole
-          line.sub(/: "(.*)"/, ': \1')
-        elsif line.include?('- "!') # IE: - "!GetAtt Foo.Arn"
-           # IamRole: - "!GetAtt Foo.Arn" => - !GetAtt Foo.Arn
-          line.sub(/- "(.*)"/, '- \1')
-        else
-          line
-        end
-      end
-      results.join("\n") + "\n"
-    end
-
-    def add_description(desc)
-      @template[:Description] = desc
-    end
-
-    def add_parameters(attributes)
-      attributes.each do |name,value|
-        add_parameter(name.to_s.camelize, Description: value)
-      end
-    end
-
-    def add_parameter(name, options={})
-      defaults = { Type: "String" }
-      options = defaults.merge(options)
-      @template[:Parameters] ||= {}
-      @template[:Parameters][name.to_s.camelize] = Jets::Camelizer.transform(options)
-    end
-
-    def add_outputs(attributes)
-      attributes.each do |name,value|
-        add_output(name.to_s.camelize, Value: value)
-      end
-    end
-
-    def add_output(name, options={})
-      @template[:Outputs] ||= {}
-      @template[:Outputs][name.camelize] = Jets::Camelizer.transform(options)
-    end
-
-    def add_resources
-      @app_class.tasks.each do |task|
-        task.associated_resources.each do |associated|
-          resource = Jets::Resource.new(associated.definition, task.replacements)
-          add_resource(resource)
-          add_resource(resource.permission)
-        end
-      end
-    end
-
-    def add_resource(resource)
-      add_template_resource(resource.logical_id, resource.type, resource.attributes)
-    end
-
-    # The add_resource method can take an options Hash with both with either
-    # top level attributes or properties.
-    #
-    # Example:
-    #
-    # Top level options:
-    #
-    #   add_template_resource("MyId", "AWS::ApiGateway::RestApi",
-    #     type: "AWS::ApiGateway::RestApi",
-    #     properties: {
-    #       name: "my-api"
-    #     },
-    #     depends_on: ["AnotherResource"]
-    #   )
-    #
-    # Simple options with properties only:
-    #
-    #   add_template_resource("MyId", "AWS::CloudFormationStack",
-    #     template_url: "template_url",
-    #     parameters: {},
-    #   )
-    #
-    def add_template_resource(logical_id, type, options)
-      options = Jets::Camelizer.transform(options)
-
-      attributes = if options.include?('Type')
-                     base = { 'Type' => type }
-                     base.merge(options) # options are top-level attributes
-                   else
-                     {
-                       'Type' => type,
-                       'Properties' => options # options are properties
-                     }
-                   end
-
-      @template['Resources'][logical_id] = attributes
-    end
-  end
-end

data/lib/jets/cfn/builders/job_builder.rb

@@ -1,14 +0,0 @@
-# Implements:
-#
-#   compose
-#   template_path
-#
-module Jets::Cfn::Builders
-  class JobBuilder < BaseChildBuilder
-    def compose
-      add_common_parameters
-      add_functions
-      add_resources
-    end
-  end
-end

data/lib/jets/cfn/builders/parent_builder.rb

@@ -1,130 +0,0 @@
-require 'erb'
-
-module Jets::Cfn::Builders
-  class ParentBuilder
-    include Interface
-    include Jets::AwsServices
-    include Stagger
-
-    def initialize(options={})
-      @options = options
-      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
-    end
-
-    # compose is an interface method
-    def compose
-      build_minimal_resources
-      build_child_resources if full?
-    end
-
-    # template_path is an interface method
-    def template_path
-      Jets::Naming.parent_template_path
-    end
-
-    def build_minimal_resources
-      add_description("Jets: #{Jets.version} Code: #{Util::Source.version}")
-
-      # Initial s3 bucket, used to store code zipfile and templates Jets generates
-      resource = Jets::Resource::S3::Bucket.new(logical_id: "s3_bucket",
-        bucket_encryption: {
-          server_side_encryption_configuration: [
-            server_side_encryption_by_default: {
-              sse_algorithm: "AES256"
-          }]}
-      )
-      add_resource(resource)
-      add_outputs(resource.outputs)
-
-      return unless full?
-      # Add application-wide IAM policy from Jets.config.iam_role
-      resource = Jets::Resource::Iam::ApplicationRole.new
-      add_resource(resource)
-      add_outputs(resource.outputs)
-
-      return if Jets.poly_only?
-      resource = Jets::Resource::Lambda::GemLayer.new
-      add_resource(resource)
-      add_outputs(resource.outputs)
-    end
-
-    def build_child_resources
-      for_each_path(:app) do |path|
-        add_app_class_stack(path)
-      end
-      for_each_path(:shared) do |path|
-        add_shared_resources(path)
-      end
-
-      if full? and !Jets::Router.routes.empty?
-        for_each_path(:authorizers) do |path|
-          add_authorizer_resources(path)
-        end
-        add_api_gateway
-        add_api_resources
-        add_api_deployment
-      end
-    end
-
-    # Example paths:
-    #    #{Jets.build_root}/templates/demo-dev-2-shared-resources.yml
-    #    #{Jets.build_root}/templates/demo-dev-2-app-comments_controller.yml
-    #    #{Jets.build_root}/templates/demo-dev-2-authorizers-main_authorizer.yml
-    def for_each_path(type)
-      expression = "#{Jets::Naming.template_path_prefix}-#{type}-*"
-      Dir.glob(expression).each do |path|
-        next unless File.file?(path)
-        yield(path)
-      end
-    end
-
-    def full?
-      @options[:templates] || @options[:stack_type] == :full
-    end
-
-    def add_app_class_stack(path)
-      resource = Jets::Resource::ChildStack::AppClass.new(@options[:s3_bucket], path: path)
-      add_stagger(resource)
-      add_child_resources(resource)
-    end
-
-    def add_authorizer_resources(path)
-      resource = Jets::Resource::ChildStack::Authorizer.new(@options[:s3_bucket], path: path)
-      add_child_resources(resource)
-    end
-
-    def add_shared_resources(path)
-      resource = Jets::Resource::ChildStack::Shared.new(@options[:s3_bucket], path: path)
-      add_child_resources(resource) if resource.resources?
-    end
-
-    def add_api_gateway
-      resource = Jets::Resource::ChildStack::ApiGateway.new(@options[:s3_bucket])
-      add_child_resources(resource)
-    end
-
-    def add_api_resources
-      expression = "#{Jets::Naming.template_path_prefix}-api-resources-*"
-      # IE: path: #{Jets.build_root}/templates/demo-dev-2-api-resources-1.yml"
-      Dir.glob(expression).sort.each do |path|
-        next unless File.file?(path)
-
-        regexp = Regexp.new("#{Jets.config.project_namespace}-api-resources-(\\d+).yml") # tricky to escape \d pattern
-        md = path.match(regexp)
-        page = md[1]
-        resource = Jets::Resource::ChildStack::ApiResource.new(@options[:s3_bucket], page: page)
-        add_child_resources(resource)
-      end
-    end
-
-    def add_api_deployment
-      resource = Jets::Resource::ChildStack::ApiDeployment.new(@options[:s3_bucket])
-      add_child_resources(resource)
-    end
-
-    def add_child_resources(resource)
-      add_resource(resource)
-      add_outputs(resource.outputs)
-    end
-  end
-end

data/lib/jets/cfn/built_template.rb

@@ -1,15 +0,0 @@
-module Jets::Cfn
-  # Caches the built template to reduce filesystem IO calls.
-  class BuiltTemplate
-    class << self
-      @@cache = {}
-      def get(path)
-        if @@cache[path]
-          @@cache[path] # using cache
-        else
-          @@cache[path] = YAML.load_file(path) # setting and using cache
-        end
-      end
-    end
-  end
-end

data/lib/jets/cfn/template_source.rb

@@ -1,61 +0,0 @@
-module Jets::Cfn
-  class TemplateSource
-    include Jets::AwsServices
-
-    attr_reader :path
-
-    def initialize(path, options)
-      @path = path
-      @options = options
-    end
-
-    def body
-      @body ||= IO.read(path)
-    end
-
-    def url
-      @url ||= upload_file_to_s3
-    end
-
-    def to_h
-      if upload_to_s3?
-        from_s3
-      else
-        from_path
-      end
-    end
-
-    private
-
-    def upload_to_s3?
-      bucket_name.present?
-    end
-
-    def from_s3
-      {
-        template_url: url
-      }
-    end
-
-    def from_path
-      {
-        template_body: body
-      }
-    end
-
-    def upload_file_to_s3
-      obj = s3_resource.bucket(bucket_name).object(s3_key)
-      obj.upload_file(path)
-
-      "https://s3.amazonaws.com/#{bucket_name}/#{s3_key}"
-    end
-
-    def bucket_name
-      @options[:s3_bucket]
-    end
-
-    def s3_key
-      @s3_key ||= "jets/cfn-templates/#{File.basename(path)}"
-    end
-  end
-end

data/lib/jets/commands/base.rb

@@ -1,145 +0,0 @@
-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/call.rb

@@ -1,182 +0,0 @@
-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.rb

@@ -1,19 +0,0 @@
-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, aliases: "y", 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