etna 0.1.11 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b95bd70a5a778deaaeb05408e95dd043dfd41914993986d770cf8c29f6ba54b
-  data.tar.gz: 9e2d68c4fcb362108ce3ebf203cf7e88fba5045e6b87164c13f7feb4a9811e17
+  metadata.gz: 345d1790412dd359129f41586677ac2ac1a53c55897768d5d695e45ac828dcb6
+  data.tar.gz: ad2a6121a6659fa1352268b1545b434a9a7777531e6a8bdea8a74d6d779f54f8
 SHA512:
-  metadata.gz: dfae596fc44742b0fd087cabd93ca8a2132f8501662cab18a2c46e86d33db9a84852ff061299bf5e694f70da1a62ed1b0057e6523799cec19b031fec3cd171ae
-  data.tar.gz: 2146b65d50ea6c9b610a762c3043748113a79c3f603fe0366f3519c81314f36983d0ea59d542e4a512ea01f8e0862a3e1f403884b755d077e75de53c5dae72a9
+  metadata.gz: 3994385c74ff519195d80cae05e87dc5bd57755efd55ef20e26fdcb5b658c0ae45da22c62a7a87e77805e8d74eed7a7fe44440f4c5cd766dcf8d4b1f9ed46598
+  data.tar.gz: e0b39e27d1b5d2aab03aeb5d7118ca6c7b908e94778fe37aee9f83deee1fac3191a399bca95ca5c147f10261092974d2d40fd22ee44862e50506f763d6c982d8

data/lib/etna/application.rb

@@ -5,6 +5,7 @@
 
 require_relative './sign_service'
 require 'singleton'
+require 'rollbar'
 
 module Etna::Application
   def self.included(other)
@@ -31,6 +32,12 @@ module Etna::Application
 
   def configure(opts)
     @config = opts
+
+    if (rollbar_config = config(:rollbar)) && rollbar_config[:access_token]
+      Rollbar.configure do |config|
+        config.access_token = rollbar_config[:access_token]
+      end
+    end
   end
 
   def setup_logger
@@ -40,10 +47,9 @@ module Etna::Application
       # Number of old copies of the log to keep.
       config(:log_copies) || 5,
       # How large the log can get before overturning.
-      config(:log_size) || 1048576
+      config(:log_size) || 1048576,
     )
     log_level = (config(:log_level) || 'warn').upcase.to_sym
-
     @logger.level = Logger.const_defined?(log_level) ? Logger.const_get(log_level) : Logger::WARN
   end
 

data/lib/etna/auth.rb

@@ -93,7 +93,7 @@ module Etna
       return false unless headers = etna_param(request, :headers)
 
       headers = headers.split(/,/).map do |header|
-        [ header.to_sym, etna_param(request, header) ]
+        [ header.to_sym, params(request)[header.to_sym] || etna_param(request, header) ]
       end.to_h
 
       # Now expect the standard headers

data/lib/etna/client.rb

@@ -4,13 +4,15 @@ require 'singleton'
 
 module Etna
   class Client
-    def initialize(host, token)
+    def initialize(host, token, routes_available: true)
       @host = host.sub(%r!/$!,'')
       @token = token
 
-      set_routes
 
-      define_route_helpers
+      if routes_available
+        set_routes
+        define_route_helpers
+      end
     end
 
     attr_reader :routes
@@ -19,6 +21,29 @@ module Etna
       Etna::Route.path(route[:route], params)
     end
 
+    def multipart_post(endpoint, content, &block)
+      uri = request_uri(endpoint)
+      multipart = Net::HTTP::Post::Multipart.new uri.path, content
+      multipart.add_field('Authorization', "Etna #{@token}")
+      request(uri, multipart, &block)
+    end
+
+    def post(endpoint, params={}, &block)
+      body_request(Net::HTTP::Post, endpoint, params, &block)
+    end
+
+    def get(endpoint, params={}, &block)
+      query_request(Net::HTTP::Get, endpoint, params, &block)
+    end
+
+    def options(endpoint, params={}, &block)
+      query_request(Net::HTTP::Options, endpoint, params, &block)
+    end
+
+    def delete(endpoint, params={}, &block)
+      body_request(Net::HTTP::Delete, endpoint, params, &block)
+    end
+
     private
 
     def set_routes
@@ -60,32 +85,10 @@ module Etna
                 end
     end
 
-    def multipart_post(endpoint, content, &block)
-      uri = request_uri(endpoint)
-      multipart = Net::HTTP::Post::Multipart.new uri.path, content
-      multipart.add_field('Authorization', "Etna #{@token}")
-      request(uri, multipart, &block)
-    end
-
-    def post(endpoint, params={}, &block)
-      body_request(Net::HTTP::Post, endpoint, params, &block)
-    end
-
-    def get(endpoint, params={}, &block)
-      query_request(Net::HTTP::Get, endpoint, params, &block)
-    end
-
-    def options(endpoint, params={}, &block)
-      query_request(Net::HTTP::Options, endpoint, params, &block)
-    end
-
-    def delete(endpoint, params={}, &block)
-      body_request(Net::HTTP::Delete, endpoint, params, &block)
-    end
 
     def body_request(type, endpoint, params={}, &block)
       uri = request_uri(endpoint)
-      req = type.new(uri.path,request_params)
+      req = type.new(uri.request_uri,request_params)
       req.body = params.to_json
       request(uri, req, &block)
     end
@@ -122,9 +125,9 @@ module Etna
     def json_error(body)
       msg = JSON.parse(body, symbolize_names: true)
       if (msg.has_key?(:errors) && msg[:errors].is_a?(Array))
-        return msg[:errors].join(', ')
+        return JSON.generate(msg[:errors])
       elsif msg.has_key?(:error)
-        return msg[:error]
+        return JSON.generate(msg[:error])
       end
     end
 

data/lib/etna/clients/magma.rb

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

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

@@ -0,0 +1,65 @@
+require 'net/http/persistent'
+require 'net/http/post/multipart'
+require 'singleton'
+require_relative '../../client'
+require_relative './models'
+
+module Etna
+  module Clients
+    class Magma
+      def initialize(host:, token:)
+        raise 'Magma client configuration is missing host.' unless host
+        raise 'Magma client configuration is missing token.' unless token
+        @etna_client = ::Etna::Client.new(host, token, routes_available: false)
+      end
+
+      # This endpoint returns models and records by name:
+      # e.g. params:
+      # {
+      #   model_name: "model_one", # or "all"
+      #   record_names: [ "rn1", "rn2" ], # or "all",
+      #   attribute_names:  "all"
+      # }
+      def retrieve(retrieval_request)
+        json = nil
+        @etna_client.post('/retrieve', retrieval_request) do |res|
+          json = JSON.parse(res.body)
+        end
+
+        RetrievalResponse.new(json)
+      end
+
+      # This 'query' end point is used to fetch data by graph query
+      # See question.rb for more detail
+      def query(query_request)
+        json = nil
+        @etna_client.post('/query', query_request) do |res|
+          json = JSON.parse(res.body)
+        end
+
+        QueryResponse.new(json)
+      end
+
+      # Post revisions to Magma records
+      # { model_name: { record_name: { attribute1: 1, attribute2: 2 } } } }
+      # data can also be a File or IO stream
+      def update(update_request)
+        json = nil
+        @etna_client.multipart_post('/update', update_request.encode_multipart_content) do |res|
+          json = JSON.parse(res.body)
+        end
+
+        UpdateResponse.new(json)
+      end
+
+      def update_model(update_model_request)
+        json = nil
+        @etna_client.post('/update_model', update_model_request) do |res|
+          json = JSON.parse(res.body)
+        end
+
+        UpdateModelResponse.new(json)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,265 @@
+require_relative '../../json_serializable_struct'
+require_relative '../../multipart_serializable_nested_hash'
+require_relative '../../directed_graph'
+
+# 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 Magma
+      class RetrievalRequest < Struct.new(:model_name, :attribute_names, :record_names, :project_name, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**params)
+          super({model_name: 'all', attribute_names: 'all', record_names: []}.update(params))
+        end
+      end
+
+      class QueryRequest < Struct.new(:query, :project_name, keyword_init: true)
+        include JsonSerializableStruct
+      end
+
+      class UpdateRequest < Struct.new(:revisions, :project_name, keyword_init: true)
+        include JsonSerializableStruct
+        include MultipartSerializableNestedHash
+
+        def initialize(**params)
+          super({revisions: {}}.update(params))
+        end
+
+        def update_revision(model_name, record_name, **attrs)
+          revision = revisions[model_name] ||= {}
+          record = revision[record_name] ||= {}
+          record.update(attrs)
+        end
+      end
+
+      class UpdateModelRequest < Struct.new(:project_name, :actions, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**params)
+          super({actions: []}.update(params))
+        end
+
+        def add_action(action)
+            actions << action
+        end
+      end
+
+      class AddAttributeAction < Struct.new(:action_name, :model_name, :attribute_name, :type, :description, :display_name, :format_hint, :hidden, :index, :link_model_name, :read_only, :restricted, :unique, :validation, keyword_init: true)
+        include JsonSerializableStruct
+        def initialize(**args)
+          super({action_name: 'add_attribute'}.update(args))
+        end
+      end
+
+      class AttributeValidation < Struct.new(:type, :value, :begin, :end, keyword_init: true)
+        include JsonSerializableStruct
+      end
+
+      class AttributeValidationType < String
+        REGEXP = AttributeValidationType.new("Regexp")
+        ARRAY = AttributeValidationType.new("Array")
+        RANGE = AttributeValidationType.new("Range")
+      end
+
+      class RetrievalResponse
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def models
+          Models.new(raw['models'])
+        end
+      end
+
+      class UpdateModelResponse < RetrievalResponse
+      end
+
+      class QueryResponse
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def answer
+          raw['answer']
+        end
+
+        def format
+          raw['format']
+        end
+
+        def type
+          raw['type']
+        end
+      end
+
+      class UpdateResponse < RetrievalResponse
+      end
+
+      class Models
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def model_keys
+          raw.keys
+        end
+
+        def model(model_key)
+          Model.new(raw[model_key])
+        end
+
+        def to_directed_graph(include_casual_links=false)
+          graph = ::DirectedGraph.new
+
+          model_keys.each do |model_name|
+            graph.add_connection(model(model_name).template.parent, model_name)
+
+            if include_casual_links
+              attributes = model(model_name).template.attributes
+              attributes.attribute_keys.each do |attribute_name|
+                attribute = attributes.attribute(attribute_name)
+
+                linked_model_name = attribute.link_model_name
+                if linked_model_name
+                  if attribute.attribute_type == AttributeType::PARENT
+                    graph.add_connection(linked_model_name, model_name)
+                  elsif attribute.attribute_type == AttributeType::COLLECTION
+                    graph.add_connection(model_name, linked_model_name)
+                  elsif attribute.attribute_type == AttributeType::CHILD
+                    graph.add_connection(model_name, linked_model_name)
+                  elsif attribute.attribute_type == AttributeType::LINK
+                    graph.add_connection(model_name, linked_model_name)
+                  end
+                end
+              end
+            end
+          end
+
+          graph
+        end
+      end
+
+      class Model
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def documents
+          Documents.new(raw['documents'])
+        end
+
+        def template
+          Template.new(raw['template'])
+        end
+      end
+
+      class Documents
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def document_keys
+          raw.keys
+        end
+
+        def document(document_key)
+          raw[document_key]
+        end
+      end
+
+      class Template
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def name
+          raw['name'] || ""
+        end
+
+        def identifier
+          raw['identifier'] || ""
+        end
+
+        def parent
+          raw['parent']
+        end
+
+        def attributes
+          Attributes.new(raw['attributes'])
+        end
+      end
+
+      class Attributes
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def attribute_keys
+          raw.keys
+        end
+
+        def attribute(attribute_key)
+          Attribute.new(raw[attribute_key])
+        end
+      end
+
+      class Attribute
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def name
+          @raw['name'] || ""
+        end
+
+        def attribute_name
+          @raw['attribute_name'] || ""
+        end
+
+        def attribute_type
+          @raw['attribute_type'] && AttributeType.new(@raw['attribute_type'])
+        end
+
+        def link_model_name
+          raw['link_model_name']
+        end
+      end
+
+      class AttributeType < String
+        STRING = AttributeType.new("string")
+        DATE_TIME = AttributeType.new("date_time")
+        BOOLEAN = AttributeType.new("boolean")
+        CHILD = AttributeType.new("child")
+        COLLECTION = AttributeType.new("collection")
+        FILE = AttributeType.new("file")
+        FLOAT = AttributeType.new("float")
+        IDENTIFIER = AttributeType.new("identifier")
+        IMAGE = AttributeType.new("image")
+        INTEGER = AttributeType.new("integer")
+        LINK = AttributeType.new("link")
+        MATCH = AttributeType.new("match")
+        MATRIX = AttributeType.new("matrix")
+        PARENT = AttributeType.new("parent")
+        TABLE = AttributeType.new("table")
+      end
+    end
+  end
+end

data/lib/etna/clients/metis.rb

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

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

@@ -0,0 +1,37 @@
+require 'net/http/persistent'
+require 'net/http/post/multipart'
+require 'singleton'
+require_relative '../../client'
+require_relative './models'
+require 'pry'
+module Etna
+  module Clients
+    class Metis
+      def initialize(host:, token:)
+        raise 'Metis client configuration is missing host.' unless host
+        raise 'Metis client configuration is missing token.' unless token
+        @etna_client = ::Etna::Client.new(host, token)
+      end
+
+      def list_all_folders(list_all_folders_request)
+        FoldersResponse.new(
+          @etna_client.folder_list_all_folders(list_all_folders_request.to_h))
+      end
+
+      def list_folder(list_folder_request)
+        FoldersAndFilesResponse.new(
+          @etna_client.folder_list(list_folder_request.to_h))
+      end
+
+      def rename_folder(rename_folder_request)
+        FoldersResponse.new(
+          @etna_client.folder_rename(rename_folder_request.to_h))
+      end
+
+      def create_folder(create_folder_request)
+        FoldersResponse.new(
+          @etna_client.folder_create(create_folder_request.to_h))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+require_relative '../../json_serializable_struct'
+
+
+module Etna
+  module Clients
+    class Metis
+      class ListFoldersRequest < Struct.new(:project_name, :bucket_name, :offset, :limit, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**params)
+          super({}.update(params))
+        end
+
+        def to_h
+          # The :project_name comes in from Polyphemus as a symbol value,
+          #   we need to make sure it's a string because it's going
+          #   in the URL.
+          super().compact.transform_values(&:to_s)
+        end
+      end
+
+      class RenameFolderRequest < Struct.new(:project_name, :bucket_name, :folder_path, :new_bucket_name, :new_folder_path, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**params)
+          super({}.update(params))
+        end
+
+        def to_h
+          # The :project_name comes in from Polyphemus as a symbol value,
+          #   we need to make sure it's a string because it's going
+          #   in the URL.
+          super().compact.transform_values(&:to_s)
+        end
+      end
+
+      class ListFolderRequest < Struct.new(:project_name, :bucket_name, :folder_path, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**params)
+          super({}.update(params))
+        end
+
+        def to_h
+          # The :project_name comes in from Polyphemus as a symbol value,
+          #   we need to make sure it's a string because it's going
+          #   in the URL.
+          super().compact.transform_values(&:to_s)
+        end
+      end
+
+      class CreateFolderRequest < Struct.new(:project_name, :bucket_name, :folder_path, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**params)
+          super({}.update(params))
+        end
+
+        def to_h
+          # The :project_name comes in from Polyphemus as a symbol value,
+          #   we need to make sure it's a string because it's going
+          #   in the URL.
+          super().compact.transform_values(&:to_s)
+        end
+      end
+
+      class FoldersResponse
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def folders
+          Folders.new(raw[:folders])
+        end
+      end
+
+      class FoldersAndFilesResponse < FoldersResponse
+        def files
+          Files.new(raw[:files])
+        end
+      end
+
+      class Files
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def all
+          raw.map { |file| File.new(file) }
+        end
+      end
+
+      class Folders
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def all
+          raw.map { |folder| Folder.new(folder) }
+        end
+      end
+
+      class File
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def file_path
+          raw[:file_path]
+        end
+
+        def file_name
+          raw[:file_name]
+        end
+      end
+
+      class Folder
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def folder_path
+          raw[:folder_path]
+        end
+
+        def bucket_name
+          raw[:bucket_name]
+        end
+      end
+    end
+  end
+end

data/lib/etna/command.rb

@@ -1,3 +1,5 @@
+require 'rollbar'
+
 module Etna
   class Command
     class << self
@@ -15,12 +17,18 @@ module Etna
     # To be overridden during inheritance.
     def execute
       raise 'Command is not implemented'
+    rescue => e
+      Rollbar.error(e)
+      raise
     end
 
     # To be overridden during inheritance, to e.g. connect to a database.
     # Should be called with super by inheriting method.
     def setup(config)
       Etna::Application.find(self.class).configure(config)
+    rescue => e
+      Rollbar.error(e)
+      raise
     end
   end
 end

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/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
 
@@ -78,7 +79,7 @@ module Etna
         # these are set as headers or params
         @nonce,
         @id,
-        @headers.map{|l| l.join('=')}.join(';'),
+        @headers.to_json,
         @expiration,
       ].join("\n")
     end

data/lib/etna/json_serializable_struct.rb

@@ -0,0 +1,34 @@
+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
+      members.map do |k|
+        v = self.class.as_json(send(k))
+        [k, v]
+      end.to_h.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,28 @@ module Etna
       "#{severity}:#{datetime.iso8601} #{msg}\n"
     end
 
+    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)
       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,45 @@
+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
+            yield [base_key, value.respond_to?(:read) ? UploadIO.new(value, 'application/octet-stream') : value.to_s]
+          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/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/test_auth.rb

@@ -74,7 +74,7 @@ module Etna
   end
   class TestHmac < Hmac
     def valid?
-      @test_signature == 'valid'
+      @test_signature == 'valid' || super
     end
   end
 end

data/lib/etna/user.rb

@@ -7,7 +7,9 @@ module Etna
     }
 
     def initialize params, token=nil
-      @first, @last, @email, @encoded_permissions = params.values_at(:first, :last, :email, :perm)
+      @first, @last, @email, @encoded_permissions, encoded_flags = params.values_at(:first, :last, :email, :perm, :flags)
+
+      @flags = encoded_flags&.split(/;/) || []
       @token = token unless !token
       raise ArgumentError, "No email given!" unless @email
     end
@@ -30,6 +32,10 @@ module Etna
       end.inject([],:+).to_h
     end
 
+    def has_flag?(flag)
+      @flags.include?(flag)
+    end
+
     def name
       "#{first} #{last}"
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: etna
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 0.1.16
 platform: ruby
 authors:
 - Saurabh Asthana
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-23 00:00:00.000000000 Z
+date: 2020-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rollbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: See summary
 email: Saurabh.Asthana@ucsf.edu
 executables: []
@@ -76,14 +90,23 @@ files:
 - lib/etna/application.rb
 - lib/etna/auth.rb
 - lib/etna/client.rb
+- lib/etna/clients/magma.rb
+- lib/etna/clients/magma/client.rb
+- lib/etna/clients/magma/models.rb
+- lib/etna/clients/metis.rb
+- lib/etna/clients/metis/client.rb
+- lib/etna/clients/metis/models.rb
 - lib/etna/command.rb
 - lib/etna/controller.rb
 - lib/etna/cross_origin.rb
 - lib/etna/describe_routes.rb
+- lib/etna/directed_graph.rb
 - lib/etna/errors.rb
 - lib/etna/ext.rb
 - lib/etna/hmac.rb
+- lib/etna/json_serializable_struct.rb
 - lib/etna/logger.rb
+- lib/etna/multipart_serializable_nested_hash.rb
 - lib/etna/parse_body.rb
 - lib/etna/route.rb
 - lib/etna/server.rb