etna 0.1.13 → 0.1.19

data/lib/etna/controller.rb

@@ -12,6 +12,7 @@ module Etna
       @logger = @request.env['etna.logger']
       @user = @request.env['etna.user']
       @request_id = @request.env['etna.request_id']
+      @hmac = @request.env['etna.hmac']
     end
 
     def log(line)
@@ -23,11 +24,14 @@ module Etna
 
       return send(@action) if @action
 
+
       [501, {}, ['This controller is not implemented.']]
     rescue Etna::Error => e
+      Rollbar.error(e)
       @logger.error(request_msg("Exiting with #{e.status}, #{e.message}"))
       return failure(e.status, error: e.message)
     rescue Exception => e
+      Rollbar.error(e)
       @logger.error(request_msg('Caught unspecified error'))
       @logger.error(request_msg(e.message))
       e.backtrace.each do |trace|

data/lib/etna/directed_graph.rb

@@ -0,0 +1,56 @@
+class DirectedGraph
+  def initialize
+    @children = {}
+    @parents = {}
+  end
+
+  attr_reader :children
+  attr_reader :parents
+
+  def add_connection(parent, child)
+    children = @children[parent] ||= {}
+    child_children = @children[child] ||= {}
+
+    children[child] = child_children
+
+    parents = @parents[child] ||= {}
+    parent_parents = @parents[parent] ||= {}
+    parents[parent] = parent_parents
+  end
+
+  def descendants(parent)
+    seen = Set.new
+
+    seen.add(parent)
+    queue = @children[parent].keys.dup
+    parent_queue = @parents[parent].keys.dup
+
+    # Because this is not an acyclical graph, the definition of descendants needs to be stronger;
+    # here we believe that any path that would move through --any-- parent to this child would not be considered
+    # descendant, so we first find all those parents and mark them as 'seen' so that they are not traveled.
+    while next_parent = parent_queue.pop
+      next if seen.include?(next_parent)
+      seen.add(next_parent)
+      parent_queue.push(*@parents[next_parent].keys)
+    end
+
+    queue = queue.nil? ? [] : queue.dup
+    paths = {}
+
+    while child = queue.pop
+      next if seen.include? child
+      seen.add(child)
+      path = (paths[child] ||= [parent])
+
+      @children[child].keys.each do |child_child|
+        queue.push child_child
+
+        unless paths.include? child_child
+          paths[child_child] = path + [child]
+        end
+      end
+    end
+
+    paths
+  end
+end

data/lib/etna/environment_scoped.rb

@@ -0,0 +1,19 @@
+class EnvironmentScoped < Module
+  def initialize(&block)
+    environment_class = Class.new do
+      class_eval(&block)
+
+      attr_reader :environment
+      def initialize(environment)
+        @environment = environment
+      end
+    end
+
+    super() do
+      define_method :environment do |env|
+        env = env.to_sym
+        (@envs ||= {})[env] ||= environment_class.new(env)
+      end
+    end
+  end
+end

data/lib/etna/generate_autocompletion_script.rb

@@ -0,0 +1,131 @@
+require_relative 'command'
+
+# application.rb instantiates this for the project scoping.
+# This generates a file, project-name.completion, which is sourced
+# in build.sh to provide autocompletion in that environment.
+module Etna
+  class GenerateCompletionScript < Etna::Command
+    def generate_for_command(command)
+      completions = command.completions
+      completions.each do |c|
+        generate_start_match(c, false)
+        write "fi"
+        write "shift"
+      end
+
+      enable_flags(command.class)
+      write 'while [[ "$#" != "0" ]]; do'
+      generate_start_match([])
+      generate_flag_handling
+
+      write "else"
+      write "return"
+      write 'fi'
+      write 'done'
+      write "return"
+    end
+
+    def generate_flag_handling
+      write %Q(elif [[ -z "$(echo $all_flag_completion_names | xargs)" ]]; then)
+      write "return"
+      write %Q(elif [[ "$all_flag_completion_names" =~ $1\\  ]]; then)
+      write %Q(all_flag_completion_names="${all_flag_completion_names//$1\\ /}")
+      write 'a=$1'
+      write 'shift'
+      write %Q(if [[ "$string_flag_completion_names" =~ $a\\  ]]; then)
+      write 'if [[ "$#" == "1" ]];  then'
+      write %Q(a="${a//--/}")
+      write %Q(a="${a//-/_}")
+      write %Q(i="_completions_for_$a")
+      write %Q(all_completion_names="${!i}")
+      write 'COMPREPLY=($(compgen -W "$all_completion_names" -- "$1"))'
+      write 'return'
+      write 'fi'
+      write 'shift'
+      write 'fi'
+    end
+
+    def generate_start_match(completions, include_flags=true)
+      write 'if [[ "$#" == "1" ]];  then'
+      write %Q(all_completion_names="#{completions.join(' ')}")
+      write %Q(all_completion_names="$all_completion_names $all_flag_completion_names") if include_flags
+      write %Q(if [[ -z "$(echo $all_completion_names | xargs)" ]]; then)
+      write 'return'
+      write 'fi'
+      write 'COMPREPLY=($(compgen -W "$all_completion_names" -- "$1"))'
+      write 'return'
+    end
+
+    def enable_flags(flags_container)
+      boolean_flags = flags_container.boolean_flags
+      string_flags = flags_container.string_flags
+      flags = boolean_flags + string_flags
+      write %Q(all_flag_completion_names="$all_flag_completion_names #{flags.join(' ')} ")
+      write %Q(string_flag_completion_names="$string_flag_completion_names #{string_flags.join(' ')} ")
+
+      string_flags.each do |flag|
+        write %Q(declare _completions_for_#{flag_as_parameter(flag)}="#{completions_for(flag_as_parameter(flag)).join(' ')}")
+      end
+    end
+
+    def generate_for_scope(scope)
+      enable_flags(scope.class)
+      write 'while [[ "$#" != "0" ]]; do'
+      generate_start_match(scope.subcommands.keys)
+
+      scope.subcommands.each do |name, command|
+        write %Q(elif [[ "$1" == "#{name}" ]]; then)
+        write 'shift'
+        if command.class.included_modules.include?(CommandExecutor)
+          generate_for_scope(command)
+        else
+          generate_for_command(command)
+        end
+      end
+
+      generate_flag_handling
+
+      write "else"
+      write "return"
+      write "fi"
+      write 'done'
+    end
+
+    def program_name
+      $PROGRAM_NAME
+    end
+
+    def execute
+      name = File.basename(program_name)
+
+      write <<-EOF
+#!/usr/bin/env bash
+
+function _#{name}_completions() {
+  _#{name}_inner_completions "${COMP_WORDS[@]:1:COMP_CWORD}"
+}
+
+function _#{name}_inner_completions() {
+  local all_flag_completion_names=''
+  local string_flag_completion_names=''
+  local all_completion_names=''
+  local i=''
+  local a=''
+EOF
+      generate_for_scope(parent)
+      write <<-EOF
+}
+
+complete -o default -F _#{name}_completions #{name}
+EOF
+
+      File.open("#{name}.completion", 'w') { |f| f.write(@script) }
+    end
+
+    def write(string)
+      @script ||= ""
+      @script << string
+      @script << "\n"
+    end
+  end
+end

data/lib/etna/hmac.rb

@@ -60,6 +60,7 @@ module Etna
     end
 
     def valid_id?
+      return false if !@application.config(:hmac_keys)
       @application.config(:hmac_keys).key?(@id)
     end
 

data/lib/etna/json_serializable_struct.rb

@@ -0,0 +1,37 @@
+module Etna
+  module JsonSerializableStruct
+    def self.included(cls)
+      cls.instance_eval do
+        def self.as_json(v)
+          if v.respond_to? :as_json
+            return v.as_json
+          end
+
+          if v.is_a? Hash
+            return v.map { |k, v| [k, as_json(v)] }.to_h
+          end
+
+          if v.class.include? Enumerable
+            return v.map { |v| as_json(v) }
+          end
+
+          v
+        end
+      end
+    end
+
+    def as_json(keep_nils: false)
+      inner_json = members.map do |k|
+        v = self.class.as_json(send(k))
+        [k, v]
+      end.to_h
+
+      return inner_json if keep_nils
+      inner_json.delete_if { |k, v| v.nil? }
+    end
+
+    def to_json
+      as_json.to_json
+    end
+  end
+end

data/lib/etna/logger.rb

@@ -1,10 +1,10 @@
 require 'logger'
+require 'rollbar'
 
 module Etna
   class Logger < ::Logger
     def initialize(log_dev, age, size)
       super
-
       self.formatter = proc do |severity, datetime, progname, msg|
         format(severity, datetime, progname, msg)
       end
@@ -14,11 +14,25 @@ module Etna
       "#{severity}:#{datetime.iso8601} #{msg}\n"
     end
 
+    def warn(msg, &block)
+      super
+    end
+
+    def error(msg, &block)
+      super
+    end
+
+    def fatal(msg, &block)
+      super
+    end
+
     def log_error(e)
       error(e.message)
       e.backtrace.each do |trace|
         error(trace)
       end
+
+      Rollbar.error(e)
     end
 
     def log_request(request)

data/lib/etna/multipart_serializable_nested_hash.rb

@@ -0,0 +1,50 @@
+module Etna
+  module MultipartSerializableNestedHash
+    def self.included(cls)
+      cls.instance_eval do
+        def self.encode_multipart_pairs(value, base_key, is_root, &block)
+          if value.is_a? Hash
+            value.each do |k, v|
+              encode_multipart_pairs(v, is_root ? k : "#{base_key}[#{k}]", false, &block)
+            end
+          elsif value.is_a? Array
+            value.each_with_index do |v, i|
+              # This is necessary to ensure that arrays of hashes that have hetergenous keys still get parsed correctly
+              # Since the only way to indicate a new entry in the array of hashes is by re-using a key that existed in
+              # the previous hash.
+              if v.is_a? Hash
+                encode_multipart_pairs(i, "#{base_key}[][_idx]", false, &block)
+              end
+
+              encode_multipart_pairs(v, "#{base_key}[]", false, &block)
+            end
+          else
+            raise "base_key cannot be empty for a scalar value!" if base_key.length == 0
+
+            if value.respond_to?(:read)
+              yield [base_key, UploadIO.new(value, 'application/octet-stream'), {filename: 'blob'}]
+            else
+              yield [base_key, value.to_s]
+            end
+          end
+        end
+
+
+        def self.encode_multipart_content(value, base_key = '', is_root = true)
+          result = []
+          self.encode_multipart_pairs(value, base_key, is_root) { |pair| result << pair }
+          result
+        end
+      end
+    end
+
+    def encode_multipart_content(base_key = '')
+      value = self
+      if value.respond_to? :as_json
+        value = value.as_json
+      end
+
+      self.class.encode_multipart_content(value, base_key)
+    end
+  end
+end

data/lib/etna/parse_body.rb

@@ -23,7 +23,7 @@ module Etna
         )
       when %r{multipart/form-data}i
         params.update(
-          Rack::Multipart.parse_multipart(env)
+          Rack::Multipart.parse_multipart(env) || {}
         )
       end
       # Always parse the params that are url-encoded.

data/lib/etna/route.rb

@@ -118,7 +118,7 @@ module Etna
 
     def hmac_authorized?(request)
       # either there is no hmac requirement, or we have a valid hmac
-      !@auth[:hmac] || request.env['etna.hmac'].valid?
+      !@auth[:hmac] || request.env['etna.hmac']&.valid?
     end
 
     def route_name(options)

data/lib/etna/server.rb

@@ -66,6 +66,9 @@ module Etna
       end
 
       [404, {}, ["There is no such path '#{request.path}'"]]
+    rescue => e
+      application.logger.log_error(e)
+      raise
     end
 
     def initialize

data/lib/etna/spec/vcr.rb

@@ -0,0 +1,98 @@
+require 'webmock/rspec'
+require 'vcr'
+require 'openssl'
+require 'digest/sha2'
+require 'base64'
+
+def setup_base_vcr(spec_helper_dir)
+  VCR.configure do |c|
+    c.hook_into :webmock
+    c.cassette_serializers
+    c.cassette_library_dir = ::File.join(spec_helper_dir, 'fixtures', 'cassettes')
+    c.allow_http_connections_when_no_cassette = true
+
+    c.register_request_matcher :try_body do |request_1, request_2|
+      if request_1.headers['Content-Type'].first =~ /application\/json/
+        if request_2.headers['Content-Type'].first =~ /application\/json/
+          request_1_json = begin
+            JSON.parse(request_1.body) rescue 'not-json'
+          end
+          request_2_json = begin
+            JSON.parse(request_2.body) rescue 'not-json'
+          end
+          request_1_json == request_2_json
+        else
+          false
+        end
+      else
+        request_1.body == request_2.body
+      end
+    end
+
+    c.default_cassette_options = {
+        serialize_with: :compressed,
+        record: if ENV['IS_CI'] == '1'
+          :none
+        else
+          ENV['RERECORD'] ? :all : :once
+        end,
+        match_requests_on: [:method, :uri, :try_body]
+    }
+
+    # Filter the authorization headers of any request by replacing any occurrence of that request's
+    # Authorization value with <AUTHORIZATION>
+    c.filter_sensitive_data('<AUTHORIZATION>') do |interaction|
+      interaction.request.headers['Authorization'].first
+    end
+
+    c.before_record do |interaction|
+      key = prepare_vcr_secret
+
+      if interaction.response.body && !interaction.response.body.empty?
+        cipher = OpenSSL::Cipher.new("AES-256-CBC")
+        iv = cipher.random_iv
+
+        cipher.encrypt
+        cipher.key = key
+        cipher.iv = iv
+
+        encrypted = cipher.update(interaction.response.body)
+        encrypted << cipher.final
+
+        interaction.response.body = [iv, encrypted].pack('mm')
+      end
+    end
+
+    c.before_playback do |interaction|
+      key = prepare_vcr_secret
+
+      if interaction.response.body && !interaction.response.body.empty?
+        iv, encrypted = interaction.response.body.unpack('mm')
+
+        cipher = OpenSSL::Cipher.new("AES-256-CBC")
+        cipher.decrypt
+        cipher.key = key
+        cipher.iv = iv
+
+        plain = cipher.update(encrypted)
+        plain << cipher.final
+
+        interaction.response.body = plain
+      end
+    end
+  end
+end
+
+def prepare_vcr_secret
+  secret = ENV["CI_SECRET"]
+
+  if (secret.nil? || secret.empty?) && ENV['IS_CI'] != '1'
+    current_example = RSpec.current_example
+    RSpec::Core::Pending.mark_pending! current_example, 'CI_SECRET must be set to run this test'
+    raise "CI_SECRET must be set to run this test"
+  end
+
+  digest = Digest::SHA256.new
+  digest.update(secret)
+  digest.digest
+end