etna 0.1.16 → 0.1.18

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/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,130 @@
+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)
+      generate_flag_handling
+
+      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
+
+      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/json_serializable_struct.rb

@@ -20,11 +20,14 @@ module Etna
       end
     end
 
-    def as_json
-      members.map do |k|
+    def as_json(keep_nils: false)
+      inner_json = members.map do |k|
         v = self.class.as_json(send(k))
         [k, v]
-      end.to_h.delete_if { |k, v| v.nil? }
+      end.to_h
+
+      return inner_json if keep_nils
+      inner_json.delete_if { |k, v| v.nil? }
     end
 
     def to_json

data/lib/etna/logger.rb

@@ -16,17 +16,14 @@ module Etna
 
     def warn(msg, &block)
       super
-      Rollbar.warn(msg)
     end
 
     def error(msg, &block)
       super
-      Rollbar.error(msg)
     end
 
     def fatal(msg, &block)
       super
-      Rollbar.error(msg)
     end
 
     def log_error(e)

data/lib/etna/multipart_serializable_nested_hash.rb

@@ -20,7 +20,12 @@ module Etna
             end
           else
             raise "base_key cannot be empty for a scalar value!" if base_key.length == 0
-            yield [base_key, value.respond_to?(:read) ? UploadIO.new(value, 'application/octet-stream') : value.to_s]
+
+            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
 

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/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

data/lib/etna/templates/attribute_actions_template.json

@@ -0,0 +1,43 @@
+// Make sure to remove all comments before using -- JSON doesn't allow comments!
+[
+  // Attribute actions can be "add_attribute", "update_attribute", "rename_attribute", or "add_link".
+  // These are all executed at the same time -- so you can't "update" an attribute that you "add"
+  //    in the same file -- everything must already exist on the server."
+  {
+    "action_name": "add_attribute",
+    "model_name": "assay_name", // Each action must include a model_name that it applies to.
+    "attribute_type": "string", // When adding, you must include attribute_type, attribute_name, desc, and display_name.
+    "attribute_name": "notes",
+    "display_name": "Notes",
+    "desc": "for notes that you have."
+  },
+  {
+    "action_name": "update_attribute",
+    "model_name": "document",
+    "attribute_name": "version", // When updating, you must include model_name and attribute_name, but any additional values are optional.
+    "read_only": true
+  },
+  {
+    "action_name": "rename_attribute",
+    "model_name": "assay_name",
+    "attribute_name": "vendor",
+    "new_attribute_name": "e_vendor" // When renaming an attribute, you need to include a "new_attribute_name" value.
+  },
+  {
+    // Links require two hashes inside of a "links" attribute.
+    "action_name": "add_link",
+    "links": [
+      {
+        "model_name": "assay_name",
+        "attribute_name": "document",
+        "attribute_type": "link" // One link must be of type "link". This has a one-to-one relationship with the other model.
+        // In this case, each assay_name has one document record, but document records can point to zero-or-more assay_name records.
+      },
+      {
+        "model_name": "document",
+        "attribute_name": "assay_name",
+        "attribute_type": "collection" // The other link must be of type "collection". This is a one-to-many relationship with the other model.
+      }
+    ]
+  }
+]

data/lib/etna/test_auth.rb

@@ -43,7 +43,9 @@ module Etna
     end
 
     def approve_hmac(request)
-      hmac_signature = etna_param(request, :signature) || 'invalid'
+      hmac_signature = etna_param(request, :signature)
+
+      return false unless hmac_signature
 
       headers = (etna_param(request, :headers)&.split(/,/) || []).map do |header|
         [ header.to_sym, etna_param(request, header) ]

data/lib/etna/user.rb

@@ -81,5 +81,9 @@ module Etna
     def is_admin? project
       is_superuser? || has_roles(project, :admin)
     end
+
+    def active? project=nil
+      permissions.keys.length > 0
+    end
   end
 end

data/lib/helpers.rb

@@ -0,0 +1,81 @@
+require_relative './etna/clients'
+require_relative './etna/environment_scoped'
+
+module WithEtnaClients
+  def environment
+    EtnaApp.instance.environment
+  end
+
+  def token
+    env_token = ENV['TOKEN']
+    if !env_token
+      puts "No environment variable TOKEN is set.  You should set your token with `export TOKEN=<your.janus.token>` before running."
+      redirect = EtnaApp.instance.config(:auth_redirect)
+
+      if redirect.nil? && EtnaApp.instance.environment == :production
+        redirect = 'https://janus.ucsf.edu/'
+      end
+
+      unless redirect.nil?
+        puts "Open your browser to #{redirect} to complete login and copy your token."
+      end
+
+      exit
+    end
+
+    env_token
+  end
+
+  def magma_client
+    @magma_client ||= Etna::Clients::Magma.new(
+        token: token,
+        ignore_ssl: EtnaApp.instance.config(:ignore_ssl),
+        # Persistent connections cause problem with magma restarts, until we can fix that we should force them
+        # to close + reopen each request.
+        persistent: false,
+        **EtnaApp.instance.config(:magma, environment) || {})
+  end
+
+  def metis_client
+    @metis_client ||= Etna::Clients::Metis.new(
+        token: token,
+        ignore_ssl: EtnaApp.instance.config(:ignore_ssl),
+        **EtnaApp.instance.config(:metis, environment) || {})
+  end
+
+  def janus_client
+    @janus_client ||= Etna::Clients::Janus.new(
+        token: token,
+        ignore_ssl: EtnaApp.instance.config(:ignore_ssl),
+        **EtnaApp.instance.config(:janus, environment) || {})
+  end
+
+  def polyphemus_client
+    @polyphemus_client ||= Etna::Clients::Polyphemus.new(
+        token: token,
+        ignore_ssl: EtnaApp.instance.config(:ignore_ssl),
+        **EtnaApp.instance.config(:polyphemus, environment) || {})
+  end
+end
+
+module WithLogger
+  def logger
+    EtnaApp.instance.logger
+  end
+end
+
+module StrongConfirmation
+  def confirm
+    puts "Confirm Y/n:"
+    input = STDIN.gets.chomp
+    if input != "Y"
+      return false
+    end
+
+    true
+  end
+end
+
+WithEtnaClientsByEnvironment = EnvironmentScoped.new do
+  include WithEtnaClients
+end