roadforest 0.5 → 0.7

data/lib/roadforest/http/user-agent.rb

@@ -54,12 +54,14 @@ module RoadForest
         when 401
           #XXX What if challenge matches existing Auth header? i.e. current
           #creds are wrong?
-          request.headers["Authorization"] = keychain.challenge_response(url, response.headers["WWW-Authenticate"])
-          raise Retryable
+          authn_response = keychain.challenge_response(request.url, response.headers["WWW-Authenticate"])
+          if !authn_response.nil? and authn_response != request.headers["Authorization"]
+            request.headers["Authorization"] = authn_response
+            raise Retryable
+          end
         end
         return response
       rescue Retryable
-        raise unless (retry_limit -= 1) > 0
         retry
       end
 

data/lib/roadforest/interface/application.rb

@@ -9,29 +9,33 @@ module RoadForest
     end
 
     class Application
-      def initialize(route_name, params, router, services)
+      def initialize(route_name, params, path_provider, services)
         @route_name = route_name
         @params = params
-        @router = router
+        @path_provider = path_provider
         @services = services
         @data = nil
         @response_values = {}
       end
-      attr_reader :route_name, :params, :services, :data, :router
+      attr_reader :route_name, :params, :services, :data, :path_provider
       attr_reader :response_values
 
       #@!group Utility methods
 
       def path_for(route_name = nil, params = nil)
-        router.path_for(route_name, params || self.params)
+        path_provider.path_for(route_name, params || self.params)
       end
 
       def url_for(route_name, params = nil)
-        Addressable::URI.parse(canonical_host.to_s).join(path_for(route_name, params))
+        ::RDF::URI.new(Addressable::URI.parse(canonical_host.to_s).join(path_for(route_name, params)))
+      end
+
+      def pattern_for(route_name, vals = nil, extra = nil)
+        path_provider.pattern_for(route_name, vals, extra)
       end
 
       def interface_for(route_name = nil, params = nil)
-        router.interface_for(route_name, params || self.params)
+        path_provider.interface_for(route_name, params || self.params)
       end
 
       def canonical_uri
@@ -56,12 +60,13 @@ module RoadForest
         end
       end
 
-      def authorization(method, header)
+      def authorization(request)
+        method = request.method
         required = required_grants(method)
         if required.empty?
           :public
         else
-          services.authz.authorization(header, required_grants(method))
+          services.authz.authorization(request, required)
         end
       end
 
@@ -80,6 +85,10 @@ module RoadForest
 
       #group Resource interface
 
+      def error_data(status)
+        nil
+      end
+
       def exists?
         !data.nil?
       end
@@ -124,6 +133,14 @@ module RoadForest
         nil
       end
 
+      def update_payload
+        nil
+      end
+
+      def create_payload
+        nil
+      end
+
       def update(data)
         raise NotImplementedError
       end

data/lib/roadforest/interface/rdf.rb

@@ -1,12 +1,109 @@
 require 'roadforest/interface/application'
 
 module RoadForest
+  Payload = Struct.new(:root, :graph)
+
+  module Graph
+    module Helpers
+      module Focus
+        def start_focus(graph = nil, resource_url=nil)
+          graph ||= ::RDF::Graph.new
+          access = RoadForest::Graph::WriteManager.new
+          access.source_graph = graph
+          focus = RoadForest::Graph::GraphFocus.new(access, resource_url || my_url)
+
+          yield focus if block_given?
+          return graph
+        end
+      end
+
+      module Payloads
+        include Focus
+
+        def payload_blocks
+          @payload_blocks ||= {}
+        end
+
+        def payload_block(domain, type, &block)
+          payload_blocks[[domain, type]] = block
+        end
+
+        def backfill_payload(domain, type, root)
+          if payload_blocks.has_key?([domain, type])
+            start_focus(nil, root) do |focus|
+              payload_blocks[[domain, type]][focus]
+            end
+          end
+        end
+
+        def payload_method(method_name, domain, type, &block)
+          payload_block(domain, type, &block)
+          define_method method_name do
+            backfill_route = path_provider.find_route do |route|
+              klass = route.interface_class
+              next if klass.nil?
+              next unless klass.respond_to? :domains
+              next unless klass.respond_to? :types
+              klass.domains.include?(domain) and klass.types.include?(type)
+            end
+            return nil if backfill_route.nil?
+
+            klass = backfill_route.interface_class
+
+            root_node = url_for(backfill_route.name) + klass.fragment_for(route_name, type)
+            return Payload.new(root_node, nil)
+          end
+        end
+
+        def payload_for_update(domain = nil, &block)
+          payload_method(:update_payload, domain || :general, :update, &block)
+        end
+
+        def payload_for_create(domain = nil, &block)
+          payload_method(:create_payload, domain || :general, :create, &block)
+        end
+      end
+    end
+  end
+
   module Interface
     class RDF < Application
-      include RoadForest::Graph::Etagging
+      include Graph::Etagging
+      include Graph::Helpers::Focus
+
+      # Utility method, useful for overriding #update_payload and
+      # #create_payload
+      def payload_pair
+        root_node = ::RDF::Node.new
+        graph = ::RDF::Graph.new
+        graph << [root_node, ::RDF.type, Graph::Path.Root]
+        yield root_node, graph
+        return Payload.new(root_node, graph)
+      end
 
       def update(graph)
-        graph_update(start_focus(graph))
+        start_focus(graph) do |focus|
+          graph_update(focus)
+        end
+      end
+
+      def error_data(status)
+        case status
+        when 401
+          begin
+            perm_list_pattern = pattern_for(:perm_list, {}, [:username])
+
+            graph = ::RDF::Graph.new
+            perm_aff = ::RDF::Node.new
+            perm_pattern = ::RDF::Node.new
+            graph << [perm_aff, ::RDF.type, Graph::Af.Navigate]
+            graph << [perm_aff, Graph::Af.target, perm_pattern]
+            graph << [perm_pattern, Graph::Af.pattern, perm_list_pattern]
+
+          rescue KeyError
+            nil
+          end
+        end
       end
 
       def graph_update(focus)
@@ -14,8 +111,10 @@ module RoadForest
       end
 
       def add_graph_child(graph)
-        add_child(start_focus(graph))
-        new_graph
+        start_focus(graph) do |focus|
+          add_child(focus)
+        end
+        new_graph #XXX?
       end
 
       def add_child(focus)
@@ -29,13 +128,10 @@ module RoadForest
       def fill_graph(graph)
       end
 
-      def start_focus(graph, resource_url=nil)
-        access = RoadForest::Graph::WriteManager.new
-        access.source_graph = graph
-        focus = RoadForest::Graph::GraphFocus.new(access, resource_url || my_url)
-
-        yield focus if block_given?
-        return focus
+      def payload_focus(&block)
+        payload_pair do |root, graph|
+          start_focus(graph, root, &block)
+        end
       end
 
       def copy_interface(node, route_name, params=nil)
@@ -61,16 +157,19 @@ module RoadForest
         current_graph
       end
 
+      def augment_graph(graph)
+        services.augmenter.augment(graph)
+      end
+
       def current_graph
         return response_data if response_values.has_key?(:data)
         new_graph
       end
 
       def new_graph
-        graph = ::RDF::Graph.new
-        focus = start_focus(graph, my_url)
-        fill_graph(focus)
-        self.response_data = graph
+        self.response_data = augment_graph(start_focus do |focus|
+          fill_graph(focus)
+        end)
       end
     end
   end

data/lib/roadforest/interface/utility.rb

@@ -0,0 +1,3 @@
+require 'roadforest/interface/utility/backfill'
+require 'roadforest/interface/utility/grant-list'
+require 'roadforest/interface/utility/grant'

data/lib/roadforest/interface/utility/backfill.rb

@@ -0,0 +1,63 @@
+require 'roadforest/interface/rdf'
+
+module RoadForest
+  module Utility
+    class Backfill < Interface::RDF
+      # A backfill domain is an opaque selector for backfills and their client
+      # resources to coordinate with. Use them to partition backfills by the
+      # stability of interface, or to group like resources or whatever.
+      # Backfill domain names will never be exposed outside of the server.
+      def self.domains
+        [:general]
+      end
+
+      def domains
+        self.class.domains
+      end
+
+      # Backfill types are used to select within a resource which backfill is
+      # being rendered - the defaults are :update and :create to correspond
+      # with PUT and POST methods and af:Update and af:Create.
+      def self.types
+        [:update, :create]
+      end
+
+      def types
+        self.class.types
+      end
+
+      def root_for(name, domain, type)
+        my_url + self.class.fragment_for(name, type)
+      end
+
+      def self.fragment_for(name, type)
+        "##{name}-#{type}"
+      end
+
+      def new_graph
+        graph = ::RDF::Graph.new
+        path_provider.each_name_and_route do |name, route|
+          interface_class = route.interface_class
+          next if interface_class.nil?
+          next unless interface_class.respond_to? :backfill_payload
+
+          domains.each do |domain|
+            types.each do |type|
+              payload_graph = interface_class.backfill_payload(domain, type, root_for(name, domain, type))
+
+              next if payload_graph.nil?
+
+              payload_graph.each_statement do |stmt|
+                graph << stmt
+              end
+            end
+          end
+
+        end
+
+        graph
+      end
+
+    end
+  end
+end

data/lib/roadforest/interface/utility/grant-list.rb

@@ -0,0 +1,45 @@
+require 'roadforest/interface/rdf'
+
+module RoadForest
+  module Utility
+    class GrantList < Interface::RDF
+      def self.path_params
+        [ :username ]
+      end
+
+      def required_grants(method)
+        if method == "GET"
+          services.authz.build_grants do |grants|
+            grants.add(:is, :name => params[:username])
+            grants.add(:admin)
+          end
+        else
+          super
+        end
+      end
+
+      def data
+        entity = Authorization::AuthEntity.new
+        entity.username = params[:username]
+        services.authz.policy.grants_for(entity)
+      end
+
+      def new_graph
+        perm_route = nil
+        begin
+          perm_route = path_provider.route_for_name(:perm)
+        rescue KeyError
+        end
+        start_focus do |focus|
+          data.each do |grant|
+            if perm_route.nil?
+              focus.add(:af, :grants,  grant)
+            else
+              focus.add(:af, :grants,  path_provider.url_for(:perm, {:grant_name => grant}))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roadforest/interface/utility/grant.rb

@@ -0,0 +1,22 @@
+module RoadForest
+  module Utility
+    class Grant < Interface::RDF
+      def path_params
+        [ :grant_name ]
+      end
+
+      def required_grants(method)
+        #except in the unlikely case that a grant hashes to "NSG"
+        [ params[:grant_name] || "no_such_grant" ]
+      end
+
+      def data
+        [ params[:grant_name] || "no_such_grant" ]
+      end
+
+      def new_graph
+        ::RDF::Graph.new
+      end
+    end
+  end
+end

data/lib/roadforest/interfaces.rb

@@ -1,2 +1,3 @@
 require 'roadforest/interface/rdf'
 require 'roadforest/interface/blob'
+require 'roadforest/interface/utility'

data/lib/roadforest/path-matcher.rb

@@ -0,0 +1,471 @@
+require 'rdf'
+require 'roadforest/graph/vocabulary'
+
+module RoadForest
+  class PathMatcher
+    class Failure < ::StandardError; end
+    class NoMatch < Failure; end
+
+    class Match
+      def initialize(matcher)
+        @success = matcher.completed_child.accepting?
+        @graph = if @success
+            statements = matcher.completed_child.matched_statements.keys
+            ::RDF::Graph.new.tap do |graph|
+              statements.each do |stmt|
+                graph << stmt
+              end
+            end
+          end
+      end
+
+      def success?
+        @success
+      end
+      alias successful? success?
+      alias succeed? success?
+
+      def graph
+        if success?
+          @graph
+        else
+          raise NoMatch, "Pattern doesn't match graph"
+        end
+      end
+    end
+
+    class MatchStep
+      attr_accessor :parent
+      attr_accessor :stem
+      attr_accessor :repeats
+      attr_accessor :satified
+      attr_accessor :pattern
+      attr_accessor :graph
+      attr_accessor :graph_term
+      attr_accessor :pattern_step
+
+      attr_accessor :exact_value, :before, :after, :order, :type
+
+      attr_reader :children
+
+      def initialize
+        @children = nil
+        reset
+        yield self
+        @satisfied ||= {}
+        @stem ||= {}
+        @repeats ||= {}
+      end
+
+      def reset
+      end
+
+      def pretty_print_instance_variables
+        instance_variables.reject do |var|
+          var == :@parent
+        end
+      end
+
+      def immediate_match
+        {}
+      end
+
+      def open
+        if excluded?
+          return @children = []
+        end
+
+        @children ||= build_children
+
+        return children
+      end
+
+      def matched_statements
+        return {} unless accepting?
+        @matched_statements ||=
+          begin
+            children.map do |child|
+              child.matched_statements
+            end.inject(immediate_match) do |set, matched|
+              set.merge(matched)
+            end
+          end
+      end
+    end
+
+    class Edge < MatchStep
+      attr_accessor :predicate
+
+      attr_reader :accepting_count, :rejecting_count
+      attr_accessor :min_multi, :max_multi, :min_repeat, :max_repeat
+
+      alias child_nodes children
+
+      class << self
+        def find_child_edges(node)
+          node.pattern.query(edge_query_pattern(node.pattern_step)).map do |solution|
+            new do |edge|
+              edge.from(node, solution)
+            end
+          end
+        end
+
+        def edge_query_pattern(pattern_node)
+          path_direction = self.path_direction
+          RDF::Query.new do
+            pattern  [  pattern_node, path_direction, :next ]
+            pattern  [  :next,  Graph::Path.predicate,  :predicate   ]
+            pattern  [  :next,  Graph::Path.minMulti,   :min_multi   ],  :optional  =>  true
+            pattern  [  :next,  Graph::Path.maxMulti,   :max_multi   ],  :optional  =>  true
+            pattern  [  :next,  Graph::Path.minRepeat,  :min_repeat  ],  :optional  =>  true
+            pattern  [  :next,  Graph::Path.maxRepeat,  :max_repeat  ],  :optional  =>  true
+            pattern  [  :next,  Graph::Path.is,         :exact_value ],  :optional  =>  true
+            pattern  [  :next,  Graph::Path.after,      :after       ],  :optional  =>  true
+            pattern  [  :next,  Graph::Path.before,     :before      ],  :optional  =>  true
+            pattern  [  :next,  Graph::Path.order,      :order       ],  :optional  =>  true
+            pattern  [  :next,  Graph::Path.type,       :type        ],  :optional  =>  true
+          end
+        end
+      end
+
+      def from(node, solution)
+        self.parent = node
+
+        self.pattern = node.pattern
+        self.graph = node.graph
+
+        self.stem = node.stem.merge(node.statement => true)
+        self.repeats = node.repeats
+        self.graph_term = node.graph_term
+
+        self.predicate = solution[:predicate]
+        unless solution[:min_multi].nil? and solution[:max_multi].nil?
+          self.min_multi = solution[:min_multi].nil? ? 0 : solution[:min_multi].object
+          self.max_multi = solution[:max_multi].nil? ? nil : solution[:max_multi].object
+        end
+        unless solution[:min_repeat].nil? and solution[:max_repeat].nil?
+          self.min_repeat = solution[:max_repeat].nil? ? 0 : solution[:min_repeat].object
+          self.max_repeat = solution[:max_repeat].nil? ? nil : solution[:max_repeat].object
+        end
+
+        self.exact_value = solution[:exact_value]
+
+        self.pattern_step = solution[:next]
+        self.after = solution[:after]
+        self.before = solution[:before]
+        self.order = solution[:order]
+        self.type = solution[:type]
+      end
+
+      def to_s
+        state = case
+                when !resolved?
+                  "?"
+                when accepting?
+                  "Acpt"
+                when rejecting?
+                  "Rjct"
+                end
+        "<#{self.class.name.sub(/.*::/,'')} #{predicate}*M:#{min_multi}(<?#{available_count rescue "-"})-(#{accepting_count rescue "-"}<?)#{max_multi} R:#{min_repeat}-#{max_repeat}:#{step_count} #{state} >"
+      end
+
+      def step_count
+        repeats.fetch(pattern_step, 0)
+      end
+
+      def excluded?
+        step_count >= max_repeat
+      end
+
+      def satisfied?
+        step_count >= min_repeat
+      end
+
+      def reset
+        @accepting_count = 0
+        @rejecting_count = 0
+        @min_multi = 1
+        @max_multi = 1
+        @min_repeat = 1
+        @max_repeat = 1
+      end
+
+      def notify_resolved(child)
+        @accepting_count += 1 if child.accepting?
+        @rejecting_count += 1 if child.rejecting?
+      end
+
+      def resolved?
+        return false if children.nil?
+        @resolved ||=
+          begin
+            if rejecting?
+              true
+            else
+              not children.any? do |node|
+                not node.resolved?
+              end
+            end
+          end
+      end
+
+      def rejecting?
+        return false if children.nil?
+        return false if excluded?
+        return false if satisfied?
+        (not max_multi.nil? and accepting_count > max_multi) or available_count < min_multi
+      end
+
+      def accepting?
+        return false if children.nil?
+        resolved? and not rejecting?
+      end
+
+      def available_count
+        child_nodes.length - rejecting_count
+      end
+
+      def build_children
+        Node.find_child_nodes(self)
+      end
+    end
+
+    class ForwardEdge < Edge
+      def self.path_direction
+        Graph::Path.forward
+      end
+
+      def pattern_hash
+        { :subject => graph_term, :predicate => predicate, :object => exact_value}
+      end
+
+      def graph_node(statement)
+        statement.object
+      end
+    end
+
+    class ReverseEdge < Edge
+      def self.path_direction
+        Graph::Path.reverse
+      end
+
+      def pattern_hash
+        { :subject => exact_value, :predicate => predicate, :object => graph_term }
+      end
+
+      def graph_node(statement)
+        statement.subject
+      end
+    end
+
+    class Node < MatchStep
+      attr_accessor :statement #the RDF statement that got here from parent
+
+      def self.find_child_nodes(edge)
+        edge.graph.query(edge.pattern_hash).map do |statement|
+          next if edge.stem.has_key?(statement)
+
+          Node.new do |node|
+            node.from(edge, statement)
+          end
+        end
+      end
+
+      def from(edge, statement)
+        self.parent = edge
+
+        self.pattern = edge.pattern
+        self.graph = edge.graph
+
+        self.stem = edge.stem
+        self.repeats = edge.repeats.merge({edge.pattern_step => edge.step_count + 1})
+        self.graph_term = edge.graph_node(statement)
+
+        self.statement = statement
+
+        self.pattern_step = edge.pattern_step
+        self.after = edge.after
+        self.before = edge.before
+        self.order = edge.order
+        self.type = edge.type
+      end
+
+      alias child_edges children
+
+      def to_s
+        state = case
+                when !resolved?
+                  "?"
+                when accepting?
+                  "Acpt"
+                when rejecting?
+                  "Rjct"
+                end
+        "[#{self.class.name.sub(/.*::/,'')} #{statement} #{graph_term}/#{pattern_step} #{state} ]"
+      end
+
+      def immediate_match
+        statement.nil? ? {} : { statement => true }
+      end
+
+      def excluded?
+        stem.has_key?(statement)
+      end
+
+      def notify_resolved(child)
+
+      end
+
+      def reject_value?
+        unless before.nil? and after.nil?
+          return true if not (before.nil? or before > graph_term)
+          return true if not (after.nil? and after < graph_term)
+        end
+
+        unless type.nil?
+          return true if graph_term.datatype != type
+        end
+
+        return false
+      end
+
+      def resolved?
+        @resolved ||= accepting? or rejecting?
+      end
+
+      def accepting?
+        @accepting ||=
+          if excluded?
+            false
+          elsif children.nil?
+            false
+          elsif reject_value?
+            false
+          else
+            child_edges.all? do |edge|
+              edge.accepting?
+            end
+          end
+      end
+
+      def rejecting?
+        @rejecting ||=
+          begin
+            if excluded?
+              true
+            elsif children.nil?
+              false
+            elsif reject_value?
+              true
+            else
+              child_edges.any? do |edge|
+                edge.rejecting?
+              end
+            end
+          end
+      end
+
+      def build_children
+        ForwardEdge.find_child_edges(self) + ReverseEdge.find_child_edges(self)
+      end
+    end
+
+    def initialize()
+      @logging = false
+      reset
+    end
+
+    attr_accessor :pattern, :logging
+    attr_reader :completed_child
+    attr_writer :pattern_root
+
+    def match(root, graph)
+      reset
+      setup(root, graph)
+      search_iteration until complete?
+      return Match.new(self)
+    end
+
+    def reset
+      @search_queue = []
+      @completed_child = nil
+    end
+
+    def setup(root, graph)
+      add_matching_nodes([Node.new do |node|
+        node.parent = self
+        node.stem = {}
+        node.repeats = {}
+        node.pattern = pattern
+        node.graph = graph
+
+        node.statement = nil
+        node.graph_term = root
+        node.pattern_step = pattern_root
+      end
+      ])
+    end
+
+    def pattern_root
+      @pattern_root ||=
+        begin
+          roots = pattern.query(:predicate => ::RDF.type, :object => Graph::Path.Root).to_a
+          if roots.length != 1
+            raise "A pattern should have exactly one root, has: #{roots.length}\n#{roots.map(&:inspect).join("\n")}"
+          end
+          roots.first.subject
+        end
+    end
+
+    def complete?
+      !@completed_child.nil? or @search_queue.empty?
+    end
+
+    def notify_resolved(matching)
+      log "Resolved:", matching
+      @completed_child = matching
+    end
+
+    def search_iteration
+      matching = next_matching_node
+      unless matching.nil?
+        matching.open
+        if matching.children.empty?
+          log "No match:", matching
+        else
+          log "Matches for:", matching
+        end
+        add_matching_nodes(matching.children)
+
+        check_complete(matching)
+      end
+    end
+
+    def next_matching_node
+      @search_queue.pop #simple depth first
+    end
+
+    def add_matching_nodes(list)
+      list.each do |node|
+        log "  Adding step:", node
+      end
+      @search_queue += list
+    end
+
+    def log(*args)
+      puts args.join(" ") if @logging
+    end
+
+    def resolved?
+      false
+    end
+
+    def check_complete(matching)
+      while matching.resolved?
+        log "Checking:", matching
+        matching.parent.notify_resolved(matching)
+        matching = matching.parent
+      end
+    end
+  end
+end