etna 0.1.52 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d6b6988d247bdac2da6cc841a5016a1aa5148fa4c34ad7f241b0257ea840fb8
-  data.tar.gz: 2958a486129aa27765188b608ba71498a8f01ab6f7955c5c0ff671dbb78c99ed
+  metadata.gz: ffd856f01fb2f4a29f162498157bf551dd3d1bb0ae2b65de37f4a7cd3ee094e1
+  data.tar.gz: 618661ad891fb65a7ff75e405f4b16b376bcbf76f2e4af35cecd861ba388738c
 SHA512:
-  metadata.gz: ad99e8e9d09c3c51d88b92ea3c92cac9b7584476e4f1631b8123673be6d272e78e6640bfed1a9a0217868c6dda27bd6276415c5b974854dcba60f7df30f642a6
-  data.tar.gz: 4b07429942fb8edb9cb131e64a3781c302dfcfcc5f74e151888fbb9e3bcddecd3f89b7b033e9ec41268e8bc5c5147e4b6884d063a391fbcdf4e0c4db91ab3976
+  metadata.gz: d257a17c567769bf16fee63592559b7ddde5ad26bd75e81ba0a1b287acae7e0295e80aa91c5eb27e3a3383829c66587434aa1bd7029a9dd7e29b0209801d038a
+  data.tar.gz: 4ffd6f992711147a6c6ed5b4abdf99833a82772a4e80436e3bf7e912b35186c162ef02720c2ea5f2393b0ba633058996343a11a08467f0e0cebd965df6f652bf

data/bin/etna

@@ -9,8 +9,8 @@ require 'yaml'
 require_relative '../lib/etna'
 require_relative '../lib/commands'
 
-config = if File.exists?(EtnaApp.config_file_path)
-  YAML.load(File.read(EtnaApp.config_file_path))
+config = if ::File.exist?(EtnaApp.config_file_path)
+  YAML.load(::File.read(EtnaApp.config_file_path))
 else
   {
     production: {

data/lib/commands.rb

@@ -328,15 +328,16 @@ class EtnaApp
         string_flags << '--target-model'
 
         def execute(project_name, target_model: 'project', file: "#{project_name}_models_#{target_model}_tree.csv")
-          unless File.exists?(file)
-            puts "File #{file} is being prepared from the #{project_name} project."
-            puts "Copying models descending from #{target_model}..."
-            prepare_template(file, project_name, target_model)
-            puts
-            puts "Done!  You can start editing the file #{file} now"
-          else
+          if ::File.exist?(file)
             puts "File #{file} already exists!  Please remove or specify a different file name before running again."
+            return
           end
+
+          puts "File #{file} is being prepared from the #{project_name} project."
+          puts "Copying models descending from #{target_model}..."
+          prepare_template(file, project_name, target_model)
+          puts
+          puts "Done!  You can start editing the file #{file} now"
         end
 
         def workflow
@@ -366,7 +367,7 @@ class EtnaApp
         def execute(project_name, target_model: 'project', file: "#{project_name}_models_#{target_model}_tree.csv")
           reset
 
-          unless File.exists?(file)
+          unless ::File.exist?(file)
             puts "Could not find file #{file}"
             return
           end
@@ -696,4 +697,5 @@ class EtnaApp
       super
     end
   end
+
 end

data/lib/etna/application.rb

@@ -144,6 +144,31 @@ module Etna::Application
   # the application logger is available globally
   attr_reader :logger
 
+  def event_log(project_name:, user:, event:, message:, payload: nil, application: nil, consolidate: nil)
+    begin
+      @polyphemus_client ||= Etna::Clients::Polyphemus.new(
+        token: nil,
+        host: config(:polyphemus)[:host],
+        routes_available: true,
+        logger: logger
+      )
+
+      @polyphemus_client.log(
+        project_name: project_name,
+        user: user.email,
+        event: event,
+        message: message,
+        payload: JSON.generate(payload),
+        consolidate: consolidate,
+        application: application,
+        signatory: self
+      )
+    rescue => e
+      logger.info("Could not log event #{event}, '#{message}'")
+      logger.log_error(e)
+    end
+  end
+
   def config(type, env = environment)
     return nil if @config.nil?
     return nil if @config[env].nil?
@@ -174,6 +199,14 @@ module Etna::Application
     ENV["APP_NAME"] || self.class.name.snake_case.split(/::/).last
   end
 
+  def host
+    URI(url).host
+  end
+
+  def url
+    config(id.to_sym)[:host]
+  end
+
   def find_descendents(klass)
     ObjectSpace.each_object(Class).select do |k|
       k < klass

data/lib/etna/auth.rb

@@ -64,7 +64,10 @@ module Etna
       uri = URI(
         application.config(:auth_redirect).chomp('/') + '/login'
       )
-      uri.query = URI.encode_www_form(refer: request.url)
+      refer = URI(
+        application.url + request.fullpath
+      )
+      uri.query = URI.encode_www_form(refer: refer)
       Etna::Redirect(request).to(uri.to_s)
     end
 
@@ -147,7 +150,7 @@ module Etna
       # Now expect the standard headers
       hmac_params = {
         method: request.request_method,
-        host: request.host,
+        host: application.host,
         path: request.path,
 
         expiration: etna_param(request, :expiration),

data/lib/etna/client.rb

@@ -4,7 +4,6 @@ require 'rack/utils'
 
 module Etna
   class Client
-
     def initialize(host, token, routes_available: true, ignore_ssl: false, max_retries: 10, backoff_time: 15, logger: nil)
       @host = host.sub(%r!/$!, '')
       @token = token
@@ -300,22 +299,18 @@ module Etna
 
       private
 
+      def verify_mode
+        @ignore_ssl ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+      end
+
       def request(uri, data)
-        if block_given?
-          verify_mode = @ignore_ssl ?
-            OpenSSL::SSL::VERIFY_NONE :
-            OpenSSL::SSL::VERIFY_PEER
-          Net::HTTP.start(uri.host, uri.port, use_ssl: true, verify_mode: verify_mode, read_timeout: 300) do |http|
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true, verify_mode: verify_mode, read_timeout: 300) do |http|
+          if block_given?
             http.request(data) do |response|
               api_error_check!(response)
               yield response
             end
-          end
-        else
-          verify_mode = @ignore_ssl ?
-            OpenSSL::SSL::VERIFY_NONE :
-            OpenSSL::SSL::VERIFY_PEER
-          Net::HTTP.start(uri.host, uri.port, use_ssl: true, verify_mode: verify_mode, read_timeout: 300) do |http|
+          else
             response = http.request(data)
             api_error_check!(response)
             return response

data/lib/etna/clients/base_client.rb

@@ -6,7 +6,7 @@ module Etna
   module Clients
     class BaseClient
       attr_reader :host, :token, :ignore_ssl
-      def initialize(host:, token:, ignore_ssl: false, logger: nil)
+      def initialize(host:, token:, ignore_ssl: false, logger: nil, routes_available: false)
         raise "#{self.class.name} client configuration is missing host." unless host
 
         @token = token
@@ -15,7 +15,7 @@ module Etna
         @etna_client = ::Etna::Client.new(
           host,
           token,
-          routes_available: false,
+          routes_available: routes_available,
           ignore_ssl: ignore_ssl,
           logger: logger)
         @host = host
@@ -27,6 +27,14 @@ module Etna
         token_will_expire?(0)
       end
 
+      def safe_parse(response)
+        if response['Content-Type'] == 'application/json'
+          return JSON.parse(response.body)
+        end
+
+        raise "Could not parse non-JSON response #{response.code} #{response.body} #{response.each_header.to_h}"
+      end
+
       def token_will_expire?(offset=3000)
         # offset in seconds
         # Will the user's token expire in the given amount of time?

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

@@ -0,0 +1,20 @@
+require 'net/http/post/multipart'
+require 'singleton'
+require_relative '../base_client'
+require_relative '../../client'
+require_relative './models'
+
+module Etna
+  module Clients
+    class Gnomon < Etna::Clients::BaseClient
+      def project_rules(project_name)
+        json = nil
+        @etna_client.get("/gnomon/#{project_name}/rules") do |res|
+          json = JSON.parse(res.body)
+        end
+
+        ProjectRulesResponse.new(json)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require_relative '../base_client'
+
+# TODO:  In the near future, I'd like to transition to specifying apis via SWAGGER and generating model stubs from the
+# common definitions.  For nowe I've written them out by hand here.
+module Etna
+  module Clients
+    class Gnomon < Etna::Clients::BaseClient
+      class ProjectRulesResponse
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def rules
+          Rules.new(raw['rules'])
+        end
+      end
+
+      class Rules
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def [](model_name)
+          raw[model_name.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/etna/clients/gnomon.rb

@@ -0,0 +1,2 @@
+require_relative './gnomon/client'
+require_relative './gnomon/models'

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

@@ -40,6 +40,14 @@ module Etna
         end
       end
 
+      def update_project(update_project_request = UpdateProjectRequest.new)
+        @etna_client.post(
+          "/api/admin/#{update_project_request.project_name}/update",
+          update_project_request) do |res|
+          # Redirect, no response data
+        end
+      end
+
       def update_permission(update_permission_request = UpdatePermissionRequest.new)
         @etna_client.post(
           "/api/admin/#{update_permission_request.project_name}/update_permission",
@@ -74,6 +82,24 @@ module Etna
 
         response.body
       end
+
+      def get_project_stats(get_stats_request = GetStatsRequest.new)
+        query = ""
+        unless get_stats_request.project_names.nil?
+          query = "?"
+          query += get_stats_request.project_names.map do |name|
+            "projects[]=#{name}"
+          end.join('&')
+        end
+
+        json = nil
+
+        @etna_client.get("/api/stats/projects#{query}") do |res|
+          json = JSON.parse(res.body, symbolize_names: true)
+        end
+
+        json
+      end
     end
   end
 end

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

@@ -31,6 +31,14 @@ module Etna
         end
       end
 
+      class UpdateProjectRequest < Struct.new(:project_name, :resource, :requires_agreement, :cc_text, :contact_email, :project_name_full, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**params)
+          super({}.update(params))
+        end
+      end
+
       class UpdatePermissionRequest < Struct.new(:project_name, :email, :role, :privileged, :affiliation, keyword_init: true)
         include JsonSerializableStruct
 
@@ -132,6 +140,14 @@ module Etna
           @raw
         end
       end
+
+      class GetStatsRequest < Struct.new(:project_names, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**params)
+          super({}.update(params))
+        end
+      end
     end
   end
 end

data/lib/etna/clients/janus/workflows/generate_token_workflow.rb

@@ -25,7 +25,7 @@ module Etna
             until private_key_file
               puts "Location of private key file?"
               private_key_file = ::File.expand_path(STDIN.gets.chomp)
-              unless File.exists?(private_key_file)
+              unless ::File.exist?(private_key_file)
                 puts "No such file."
                 private_key_file = nil
               end

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

@@ -56,9 +56,13 @@ module Etna
       #   attribute_names:  "all"
       # }
       def retrieve(retrieval_request = RetrievalRequest.new)
+        if retrieval_request.is_a?(Hash)
+          retrieval_request = RetrievalRequest.new(retrieval_request)
+        end
+
         json = nil
         @etna_client.post('/retrieve', retrieval_request) do |res|
-          json = JSON.parse(res.body)
+          json = safe_parse(res)
         end
 
         RetrievalResponse.new(json)
@@ -69,7 +73,7 @@ module Etna
       def query(query_request = QueryRequest.new)
         json = nil
         @etna_client.post('/query', query_request) do |res|
-          json = JSON.parse(res.body)
+          json = safe_parse(res)
         end
 
         QueryResponse.new(json)
@@ -77,17 +81,124 @@ module Etna
 
       def update(update_request = UpdateRequest.new)
         json = nil
+
         @etna_client.multipart_post('/update', update_request.encode_multipart_content) do |res|
-          json = JSON.parse(res.body)
+          json = safe_parse(res)
         end
 
         UpdateResponse.new(json)
       end
 
-      def update_json(update_request = UpdateRequest.new)
+      class Pager
+        def initialize(client, update_request, page_size)
+          @client = client
+
+          @update_request = update_request
+
+          @page_size = [ page_size || 2, 2 ].max
+        end
+
+        def response
+          page_count = 0
+          page = {}
+
+          results = UpdateResponse.new({"models" => {}})
+
+          flat_records.each do |flat_record|
+            page_count += 1 + flat_record[:tables].length
+
+            add_to_page( page, flat_record )
+
+            flat_record[:tables].each do |table_record|
+              add_to_page(page, table_record)
+            end
+
+            if page_count >= @page_size
+              results.update(update_part(page))
+              page = {}
+              page_count = 0
+            end
+          end
+
+          results.update(update_part(page)) if page_count > 0
+
+          return results
+        end
+
+        def revisions
+          @update_request.revisions
+        end
+
+        def flat_records
+          project = @client.retrieve(
+            project_name: @update_request.project_name,
+            hide_templates: false
+          )
+
+          flat_records = {}
+          revisions.each do |model_name, records|
+            records.each do |record_name, record|
+              flat = {
+                  model_name: model_name,
+                  record_name: record_name,
+                  record: record
+              }
+              flat_name = "#{model_name}.#{record_name}"
+
+              # if the update sets a table attribute, attach table records to their parent so they are submitted together
+              flat_tables = []
+              record.each do |attribute_name, value|
+                att = project.models.model(model_name).template.attributes.attribute(attribute_name)
+                if att.attribute_type == 'table'
+                  value.each do |table_entry_name|
+                    table_record = revisions[ att.link_model_name ][table_entry_name]
+                    flat_tables.push(
+                      {
+                        model_name: att.link_model_name,
+                        record_name: table_entry_name,
+                        record: table_record
+                      }
+                    )
+
+                    # exclude the attached table record from the flattened list of records
+                    flat_records[ "#{ att.link_model_name }.#{table_entry_name}" ] = nil
+                  end
+                end
+              end
+              flat[:tables] = flat_tables
+              flat_records[ flat_name ] = flat unless flat_records.has_key?(flat_name)
+            end
+          end
+
+          return flat_records.values.compact.shuffle
+        end
+
+        def update_part(page)
+          @client.update_json(
+            UpdateRequest.new(
+              project_name: @update_request.project_name,
+              revisions: page,
+              dry_run: @update_request.dry_run,
+              autolink: @update_request.autolink
+            )
+          )
+        end
+
+        def add_to_page(page, entry)
+          page[ entry[:model_name] ] ||= {}
+          page[ entry[:model_name] ][ entry[:record_name] ] = entry[:record]
+        end
+      end
+
+      def update_json(update_request = UpdateRequest.new, page_size=nil)
         json = nil
+
+        if page_size
+          return Etna::Clients::Magma::Pager.new(self, update_request, page_size).response
+        end
+
         @etna_client.post('/update', update_request) do |res|
-          json = JSON.parse(res.body)
+          json = safe_parse(res)
         end
 
         UpdateResponse.new(json)
@@ -96,11 +207,20 @@ module Etna
       def update_model(update_model_request = UpdateModelRequest.new)
         json = nil
         @etna_client.post('/update_model', update_model_request) do |res|
-          json = JSON.parse(res.body)
+          json = safe_parse(res)
         end
 
         UpdateModelResponse.new(json)
       end
+
+      def set_flags(project_name:, flags:)
+        json = nil
+        @etna_client.post("/flags/#{project_name}", { flags: flags }) do |res|
+          json = safe_parse(res)
+        end
+
+        json
+      end
     end
   end
 end