etna 0.1.43 → 0.1.44

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e30f0d83fdf8f5781f723080ddd042d371f3131a415c85ec441b56178cef27c
-  data.tar.gz: a543a3464ca34e0d6daedddbf702cf067f7dfdcbdc972e4e9a9a626118d5fbbd
+  metadata.gz: bea4cbc1d94fca11f52c02b75ef487d11e7b0a6f2aaa7d64c03a09803891d627
+  data.tar.gz: cb764eb044b4b711ddcc4ea46efa598763a34fedf2dc1984a9a2e88234094e2c
 SHA512:
-  metadata.gz: d11b9f2882e7499decb4854c5c399bce24e31b14ff52c83006708bd4f83706e4a754d2c96838241b1885ae2ad4f2eb360a0f815b38f5009f1a75fb4fe7246275
-  data.tar.gz: 3447fa61b285fdbe78e5e0646b36d489f3fd2677cce2415ebe001f8b691ddc281b9514a12bd9424ed9023f0b58609482edba77156066377ab1840e06bf359a5a
+  metadata.gz: 30100186f9af0e44654cc0a72d23eff04872f9479e119d308ac749bac4c7125358ea6e62f0a5cafd751512068715ac7831cbb5770ec554394c35c8c3781c30ce
+  data.tar.gz: dcee2b46965993e00d0dcae0a516b501a2afbbe968f1c9df35e45fcff4cd05535af7de52ddfec7e345943f3a1f4536aca196dd8150632d1a628559af482c6d7a

data/lib/etna/application.rb

@@ -50,13 +50,29 @@ module Etna::Application
     Etna::Application.register(self)
   end
 
+  # a <- b
+  def deep_merge(a, b)
+    if a.is_a?(Hash)
+      if b.is_a?(Hash)
+        b.keys.each do |b_key|
+          a[b_key] = deep_merge(a[b_key], b[b_key])
+        end
+
+        return a
+      end
+    end
+
+    a.nil? ? b : a
+  end
+
   def configure(opts)
     @config = opts
 
-    # Apply environmental variables of the form "APP__x__y__z"
-    prefix = "#{self.class.name.upcase}__"
-    ENV.keys.select { |k| k.start_with?(prefix) }.each do |key|
-      path = key.split("__", -1)
+    # Apply environmental variables of the form "ETNA__x__y__z_FILE"
+    # by reading the given file.
+    prefix = "ETNA__"
+    ENV.keys.select { |k| k.start_with?(prefix) && k.end_with?("_FILE") }.each do |key|
+      path = key.sub(/_FILE/, '').split("__", -1)
       path.shift # drop the first, just app name
 
       target = @config
@@ -65,7 +81,9 @@ module Etna::Application
         target = (target[n.downcase.to_sym] ||= {})
       end
 
-      target[path.last.downcase.to_sym] ||= ENV[key]
+      v = YAML.load(File.read(ENV[key]))
+      target[path.last.downcase.to_sym] =
+        deep_merge(target[path.last.downcase.to_sym], v)
     end
 
     if (rollbar_config = config(:rollbar)) && rollbar_config[:access_token]

data/lib/etna/auth.rb

@@ -76,23 +76,63 @@ module Etna
       # some routes don't need janus approval
       return true if route && route.ignore_janus?
 
-      # only process task tokens right now
-      return true unless payload['task']
+      # process task tokens
+      payload['task'] ? valid_task_token?(token) : true
+    end
+
+    def resource_projects(token)
+      return [] unless has_janus_config?
 
-      return false unless application.config(:janus) && application.config(:janus)[:host]
+      janus_client(token).get_projects.projects.select do |project|
+        project.resource
+      end
+    rescue
+      # If encounter any issue with Janus, we'll return no resource projects
+      []
+    end
 
-      janus_client = Etna::Clients::Janus.new(
+    def janus_client(token)
+      Etna::Clients::Janus.new(
         token: token,
         host: application.config(:janus)[:host]
       )
+    end
+
+    def valid_task_token?(token)
+      return false unless has_janus_config?
 
-      response = janus_client.validate_task_token
+      response = janus_client(token).validate_task_token
 
       return false unless response.code == '200'
 
       return true
     end
 
+    def has_janus_config?
+      application.config(:janus) && application.config(:janus)[:host]
+    end
+
+    def update_payload(payload, token, request)
+      route = server.find_route(request)
+
+      payload = payload.map{|k,v| [k.to_sym, v]}.to_h
+
+      return payload unless route
+
+      begin      
+        permissions = Etna::Permissions.from_encoded_permissions(payload[:perm])
+
+        resource_projects(token).each do |resource_project|
+          permissions.add_permission(
+            Etna::Permission.new('v', resource_project.project_name)
+          )
+        end
+        payload[:perm] = permissions.to_string
+      end if (!route.ignore_janus? && route.has_user_constraint?(:can_view?))
+
+      payload
+    end
+
     def approve_user(request)
       token = request.cookies[application.config(:token_name)] || auth(request, :etna)
 
@@ -102,8 +142,11 @@ module Etna
         payload, header = application.sign.jwt_decode(token)
 
         return false unless janus_approved?(payload, token, request)
-        return request.env['etna.user'] = Etna::User.new(payload.map{|k,v| [k.to_sym, v]}.to_h, token)
-      rescue
+        return request.env['etna.user'] = Etna::User.new(
+          update_payload(payload, token, request),
+          token)
+      rescue => e
+        application.logger.log_error(e)
         # bail out if anything goes wrong
         return false
       end

data/lib/etna/clients/janus/client.rb

@@ -8,25 +8,33 @@ module Etna
   module Clients
     class Janus < Etna::Clients::BaseClient
       def get_project(get_project_request = GetProjectRequest.new)
-        html = nil
+        json = nil
         @etna_client.get(
-          "/project/#{get_project_request.project_name}",
-          get_project_request) do |res|
-          html = res.body
+          "/api/admin/#{get_project_request.project_name}/info") do |res|
+            json = JSON.parse(res.body, symbolize_names: true)
         end
 
-        HtmlResponse.new(html)
+        GetProjectResponse.new(json)
+      end
+
+      def get_projects()
+        json = nil
+        @etna_client.get('/api/user/projects') do |res|
+          json = JSON.parse(res.body, symbolize_names: true)
+        end
+
+        GetProjectsResponse.new(json)
       end
 
       def add_project(add_project_request = AddProjectRequest.new)
-        @etna_client.post('/add_project', add_project_request) do |res|
+        @etna_client.post('/api/admin/add_project', add_project_request) do |res|
           # Redirect, no response data
         end
       end
 
       def add_user(add_user_request = AddUserRequest.new)
         @etna_client.post(
-          "/add_user/#{add_user_request.project_name}",
+          "/api/admin/#{add_user_request.project_name}/add_user",
           add_user_request) do |res|
           # Redirect, no response data
         end
@@ -34,7 +42,7 @@ module Etna
 
       def update_permission(update_permission_request = UpdatePermissionRequest.new)
         @etna_client.post(
-          "/update_permission/#{update_permission_request.project_name}",
+          "/api/admin/#{update_permission_request.project_name}/update_permission",
           update_permission_request) do |res|
           # Redirect, no response data
         end
@@ -42,16 +50,7 @@ module Etna
 
       def refresh_token(refresh_token_request = RefreshTokenRequest.new)
         token = nil
-        @etna_client.get('/refresh_token', refresh_token_request) do |res|
-          token = res.body
-        end
-
-        TokenResponse.new(token)
-      end
-
-      def viewer_token(viewer_token_request = ViewerTokenRequest.new)
-        token = nil
-        @etna_client.get('/viewer_token', viewer_token_request) do |res|
+        @etna_client.post('/api/tokens/generate') do |res|
           token = res.body
         end
 

data/lib/etna/clients/janus/models.rb

@@ -69,6 +69,54 @@ module Etna
         end
       end
 
+      class GetProjectResponse
+        attr_reader :raw
+
+        def initialize(raw = '')
+          @raw = raw
+        end
+
+        def project
+          Project.new(@raw[:project])
+        end
+      end
+
+      class GetProjectsResponse
+        attr_reader :raw
+
+        def initialize(raw = '')
+          @raw = raw
+        end
+
+        def projects
+          @raw[:projects].map do |project|
+            Project.new(project)
+          end
+        end
+      end
+
+      class Project
+        def initialize(raw = '')
+          @raw = raw
+        end
+
+        def project_name
+          @raw[:project_name]
+        end
+
+        def project_name_full
+          @raw[:project_name_full]
+        end
+
+        def permissions
+          @raw[:permissions] || []
+        end
+
+        def resource
+          !!@raw[:resource]
+        end
+      end
+
       class TokenResponse
         attr_reader :raw
 

data/lib/etna/clients/magma/client.rb

@@ -6,6 +6,47 @@ require_relative './models'
 
 module Etna
   module Clients
+    class LocalMagmaClient # May only be used from within magma app.
+      def logger
+        ::Magma.instance.logger
+      end
+
+      def user
+        permissions = Etna::Permissions.new([])
+        permissions.add_permission(Etna::Permission.new('A', 'administration'))
+        @user ||= Etna::User.new({name: 'Admin', email: 'etnaagent@ucsf.edu', perm: permissions.to_string})
+      end
+
+      def fake_request(request)
+        Rack::Request.new({
+          'rack.request.params' => request.as_json,
+          'etna.logger' => self.logger,
+          'etna.user' => user,
+          'etna.request_id' => 'local',
+        })
+      end
+
+      def parse_json_response(response)
+        status, headers, body = response
+        body = body.join('')
+        if status < 200 || status >= 300
+          raise Etna::Error.new(body, status)
+        end
+
+        JSON.parse(body)
+      end
+
+      def retrieve(retrieval_request = RetrievalRequest.new)
+        controller = ::RetrieveController.new(fake_request(retrieval_request), nil)
+        Magma::RetrievalResponse.new(parse_json_response(controller.action))
+      end
+
+      def update_model(update_model_request = UpdateModelRequest.new)
+        controller = ::UpdateModelController.new(fake_request(update_model_request), nil)
+        Magma::UpdateModelResponse.new(parse_json_response(controller.action))
+      end
+    end
+
     class Magma < Etna::Clients::BaseClient
       # This endpoint returns models and records by name:
       # e.g. params:

data/lib/etna/clients/magma/models.rb

@@ -22,12 +22,12 @@ module Etna
         include JsonSerializableStruct
       end
 
-      class UpdateRequest < Struct.new(:revisions, :project_name, keyword_init: true)
+      class UpdateRequest < Struct.new(:revisions, :project_name, :dry_run, keyword_init: true)
         include JsonSerializableStruct
         include MultipartSerializableNestedHash
 
         def initialize(**params)
-          super({revisions: {}}.update(params))
+          super({revisions: {}, dry_run: false}.update(params))
         end
 
         def update_revision(model_name, record_name, attrs)
@@ -110,7 +110,7 @@ module Etna
         include JsonSerializableStruct
       end
 
-      class AddProjectAction < Struct.new(:action_name, keyword_init: true)
+      class AddProjectAction < Struct.new(:action_name, :no_metis_bucket, keyword_init: true)
         include JsonSerializableStruct
 
         def initialize(**args)
@@ -215,8 +215,8 @@ module Etna
         end
 
         def model(model_key)
-          return nil unless raw.include?(model_key)
-          Model.new(raw[model_key])
+          return nil unless raw.include?(model_key.to_s)
+          Model.new(raw[model_key.to_s])
         end
 
         def all
@@ -434,8 +434,8 @@ module Etna
         end
 
         def attribute(attribute_key)
-          return nil unless raw.include?(attribute_key)
-          Attribute.new(raw[attribute_key])
+          return nil unless raw.include?(attribute_key.to_s)
+          Attribute.new(raw[attribute_key.to_s])
         end
 
         def build_attribute(key)

data/lib/etna/clients/magma/workflows/json_validators.rb

@@ -172,10 +172,6 @@ module Etna
           link_attributes.each do |attribute|
             check_key("attribute #{attribute.attribute_name}", attribute.raw, 'link_model_name')
 
-            if attribute.attribute_name != attribute.link_model_name
-              @errors << "Linked model, \"#{attribute.link_model_name}\", does not match attribute #{attribute.attribute_name}, link attribute names must match the model name."
-            end
-
             unless @models.model_keys.include?(attribute.link_model_name)
               @errors << "Linked model, \"#{attribute.link_model_name}\", on attribute #{attribute.attribute_name} does not exist!"
             end

data/lib/etna/clients/magma/workflows/model_synchronization_workflow.rb

@@ -29,7 +29,7 @@ module Etna
         end
 
         def execute_planned!
-          @planned_actions.each do |action|
+          planned_actions.each do |action|
             execute_update(action)
           end
         end
@@ -161,7 +161,7 @@ module Etna
           return if target_attributes.attribute_keys.include?(target_link_model_name)
 
           add_link = AddLinkAction.new
-          add_link.links << AddLinkDefinition.new(model_name: target_model_name, attribute_name: target_link_model_name, type: source_attribute.attribute_type)
+          add_link.links << AddLinkDefinition.new(model_name: target_model_name, attribute_name: attribute_name, type: source_attribute.attribute_type)
           add_link.links << AddLinkDefinition.new(model_name: target_link_model_name, attribute_name: reciprocal.attribute_name, type: reciprocal.attribute_type)
 
           queue_update(add_link)

data/lib/etna/clients/metis/client.rb

@@ -24,8 +24,13 @@ module Etna
       end
 
       def list_folder(list_folder_request = ListFolderRequest.new)
-        FoldersAndFilesResponse.new(
-          @etna_client.folder_list(list_folder_request.to_h))
+        if list_folder_request.folder_path != ''
+          FoldersAndFilesResponse.new(
+            @etna_client.folder_list(list_folder_request.to_h))
+        else
+          FoldersAndFilesResponse.new(
+            @etna_client.bucket_list(list_folder_request.to_h))
+        end
       end
 
       def list_folder_by_id(list_folder_by_id_request = ListFolderByIdRequest.new)

data/lib/etna/clients/metis/models.rb

@@ -50,7 +50,10 @@ module Etna
         end
       end
 
-      class ListFolderRequest < Struct.new(:project_name, :bucket_name, :folder_path, keyword_init: true)
+      class FolderRequest < Struct.new(:project_name, :bucket_name, :folder_path, keyword_init: true)
+      end
+
+      class ListFolderRequest < FolderRequest
         include JsonSerializableStruct
 
         def initialize(**params)
@@ -110,7 +113,7 @@ module Etna
         end
       end
 
-      class CreateFolderRequest < Struct.new(:project_name, :bucket_name, :folder_path, keyword_init: true)
+      class CreateFolderRequest < FolderRequest
         include JsonSerializableStruct
 
         def initialize(**params)
@@ -125,7 +128,7 @@ module Etna
         end
       end
 
-      class DeleteFolderRequest < Struct.new(:project_name, :bucket_name, :folder_path, keyword_init: true)
+      class DeleteFolderRequest < FolderRequest
         include JsonSerializableStruct
 
         def initialize(**params)

data/lib/etna/clients/metis/workflows/metis_download_workflow.rb

@@ -18,7 +18,7 @@ module Etna
           completed = 0.0
           start = Time.now
 
-          unless dest_file_or_io.is_a?(IO)
+          unless dest_file_or_io.is_a?(IO) || dest_file_or_io.is_a?(StringIO)
             ::File.open(dest_file_or_io, 'w') do |io|
               return do_download(dest_file_or_io, metis_file, &block)
             end

data/lib/etna/clients/metis/workflows/walk_metis_diff_workflow.rb

@@ -0,0 +1,95 @@
+module Etna
+  module Clients
+    class Metis
+      class WalkMetisDiffWorkflow < Struct.new(:left_walker, :right_walker, keyword_init: true)
+        # Iterates entries of the form [kind, left | nil, right | nil]
+        # where kind is one of
+        #   :left_unique | :right_unique | :left_is_folder | :right_is_folder
+        #   :unknown | :equal | :right_older | :left_older
+        # and left / right is one of
+        #   nil | Etna::Clients::Metis::File | Etna::Clients::Metis::Folder
+        def each(&block)
+          left_enum = self.left_walker.to_enum
+          right_enum = self.right_walker.to_enum
+
+          l, l_path = next_or_nil(left_enum)
+          r, r_path = next_or_nil(right_enum)
+
+          while l && r
+            if l_path == r_path
+              yield [compare_file_or_folders(l, r), l, r]
+
+              l, l_path = next_or_nil(left_enum)
+              r, r_path = next_or_nil(right_enum)
+            elsif l_path < r_path
+              yield [:left_unique, l, nil]
+              l, l_path = next_or_nil(left_enum)
+            else
+              yield [:right_unique, nil, r]
+              r, r_path = next_or_nil(right_enum)
+            end
+          end
+
+          while l
+            yield [:left_unique, l, nil]
+            l, l_path = next_or_nil(left_enum)
+          end
+
+          while r
+            yield [:right_unique, nil, r]
+            r, r_path = next_or_nil(right_enum)
+          end
+        end
+
+        def next_or_nil(enum)
+          enum.next
+        rescue StopIteration
+          [nil, nil]
+        end
+
+        def compare_file_or_folders(l, r)
+          if l.is_a?(Etna::Clients::Metis::Folder)
+            if r.is_a?(Etna::Clients::Metis::Folder)
+              return compare_file_or_folder_age(l, r)
+            end
+
+            return :left_is_folder
+          end
+
+          if r.is_a?(Etna::Clients::Metis::Folder)
+            return :right_is_folder
+          end
+
+
+          if l.file_hash.nil? || r.file_hash.nil?
+            return :unknown
+          end
+
+          if l.file_hash == r.file_hash
+            return :equal
+          end
+
+          return compare_file_or_folder_age(l, r)
+        end
+
+        def compare_file_or_folder_age(l, r)
+          if l.updated_at.nil?
+            return :unknown
+          end
+
+          if r.updated_at.nil?
+            return :unknown
+          end
+
+          if l.updated_at < r.updated_at
+            return :left_older
+          elsif l.updated_at > r.updated_at
+            return :right_older
+          else
+            return :equal
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etna/clients/metis/workflows/walk_metis_workflow.rb

@@ -0,0 +1,31 @@
+module Etna
+  module Clients
+    class Metis
+      class WalkMetisWorkflow < Struct.new(:metis_client, :project_name,
+          :bucket_name, :logger, :root_dir, keyword_init: true)
+        def each(&block)
+          q = [self.root_dir]
+
+          while (n = q.pop)
+            req = Etna::Clients::Metis::ListFolderRequest.new(
+              project_name: project_name,
+              bucket_name: bucket_name,
+              folder_path: n
+            )
+            next unless metis_client.folder_exists?(req)
+            resp = metis_client.list_folder(req)
+
+            resp.files.all.sort_by { |f| f.file_path[self.root_dir.length..-1] }.each do |file|
+              yield [file, file.file_path[self.root_dir.length..-1]]
+            end
+
+            resp.folders.all.sort_by { |f| f.folder_path[self.root_dir.length..-1] }.each do |f|
+              yield [f, f.folder_path[self.root_dir.length..-1]]
+              q << f.folder_path
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etna/clients/metis/workflows.rb

@@ -2,3 +2,5 @@ require_relative "./workflows/metis_download_workflow"
 require_relative "./workflows/metis_upload_workflow"
 require_relative "./workflows/sync_metis_data_workflow"
 require_relative "./workflows/ingest_metis_data_workflow"
+require_relative "./workflows/walk_metis_workflow"
+require_relative "./workflows/walk_metis_diff_workflow"

data/lib/etna/controller.rb

@@ -48,6 +48,34 @@ module Etna
       return handle_error(error) if error
     end
 
+    def try_stream(content_type, &block)
+      if @request.env['rack.hijack?']
+        @request.env['rack.hijack'].call
+        stream = @request.env['rack.hijack_io']
+
+        headers = [
+          "HTTP/1.1 200 OK",
+          "Content-Type: #{content_type}"
+        ]
+        stream.write(headers.map { |header| header + "\r\n" }.join)
+        stream.write("\r\n")
+        stream.flush
+
+        Thread.new do
+          block.call(stream)
+        ensure
+          stream.close
+        end
+
+        # IO is now streaming and will be processed by above thread.
+        @response.close
+      else
+        @response['Content-Type'] = content_type
+        block.call(@response)
+        @response.finish
+      end
+    end
+
     def require_params(*params)
       missing_params = params.reject{|p| @params.key?(p) }
       raise Etna::BadRequest, "Missing param #{missing_params.join(', ')}" unless missing_params.empty?

data/lib/etna/permissions.rb

@@ -0,0 +1,99 @@
+module Etna
+  class Permissions
+    def initialize(permissions)
+      @permissions = permissions
+    end
+
+    def self.from_encoded_permissions(encoded_permissions)
+      perms = encoded_permissions.split(/\;/).map do |roles|
+        role, projects = roles.split(/:/)
+
+        projects.split(/\,/).reduce([]) do |perms, project_name|
+          perms << Etna::Permission.new(role, project_name)
+        end
+      end.flatten
+
+      Etna::Permissions.new(perms)
+    end
+
+    def self.from_hash(permissions_hash)
+      perms = permissions_hash.map do |project_name, role_hash|
+        Etna::Permission.new(
+          Etna::Role.new(role_hash[:role], role_hash[:restricted]).key,
+          project_name
+        )
+      end
+
+      Etna::Permissions.new(perms)
+    end
+
+    def to_string
+      @permissions_string ||= @permissions.group_by(&:role_key)
+        .sort_by(&:first)
+        .map do |role_key, permissions|
+        [
+          role_key,
+          permissions.map(&:project_name).sort.join(","),
+        ].join(":")
+      end.join(";")
+    end
+
+    def to_hash
+      @permissions_hash ||= @permissions.map do |permission|
+        [permission.project_name, permission.to_hash]
+      end.to_h
+    end
+
+    def add_permission(permission)
+      return if current_project_names.include?(permission.project_name)
+
+      @permissions << permission
+    end
+
+    private
+
+    def current_project_names
+      @permissions.map(&:project_name)
+    end
+  end
+
+  class Permission
+    attr_reader :role, :project_name, :role_key
+
+    ROLE_NAMES = {
+      "A" => :admin,
+      "E" => :editor,
+      "V" => :viewer,
+    }
+
+    def initialize(role_key, project_name)
+      @role_key = role_key
+      @role = Etna::Role.new(ROLE_NAMES[role_key.upcase], role_key == role_key.upcase)
+      @project_name = project_name
+    end
+
+    def to_hash
+      role.to_hash
+    end
+  end
+
+  class Role
+    attr_reader :role, :restricted
+    def initialize(role, restricted)
+      @role = role
+      @restricted = restricted
+    end
+
+    def key
+      role_key = role.to_s[0]
+      restricted ? role_key.upcase : role_key
+    end
+
+    def to_hash
+      {
+        role: role,
+        restricted: restricted,
+      }
+    end
+  end
+end

data/lib/etna/route.rb

@@ -154,6 +154,10 @@ module Etna
       @auth && @auth[:ignore_janus]
     end
 
+    def has_user_constraint?(constraint)
+      @auth && @auth[:user] && @auth[:user][constraint]
+    end
+
     private
 
     def application

data/lib/etna/spec/vcr.rb

@@ -1,9 +1,27 @@
+require 'cgi'
 require 'webmock/rspec'
 require 'vcr'
 require 'openssl'
 require 'digest/sha2'
 require 'base64'
 
+def clean_query(json_or_string)
+  if json_or_string.is_a?(Hash) && json_or_string.include?('upload_path')
+    json_or_string['upload_path'] = clean_query(json_or_string['upload_path'])
+    json_or_string
+  elsif json_or_string.is_a?(String)
+    uri = URI(json_or_string)
+
+    if uri.query&.include?('X-Etna-Signature')
+      uri.query = 'etna-signature'
+    end
+
+    uri.to_s
+  else
+    json_or_string
+  end
+end
+
 def setup_base_vcr(spec_helper_dir, server: nil, application: nil)
   VCR.configure do |c|
     c.hook_into :webmock
@@ -30,6 +48,10 @@ def setup_base_vcr(spec_helper_dir, server: nil, application: nil)
       end
     end
 
+    c.register_request_matcher :try_uri do |request_1, request_2|
+      clean_query(request_1.uri) == clean_query(request_2.uri)
+    end
+
     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/
@@ -40,7 +62,7 @@ def setup_base_vcr(spec_helper_dir, server: nil, application: nil)
             JSON.parse(request_2.body) rescue 'not-json'
           end
 
-          request_1_json == request_2_json
+          clean_query(request_1_json) == clean_query(request_2_json)
         else
           false
         end
@@ -49,7 +71,9 @@ def setup_base_vcr(spec_helper_dir, server: nil, application: nil)
       end
     end
 
-    # c.debug_logger = File.open('log/vcr_debug.log', 'w')
+    if File.exists?('log')
+      c.debug_logger = File.open('log/vcr_debug.log', 'w')
+    end
 
     c.default_cassette_options = {
         serialize_with: :compressed,
@@ -58,7 +82,7 @@ def setup_base_vcr(spec_helper_dir, server: nil, application: nil)
         else
           ENV['RERECORD'] ? :all : :once
         end,
-        match_requests_on: [:method, :uri, :try_body, :verify_uri_route]
+        match_requests_on: [:method, :try_uri, :try_body, :verify_uri_route]
     }
 
     # Filter the authorization headers of any request by replacing any occurrence of that request's

data/lib/etna/test_auth.rb

@@ -31,6 +31,24 @@ module Etna
       end.to_h
     end
 
+    def update_payload(payload, token, request)
+      route = server.find_route(request)
+
+      payload = payload.map{|k,v| [k.to_sym, v]}.to_h
+
+      return payload unless route
+
+      begin      
+        permissions = Etna::Permissions.from_encoded_permissions(payload[:perm])
+
+        # Skip making an actual call to Janus. This behavior is tested in auth_spec
+
+        payload[:perm] = permissions.to_string
+      end if (!route.ignore_janus? && route.has_user_constraint?(:can_view?))
+
+      payload
+    end
+
     def approve_user(request)
       token = auth(request,:etna)
 
@@ -42,7 +60,10 @@ module Etna
       # We do this to support Metis client tests, we pass in tokens with multiple "."-separated parts, so
       #   have to account for that.
       payload = JSON.parse(Base64.decode64(token.split('.')[1]))
-      request.env['etna.user'] = Etna::User.new(payload.map{|k,v| [k.to_sym, v]}.to_h, token)
+      request.env['etna.user'] = Etna::User.new(
+        update_payload(payload, token, request),
+        token
+      )
     end
 
     def approve_hmac(request)

data/lib/etna/user.rb

@@ -1,11 +1,7 @@
+require_relative './permissions'
+
 module Etna
   class User
-    ROLE_NAMES = {
-      'A' => :admin,
-      'E' => :editor,
-      'V' => :viewer
-    }
-
     def initialize params, token=nil
       @name, @email, @encoded_permissions, encoded_flags, @task = params.values_at(:name, :email, :perm, :flags, :task)
 
@@ -21,19 +17,7 @@ module Etna
     end
 
     def permissions
-      @permissions ||= @encoded_permissions.split(/\;/).map do |roles|
-        role, projects = roles.split(/:/)
-
-        projects.split(/\,/).reduce([]) do |perms,project_name|
-          perms.push([
-            project_name,
-            {
-              role: ROLE_NAMES[role.upcase],
-              restricted: role == role.upcase
-            }
-          ])
-        end
-      end.inject([],:+).to_h
+      @permissions ||= Etna::Permissions.from_encoded_permissions(@encoded_permissions).to_hash
     end
 
     def has_flag?(flag)
@@ -44,12 +28,6 @@ module Etna
       permissions.keys
     end
 
-    ROLE_MATCH = {
-      admin: /[Aa]/,
-      editor: /[Ee]/,
-      viewer: /[Vv]/,
-      restricted: /[AEV]/,
-    }
     def has_any_role?(project, *roles)
       perm = permissions[project.to_s]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: etna
 version: !ruby/object:Gem::Version
-  version: 0.1.43
+  version: 0.1.44
 platform: ruby
 authors:
 - Saurabh Asthana
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-28 00:00:00.000000000 Z
+date: 2022-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -177,6 +177,8 @@ files:
 - lib/etna/clients/metis/workflows/metis_download_workflow.rb
 - lib/etna/clients/metis/workflows/metis_upload_workflow.rb
 - lib/etna/clients/metis/workflows/sync_metis_data_workflow.rb
+- lib/etna/clients/metis/workflows/walk_metis_diff_workflow.rb
+- lib/etna/clients/metis/workflows/walk_metis_workflow.rb
 - lib/etna/clients/polyphemus.rb
 - lib/etna/clients/polyphemus/client.rb
 - lib/etna/clients/polyphemus/models.rb
@@ -201,6 +203,7 @@ files:
 - lib/etna/metrics.rb
 - lib/etna/multipart_serializable_nested_hash.rb
 - lib/etna/parse_body.rb
+- lib/etna/permissions.rb
 - lib/etna/remote.rb
 - lib/etna/route.rb
 - lib/etna/server.rb