neo4j 1.0.0.beta.9 → 1.0.0.beta.10

data/lib/neo4j.old/extensions/rest/stubs.rb

@@ -1,141 +0,0 @@
-module Neo4j
-  module Rest
-    # A stub class that talk to a neo4j rest server.
-    # It behaves like a Neo4j::Node, but instead of actually performing operation
-    # it talks to the server over HTTP/JSON
-    #
-    module RestStubMixin
-      attr_accessor :json
-
-      def initialize(uri_or_json_hash)
-        if uri_or_json_hash.kind_of?(Hash)
-          @json = uri_or_json_hash
-        else
-          @json = RestHttpMethods.get_request(uri_or_json_hash)
-        end
-      end
-
-      def [](key)
-        @json['properties'][key.to_s]
-      end
-
-      def relationships
-        RelationshipTraverserStub.new(@json['rels'])
-      end
-
-
-      def relationship?(type, dir=:outgoing)
-        rels.rel?(type, dir)
-      end
-
-      def props
-        @json['properties']
-      end
-    end
-
-    module RestHttpMethods # :nodoc:
-      class << self
-        def get_request(resource, args = {})
-          body = _get_request(resource, args)
-          JSON.parse(body)
-        end
-
-        def _get_request(resource, args)
-          _request(resource, :get, args)
-        end
-
-        def _request(resource, method = :get, args = {})
-          url = URI.parse(resource)
-          host = url.host
-          host.sub!(/0\.0\.0\.0/, 'localhost')
-
-          #if args
-          #  url.query = args.map { |k, v| "%s=%s" % [URI.encode(k), URI.encode(v)] }.join("&")
-          #end
-
-          req =
-                  case method
-                    when :put
-                      Net::HTTP::Put.new(url.path)
-                    when :get
-                      Net::HTTP::Get.new(url.path)
-                    when :post
-                      Net::HTTP::Post.new(url.path)
-                  end
-
-          http = Net::HTTP.new(host, url.port)
-          res = http.start() { |conn| conn.request(req) }
-          res.body
-        end
-      end
-    end
-
-
-    class RelationshipStub # :nodoc:
-      include RestStubMixin
-
-      def start_node
-        uri = @json['start_node']['uri']
-        NodeStub.new(uri)
-      end
-
-      def end_node
-        uri = @json['end_node']['uri']
-        NodeStub.new(uri)
-      end
-
-    end
-
-    class RelationshipTraverserStub
-      include Enumerable
-
-      def initialize(json)
-        @json = json
-      end
-
-      def outgoing(rel_type)
-        @rel_type = rel_type
-        self
-      end
-
-      def relationship?(type, dir=:outgoing)
-        !@json[type.to_s].nil?
-      end
-
-      def nodes
-        @return_nodes = true
-        self
-      end
-
-      def first
-        each do |x|
-          return x if !block_given? || yield(x)
-        end
-      end
-
-      def each
-        keys =
-                if @rel_type.nil?
-                  @json.keys # take all keys
-                else
-                  [@rel_type.to_s]
-                end
-
-        keys.each do |rel_type|
-          next unless rel?(rel_type)
-          if @return_nodes
-            @json[rel_type.to_s].each {|uri| yield RelationshipStub.new(uri).end_node}
-          else
-            @json[rel_type.to_s].each {|uri| yield RelationshipStub.new(uri)}
-          end
-        end
-      end
-    end
-
-    # A class that simply includes the RestStubMixin
-    class NodeStub
-      include RestStubMixin
-    end
-
-  end
-end

data/lib/neo4j.old/extensions/rest.rb

@@ -1,21 +0,0 @@
-require 'net/http'
-require 'thread'
-require 'json'
-require 'sinatra/base'
-
-require 'neo4j/extensions/rest/rest'
-require 'neo4j/extensions/rest/rest_mixin'
-require 'neo4j/extensions/rest/stubs'
-require 'neo4j/extensions/rest/server'
-
-# Provides Neo4j::NodeMixin::ClassMethods#all
-require 'neo4j/extensions/reindexer'
-
-
-module Neo4j
-  # Make the ReferenceNode available as a REST resource
-  # not possible to do much without that node being exposed ...
-  class ReferenceNode
-    include Neo4j::RestMixin
-  end
-end

data/lib/neo4j.old/extensions/rest_master.rb

@@ -1,34 +0,0 @@
-require 'neo4j'
-require 'neo4j/extensions/rest'
-require 'neo4j/extensions/tx_tracker'
-
-module Neo4j
-  class TxNode
-    include Neo4j::RestMixin
-  end
-
-  class TxRelationshipCreatedNode
-    include Neo4j::RestMixin
-  end
-
-  class TxNodeCreated
-    include Neo4j::RestMixin
-  end
-
-  class TxNodeList
-    include Neo4j::RestMixin
-  end
-
-  class ReferenceNode
-    include Neo4j::RestMixin
-  end
-
-
-  # FOR TESTING PURPOSE ----
-  
-  class Node
-    include Neo4j::RestMixin # for making it easier to test    
-  end
-
-  Neo4j::Config[:storage_path] = 'tmp/master'
-end

data/lib/neo4j.old/extensions/rest_slave.rb

@@ -1,31 +0,0 @@
-require 'net/http'
-require 'thread'
-require 'json'
-#require 'sinatra/base'
-require 'neo4j/extensions/rest/stubs'
-
-
-require 'neo4j/extensions/tx_tracker'
-
-module Neo4j
-
-  module Rest #:nodoc: all
-    def self.base_uri
-      Neo4j::Config[:master_neo4j_uri]
-    end
-  end
-  
-
-  # TODO This is not working yet !
-  def self.replicate
-    neo_master = Neo4j::Rest::NodeStub.new(Config[:master_neo4j_uri] + "/neo")
-    neo_ref_node = Neo4j::Rest::NodeStub.new(neo_master[:ref_node])
-    tx_node_list = neo_ref_node.rels.outgoing(:tx_node_list).nodes.first
-    tx_node = tx_node_list.rels.outgoing(:tx_nodes).nodes.first
-    Neo4j::Transaction.run do
-      Neo4j::TxNodeList.instance.redo_tx(tx_node)
-    end
-  end
-
-  Config[:master_neo4j_uri] = 'http://localhost:9123'
-end

data/lib/neo4j.old/extensions/tx_tracker.rb

@@ -1,392 +0,0 @@
-module Neo4j
-
-
-  # The relationship class between TxNodes
-  class TxNodeRelationship
-    include Neo4j::RelationshipMixin
-  end
-
-  # This nodes listen for all events like node nodes created/deleted or
-  # if a property/relationship has changed. When a event is triggered it
-  #
-  class TxNodeList
-    include Neo4j::NodeMixin
-
-    has_list(:tx_nodes).relationship(TxNodeRelationship)
-
-    def on_node_created(node)
-      tx = TxNodeCreated.new
-      uuid = Neo4j.create_uuid
-      node[:uuid] = uuid # TODO should use a better UUID
-      tx[:tracked_neo_id] = node.neo_id
-      tx[:tracked_classname] = node.class.to_s unless node.kind_of?(org.neo4j.graphdb.Node)
-      tx[:created] = true
-      tx[:uuid] = uuid
-      tx_nodes << tx
-    end
-
-    def on_node_deleted(node)
-      tx = TxNode.new
-      tx[:uuid] = node[:uuid]
-      tx[:deleted] = true
-      tx[:tracked_classname] = node.class.to_s unless node.kind_of?(org.neo4j.graphdb.Node)
-      tx_nodes << tx
-    end
-
-
-    def on_tx_finished(tx)
-      return if self.tx_nodes.empty? # nothing yet commited
-      last_commited_node = self.tx_nodes.first
-      last_commited_node[:tx_finished] = true
-    end
-
-    def on_property_changed(node, key, old_value, new_value)
-      return if "uuid" == key.to_s # do not track uuid
-      tx = TxNode.new
-      tx[:uuid] = node[:uuid]
-      tx[:property_changed] = true
-      tx[:tracked_neo_id] = node.neo_id
-      tx[:key] = key
-      tx[:old_value] = old_value
-      tx[:new_value] = new_value
-      tx_nodes << tx
-    end
-
-    def on_relationship_created(relationship)
-      # check so that it was no this method that caused this event
-      return if tx_nodes.relationship_type.to_sym == relationship.relationship_type.to_sym
-      tx = TxRelationshipCreatedNode.new
-      uuid = Neo4j.create_uuid
-      tx[:uuid] = uuid
-      tx[:relationship_created] = true
-      tx[:tracked_neo_id] = relationship.neo_id
-      tx[:start_node_uuid] = relationship.start_node[:uuid]
-      tx[:end_node_uuid] = relationship.end_node[:uuid]
-      tx[:relationship_type] = relationship.relationship_type.to_s
-      relationship[:uuid] = uuid
-      tx_nodes << tx
-    end
-
-
-    def on_relationship_deleted(relationship)
-      # check so that it was no this method that caused this event
-      return if tx_nodes.relationship_type.to_sym == relationship.relationship_type.to_sym
-      tx = TxNode.new
-      uuid = Neo4j.create_uuid
-      tx[:uuid] = uuid
-      tx[:relationship_deleted] = true
-      tx[:tracked_neo_id] = relationship.neo_id
-      tx[:relationship_type] = relationship.relationship_type.to_s
-      tx[:start_node_uuid] = relationship.start_node[:uuid]
-      tx[:end_node_uuid] = relationship.end_node[:uuid]
-      tx_nodes << tx
-    end
-
-
-    # Return a list of TxNodes that belongs to the same transaction
-    # Will always include the specified from_tx_node
-    # It will follow the linked list of tx nodes until it founds a new transaction.
-    def tx_nodes_belonging_to_same_tx(from_tx_node)
-      nodes_in_same_tx = []
-      nodes_in_same_tx << from_tx_node # always include the first one
-
-      # include all other nodes until we find a new transaction marker
-      curr_node = from_tx_node
-
-      while (true) do
-        curr_node = curr_node.list(:tx_nodes).next
-        break if curr_node.nil?
-        break if curr_node[:tx_finished]
-        nodes_in_same_tx << curr_node
-      end
-      nodes_in_same_tx
-    end
-
-    def create_node(tx_node)
-      classname = tx_node[:tracked_classname]
-      node = if classname.nil?
-        Neo4j::Node.new
-      else
-        clazz = classname.split("::").inject(Kernel) do |container, name|
-          container.const_get(name.to_s)
-        end
-        clazz.new
-      end
-
-      uuid = tx_node[:uuid]
-      tx_node = find_tx(node.neo_id, :tracked_neo_id)
-      #tx_node = find_tx_node(uuid)
-      tx_node[:uuid] = uuid
-      tx_node[:tracked_neo_id] = node.neo_id
-      node[:uuid] = uuid
-    end
-
-    def delete_node(tx_node)
-      uuid = tx_node[:uuid]
-      node = load_node_with_uuid(uuid)
-      node.del
-    end
-
-    def undo_property_changed(tx_node)
-      uuid = tx_node[:uuid]
-      node = load_node_with_uuid(uuid)
-      key = tx_node[:key]
-      old_value = tx_node[:old_value]
-      node[key] = old_value
-    end
-
-    def redo_property_changed(tx_node)
-      uuid = tx_node[:uuid]
-      node = load_node_with_uuid(uuid)
-      key = tx_node[:key]
-      new_value = tx_node[:new_value]
-      node[key] = new_value
-    end
-
-    def create_relationship(tx_node)
-      # recreate deleted relationship
-      type = tx_node[:relationship_type]
-      start_node_uuid = tx_node[:start_node_uuid]
-      end_node_uuid = tx_node[:end_node_uuid]
-      start_node = load_node_with_uuid(start_node_uuid)
-      end_node = load_node_with_uuid(end_node_uuid)
-      start_node.rels.outgoing(type) << end_node
-    end
-
-    def delete_relationship(tx_node)
-      relationship = load_relationship_with_uuid(tx_node[:uuid])
-      relationship.del
-    end
-
-
-    def redo_tx(from_tx_node)
-      nodes_to_redo = tx_nodes_belonging_to_same_tx(from_tx_node)
-      nodes_to_redo.reverse_each do |curr_node|
-        if (curr_node[:created])
-          create_node(curr_node)
-        elsif (curr_node[:deleted])
-          delete_node(curr_node)
-        elsif (curr_node[:property_changed])
-          redo_property_changed(curr_node)
-        elsif (curr_node[:relationship_created])
-          create_relationship(curr_node)
-        elsif (curr_node[:relationship_deleted])
-          delete_relationship(curr_node)
-        else
-          raise "unknow tx #{curr_node.props.inspect}"
-        end
-      end
-    end
-
-    def undo_tx(from_tx_node = tx_nodes.first)
-      return if from_tx_node.nil?
-
-      nodes_to_undo = tx_nodes_belonging_to_same_tx(from_tx_node)
-
-      nodes_to_undo.each do |curr_node|
-        if (curr_node[:created])
-          delete_node(curr_node)
-        elsif (curr_node[:deleted])
-          create_node(curr_node)
-        elsif (curr_node[:property_changed])
-          undo_property_changed(curr_node)
-        elsif (curr_node[:relationship_created])
-          delete_relationship(curr_node)
-        elsif (curr_node[:relationship_deleted])
-          create_relationship(curr_node)
-        else
-          raise "unknow tx #{curr_node.props.inspect}"
-        end
-      end
-    end
-
-
-    # Load a neo4j node given a cluster wide UUID (instead of id)
-    # :api: public
-    def load_node_with_uuid(uuid)
-      txnode = find_tx_node(uuid)
-      return if txnode.nil?
-      # does this node exist ?
-      id = txnode[:tracked_neo_id]
-      Neo4j.load_node(id)
-    end
-
-
-    # Load a neo4j relatinship given a cluster wide UUID (instead of id)
-    # :api: public
-    def load_relationship_with_uuid(uuid)
-      txnode = find_tx_relationship(uuid)
-      return if txnode.nil?
-      # does this node exist ?
-      id = txnode[:tracked_neo_id]
-      Neo4j.load_rel(id)
-    end
-
-
-    # :api: private
-    def find_tx_node(uuid) # :nodoc:
-      # since lucene only updates the index after the transaction commits we
-      # first look in the current transaction
-      found = find_tx(uuid)
-      # if not found that find it with lucene
-      found ||= TxNodeCreated.find(:uuid => uuid).first
-      found
-    end
-
-
-    # :api: private
-    def find_tx_relationship(uuid) # :nodoc:
-      TxRelationshipCreatedNode.find(:uuid => uuid).first
-    end
-
-
-    # Find a TxNodeCreate node in the latest transaction with the given uuid
-    def find_tx(value, key = :uuid) # :nodoc:
-      tx_nodes.find {|node| node[:_classname] == TxNodeCreated.to_s && node[key] == value}
-    end
-
-    # Create a new a neo4j node given a cluster wide UUID (instead of id)
-    # :nodoc:
-    # :api: private
-    def create_node_with_uuid(uuid)
-      txnode = find_tx_node(uuid)
-      return if txnode.nil?
-      # does this node exist ?
-      id = txnode[:tracked_neo_id]
-      Neo4j.load_node(id)
-    end
-
-    #
-    # Class methods ------------------------------------------------------
-    #
-
-    def self.on_neo_started(neo_instance)
-      Neo4j::Transaction.run do
-        # has the tx_node_list already been created ?
-        unless neo_instance.ref_node.rel?(:tx_node_list)
-          # it does not exist - create it
-          neo_instance.ref_node.rels.outgoing(:tx_node_list) << TxNodeList.new
-        end
-        # cache this so we do not have to look it up always
-        @tx_node_list = neo_instance.ref_node.rels.outgoing(:tx_node_list).nodes.first
-        Neo4j.event_handler.add(@tx_node_list)
-      end
-    end
-
-    def self.on_neo_stopped(neo_instance)
-      # unregister the instance
-      Neo4j.event_handler.remove(@tx_node_list)
-      @tx_node_list = nil
-    end
-
-
-    def self.instance
-      Neo4j.start unless @tx_node_list
-      @tx_node_list
-    end
-  end
-
-
-  # Keeps the uuid of created relationship in a lucene index
-  class TxRelationshipCreatedNode
-    include Neo4j::NodeMixin
-
-    belongs_to_list(:tx_nodes).relationship(TxNodeRelationship)
-
-    property :uuid
-    index :uuid
-
-    def to_s
-      "TxRelationshipCreatedNode: " + props.inspect
-    end
-  end
-
-
-  # Keeps the uuid of created nodes in a lucene index
-  class TxNodeCreated
-    include Neo4j::NodeMixin
-
-    belongs_to_list(:tx_nodes).relationship(TxNodeRelationship)
-
-    property :uuid
-    index :uuid
-
-    def to_s
-      "TxNodeCreated: " + props.inspect
-    end
-  end
-
-
-  # Represent an events like property change
-  # Does not represend events for relationship and node creations
-  class TxNode
-    include Neo4j::NodeMixin
-
-    belongs_to_list(:tx_nodes).relationship(TxNodeRelationship)
-
-    def to_s
-      "TxNode: " + props.inspect
-    end
-  end
-
-
-  #-------------------------------------------------
-  # Neo4j Module Methods
-  #
-  #-------------------------------------------------
-
-
-  # Loads the tx tracker extension
-  def self.load_tx_tracker
-    Neo4j.event_handler.add_filter(TxNode)
-    Neo4j.event_handler.add_filter(TxNodeCreated)
-    Neo4j.event_handler.add_filter(TxRelationshipCreatedNode)
-
-    Neo4j.event_handler.add(TxNodeList)
-    Neo4j.event_handler.add(TxNodeRelationship)
-    # if neo is already run we have to let txnodelist have a chance to add it self
-    # TxNodeList.on_neo_started(Neo4j.instance) if Neo4j.running?
-    Neo4j::Transaction.run { TxNodeList.on_neo_started(Neo4j) } if Neo4j.running?
-  end
-
-  def self.unload_tx_tracker
-    Neo4j.event_handler.remove_filter(TxNode)
-    Neo4j.event_handler.remove_filter(TxNodeCreated)
-    Neo4j.event_handler.remove_filter(TxRelationshipCreatedNode)
-
-    Neo4j.event_handler.remove(TxNodeList)
-    Neo4j.event_handler.remove(TxNodeRelationship)
-  end
-
-  #  Undo the last transaction
-  #
-  # :api: public
-  def self.undo_tx
-    TxNodeList.instance.undo_tx
-  end
-
-
-  #  Loads a node with the given uuid
-  #  Returns nil if not found other wise the Node.
-  # :api: public
-  def self.load_node_with_uuid(uuid)
-    TxNodeList.instance.load_node_with_uuid(uuid)
-  end
-
-
-  #  Loads a relationship with the given uuid
-  #  Returns nil if not found other wise the Node.
-  # :api: public
-  def self.load_relationship_with_uuid(uuid)
-    TxNodeList.instance.load_relationship_with_uuid(uuid)
-  end
-
-# Generates a new unique uuid
-  def self.create_uuid
-    rand(100000000) # TODO a very bad UUID generator ...
-  end
-
-  Neo4j.load_tx_tracker
-
-
-end