omf_sfa 0.2.6 → 0.2.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c8e057cf74d9cfbe634681eb5a86a56d1b06f48e
+  data.tar.gz: df5ac1030bab27d3db06ff6bd67e72c899ae75ee
+SHA512:
+  metadata.gz: 6e561cdb795206908e2dc0f32cc58be10af3e5cb959bfafdf89f6b3be285ee470e92c46ce012b11dad2749ae998356aab1576fc71cffcc80272104eeb3100c59
+  data.tar.gz: dfbc2f4d3e40a9c4895c7ea6479d3e5dc7cd2a7df030522ea257aac78a8649e856745130048455501c067b031a70359800a1380df97d6bf79bd79a720082d1c9

data/.gitignore

@@ -22,3 +22,4 @@ Gemfile.lock
 .project
 .DS_Store
 *.original
+.idea

data/lib/omf-sfa/am.rb

@@ -3,5 +3,8 @@
 require 'omf_sfa'
 
 module OMF::SFA
-  module AM; end
+  module AM
+    class AMException < Exception; end
+  end
 end
+

data/lib/omf-sfa/am/am-rest/promise_handler.rb

@@ -0,0 +1,119 @@
+
+module OMF::SFA::AM::Rest
+
+  class PromiseHandler < RestHandler
+
+    @@contexts = {}
+
+    def self.register_promise(promise, uuid = nil, html_reply = false, collection_set = nil)
+      debug "Registering promise '#{uuid}' - #{promise}"
+      uuid ||= UUIDTools::UUID.random_create
+      #uuid = 1 # TODO: REMOVE
+      @@contexts[uuid.to_s] = {
+        promise: promise,
+        html_reply: html_reply,
+        collection_set: collection_set || Set.new,
+        timestamp: Time.now
+      }
+      path = "/promises/#{uuid}"
+      debug "Redirecting to #{path}"
+      return [302, {'Location' => path}, ['Promised, but not ready yet.']]
+    end
+
+    def call(env)
+      begin
+        req = ::Rack::Request.new(env)
+        headers = {
+          'Access-Control-Allow-Origin' => '*',
+          'Access-Control-Allow-Methods' => 'GET, POST, OPTIONS',
+          'Access-Control-Allow-Headers' => 'origin, x-csrftoken, content-type, accept'
+        }
+        if req.request_method == 'OPTIONS'
+          return [200 , headers, ""]
+        end
+
+        uuid = req.path_info.split('/')[-1]
+        debug "Checking for promise '#{uuid}'"
+
+        unless context = @@contexts[uuid]
+          return [404, {}, "Can't find requested promise"]
+        end
+        context[:timestamp] = Time.now # keep reaper away
+        promise = context[:promise]
+        case promise.status
+        when :pending
+          return retry_later(req, context)
+        when :rejected
+          body = {
+            type: 'error',
+            error: {
+              reason: promise.error_msg,
+              code: promise.error_code
+            }
+          }
+          headers['Content-Type'] = 'application/json'
+          return [500, headers, JSON.pretty_generate(body)]
+        end
+
+        # OK, the promise seems to have been resolved
+        content_type, body = promise.value
+        #puts ">>>>VALUE #{body.class} - #{content_type}>>>>> #{body}"
+        if body.is_a? Thin::AsyncResponse
+          return body.finish
+        end
+
+        begin
+          if content_type == 'text/html'
+            #body = self.class.convert_to_html(body, env, Set.new((@coll_handlers || {}).keys))
+            body = convert_to_html(body, env, {}, context[:collection_set])
+          else
+            content_type = 'application/json'
+            body = JSON.pretty_generate(body)
+          end
+        rescue OMF::SFA::Util::PromiseUnresolvedException => pex
+          proxy = OMF::SFA::Util::Promise.new
+          pex.promise.on_success do |d|
+            proxy.resolve [content_type, body]
+          end.on_error(proxy)
+          uuid = pex.uuid
+          path = "/promises/#{uuid}"
+          require 'omf-sfa/am/am-rest/promise_handler' # delay loading as PromiseHandler sub classes this class
+          self.class.register_promise(proxy, uuid, context[:html_reply], context[:collection_set])
+          debug "Redirecting to #{path}"
+          return [302, {'Location' => path}, ['Promised, but not ready yet.']]
+        end
+        headers['Content-Type'] = content_type
+        return [200 , headers, (body || '') + "\n"]
+
+      rescue RackException => rex
+        return rex.reply
+      rescue Exception => ex
+        body = {
+          type: 'error',
+          error: {
+            reason: ex.to_s,
+            bt: ex.backtrace #.select {|l| !l.start_with?('/') }
+          }
+        }
+        warn "ERROR: #{ex}"
+        debug ex.backtrace.join("\n")
+        headers['Content-Type'] = 'application/json'
+        return [500, headers, JSON.pretty_generate(body)]
+      end
+    end
+
+    def retry_later(req, context)
+      body = {
+        type: 'retry',
+        delay: 10, # rex.delay,
+        url: absolute_path(req.env['REQUEST_PATH']),
+        progress: context[:promise].progress.map do |ts, msg|
+          "#{ts.utc.iso8601}: #{msg}"
+        end
+      }
+      debug "Retry later request - #{req.url}"
+      headers = {'Content-Type' => 'application/json'}
+      return [504, headers, JSON.pretty_generate(body)]
+    end
+  end
+end

data/lib/omf-sfa/am/am-rest/rest_handler.rb

@@ -8,6 +8,7 @@ require 'thin/async'
 require 'cgi'
 
 require 'omf_base/lobject'
+require 'omf-sfa/util/promise'
 
 
 module OMF::SFA::AM::Rest
@@ -75,6 +76,12 @@ module OMF::SFA::AM::Rest
     end
   end
 
+  class TemporaryUnavailableException < RackException
+    def initialize()
+      super 504, "Upstream servers haven't responded yet, please try again a bit later"
+    end
+  end
+
   class RedirectException < Exception
     attr_reader :path
 
@@ -83,17 +90,68 @@ module OMF::SFA::AM::Rest
     end
   end
 
+  class ContentFoundException < Exception
+    def initialize(content, type = 'text', &block)
+      @type = case type.to_sym
+              when :json
+                'application/json'
+              when :xml
+                'text/xml'
+              when :text
+                'text'
+              else
+                (type || 'text').to_s
+              end
+      if content.is_a? OMF::SFA::Util::Promise
+        @content = OMF::SFA::Util::Promise.new
+        content.on_success do |pv|
+          v = block ? block.call(pv) : pv
+          @content.resolve [@type, v]
+        end.on_error(@content).on_progress(@content)
+      else
+        @content = content
+      end
+    end
+
+    def reply
+      if @content.is_a? OMF::SFA::Util::Promise
+        require 'omf-sfa/am/am-rest/promise_handler' # delay loading as PromiseHandler sub classes this class
+        OMF::SFA::AM::Rest::PromiseHandler.register_promise(@content)
+      else
+        headers = {'Content-Type' => @type}
+        [200 , headers, @content]
+      end
+    end
+  end
+
+  # class PromiseUnresolvedException < Exception
+  #   attr_reader :uuid, :promise
+  #
+  #   def initialize(promise)
+  #     @uuid = UUIDTools::UUID.random_create
+  #     @promise = promise
+  #   end
+  # end
+
   # Raised when a request triggers an async call whose
   # result we need before answering the request
   #
   class RetryLaterException < Exception
     attr_reader :delay
 
-    def initialize(delay = 3)
+    def initialize(delay = 10)
       @delay = delay
     end
   end
 
+  # class FoundUnresolvedPromiseException < Exception
+  #   attr_reader :promise
+  #
+  #   def initialize(promise)
+  #     @promise = promise
+  #   end
+  # end
+
 
 
   class RestHandler < OMF::Base::LObject
@@ -147,40 +205,63 @@ module OMF::SFA::AM::Rest
           return [200 , headers, ""]
         end
         content_type, body = dispatch(req)
+        #puts "BODY(#{body.class}) - #{content_type}) >>>>> #{body}"
         if body.is_a? Thin::AsyncResponse
           return body.finish
         end
-        if req['_format'] == 'html'
-          #body = self.class.convert_to_html(body, env, Set.new((@coll_handlers || {}).keys))
-          body = convert_to_html(body, env, {}, Set.new((@coll_handlers || {}).keys))
-          content_type = 'text/html'
-        elsif content_type == 'application/json'
-          body = JSON.pretty_generate(body)
-        end
+        content_type, body  = _format_body(body, content_type, req, env)
+        # if req['_format'] == 'html'
+        #   #body = self.class.convert_to_html(body, env, Set.new((@coll_handlers || {}).keys))
+        #   body = convert_to_html(body, env, {}, Set.new((@coll_handlers || {}).keys))
+        #   content_type = 'text/html'
+        # elsif content_type == 'application/json'
+        #   body = JSON.pretty_generate(body)
+        # end
         #return [200 ,{'Content-Type' => content_type}, body + "\n"]
         headers['Content-Type'] = content_type
-        return [200 , headers, body + "\n"]
+        return [200 , headers, (body || '') + "\n"]
+      rescue ContentFoundException => cex
+        return cex.reply
       rescue RackException => rex
+        unless rex.is_a? TemporaryUnavailableException
+          warn "Caught #{rex} - #{env['REQUEST_METHOD']} - #{env['REQUEST_PATH']}"
+          debug "#{rex.class} - #{req.inspect}"
+          debug rex.backtrace.join("\n")
+        end
         return rex.reply
-      rescue RedirectException => rex
+      rescue OMF::SFA::Util::PromiseUnresolvedException => pex
+        require 'omf-sfa/am/am-rest/promise_handler' # delay loading as PromiseHandler sub classes this class
+        OMF::SFA::AM::Rest::PromiseHandler.register_promise(pex.promise,
+                                                            pex.uuid,
+                                                            req['_format'] == 'html',
+                                                            Set.new((@coll_handlers || {}).keys))
+        #return [302, {'Location' => path}, ['Promised, but not ready yet.']]
+      rescue OMF::SFA::AM::Rest::RedirectException => rex
         debug "Redirecting to #{rex.path}"
-        return [301, {'Location' => rex.path, "Content-Type" => ""}, ['Next window!']]
+        return [302, {'Location' => rex.path}, ['Next window, please.']]
+
       # rescue OMF::SFA::AM::AMManagerException => aex
         # return RackException.new(400, aex.to_s).reply
-      rescue RetryLaterException => rex
-        body = {
-          type: 'retry',
-          delay: rex.delay
-        }
-        debug "Retry later request"
-        if req['_format'] == 'html'
-          headers['Refresh'] = rex.delay.to_s
-          opts = {} #{html_header: "<META HTTP-EQUIV='refresh' CONTENT='#{rex.delay}'>"}
-          body = convert_to_html(body, env, opts)
-          return [200 , headers, body + "\n"]
-        end
-        headers['Content-Type'] = 'application/json'
-        return [504, headers, JSON.pretty_generate(body)]
+      # rescue RetryLaterException => rex
+      #   body = {
+      #     type: 'retry',
+      #     delay: rex.delay,
+      #     request_id: Thread.current[:request_context_id] || 'unknown'
+      #   }
+      #   debug "Retry later request - #{req.url}"
+      #   if req['_format'] == 'html'
+      #     refresh = rex.delay.to_s
+      #     if (req_id = Thread.current[:request_context_id])
+      #       refresh += "; url=#{req.url}&_request_id=#{req_id}"
+      #     end
+      #     headers['Refresh'] = refresh # 10; url=
+      #     headers['X-Request-ID'] = req_id
+      #     opts = {} #{html_header: "<META HTTP-EQUIV='refresh' CONTENT='#{rex.delay}'>"}
+      #     body = convert_to_html(body, env, opts)
+      #     return [200 , headers, body + "\n"]
+      #   end
+      #   headers['Content-Type'] = 'application/json'
+      #   return [504, headers, JSON.pretty_generate(body)]
 
       rescue Exception => ex
         body = {
@@ -197,6 +278,37 @@ module OMF::SFA::AM::Rest
       end
     end
 
+    def _format_body(body, content_type, req, env, proxy_promise = nil)
+      begin
+        if req['_format'] == 'html'
+          #body = self.class.convert_to_html(body, env, Set.new((@coll_handlers || {}).keys))
+          content_type = 'text/html'
+          body = convert_to_html(body, env, {}, Set.new((@coll_handlers || {}).keys))
+        elsif content_type == 'application/json'
+          body = JSON.pretty_generate(body)
+        end
+        [content_type, body]
+      rescue OMF::SFA::Util::PromiseUnresolvedException => pex
+        proxy = OMF::SFA::Util::Promise.new
+        pex.promise.on_success do |d|
+          proxy.resolve [content_type, body]
+        end.on_error(proxy).on_progress(proxy)
+        raise OMF::SFA::Util::PromiseUnresolvedException.new proxy
+      end
+    end
+
+    # def _x(promise, req)
+    #   uuid = 1 #pex.uuid
+    #   path = "/promises/#{uuid}"
+    #   require 'omf-sfa/am/am-rest/promise_handler' # delay loading as PromiseHandler sub classes this class
+    #   OMF::SFA::AM::Rest::PromiseHandler.register_promise(promise,
+    #                                                       uuid,
+    #                                                       req['_format'] == 'html',
+    #                                                       Set.new((@coll_handlers || {}).keys))
+    #   debug "Redirecting to #{path}"
+    #   return [302, {'Location' => path}, ['Promised, but not ready yet.']]
+    # end
+
     def on_get(resource_uri, opts)
       debug 'get: resource_uri: "', resource_uri, '"'
       if resource_uri
@@ -207,6 +319,11 @@ module OMF::SFA::AM::Rest
       end
     end
 
+    def on_put(resource_uri, opts)
+      debug '>>> PUT NOT IMPLEMENTED'
+      raise UnsupportedMethodException.new('on_put', @resource_class)
+    end
+
     def on_post(resource_uri, opts)
       #debug 'POST: resource_uri "', resource_uri, '" - ', opts.inspect
       description, format = parse_body(opts, [:json, :form])
@@ -214,7 +331,7 @@ module OMF::SFA::AM::Rest
 
       if resource = opts[:resource]
         debug 'POST: Modify ', resource, ' --- ', resource.class
-        modify_resource(resource, description, opts)
+        resource = modify_resource(resource, description, opts)
       else
         if description.is_a? Array
           resources = description.map do |d|
@@ -268,7 +385,7 @@ module OMF::SFA::AM::Rest
 
     def find_handler(path, opts)
       #debug "find_handler: path; '#{path}' opts: #{opts}"
-      debug "find_handler: path; '#{path}'"
+      debug "find_handler: path: '#{path}'"
       rid = path.shift
       resource_id = opts[:resource_uri] = (rid ? URI.decode(rid) : nil) # make sure we get rid of any URI encoding
       opts[:resource] = nil
@@ -279,6 +396,7 @@ module OMF::SFA::AM::Rest
 
       raise OMF::SFA::AM::Rest::UnknownResourceException.new "Unknown resource '#{resource_id}'." unless resource
       opts[:context] = resource
+      opts[:contexts][opts[:context_name].to_sym] = resource
       comp = path.shift
       if (handler = @coll_handlers[comp.to_sym])
         opts[:context_name] = comp
@@ -292,7 +410,6 @@ module OMF::SFA::AM::Rest
     end
 
 
-
     protected
 
     def modify_resource(resource, description, opts)
@@ -301,6 +418,7 @@ module OMF::SFA::AM::Rest
       end
       description.delete(:href)
       resource.update(description) ? resource : nil
+      resource
     end
 
 
@@ -384,15 +502,34 @@ module OMF::SFA::AM::Rest
     #
     def populate_opts(req, opts)
       opts[:req] = req
+      opts[:context_name] = (req.env['REQUEST_PATH'].split('/') - req.path_info.split('/'))[-1]
+      opts[:contexts] ||= {}
       path = req.path_info.split('/').select { |p| !p.empty? }
       opts[:target] = find_handler(path, opts)
       rl = req.params.delete('_level')
-      opts[:max_level] = rl ? rl.to_i : 0
+      opts[:max_level] = rl ? rl.to_i : 1
       #opts[:target].inspect
       opts
     end
 
+    # Return a named context resource. If it is a promise and not yet
+    # available, a TemporaryUnavailableException is being thrown.
+    #
+    # For instance if we have a path /users/xxx/friends/yyy/favorites
+    # by the time we get to the 'favorites' handler, we can access
+    # the respective 'users', 'friends' object through this method.
+    # PLEASE note the plurals 'users', 'friends'.
+    #
+    def get_context_resource(name, opts)
+      resource = opts[:contexts][name]
+      if resource.is_a? OMF::SFA::Util::Promise
+        resource = resource.value(OMF::SFA::AM::Rest::TemporaryUnavailableException)
+      end
+      resource
+    end
+
     def parse_body(opts, allowed_formats = [:json, :xml])
+      puts "ALLOWD>>>> #{allowed_formats}"
       req = opts[:req]
       body = req.body #req.POST
       raise EmptyBodyException.new unless body
@@ -424,12 +561,16 @@ module OMF::SFA::AM::Rest
           raise UnsupportedBodyFormatException.new(:json) unless allowed_formats.include?(:json)
           jb = JSON.parse(body)
           return [_rec_sym_keys(jb), :json]
+        when 'application/gjson'
+          raise UnsupportedBodyFormatException.new(:gjson) unless allowed_formats.include?(:gjson)
+          jb = JSON.parse(body)
+          return [_rec_sym_keys(jb), :gjson]
         when 'text/xml'
           xb = Nokogiri::XML(body)
           raise UnsupportedBodyFormatException.new(:xml) unless allowed_formats.include?(:xml)
           return [xb, :xml]
         when 'application/x-www-form-urlencoded'
-          raise UnsupportedBodyFormatException.new(:xml) unless allowed_formats.include?(:form)
+          raise UnsupportedBodyFormatException.new(:form) unless allowed_formats.include?(:form)
           fb = req.POST
           #puts "FORM: #{fb.inspect}"
           return [fb, :form]
@@ -447,11 +588,18 @@ module OMF::SFA::AM::Rest
     def dispatch(req)
       opts = {}
       populate_opts(req, opts)
-      opts[:req] = req
+      #opts[:req] = req
       #puts "OPTS>>>> #{opts.inspect}"
       method = req.request_method
       target = opts[:target] #|| self
+      if target.is_a? OMF::SFA::AM::Rest::ContentFoundException
+        raise target
+      end
       resource_uri = opts[:resource_uri]
+      _dispatch(method, target, resource_uri, opts)
+    end
+
+    def _dispatch(method, target, resource_uri, opts)
       case method
       when 'GET'
         res = target.on_get(resource_uri, opts)
@@ -468,22 +616,30 @@ module OMF::SFA::AM::Rest
 
     def show_resource_status(resource, opts)
       if resource
+        resource = resolve_promise(resource) do |r|
+          show_resource_status(r, opts)
+        end
         about = opts[:req].path
-        props = resource.to_hash({}, :max_level => opts[:max_level])
+        refresh = ['', '1', 't', 'T', 'true', 'TRUE'].include?(opts[:req].params['_refresh'])
+        props = resource.to_hash({}, max_level: opts[:max_level], refresh: refresh)
         props.delete(:type)
-        res = {
+        res = after_resource_to_hash_hook({
           #:about => about,
           :type => resource.resource_type,
-        }.merge!(props)
+        }.merge!(props), resource)
       else
         res = {:error => 'Unknown resource'}
       end
-
-      ['application/json', res]
+      check_for_promises 'application/json', res
     end
 
+    def after_resource_to_hash_hook(res_hash, resource)
+      res_hash
+    end
 
-
+    def absolute_path(rel_path)
+      "http://#{Thread.current[:http_host]}#{rel_path.start_with?('/') ? '' : '/'}#{rel_path}"
+    end
 
     def find_resource(resource_uri, description = {}, opts = {})
       descr = description.dup
@@ -497,10 +653,21 @@ module OMF::SFA::AM::Rest
       end
 
       #authenticator = Thread.current["authenticator"]
+      descr = _find_resource_before_hook(descr, opts)
+      _find_resource(descr)
+    end
+
+    # Allow sub class to override actual finding of resource - may create it on the fly
+    def _find_resource(descr)
       debug "Finding #{@resource_class}.first(#{descr})"
       @resource_class.first(descr)
     end
 
+    # Allow sub class to override search criteria for resource
+    def _find_resource_before_hook(descr, opts)
+      descr
+    end
+
     def show_resource_list(opts)
       # authenticator = Thread.current["authenticator"]
       if (context = opts[:context])
@@ -512,12 +679,21 @@ module OMF::SFA::AM::Rest
     end
 
     def show_resources(resources, resource_name, opts)
+      resources = resolve_promise(resources) do |r|
+        show_resources(r, resource_name, opts)
+      end
       #hopts = {max_level: opts[:max_level], level: 1}
-      hopts = {max_level: opts[:max_level], level: 0}
+      hopts = {max_level: opts[:max_level] - 1, level: 0}
       objs = {}
       res_hash = resources.map do |a|
+        a = resolve_promise(a) do |r|
+          # The resolved promise was embeded, so we need to start afresh from the top
+          show_resources(resources, resource_name, opts)
+        end
         next unless a # TODO: This seems to be a bug in OProperty (removing objects)
-        a.to_hash(objs, hopts)
+        #puts ">>>>>>>>> #{a.to_hash({}, hopts.dup)}"
+        #a.to_hash(objs, hopts.dup)
+        after_resource_to_hash_hook(a.to_hash(objs, hopts), a)
         #a.to_hash_brief(:href_use_class_prefix => true)
       end.compact
       if resource_name
@@ -529,9 +705,84 @@ module OMF::SFA::AM::Rest
       else
         res = res_hash
       end
-      ['application/json', res]
+      check_for_promises 'application/json', res
     end
 
+    # Check if 'value' is a promise. If not, return it immediately. If it is
+    # a promise, return it's value if it has been already resolved. Otherwise
+    # throw a PromiseDeferException. If the promise gets resolved at some later
+    # stage the 'block' is called and is expected to return the same result as
+    # the caller of this function would have returned if this function would have
+    # returned immediately.
+    #
+    def resolve_promise(value, &block)
+      if (promise = value).is_a? OMF::SFA::Util::Promise
+        case promise.status
+        when :pending
+          proxy = OMF::SFA::Util::Promise.new
+          promise.on_success do |d|
+            proxy.resolve block.call(d)
+          end.on_error(proxy).on_progress(proxy)
+          raise OMF::SFA::Util::PromiseUnresolvedException.new proxy
+        when :rejected
+          raise promise.error_msg
+        else
+          value = promise.value
+        end
+      end
+      #puts "RESOLVE PROMISE(#{value.class}>>> #{value}"
+      value
+    end
+
+    # Check if any elements in res, which is either an array
+    # or hash, is a promise. If one is found, and can't be resolved,
+    # a PromiseDeferException is thrown. The proxy promise in the exception
+    # will monitor the unresolved promises and after all of them are resolved
+    # will resolve the associated promise with a 'clean' res.
+    #
+    def check_for_promises(mime_type, res, proxy = nil)
+      begin
+        res = _scan_for_promises(res)
+      rescue OMF::SFA::Util::PromiseUnresolvedException => pex
+        unless proxy
+          proxy = OMF::SFA::Util::Promise.new
+          pex.promise.on_success do |x|
+            check_for_promises(mime_type, res, proxy)
+          end.on_error do |ec, em|
+            proxy.reject(ec, em)
+          end.on_progress(proxy)
+          raise OMF::SFA::Util::PromiseUnresolvedException.new proxy
+        end
+      end
+      if proxy
+        proxy.resolve [mime_type, res]
+      end
+      [mime_type, res]
+    end
+
+    def _scan_for_promises(res)
+      if res.is_a? Array
+        res = res.map do |el|
+          _scan_for_promises(el)
+        end
+      elsif res.is_a? Hash
+        res.each do |key, val|
+          res[key] = _scan_for_promises(val)
+        end
+      elsif res.is_a? OMF::SFA::Util::Promise
+        case res.status
+        when :resolved
+          return res.value
+        when :rejected
+          raise res.err_message
+        else
+          raise OMF::SFA::Util::PromiseUnresolvedException.new(res)
+        end
+      end
+      res # seems to be 'normal' value
+    end
+
+
     def show_deleted_resource(uuid)
       res = {
         uuid: uuid,
@@ -602,12 +853,13 @@ module OMF::SFA::AM::Rest
       tmpl
     end
 
-    def convert_to_html(body, env, opts, collections = Set.new)
+    def convert_to_html(obj, env, opts, collections = Set.new)
       req = ::Rack::Request.new(env)
       opts = {
         collections: collections,
         level: 0,
-        href_prefix: "#{req.path}/"
+        href_prefix: "#{req.path}/",
+        env: env
       }.merge(opts)
 
       path = req.path.split('/').select { |p| !p.empty? }
@@ -617,11 +869,11 @@ module OMF::SFA::AM::Rest
       end
 
       res = []
-      _convert_obj_to_html(body, nil, res, opts)
+      _convert_obj_to_html(obj, nil, res, opts)
 
       render_html(
         header: opts[:html_header] || '',
-        result: body,
+        result: obj,
         title: @@service_name || env["HTTP_HOST"],
         service: h2.join('/'),
         content: res.join("\n")
@@ -636,6 +888,9 @@ module OMF::SFA::AM::Rest
     def _convert_obj_to_html(obj, ref_name, res, opts)
       klass = obj.class
       #puts "CONVERT>>>> #{ref_name} ... #{obj.class}::#{obj.to_s[0 .. 80]}"
+      if obj.is_a? OMF::SFA::Util::Promise
+        obj = obj.to_html()
+      end
       if (obj.is_a? OMF::SFA::Resource::OPropertyArray) || obj.is_a?(Array)
         if obj.empty?
           res << '<span class="empty">empty</span>'
@@ -661,7 +916,7 @@ module OMF::SFA::AM::Rest
     end
 
     def _convert_array_to_html(array, ref_name, res, opts)
-      opts = opts.merge(level: opts[:level] + 1)
+      opts = opts.merge(level: opts[:level] + 1, context: array)
       array.each do |obj|
         #puts "AAA>>>> #{obj}::#{opts}"
         name = nil
@@ -684,6 +939,7 @@ module OMF::SFA::AM::Rest
 
     def _convert_hash_to_html(hash, ref_name, res, opts)
       #puts ">>>> #{hash}::#{opts}"
+      opts = opts.merge(context: hash)
       hash.each do |key, obj|
         #key = "#{key}-#{opts[:level]}-#{opts[:collections].to_a.inspect}"
         if opts[:level] == 0 && opts[:collections].include?(key.to_sym)