marty 2.3.15 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a297a85d0d4cdfde6d667e399b64684900dba8e9b9faaffa355737c8c5c5678b
-  data.tar.gz: 46c85fe0f1c7de9d3fba4d55b216d3e7daa24cc6a9f76cf1d75befb15cdf5284
+  metadata.gz: 8d6215dc0386a1fa52611c23d576350432d8dc8867f72dec1a7865717182e9e5
+  data.tar.gz: 66fe4f011556128fe04d5b897f653db57eb6032c4ef3f440ab363c105f0052ef
 SHA512:
-  metadata.gz: ac982f3abebddb0f92269d41eed6c100c297feac1a9726693abaeba7b93b3d0c281525f2df3ed7d94d43e67a12a95eb2782f65d8010ab94e4e4157b43bb5bbf6
-  data.tar.gz: f4816a56f8b3b61f72acb67faeffdd17f55010db418ab520f60f11c2058c123928c54e813c78e28c9b22a94b45620ea84568b091de90b41352735334da6658a7
+  metadata.gz: 8bde7326c5b29b7561371316e43207ded0b9d5b4246b5eb6948aa711eef74fc7e5fbed0fdf5758b61e7eb1549f0109ada0bcfed3910f86dc4e0cf4eeff128153
+  data.tar.gz: 4b2a99929bb2f8fcf4bd75a3b719c3c689dc3cd5e6e04726ea6e6fd07e900bcce821aaec76071d9befd33f604e9a3d4c3884bb0d0051a64669a5dd5c80ccfdd7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    marty (2.3.15)
+    marty (2.4.0)
       aws-sigv4 (~> 1.0, >= 1.0.2)
       axlsx (= 3.0.0pre)
       coderay
@@ -106,7 +106,7 @@ GEM
     i18n (0.9.5)
       concurrent-ruby (~> 1.0)
     io-like (0.3.0)
-    json-schema (2.8.1)
+    json-schema (2.8.0)
       addressable (>= 2.4)
     loofah (2.2.2)
       crass (~> 1.0.2)

data/app/components/marty/api_auth_view.rb

@@ -7,14 +7,37 @@ class Marty::ApiAuthView < Marty::McflyGridPanel
   def configure(c)
     super
 
-    c.title   = I18n.t('api_auth', default: "API Authorization")
-    c.model   = "Marty::ApiAuth"
-    c.attributes = [:app_name, :api_key, :script_name]
+    c.title      = I18n.t('api_auth', default: "API Authorization")
+    c.editing    = :in_form
+    c.pagination = :pagination
+    c.model      = "Marty::ApiAuth"
+    c.attributes = [:aws, :entity_name, :api_key, :script_name]
     c.store_config.merge!({sorters: [{property: :app_name, direction: 'ASC'}]})
   end
 
-  attribute :app_name do |c|
+  attribute :aws do |c|
+    c.width     = 60
+    c.read_only = true
+    c.text      = "AWS"
+    c.type      = :boolean
+    c.getter = lambda do |r|
+      !!r.parameters['aws_api_key']
+    end
+    c.sorting_scope = get_json_sorter('parameters', 'aws_api_key')
+    c.filterable = true
+    c.filter_with = lambda do |rel, value, op|
+      rel.where("parameters->>'aws_api_key' IS #{value ? 'NOT' : ''} NULL")
+    end
+  end
+
+  attribute :entity_name do |c|
     c.flex = 1
+    c.text = "Entity Name"
+    c.getter = lambda do |r|
+      aws    = !!r.parameters['aws_api_key']
+      entity = r.entity
+      entity ? entity.name : (aws ? nil : r.app_name)
+    end
   end
 
   attribute :api_key do |c|

data/app/components/marty/api_config_view.rb

@@ -12,6 +12,7 @@ class Marty::ApiConfigView < Marty::Grid
       :script,
       :node,
       :attr,
+      :api_class,
       :logged,
       :input_validated,
       :output_validated,
@@ -19,15 +20,33 @@ class Marty::ApiConfigView < Marty::Grid
       :created_at,
       :updated_at,
     ]
-    c.paging = :pageination
+    c.paging = :pagination
     c.editing = :in_form
     c.store_config.merge!(
       sorters: [{ property: :script, direction: :ASC},
-                { property: :node, direction: :ASC},
-                { property: :attr, direction: :ASC},
+                { property: :node,      direction: :ASC},
+                { property: :attr,      direction: :ASC},
+                { property: :api_class, direction: :ASC},
                ])
     @model = c.model
   end
+
+  attribute :api_class do |c|
+    editor_config = {
+      trigger_action: :all,
+      xtype:          :combo,
+      store:          Marty::Api::Base.class_list,
+      forceSelection: true,
+    }
+    c.merge!(
+      column_config: { editor: editor_config },
+      field_config:  editor_config,
+      type:          :string,
+    )
+    c.width = 200
+    c.label = "API Class"
+  end
+
   attribute :script do |c|
     editor_config = {
       trigger_action: :all,
@@ -43,34 +62,38 @@ class Marty::ApiConfigView < Marty::Grid
     )
     c.width = 150
   end
+
   [:node, :attr].each do |a|
     attribute a do |c|
       c.width = 150
       c.setter = lambda { |r, v| r.send("#{a}=", v.blank? ? nil : v) }
     end
   end
+
   [:logged, :input_validated, :output_validated, :strict_validate].each do
     |a|
     attribute a do |c|
       c.width = 110
     end
   end
+
   [:created_at, :updated_at].each do |a|
     attribute a do |c|
       c.read_only = true
     end
   end
+
   def default_form_items
     [
       :script,
       :node,
       :attr,
+      :api_class,
       :logged,
       :input_validated,
       :output_validated,
       :strict_validate,
     ]
   end
-
 end
 ApiConfigView = Marty::ApiConfigView

data/app/components/marty/extras/layout.rb

@@ -73,8 +73,7 @@ module Layout
   ######################################################################
   # PG ENUM field handling
 
-  def enum_column(c, class_or_array, col=nil)
-    col ||= c.name.demodulize.tableize.singularize
+  def enum_column(c, class_or_array)
     vals = class_or_array.is_a?(Array) ? class_or_array : class_or_array::VALUES
     editor_config = {
       trigger_action: :all,
@@ -92,7 +91,6 @@ module Layout
       field_config:  editor_config,
       type:          :string,
       setter:        enum_setter(c.name),
-      sorting_scope: get_sorter(col)
     )
   end
 
@@ -114,10 +112,6 @@ module Layout
     lambda {|r, v| r.send("#{name}=", v.blank? || v == '---' ? nil : v)}
   end
 
-  def get_sorter(col)
-    lambda {|rel, dir| rel.order("#{col}::text #{dir.to_s}")}
-  end
-
   ######################################################################
   # employ lots of hakery to implement NULLable boolean field in
   # Netzke 8.x.
@@ -203,4 +197,7 @@ module Layout
     c.align  = 'right'
   end
 
+  def tooltip s1, s2
+    "<span data-qtip=\"#{s2}\">#{s1}</span>"
+  end
 end; end; end

data/app/components/marty/form.rb

@@ -1,3 +1,11 @@
 class Marty::Form < Netzke::Form::Base
   extend ::Marty::Permissions
+
+  client_class do |c|
+    c.find_component = l(<<-JS)
+    function(name) {
+      return Ext.ComponentQuery.query(`[name=${name}]`)[0];
+    }
+    JS
+  end
 end

data/app/components/marty/grid.rb

@@ -13,6 +13,28 @@ class Marty::Grid < ::Netzke::Grid::Base
   end
 
   client_class do |c|
+    c.get_component = l(<<-JS)
+    function(name) {
+      return Ext.getCmp(name);
+    }
+    JS
+
+    c.find_component = l(<<-JS)
+    function(name) {
+      return Ext.ComponentQuery.query(`[name=${name}]`)[0];
+    }
+    JS
+
+    c.toggle_component_actions = l(<<-JS)
+    function(prefix, flag) {
+      for (var key in this.actions) {
+        if (key.substring(0, prefix.length) == prefix) {
+          this.actions[key].setDisabled(flag);
+        }
+      }
+    }
+    JS
+
     c.init_component = l(<<-JS)
     function() {
       this.dockedItems = this.dockedItems || [];
@@ -48,8 +70,7 @@ class Marty::Grid < ::Netzke::Grid::Base
       var me = this;
 
       var children = me.serverConfig.child_components || [];
-      me.getSelectionModel().on(
-      'selectionchange',
+      me.onSelectionChange(
       function(m) {
         var has_sel = m.hasSelection();
 
@@ -66,18 +87,15 @@ class Marty::Grid < ::Netzke::Grid::Base
         }
 
         me.serverConfig.selected = rid;
-
-        for (var key in me.actions) {
-          // hacky -- assumes our functions start with "do"
-          if (key.substring(0, 2) == "do") {
-            me.actions[key].setDisabled(!has_sel);
-          }
-        }
+        me.toggleComponentActions('do', !has_sel);
 
         for (var child of children) {
-          var comp = me.netzkeGetComponentFromParent(child);
+          var comp = me.getComponent(child)
           if (comp) {
             comp.serverConfig.parent_id = rid;
+            if (comp.toggleComponentActions) {
+              comp.toggleComponentActions('parent', !has_sel);
+            }
             if (comp.reload) { comp.reload() }
           }
         }
@@ -88,7 +106,7 @@ class Marty::Grid < ::Netzke::Grid::Base
       for (var event of ['update', 'netzkerefresh']) {
         store.on(event, function() {
         for (var link of linked) {
-            var comp = me.netzkeGetComponentFromParent(link);
+            var comp = me.findComponent(link);
             if (comp && comp.reload) { comp.reload() }
           }
         }, this);
@@ -96,6 +114,15 @@ class Marty::Grid < ::Netzke::Grid::Base
     }
     JS
 
+    c.on_selection_change = l(<<-JS)
+    function(f) {
+      var me = this;
+      me.getSelectionModel().on('selectionchange', function(m) {
+        f(m);
+      });
+    }
+    JS
+
     c.do_view_in_form = l(<<-JS)
     function(record){
       this.netzkeLoadComponent("view_window", {
@@ -123,7 +150,7 @@ class Marty::Grid < ::Netzke::Grid::Base
       var children = me.serverConfig.child_components || [];
       this.store.reload();
       for (child of children) {
-        var comp = me.netzkeGetComponentFromParent(child);
+        var comp = me.getComponent(child);
         if (comp && comp.reload) { comp.reload() }
       }
     }
@@ -134,13 +161,6 @@ class Marty::Grid < ::Netzke::Grid::Base
       this.filters.clearFilters();
     }
     JS
-
-    c.netzkeGetComponentFromParent = l(<<-JS)
-    function(component_path) {
-      return this.netzkeGetParentComponent().netzkeGetComponent(component_path);
-    }
-    JS
-
   end
 
   ######################################################################
@@ -168,6 +188,12 @@ class Marty::Grid < ::Netzke::Grid::Base
     false
   end
 
+  action :clear_filters do |a|
+    a.text    = "X"
+    a.tooltip = "Clear filters"
+    a.handler = :clear_filters
+  end
+
   def get_json_sorter(json_col, field)
     lambda do |r, dir|
       r.order("#{json_col} ->> '#{field}' " + dir.to_s)

data/app/components/marty/main_auth_app.rb

@@ -58,7 +58,7 @@ class Marty::MainAuthApp < Marty::AuthApp
     [
       {
         text: 'API Management',
-        icon_cls: "fa fa-wrench glyph",
+        icon_cls: "fa fa-fighter-jet glyph",
         disabled: !self.class.has_admin_perm?,
         menu: [
           :api_auth_view,
@@ -215,17 +215,19 @@ class Marty::MainAuthApp < Marty::AuthApp
   end
 
   action :api_config_view do |a|
-    a.text      = 'API Config Management'
-    a.handler   = :netzke_load_component_by_action
-    a.icon_cls   = "fa fa-cogs glyph"
-    a.disabled  = !self.class.has_admin_perm?
+    a.text     = 'API Config Management'
+    a.tooltip  = 'Manage API behavior and settings'
+    a.handler  = :netzke_load_component_by_action
+    a.icon_cls = "fa fa-sliders-h glyph"
+    a.disabled = !self.class.has_admin_perm?
   end
 
   action :api_log_view do |a|
-    a.text      = 'API Log View'
-    a.handler   = :netzke_load_component_by_action
-    a.icon_cls   = "fa fa-cogs glyph"
-    a.disabled  = !self.class.has_admin_perm?
+    a.text     = 'API Log View'
+    a.tooltip  = 'View API logs'
+    a.handler  = :netzke_load_component_by_action
+    a.icon_cls = "fa fa-pencil-alt glyph"
+    a.disabled = !self.class.has_admin_perm?
   end
 
   action :data_grid_view do |a|
@@ -285,7 +287,7 @@ class Marty::MainAuthApp < Marty::AuthApp
     a.disabled = !self.class.has_admin_perm?
   end
 
-   ######################################################################
+  ######################################################################
 
   def bg_command(param)
     e, root, p = ENV['RAILS_ENV'], Rails.root, Marty::Config["RUBY_PATH"]
@@ -480,7 +482,6 @@ class Marty::MainAuthApp < Marty::AuthApp
        });
     }
     JS
-
   end
 
   action :select_posting do |a|

data/app/controllers/marty/rpc_controller.rb

@@ -1,63 +1,53 @@
 class Marty::RpcController < ActionController::Base
   def evaluate
-    res = do_eval(params["script"],
-                  params["tag"],
-                  params["node"],
-                  params["attrs"] || "[]",
-                  params["params"] || "{}",
-                  params["api_key"] || nil,
-                  params["background"],
-                 )
-    respond_to do |format|
-      format.json { send_data res.to_json }
-      format.csv  {
-        # SEMI-HACKY: strip outer list if there's only one element.
-        res = res[0] if res.is_a?(Array) && res.length==1
-        send_data Marty::DataExporter.to_csv(res)
-      }
-    end
-  end
+    massaged_params = massage_params(params)
+    api_config = Marty::ApiConfig.lookup(*massaged_params.values_at(
+                                           :script,
+                                           :node,
+                                           :attr)
+                                        ) || {}
 
-  private
-  # FIXME: move to (probably) agrim's schema code in lib
-  def get_schema(tag, sname, node, attr)
-    begin
-      Marty::ScriptSet.new(tag).get_engine(sname+'Schemas').
-        evaluate(node, attr, {})
-    rescue => e
-      use_message = e.message == 'No such script' ?
-                      'Schema not defined' : 'Problem with schema: ' + e.message
-      raise "Schema error for #{sname}/#{node} attrs=#{attr}: #{use_message}"
-    end
-  end
+    api = api_config.present? ? api_config[:api_class].constantize :
+            Marty::Api::Base
 
-  def massage_message(msg)
-    m = %r|'#/([^']+)' of type ([^ ]+) matched the disallowed schema|.match(msg)
-    return msg unless m
-    "disallowed parameter '#{m[1]}' of type #{m[2]} was received"
-  end
+    api.respond_to(self) do
+      next massaged_params if massaged_params.include?(:error)
 
-  def _get_errors(errs)
-    if errs.is_a?(Array)
-      errs.map { |err| _get_errors(err) }
-    elsif errs.is_a?(Hash)
-      if !errs.include?(:failed_attribute)
-        errs.map { |k, v| _get_errors(v) }
-      else
-        fa, fragment, message, errors = errs.values_at(:failed_attribute,
-                                                       :fragment,
-                                                       :message, :errors)
-        ((['AllOf','AnyOf','Not'].include?(fa) && fragment =='#/') ?
-           [] : [massage_message(message)]) + _get_errors(errors || {})
-      end
+      auth = api.is_authorized?(massaged_params)
+      next {error: "Permission denied"} unless auth
+
+      start_time = Time.zone.now
+
+      api_params = api.process_params(massaged_params)
+      api.before_evaluate(api_params)
+      result = api.evaluate(api_params.deep_dup, request, api_config.deep_dup)
+      api.after_evaluate(api_params.deep_dup, result)
+
+      log_params = {start_time: start_time, auth: auth}
+      api.log(result, api_params + log_params, request) if
+        api_config[:logged]
+
+      result
     end
   end
 
-  def get_errors(errs)
-    _get_errors(errs).flatten
-  end
+  private
+
+  def massage_params request_params
+    sname,
+    tag,
+    node,
+    attr,
+    params,
+    api_key,
+    background = request_params.values_at(:script,
+                                          :tag,
+                                          :node,
+                                          :attrs,
+                                          :params,
+                                          :api_key,
+                                          :background)
 
-  def do_eval(sname, tag, node, attr, params, api_key, background)
     # FIXME: small patch to allow for single attr array
     attr = ActiveSupport::JSON.decode(attr) rescue attr
 
@@ -66,116 +56,39 @@ class Marty::RpcController < ActionController::Base
 
     # if attr is a single attr array, remember to return as an array
     if attr.is_a? Array
-      attr = attr[0]
+      attr    = attr[0]
       ret_arr = true
     end
 
-    start_time = Time.zone.now
     return {error: "Malformed attrs"} unless attr =~ /\A[a-z][a-zA-Z0-9_]*\z/
-    return {error: "Bad params"} unless params.is_a?(String)
 
     begin
-      params = ActiveSupport::JSON.decode(params)
-      orig_params = params.clone
+      case params
+      when String
+        params = ActiveSupport::JSON.decode(params)
+      when ActionController::Parameters
+        params.permit!
+        params = JSON.parse(params.to_h.to_json)
+      when nil
+        params = {}
+      else
+        return {error: "Bad params"}
+      end
     rescue JSON::ParserError => e
       return {error: "Malformed params"}
     end
 
     return {error: "Malformed params"} unless params.is_a?(Hash)
-    need_log,
-    need_input_validate,
-    need_output_validate,
-    need_strict_validate = Marty::ApiConfig.lookup(sname, node, attr)
-    opt                  = {validate_schema:   true,
-                            errors_as_objects: true,
-                            version:           Marty::JsonSchema::RAW_URI }
-    to_append            = {"\$schema" => Marty::JsonSchema::RAW_URI}
-    validation_error     = nil
-
-    if need_input_validate
-      begin
-        schema = get_schema(tag, sname, node, attr)
-      rescue => e
-        return {error: e.message}
-      end
-      begin
-        er = JSON::Validator.
-               fully_validate(schema.merge(to_append), params, opt)
-      rescue NameError
-        return {error: "Unrecognized PgEnum for attribute #{attr}"}
-      rescue => ex
-        return {error: "#{attr}: #{ex.message}"}
-      end
-      validation_error = get_errors(er) if er.size > 0
-    end
-    return {error: "Error(s) validating: #{validation_error}"} if
-      validation_error
-
-    auth = Marty::ApiAuth.authorized?(sname, api_key)
-    return {error: "Permission denied" } unless auth
 
-    begin
-      engine = Marty::ScriptSet.new(tag).get_engine(sname)
-    rescue => e
-      err_msg = "Can't get engine: #{sname || 'nil'} with tag: " +
-                "#{tag || 'nil'}; message: #{e.message}"
-      logger.info err_msg
-      return {error: err_msg}
-    end
-
-    retval = nil
-
-    begin
-      if background
-        result = engine.background_eval(node, params, attr)
-        return retval = {"job_id" => result.__promise__.id}
-      end
-
-      res = engine.evaluate(node, attr, params)
-
-      if need_output_validate && !(res.is_a?(Hash) && res['error'])
-        begin
-          schema = get_schema(tag, sname, node, attr + '_')
-        rescue => e
-          return {error: e.message}
-        end
-
-        begin
-          er = JSON::Validator.fully_validate(schema.merge(to_append), res, opt)
-        rescue NameError
-          return {error: "Unrecognized PgEnum for attribute #{attr}"}
-        rescue => ex
-          return {error: "#{attr}: #{ex.message}"}
-        end
-
-        if er.size > 0
-          errors = er.map{|e| e[:message]}
-          Marty::Logger.error("API #{sname}:#{node}.#{attr}",
-                              {error: errors, data: res})
-          res = need_strict_validate ? {error: "Error(s) validating: #{errors}",
-                                        data: res} : res
-        end
-      end
-      return retval = ret_arr ? [res] : res
-    rescue => exc
-      err_msg = Delorean::Engine.grok_runtime_exception(exc).symbolize_keys
-      logger.info "Evaluation error: #{err_msg}"
-      return retval = err_msg
-    ensure
-      error = Hash === retval ? retval[:error] : nil
-      Marty::Log.write_log('api',
-                           "#{sname} - #{node}",
-                           {script:     sname,
-                            node:       node,
-                            attrs:       (ret_arr ? [attr] : attr),
-                            input:      orig_params,
-                            output:     error ? nil : retval,
-                            start_time: start_time,
-                            end_time:   Time.zone.now,
-                            error:      error,
-                            remote_ip:  request.remote_ip,
-                            auth_name:  auth
-                           }) if need_log.present?
-    end
+    {
+      script:       sname,
+      tag:          tag,
+      node:         node,
+      attr:         attr,
+      params:       params,
+      api_key:      api_key,
+      background:   background,
+      return_array: ret_arr
+    }
   end
 end