neo4j-core 3.0.8 → 3.1.0

data/lib/neo4j-server/cypher_relationship.rb

@@ -34,7 +34,7 @@ module Neo4j::Server
 
     def load_resource
       if resource_data.nil? || resource_data.empty?
-        @resource_data = @session._query_or_fail("START n=relationship(#{id}) RETURN n", true) # r.first_data
+        @resource_data = @session._query_or_fail("#{match_start} RETURN n", true) # r.first_data
       end
     end
 
@@ -69,15 +69,15 @@ module Neo4j::Server
     end
 
     def get_property(key)
-      @session._query_or_fail("START n=relationship(#{id}) RETURN n.`#{key}`", true)
+      @session._query_or_fail("#{match_start} RETURN n.`#{key}`", true)
     end
 
     def set_property(key,value)
-      @session._query_or_fail("START n=relationship(#{id}) SET n.`#{key}` = {value}", false, {value: value})
+      @session._query_or_fail("#{match_start} SET n.`#{key}` = {value}", false, {value: value})
     end
 
     def remove_property(key)
-      @session._query_or_fail("START n=relationship(#{id}) REMOVE n.`#{key}`")
+      @session._query_or_fail("#{match_start} REMOVE n.`#{key}`")
     end
 
     # (see Neo4j::Relationship#props)
@@ -85,21 +85,21 @@ module Neo4j::Server
       if @props
         @props
       else
-        hash = @session._query_entity_data("START n=relationship(#{neo_id}) RETURN n")
+        hash = @session._query_entity_data("#{match_start} RETURN n")
         @props = Hash[hash['data'].map{ |k, v| [k.to_sym, v] }]
       end
     end
 
     # (see Neo4j::Relationship#props=)
     def props=(properties)
-      @session._query_or_fail("START n=relationship(#{neo_id}) SET n = { props }", false, {props: properties})
+      @session._query_or_fail("#{match_start} SET n = { props }", false, {props: properties})
       properties
     end
 
     # (see Neo4j::Relationship#update_props)
     def update_props(properties)
       return if properties.empty?
-      q = "START n=relationship(#{neo_id}) SET " + properties.keys.map do |k|
+      q = "#{match_start} SET " + properties.keys.map do |k|
         "n.`#{k}`= #{escape_value(properties[k])}"
       end.join(',')
       @session._query_or_fail(q)
@@ -111,24 +111,21 @@ module Neo4j::Server
     end
 
     def del
-      id = neo_id
-      @session._query("START n=relationship(#{id}) DELETE n").raise_unless_response_code(200)
+      @session._query("#{match_start} DELETE n").raise_unless_response_code(200)
     end
     alias_method :delete, :del
     alias_method :destroy, :del
 
     def exist?
-      id = neo_id
-      response = @session._query("START n=relationship(#{id}) RETURN n")
-
-      if (!response.error?)
-        return true
-      elsif (response.error_status == 'BadInputException') # TODO see github issue neo4j/1061
-        return false
-      else
-        response.raise_error
-      end
+      response = @session._query("#{match_start} RETURN n")
+      # binding.pry
+      (response.data.nil? || response.data.empty?) ? false : true
     end
 
+    private
+
+    def match_start(identifier = 'n')
+      "MATCH (node)-[#{identifier}]-() WHERE ID(#{identifier}) = #{neo_id}"
+    end
   end
 end

data/lib/neo4j-server/cypher_session.rb

@@ -10,7 +10,15 @@ module Neo4j::Server
     include Neo4j::Core::CypherTranslator
 
     alias_method :super_query, :query
-    attr_reader :connection
+    attr_reader :connection, :auth
+
+    def initialize(data_url, connection, auth_obj = nil)
+      @connection = connection
+      @auth = auth_obj if auth_obj
+      Neo4j::Session.register(self)
+      initialize_resource(data_url)
+      Neo4j::Session._notify_listeners(:session_available, self)
+    end
 
     # @param [Hash] params could be empty or contain basic authentication user and password
     # @return [Faraday]
@@ -26,7 +34,7 @@ module Neo4j::Server
         b.use Faraday::Adapter::NetHttpPersistent
         # b.adapter  Faraday.default_adapter
       end
-      conn.headers = {'Content-Type' => 'application/json', 'User-Agent' => ::Neo4j::Session.user_agent_string}
+      conn.headers = { 'Content-Type' => 'application/json', 'User-Agent' => ::Neo4j::Session.user_agent_string }
       conn
     end
 
@@ -35,18 +43,21 @@ module Neo4j::Server
     #
     # @param [String] endpoint_url - the url to the neo4j server, defaults to 'http://localhost:7474'
     # @param [Hash] params faraday params, see #create_connection or an already created faraday connection
-    def self.open(endpoint_url=nil, params = {})
+    def self.open(endpoint_url = nil, params = {})
       extract_basic_auth(endpoint_url, params)
       connection = params[:connection] || create_connection(params)
       url = endpoint_url || 'http://localhost:7474'
+      auth_obj = CypherAuthentication.new(url, connection, params)
+      auth_obj.authenticate
       response = connection.get(url)
       raise "Server not available on #{url} (response code #{response.status})" unless response.status == 200
+      establish_session(response.body, connection, auth_obj)
+    end
 
-      root_data = response.body
+    def self.establish_session(root_data, connection, auth_obj)
       data_url = root_data['data']
       data_url << '/' unless data_url.end_with?('/')
-
-      CypherSession.new(data_url, connection)
+      CypherSession.new(data_url, connection, auth_obj)
     end
 
     def self.extract_basic_auth(url, params)
@@ -56,14 +67,8 @@ module Neo4j::Server
         password: URI(url).password
       }
     end
-    private_class_method :extract_basic_auth
 
-    def initialize(data_url, connection)
-      @connection = connection
-      Neo4j::Session.register(self)
-      initialize_resource(data_url)
-      Neo4j::Session._notify_listeners(:session_available, self)
-    end
+    private_class_method :extract_basic_auth
 
     def db_type
       :server_db
@@ -105,21 +110,16 @@ module Neo4j::Server
       Neo4j::Transaction.current
     end
 
-    def create_node(props=nil, labels=[])
-      l = labels.empty? ? "" : ":" + labels.map{|k| "`#{k}`"}.join(':')
-      q = "CREATE (n#{l} #{cypher_prop_list(props)}) RETURN ID(n)"
-      cypher_response = _query_or_fail(q, true)
-      CypherNode.new(self, cypher_response)
+    def create_node(props = nil, labels = [])
+      CypherNode.new self, _query_or_fail(cypher_string(labels, props), true, cypher_prop_list(props))
     end
 
     def load_node(neo_id)
-      cypher_response = _query("START n=node(#{neo_id}) RETURN n")
-      load_entity(CypherNode, cypher_response)
+      load_entity(CypherNode, _query("MATCH (n) WHERE ID(n) = #{neo_id} RETURN n"))
     end
 
     def load_relationship(neo_id)
-      cypher_response = _query("START r=relationship(#{neo_id}) RETURN r")
-      load_entity(CypherRelationship, cypher_response)
+      load_entity(CypherRelationship, _query("MATCH (n)-[r]-() WHERE ID(r) = #{neo_id} RETURN r"))
     end
 
     def load_entity(clazz, cypher_response)
@@ -144,36 +144,21 @@ module Neo4j::Server
     end
 
     def uniqueness_constraints(label)
-      response = @connection.get("#{@resource_url}schema/constraint/#{label}/uniqueness")
-      expect_response_code(response, 200)
-      data_resource = response.body
-
-      property_keys = data_resource.map do |row|
-        row['property_keys'].map(&:to_sym)
-      end
-
-      {
-          property_keys: property_keys
-      }
+      schema_properties("#{@resource_url}schema/constraint/#{label}/uniqueness")
     end
 
     def indexes(label)
-      response = @connection.get("#{@resource_url}schema/index/#{label}")
-      expect_response_code(response, 200)
-      data_resource = response.body
-
-      property_keys = data_resource.map do |row|
-        row['property_keys'].map(&:to_sym)
-      end
+      schema_properties("#{@resource_url}schema/index/#{label}")
+    end
 
-      {
-          property_keys: property_keys
-      }
+    def schema_properties(query_string)
+      response = @connection.get(query_string)
+      expect_response_code(response, 200)
+      { property_keys: response.body.map { |row| row['property_keys'].map(&:to_sym) } }
     end
 
     def find_all_nodes(label_name)
-      response = _query_or_fail("MATCH (n:`#{label_name}`) RETURN ID(n)")
-      search_result_to_enumerable_first_column(response)
+      search_result_to_enumerable_first_column(_query_or_fail("MATCH (n:`#{label_name}`) RETURN ID(n)"))
     end
 
     def find_nodes(label_name, key, value)
@@ -254,41 +239,16 @@ module Neo4j::Server
           yielder << CypherNode.new(self, data[0]).wrapper
         end
       end
-  end
+    end
 
     def map_column(key, map, data)
-      case map[key]
-        when :node
-          CypherNode.new(self, data).wrapper
-        when :rel, :relationship
-          CypherRelationship.new(self, data)
-        else
-          data
+      if map[key] == :node
+        CypherNode.new(self, data).wrapper
+      elsif map[key] == :rel || map[:key] || :relationship
+        CypherRelationship.new(self, data)
+      else
+        data
       end
     end
-
-
-    # def search_result_to_enumerable(response, ret, map)
-    #   return [] unless response.data
-
-    #   if (ret.size == 1)
-    #     Enumerator.new do |yielder|
-    #       response.data.each do |data|
-    #         yielder << map_column(key, map, data[0])
-    #       end
-    #     end
-
-    #   else
-    #     Enumerator.new do |yielder|
-    #       response.data.each do |data|
-    #         hash = {}
-    #         ret.each_with_index do |key, i|
-    #           hash[key] = map_column(key, map, data[i])
-    #         end
-    #         yielder << hash
-    #       end
-    #     end
-    #   end
-    # end
   end
 end

data/lib/neo4j/tasks/config_server.rb

@@ -1,15 +1,31 @@
 module Neo4j
   module Tasks
-
     module ConfigServer
 
-      def config(data, port)
-        s = set_property(data, 'org.neo4j.server.webserver.https.enabled', 'false')
+      def config(source_text, port)
+        s = set_property(source_text, 'org.neo4j.server.webserver.https.enabled', 'false')
         set_property(s, 'org.neo4j.server.webserver.port', port)
       end
 
-      def set_property(data, property, value)
-        data.gsub(/#{property}\s*=\s*(\w+)/, "#{property}=#{value}")
+      def set_property(source_text, property, value)
+        source_text.gsub(/#{property}\s*=\s*(\w+)/, "#{property}=#{value}")
+      end
+
+      # Toggles the status of Neo4j 2.2's basic auth
+      def toggle_auth(status, source_text)
+        status_string = status == :enable ? 'true' : 'false'
+        set_property(source_text, 'dbms.security.authorization_enabled', status_string)
+      end
+
+      # POSTs to an endpoint with the form required to change a Neo4j password
+      # @param [String] target_address The server address, with protocol and port, against which the form should be POSTed
+      # @param [String] old_password The existing password for the "neo4j" user account
+      # @param [String] new_password The new password you want to use. Shocking, isn't it?
+      # @return [Hash] The response from the server indicating success/failure.
+      def change_password(target_address, old_password, new_password)
+        uri = URI.parse("#{target_address}/user/neo4j/password")
+        response = Net::HTTP.post_form(uri, { 'password' => old_password, 'new_password' => new_password })
+        JSON.parse(response.body)
       end
 
       extend self

data/lib/neo4j/tasks/neo4j_server.rake

@@ -1,3 +1,4 @@
+# :nocov:
 # borrowed from architect4r
 require 'os'
 require 'httparty'
@@ -6,24 +7,18 @@ require 'httparty'
 require File.expand_path("../config_server", __FILE__)
 
 namespace :neo4j do
-
   def download_neo4j(file)
-    if OS::Underlying.windows? then
-      file_name = "neo4j.zip"
-      download_url = "http://dist.neo4j.org/neo4j-#{file}-windows.zip"
-    else
-      file_name = "neo4j-unix.tar.gz"
-      download_url = "http://dist.neo4j.org/neo4j-#{file}-unix.tar.gz"
-    end
+    file_name, download_url = if OS::Underlying.windows?
+                                ["neo4j.zip", "http://dist.neo4j.org/neo4j-#{file}-windows.zip"]
+                              else
+                                ["neo4j-unix.tar.gz", "http://dist.neo4j.org/neo4j-#{file}-unix.tar.gz"]
+                              end
 
     unless File.exist?(file_name)
       # check if file is available
       status = HTTParty.head(download_url).code
       raise "#{file} is not available to download, try a different version" if status < 200 || status >= 300
-
       df = File.open(file_name, 'wb')
-
-
       success = false
       begin
         df << HTTParty.get(download_url)
@@ -34,8 +29,6 @@ namespace :neo4j do
       end
     end
 
-
-
     # # http://download.neo4j.org/artifact?edition=community&version=2.1.2&distribution=tarball&dlid=3462770&_ga=1.110610309.1220184053.1399636580
     #
     # parsed_url = URI.parse(download_url)
@@ -67,25 +60,29 @@ namespace :neo4j do
     "db/neo4j/#{get_environment(args)}"
   end
 
-  desc "Install Neo4j, example neo4j:install[community-2.1.3,development]"
+  def config_location(args)
+    "#{install_location(args)}/conf/neo4j-server.properties"
+  end
+
+  desc "Install Neo4j with auth disabled in v2.2+, example neo4j:install[community-2.1.3,development]"
   task :install, :edition, :environment do |_, args|
     file = args[:edition]
     environment = get_environment(args)
     puts "Installing Neo4j-#{file} environment: #{environment}"
 
     downloaded_file = download_neo4j file
-    
+
     if OS::Underlying.windows?
       # Extract and move to neo4j directory
       unless File.exist?(install_location(args))
         Zip::ZipFile.open(downloaded_file) do |zip_file|
           zip_file.each do |f|
-           f_path=File.join(".", f.name)
+           f_path = File.join(".", f.name)
            FileUtils.mkdir_p(File.dirname(f_path))
            begin
              zip_file.extract(f, f_path) unless File.exist?(f_path)
            rescue
-             puts f.name + " failed to extract."
+             puts "#{f.name} failed to extract."
            end
           end
         end
@@ -105,19 +102,20 @@ namespace :neo4j do
       %x[rm #{downloaded_file}]
       puts "Neo4j Installed in to neo4j directory."
     end
+    rake_auth_toggle(args, :disable) unless /-2\.0|1\.[0-9]/.match(args[:edition])
     puts "Type 'rake neo4j:start' or 'rake neo4j:start[ENVIRONMENT]' to start it\nType 'neo4j:config[ENVIRONMENT,PORT]' for changing server port, (default 7474)"
   end
-  
+
   desc "Start the Neo4j Server"
   task :start, :environment do |_, args|
     puts "Starting Neo4j #{get_environment(args)}..."
-    if OS::Underlying.windows? 
-      if %x[reg query "HKU\\S-1-5-19"].size > 0 
+    if OS::Underlying.windows?
+      if %x[reg query "HKU\\S-1-5-19"].size > 0
         %x[#{install_location(args)}/bin/Neo4j.bat start]  #start service
       else
         puts "Starting Neo4j directly, not as a service."
         %x[#{install_location(args)}/bin/Neo4j.bat]
-      end      
+      end
     else
       %x[#{install_location(args)}/bin/neo4j start]
     end
@@ -129,7 +127,7 @@ namespace :neo4j do
     port = args[:port]
     raise "no port given" unless port
     puts "Config Neo4j #{get_environment(args)} for port #{port}"
-    location = "#{install_location(args)}/conf/neo4j-server.properties"
+    location = config_location(args)
     text = File.read(location)
     replace = Neo4j::Tasks::ConfigServer.config(text, port)
     File.open(location, "w") {|file| file.puts replace}
@@ -138,13 +136,13 @@ namespace :neo4j do
   desc "Stop the Neo4j Server"
   task :stop, :environment do |_, args|
     puts "Stopping Neo4j #{get_environment(args)}..."
-    if OS::Underlying.windows? 
+    if OS::Underlying.windows?
       if %x[reg query "HKU\\S-1-5-19"].size > 0
          %x[#{install_location(args)}/bin/Neo4j.bat stop]  #stop service
       else
-        puts "You do not have administrative rights to stop the Neo4j Service"   
+        puts "You do not have administrative rights to stop the Neo4j Service"
       end
-    else  
+    else
       %x[#{install_location(args)}/bin/neo4j stop]
     end
   end
@@ -166,13 +164,13 @@ namespace :neo4j do
   desc "Restart the Neo4j Server"
   task :restart, :environment do |_, args|
     puts "Restarting Neo4j #{get_environment(args)}..."
-    if OS::Underlying.windows? 
+    if OS::Underlying.windows?
       if %x[reg query "HKU\\S-1-5-19"].size > 0
          %x[#{install_location(args)}/bin/Neo4j.bat restart]
       else
-        puts "You do not have administrative rights to restart the Neo4j Service"   
+        puts "You do not have administrative rights to restart the Neo4j Service"
       end
-    else  
+    else
       %x[#{install_location(args)}/bin/neo4j restart]
     end
   end
@@ -180,36 +178,83 @@ namespace :neo4j do
   desc "Reset the Neo4j Server"
   task :reset_yes_i_am_sure, :environment do |_, args|
     # Stop the server
-    if OS::Underlying.windows? 
+    if OS::Underlying.windows?
       if %x[reg query "HKU\\S-1-5-19"].size > 0
          %x[#{install_location(args)}/bin/Neo4j.bat stop]
-         
+
         # Reset the database
         FileUtils.rm_rf("#{install_location(args)}/data/graph.db")
         FileUtils.mkdir("#{install_location(args)}/data/graph.db")
-        
+
         # Remove log files
         FileUtils.rm_rf("#{install_location(args)}/data/log")
         FileUtils.mkdir("#{install_location(args)}/data/log")
 
         %x[#{install_location(args)}/bin/Neo4j.bat start]
       else
-        puts "You do not have administrative rights to reset the Neo4j Service"   
+        puts "You do not have administrative rights to reset the Neo4j Service"
       end
-    else  
+    else
       %x[#{install_location(args)}/bin/neo4j stop]
-      
+
       # Reset the database
       FileUtils.rm_rf("#{install_location(args)}/data/graph.db")
       FileUtils.mkdir("#{install_location(args)}/data/graph.db")
-      
+
       # Remove log files
       FileUtils.rm_rf("#{install_location(args)}/data/log")
       FileUtils.mkdir("#{install_location(args)}/data/log")
-      
+
       # Start the server
       %x[#{install_location(args)}/bin/neo4j start]
     end
   end
 
-end  
+  desc "Neo4j 2.2: Change connection password"
+  task :change_password do |_, args|
+    puts "This will change the password for a Neo4j server"
+    puts "Enter target IP address or host name without protocal and port, press enter for http://localhost:7474"
+    address = STDIN.gets.chomp
+    target_address = address.empty? ? "http://localhost:7474" : address
+
+    puts "Input current password. Leave blank if this is a fresh installation of Neo4j."
+    password = STDIN.gets.chomp
+    old_password = password.empty? ? "neo4j" : password
+
+    puts "Input new password."
+    new_password = STDIN.gets.chomp
+    raise 'A new password is required' if new_password.empty?
+
+    body = Neo4j::Tasks::ConfigServer.change_password(target_address, old_password, new_password)
+    if body['errors']
+      puts "An error was returned: #{body['errors'][0]['message']}"
+    else
+      puts "Password changed successfully! Please update your app to use:"
+      puts "username: neo4j"
+      puts "password: #{new_password}"
+    end
+  end
+
+  def rake_auth_toggle(args, status)
+    location = config_location(args)
+    text = File.read(location)
+    replace = Neo4j::Tasks::ConfigServer.toggle_auth(status, text)
+    File.open(location, "w") {|file| file.puts replace}
+  end
+
+  def auth_toggle_complete(status)
+    puts "Neo4j basic authentication #{status}. Restart server to apply."
+  end
+
+  desc "Neo4j 2.2: Enable Auth"
+  task :enable_auth, :environment do |_, args|
+    rake_auth_toggle(args, :enable)
+    auth_toggle_complete('enabled')
+  end
+
+  desc "Neo4j 2.2: Disable Auth"
+  task :disable_auth, :environment do |_, args|
+    rake_auth_toggle(args, :disable)
+    auth_toggle_complete('disabled')
+  end
+end