etna 0.1.45 → 0.1.46

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 217bba41b5188f5d0e2349ba31dcb6f84477a3dcb36d04fd598977e814190ae8
-  data.tar.gz: 758215abeb4ce074eb9dc6dd0313a3d271f2875f4071314cc7db30e9c4f19ad6
+  metadata.gz: bf5d46399bfc782d537d246013aeb1cc16bf3b56c8040f84baa92a36c5949fda
+  data.tar.gz: 32fabdd9b634b7a0026b8277a55635c16be52e30a60cd7568e8c68938d44d221
 SHA512:
-  metadata.gz: 52f1098ebc84e4fef32e8230246c09415adaf010bc748231fbcb3062f66aa7b43d2a34e78c99f43d3186f4d856d2f80447da72f15ccd47b0445936c5658f4d77
-  data.tar.gz: 9c3feccc37d002e3493052aee8eccf3c6fedcfbf79a7251eda1a68d1324f4e05908e4dfc5d7c20996be34c448c739706e0e6a38fbc5a582918ebf0e4ea7859fc
+  metadata.gz: f7b48496c8b36afe4aa6f08ef911913bfee6233b3ce50f17e723b38aef03f3aa2b7c9ee6beab94748fa42ff67bfcf68bb73145962ce102d79593055025c439d4
+  data.tar.gz: 4f074e556b455f2e6a2e36b30212b781316f198acfa99879059c803d2254ae701bd784adf515e1fb3427734a299546d42a182f08908645ff340ae5a9581dcb91

data/lib/etna/clients/magma/formatting/models_csv.rb

@@ -22,6 +22,7 @@ module Etna
                 :new_attribute_name,
                 :attribute_type,
                 :link_model_name,
+                :link_attribute_name,
                 :description,
                 :display_name,
                 :format_hint,
@@ -114,7 +115,10 @@ module Etna
             if attribute.attribute_type == Etna::Clients::Magma::AttributeType::IDENTIFIER
               # Identifiers for models whose parent link type ends up being a table are non configurable, so we don't
               # want to include them in the CSV.
-              if models.find_reciprocal(model: model, link_attribute_name: model.template.parent)&.attribute_type == Etna::Clients::Magma::AttributeType::TABLE
+              if models.find_reciprocal(
+                model: model,
+                link_attribute_name: model.name,
+                link_model: models.model(model.template.parent))&.attribute_type == Etna::Clients::Magma::AttributeType::TABLE
                 return
               end
             else
@@ -137,6 +141,7 @@ module Etna
                 attribute_name: attribute.name,
                 attribute_type: attribute.attribute_type,
                 link_model_name: attribute.link_model_name,
+                link_attribute_name: attribute.link_attribute_name,
                 reciprocal_link_type: models.find_reciprocal(model: model, attribute: attribute)&.attribute_type,
                 description: attribute.description,
                 display_name: attribute.display_name,
@@ -175,7 +180,7 @@ module Etna
           # This should line up with the attribute names _on the model itself_.
           ATTRIBUTE_ROW_ENTRIES = [
               :attribute_type,
-              :link_model_name, :description,
+              :link_model_name, :link_attribute_name, :description,
               :display_name, :format_hint,
               :restricted, :read_only,
               :validation, :attribute_group,
@@ -223,6 +228,7 @@ module Etna
             end
           rescue ImportError => e
             validation_err_block.call(e.message)
+            raise e
           end
 
 
@@ -255,7 +261,11 @@ module Etna
             end
 
             row_processor.process(:parent_link_type, :model_name, :parent_model_name) do |parent_link_type, template|
-              reciprocal = models.find_reciprocal(model_name: template.name, link_attribute_name: template.parent)
+              reciprocal = models.find_reciprocal(
+                model_name: template.name,
+                link_attribute_name: template.name,
+                link_model: models.model(template.parent)
+              )
               if reciprocal && reciprocal.attribute_type.to_s != parent_link_type
                 raise ImportError.new("Model #{template.name} was provided multiple parent_link_types: #{reciprocal.attribute_type} and #{parent_link_type}")
               end
@@ -333,7 +343,7 @@ module Etna
                 att.send(:"#{prop_name}=", value)
 
                 if att.attribute_type && att.link_model_name
-                  if att.attribute_type == Etna::Clients::Magma::AttributeType::LINK && models.find_reciprocal(model_name: template.name, attribute: att).nil?
+                  if att.attribute_type == Etna::Clients::Magma::AttributeType::LINK && models.find_reciprocal(model_name: template.name, attribute: att, link_attribute_name: att.link_attribute_name).nil?
                     models.build_model(att.link_model_name).build_template.build_attributes.build_attribute(template.name).tap do |rec_att|
                       rec_att.attribute_name = rec_att.name = template.name
                       rec_att.display_name = prettify(template.name)

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

@@ -239,6 +239,9 @@ module Etna
             link_model: self.model(attribute&.link_model_name)
         )
           return nil if model.nil? || model.name.nil?
+
+          return link_model&.template&.attributes&.all&.find { |a| a.name == link_attribute_name } if link_attribute_name
+
           link_model&.template&.attributes&.all&.find { |a| a.link_model_name == model.name }
         end
 
@@ -457,7 +460,7 @@ module Etna
         def is_edited?(other)
           # Don't just override == in case need to do a full comparison.
           editable_attribute_names = Attribute::EDITABLE_ATTRIBUTE_ATTRIBUTES.map(&:to_s)
-          
+
           self_editable = raw.slice(*editable_attribute_names)
           other_editable = other.raw.slice(*editable_attribute_names)
 
@@ -505,6 +508,14 @@ module Etna
           @raw['attribute_type'] = val
         end
 
+        def link_attribute_name
+          @raw['link_attribute_name']
+        end
+
+        def link_attribute_name=(val)
+          @raw['link_attribute_name'] = val
+        end
+
         def link_model_name
           @raw['link_model_name']
         end

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

@@ -113,7 +113,11 @@ module Etna
         end
 
         def parent_reciprocal_attribute
-          @models.find_reciprocal(model: @model, link_attribute_name: @model.template.parent)
+          @models.find_reciprocal(
+            model: @model,
+            link_attribute_name: @model.name,
+            link_model: @models.model(@model.template.parent)
+          )
         end
 
         def name

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

@@ -131,7 +131,7 @@ module Etna
             unless attribute.attribute_type == AttributeType::PARENT
               if attribute.link_model_name
                 ensure_model(attribute.link_model_name)
-                ensure_model_link(model_name, attribute.link_model_name, attribute.attribute_name)
+                ensure_model_link(model_name, attribute.link_model_name, attribute.attribute_name, attribute.link_attribute_name)
               else
                 ensure_model_attribute(model_name, attribute.attribute_name)
               end
@@ -144,26 +144,26 @@ module Etna
           end
         end
 
-        def ensure_model_link(model_name, link_model_name, attribute_name)
+        def ensure_model_link(model_name, link_model_name, attribute_name, link_attribute_name)
           return unless (model = source_models.model(model_name))
           return unless (source_attribute = model.template.attributes.attribute(attribute_name))
 
           return unless (link_model = source_models.model(link_model_name))
-          link_model_attributes = link_model.template.attributes
-          reciprocal = link_model_attributes.all.find do |attr|
-            attr.link_model_name == model_name
-          end
+          return unless (reciprocal = link_model.template.attributes.attribute(link_attribute_name))
 
           target_model_name = target_of_source(model_name)
           target_link_model_name = target_of_source(link_model_name)
 
           target_attributes = target_models.model(target_model_name).template.attributes
           return if target_attributes.attribute_keys.include?(target_link_model_name)
+          return if target_attributes.attribute_keys.include?(reciprocal.attribute_name)
+
+          # skip non-links for circular references so they don't get added twice
+          return if link_model_name == model_name && reciprocal.attribute_type != 'link'
 
           add_link = AddLinkAction.new
           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)
         end
 

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

@@ -6,6 +6,8 @@ module Etna
   module Clients
     class Metis
       class SyncMetisDataWorkflow < Struct.new(:metis_client, :filesystem, :project_name, :bucket_name, :logger, keyword_init: true)
+        DOWNLOAD_REGEX = /^https:\/\/[^\/]*\/(?<project_name>.*)\/download\/(?<bucket_name>.*)\/(?<file_path>[^\?]*).*$/
+
         def copy_directory(src, dest, root = dest)
           response = metis_client.list_folder(ListFolderRequest.new(project_name: project_name, bucket_name: bucket_name, folder_path: src))
 
@@ -20,6 +22,27 @@ module Etna
         end
 
         def copy_file(dest:, url:, stub: false)
+          # This does not work due to the magma bucket's restrictions, but if it did work, it'd be super sweet.
+          # url_match = DOWNLOAD_REGEX.match(url)
+          #
+          # if filesystem.instance_of?(Etna::Filesystem::Metis) && !url_match.nil?
+          #   bucket_name = url_match[:bucket_name]
+          #   project_name = url_match[:project_name]
+          #   file_path = url_match[:file_path]
+          #
+          #   metis_client.copy_files(
+          #     Etna::Clients::Metis::CopyFilesRequest.new(
+          #       project_name: project_name,
+          #       revisions: [
+          #         Etna::Clients::Metis::CopyRevision.new(
+          #           source: "metis://#{project_name}/#{bucket_name}/#{file_path}",
+          #           dest: "metis://#{filesystem.project_name}/#{filesystem.bucket_name}#{dest}",
+          #         )
+          #       ]
+          #     )
+          #   )
+          # end
+
           metadata = metis_client.file_metadata(url)
           size = metadata[:size]
 

data/lib/etna/filesystem.rb

@@ -251,6 +251,8 @@ module Etna
     end
 
     class Metis < Filesystem
+      attr_reader :project_name, :bucket_name
+
       def initialize(metis_client:, project_name:, bucket_name:, root: '/', uuid: SecureRandom.uuid)
         @metis_client = metis_client
         @project_name = project_name

data/lib/etna/route.rb

@@ -38,11 +38,11 @@ module Etna
 
     UNSAFE=/[^\-_.!~*'()a-zA-Z\d;\/?:@&=+$,]/
 
-    def self.path(route, params=nil)
+    def self.path(route, params=nil, &block)
       if params
         PARAM_TYPES.reduce(route) do |path,pat|
           path.gsub(pat) do
-            params[$1.to_sym].split('/').map { |c| URI.encode_www_form_component(c) }.join('/')
+            params[$1.to_sym].split('/').map { |c| block_given? ? yield(c) : URI.encode_www_form_component(c) }.join('/')
           end
         end
       else
@@ -50,8 +50,8 @@ module Etna
       end
     end
 
-    def path(params=nil)
-      self.class.path(@route, params)
+    def path(params=nil, &block)
+      self.class.path(@route, params, &block)
     end
 
     def parts

data/lib/etna/server.rb

@@ -3,7 +3,19 @@ module Etna
   class Server
     class << self
       def route(method, path, options={}, &block)
-        @routes ||= []
+        # For healthchecks, set up servers
+        #   with an OPTIONS route on /, with noauth
+        @routes ||= [
+          Etna::Route.new(
+            'OPTIONS',
+            '/',
+            {
+              auth: {
+                noauth: true
+              }
+            }
+          )
+        ]
 
         @routes << Etna::Route.new(
           method,

data/lib/etna/test_auth.rb

@@ -54,6 +54,9 @@ module Etna
 
       return false unless token
 
+      # Useful for testing certain behavior
+      params = request.env["rack.request.params"]
+
       # Here we simply base64-encode our user hash and pass it through
       # In order to behave more like "real" tokens, we expect the user hash to be
       #   in index 1 after splitting by ".".
@@ -63,7 +66,7 @@ module Etna
       request.env['etna.user'] = Etna::User.new(
         update_payload(payload, token, request),
         token
-      )
+      ) unless !!params[:do_not_set_user]
     end
 
     def approve_hmac(request)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: etna
 version: !ruby/object:Gem::Version
-  version: 0.1.45
+  version: 0.1.46
 platform: ruby
 authors:
 - Saurabh Asthana
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-29 00:00:00.000000000 Z
+date: 2022-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack