marklogic 0.0.1

data/lib/marklogic/collection.rb

@@ -0,0 +1,265 @@
+require 'securerandom'
+
+module MarkLogic
+  class Collection
+
+    attr_accessor :collection
+    attr_reader :database
+
+    alias_method :name, :collection
+    def initialize(name, database)
+      @collection = name
+      @database = database
+      @operators = %w{GT LT GE LE EQ NE ASC DESC}
+    end
+
+    def count
+      MarkLogic::Cursor.new(self).count
+    end
+
+    def load(id)
+      url = "/v1/documents?uri=#{gen_uri(id)}&format=json"
+      response = @database.connection.get(url)
+      raise Exception.new("Invalid response: #{response.code.to_i}, #{response.body}") unless response.code.to_i == 200
+      JSON.parse(response.body)
+    end
+
+    def save(doc)
+      if (doc.is_a?(Array))
+        docs = {}
+        doc.each do |d|
+          docs[doc_uri(d)] = JSON.generate(d)
+        end
+        body = build_multipart_body(docs)
+        response = @database.connection.post_multipart("/v1/documents", body)
+        raise Exception.new("Invalid response: #{response.code.to_i}, #{response.body}\n") unless response.code.to_i == 200
+      else
+        uri = doc_uri(doc)
+        url = "/v1/documents?uri=#{uri}&format=json&collection=#{collection}"
+        json = JSON.generate(doc)
+        response = @database.connection.put(url, json)
+        raise Exception.new("Invalid response: #{response.code.to_i}, #{response.body}\n") unless [201, 204].include? response.code.to_i
+        doc[:_id] || doc[:id] || doc['_id'] || doc['id']
+      end
+    end
+
+    def update(selector, document, opts={})
+      find(selector).each do |doc|
+        document.each do |key, value|
+          case key
+          when "$set"
+            value.each do |kk, vv|
+              doc[kk.to_s] = vv
+            end
+          when "$inc"
+            value.each do |kk, vv|
+              prev = doc[kk.to_s] || 0
+              doc[kk.to_s] = prev + vv
+            end
+          when "$unset"
+            value.keys.each do |kk|
+              doc.delete(kk.to_s)
+            end
+          when "$push"
+            value.each do |kk, vv|
+              if doc.has_key?(kk.to_s)
+                doc[kk.to_s].push(vv)
+              else
+                doc[kk.to_s] = [vv]
+              end
+            end
+          when "$pushAll"
+            value.each do |kk, vv|
+              if doc.has_key?(kk.to_s)
+                doc[kk.to_s] = doc[kk.to_s] + vv
+              else
+                doc[kk.to_s] = vv
+              end
+            end
+          end
+          save(doc)
+        end
+      end
+    end
+
+    alias_method :create, :save
+    alias_method :insert, :save
+
+    def remove(query = nil, options = {})
+      if query.nil? || (query.is_a?(Hash) && query.empty?)
+        drop
+      else
+        if query.class == Hash
+          query = from_criteria(query)
+        elsif query.nil?
+          query = Queries::AndQuery.new()
+        end
+
+        xqy = %Q{cts:search(fn:collection("#{collection}"), #{query.to_xqy}, ("unfiltered")) / xdmp:node-delete(.)}
+        response = @database.connection.run_query(xqy, "xquery")
+        raise Exception.new("Invalid response: #{response.code.to_i}, #{response.body}") unless response.code.to_i == 200
+      end
+    end
+
+    def drop
+      url = "/v1/search?collection=#{collection}"
+      response =@database.connection.delete(url)
+      raise Exception.new("Invalid response: #{response.code.to_i}, #{response.body}") unless [204].include? response.code.to_i
+    end
+
+    def find_one(query = nil, options = {})
+      opts = options.merge(:per_page => 1)
+      find(query, opts).next
+    end
+
+    def find(query = nil, options = {})
+      if query.class == Hash
+        query = from_criteria(query)
+      elsif query.nil?
+        query = Queries::AndQuery.new()
+      end
+      options[:query] = query
+      cursor = MarkLogic::Cursor.new(self, options)
+
+      if block_given?
+        yield cursor
+        nil
+      else
+        cursor
+      end
+    end
+
+    def build_query(name, operator, value, query_options = {})
+      if database.has_range_index?(name) && (query_options.has_key?(:case_sensitive) == false || query_options[:case_sensitive] == true)
+        index = database.range_index(name)
+        type = index.scalar_type
+        Queries::RangeQuery.new(name, operator, type, value, query_options)
+      elsif operator != 'EQ'
+        raise MissingIndexError.new("Missing index on #{name}")
+      elsif value.nil?
+        Queries::OrQuery.new([
+          Queries::ValueQuery.new(name, value, query_options),
+          Queries::NotQuery.new(Queries::ContainerQuery.new(name, Queries::AndQuery.new))
+        ])
+      elsif operator == 'EQ'
+        Queries::ValueQuery.new(name, value, query_options)
+      end
+    end
+
+    # Builds a MarkLogic Query from Mongo Style Criteria
+    #
+    # @param [Hash] criteria The Criteria to use when searching
+    #
+    # @example Build a query from criteria
+    #
+    #    # Query on age == 3
+    #    collection.from_criteria({ 'age' => { '$eq' =>  3  } })
+    #
+    #    # Query on age < 3
+    #    collection.from_criteria({ 'age' => { '$lt' =>  3  } })
+    #
+    #    # Query on age <= 3
+    #    collection.from_criteria({ 'age' => { '$le' =>  3  } })
+    #
+    #    # Query on age > 3
+    #    collection.from_criteria({ 'age' => { '$gt' =>  3  } })
+    #
+    #    # Query on age >= 3
+    #    collection.from_criteria({ 'age' => { '$ge' =>  3  } })
+    #
+    #    # Query on age != 3
+    #    collection.from_criteria({ 'age' => { '$ne' =>  3  } })
+    #
+    # @since 0.0.1
+    def from_criteria(criteria)
+      queries = []
+
+      criteria.each do |k, v|
+        name, operator, index_type, value = nil
+        query_options = {}
+
+        if (v.is_a?(Hash))
+          name = k.to_s
+          query_options.merge!(v.delete(:options) || {})
+
+          sub_queries = []
+          v.each do |kk, vv|
+            operator = kk.to_s.gsub('$', '').upcase || "EQ"
+            if @operators.include?(operator)
+              value = vv
+              value = value.to_s if value.is_a?(MarkLogic::ObjectId)
+              sub_queries << build_query(name, operator, value, query_options)
+            elsif value.is_a?(Hash)
+              child_queries = value.map do |kk, vv|
+                build_query(kk, vv, query_options)
+              end
+              sub_queries << Queries::ContainerQuery.new(name, Queries::AndQuery.new(child_queries))
+            end
+          end
+
+          if sub_queries.length > 1
+            queries << Queries::AndQuery.new(sub_queries)
+          elsif sub_queries.length == 1
+            queries << sub_queries[0]
+          end
+        else
+          name = k.to_s
+          value = v
+          operator = "EQ"
+          queries << build_query(name, operator, value, query_options)
+        end
+      end
+
+      if queries.length > 1
+        MarkLogic::Queries::AndQuery.new(*queries)
+      elsif queries.length == 1
+        queries[0]
+      end
+    end
+
+    private
+
+    def doc_uri(doc)
+      id = doc[:_id] || doc['_id']
+      if id.nil?
+        id = SecureRandom.hex
+        doc[:_id] = id
+      end
+      gen_uri(id)
+    end
+
+    def gen_uri(id)
+      if id.is_a?(Hash)
+        id_str = id.hash.to_s
+      else
+        id_str = id.to_s
+      end
+      %Q{/#{collection}/#{id_str}.json}
+    end
+
+    def build_multipart_body(docs, boundary = "BOUNDARY")
+      tmp = ""
+
+      # collection
+      metadata = JSON.generate({ collections: [ collection ]})
+      tmp << %Q{--#{boundary}\r\n}
+      tmp << %Q{Content-Type: application/json\r\n}
+      tmp << %Q{Content-Disposition: inline; category=metadata\r\n}
+      tmp << %Q{Content-Length: #{metadata.size}\r\n\r\n}
+      tmp << metadata
+      tmp << %Q{\r\n}
+
+      docs.each do |uri, doc|
+        # doc
+        tmp << %Q{--#{boundary}\r\n}
+        tmp << %Q{Content-Type: application/json\r\n}
+        tmp << %Q{Content-Disposition: attachment; filename="#{uri}"; category=content; format=json\r\n}
+        tmp << %Q{Content-Length: #{doc.size}\r\n\r\n}
+        tmp << doc
+        tmp << %Q{\r\n}
+      end
+      tmp << "--#{boundary}--"
+      tmp
+    end
+  end
+end

data/lib/marklogic/connection.rb

@@ -0,0 +1,308 @@
+require 'net/http'
+require 'date'
+require 'json'
+require 'digest'
+
+module Net
+  module HTTPHeader
+    @@nonce_count = -1
+    CNONCE = Digest::MD5.hexdigest "%x" % (Time.now.to_i + rand(65535))
+
+    def create_digest_auth(user, password, response)
+      # based on http://segment7.net/projects/ruby/snippets/digest_auth.rb
+      @@nonce_count += 1
+
+      response['www-authenticate'] =~ /^(\w+) (.*)/
+
+      params = {}
+      $2.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+
+      digest_auth(user, password, params)
+    end
+
+    def digest_auth(user, password, params)
+
+      a_1 = "#{user}:#{params['realm']}:#{password}"
+      a_2 = "#{@method}:#{@path}"
+      request_digest = ''
+      request_digest << Digest::MD5.new.update(a_1).hexdigest
+      request_digest << ':' << params['nonce']
+      request_digest << ':' << ('%08x' % @@nonce_count)
+      request_digest << ':' << CNONCE
+      request_digest << ':' << params['qop']
+      request_digest << ':' << Digest::MD5.new.update(a_2).hexdigest
+
+      header = []
+      header << "Digest username=\"#{user}\""
+      header << "realm=\"#{params['realm']}\""
+
+      header << "qop=#{params['qop']}"
+
+      header << "algorithm=MD5"
+      header << "uri=\"#{@path}\""
+      header << "nonce=\"#{params['nonce']}\""
+      header << "nc=#{'%08x' % @@nonce_count}"
+      header << "cnonce=\"#{CNONCE}\""
+      header << "response=\"#{Digest::MD5.hexdigest(request_digest)}\""
+
+      @header['Authorization'] = header
+      params
+    end
+
+    def basic_auth(user, password)
+      encoded = Base64.encode64("#{user}:#{password}").chomp
+
+      @header['Authorization'] = ["Basic #{encoded}"]
+    end
+  end
+end
+
+module MarkLogic
+  class Connection
+    include MarkLogic::Loggable
+
+    attr_accessor :admin, :manage, :app_services, :username, :password, :host, :port, :request_retries
+
+    def self.configure(options = {})
+      @@__host_name = options[:host] if options[:host]
+      @@__app_services_port = options[:app_services_port] if options[:app_services_port]
+      @@__admin_port = options[:admin_port] if options[:admin_port]
+      @@__manage_port = options[:manage_port] if options[:manage_port]
+      @@__default_user = options[:default_user] if options[:default_user]
+      @@__default_password = options[:default_password] if options[:default_password]
+    end
+
+    def self.default_user
+      @@__default_user ||= "admin"
+    end
+
+    def self.default_password
+      @@__default_password ||= "admin"
+    end
+
+    def self.host_name
+      @@__host_name ||= "localhost"
+    end
+
+    def self.app_services_port
+      @@__app_services_port ||= 8000
+    end
+
+    def self.admin_port
+      @@__admin_port ||= 8001
+    end
+
+    def self.manage_port
+      @@__manage_port ||= 8002
+    end
+
+    def self.admin_connection(username = self.default_user, password = self.default_password)
+      @@__admin_connection ||= Connection.new(self.host_name, self.admin_port, username, password)
+    end
+
+    def self.manage_connection(username = self.default_user, password = self.default_password)
+      @@__manage_connection ||= Connection.new(self.host_name, self.manage_port, username, password)
+    end
+
+    def self.app_services_connection(username = self.default_user, password = self.default_password)
+      @@__app_services_connection ||= Connection.new(self.host_name, self.app_services_port, username, password)
+    end
+
+    def host
+      @host
+    end
+
+    def initialize(host, port, username = nil, password = nil, options = {})
+      @host = host
+      @port = port
+      @username = username || self.class.default_user
+      @password = password || self.class.default_password
+      @request_retries = options[:request_retries] || 3
+      @http = Net::HTTP.new(host, port)
+    end
+
+    def run_query(query, type = "javascript", options = {})
+      params = {
+        type.to_sym => query
+      }
+      params[:dbname] = options[:db] if options[:db]
+      response = post('/eval', params)
+        # :xquery => options[:query],
+        # :locale => LOCALE,
+        # :tzoffset => "-18000",
+        # :dbname => options[:db]
+    end
+
+    def head(url, headers = {})
+      request(url, 'head', headers)
+    end
+
+    def get(url, headers = {})
+      request(url, 'get', headers)
+    end
+
+    def put(url, body = nil, headers = {})
+      request(url, 'put', headers, body)
+    end
+
+    def post(url, params = nil, headers = {})
+      request(url, 'post', headers, nil, params)
+    end
+
+    def post_json(url, params = nil, headers = {})
+      request(url, 'post', headers, ::JSON.generate(params))
+    end
+
+    def post_multipart(url, body = nil, headers = {}, boundary = "BOUNDARY")
+      headers['Content-Type'] = %Q{multipart/mixed; boundary=#{boundary}}
+      headers['Accept'] = %Q{application/json}
+      request(url, 'post', headers, body)
+    end
+
+    def delete(url, headers = {}, body = nil)
+      request(url, 'delete', headers, body)
+    end
+
+    def wait_for_restart(body)
+      json = JSON.parse(body)
+      ts_value = json["restart"]["last-startup"][0]["value"]
+      timestamp = DateTime.iso8601(ts_value).to_time
+      new_timestamp = timestamp
+
+      code = nil
+      logger.debug "Waiting for restart"
+      until code == 200 and new_timestamp > timestamp
+        begin
+          rr = get(%Q{/admin/v1/timestamp})
+          code = rr.code.to_i
+          bb = rr.body
+          new_timestamp = DateTime.iso8601(bb).to_time if code == 200
+        rescue
+        end
+      end
+      logger.debug "Restart Complete"
+    end
+
+    def ==(other)
+      @host == other.host &&
+      @port == other.port &&
+      @username == other.username &&
+      @password == other.password
+    end
+
+    private
+
+    def default_headers
+      {
+        'Connection' => 'keep-alive',
+        'Keep-Alive' => '30',
+        'User-Agent' => 'MarkLogic',
+        'Content-type' => 'application/json'
+      }
+    end
+
+    def split_multipart(response)
+      if response.read_body
+        body = response.body
+
+        if body.length == 0
+          response.body = nil
+          return
+        end
+
+        content_type = response['Content-Type']
+        if (content_type and content_type.match(/multipart\/mixed.*/))
+          boundary = $1 if content_type =~ /^.*boundary=(.*)$/
+
+          body.sub!(Regexp.new("[\r\n]+--#{boundary}--[\r\n]+$", Regexp::MULTILINE), "")
+          body.sub!(Regexp.new("^[\r\n]+--#{boundary}.+?[\r\n]+", Regexp::MULTILINE), "")
+
+          values = []
+          body.split(Regexp.new(%Q{[\r\n]+--#{boundary}[\r\n]+}, Regexp::MULTILINE)).each do |item|
+            splits = item.split(/\r\n\r\n/m)
+            metas = splits[0]
+            raw_value = splits[1]
+
+            value_content_type = type = xpath = nil
+
+            metas.split(/\r\n/m).each do |meta|
+              if meta.match(/^Content-Type:.*/m)
+                value_content_type = $1 if meta =~ /Content-Type:\s+(.*)$/
+              elsif meta.match(/^X-Primitive:.*/)
+                type = $1 if meta =~ /X-Primitive:\s+(.*)$/
+              elsif meta.match(/^X-Path:.*/)
+                xpath = $1 if meta =~ /X-Path:\s+(.*)$/
+              end
+            end
+
+            if (value_content_type == "application/json") then
+              value = JSON.parse(raw_value)
+            else
+              case type
+              when "integer"
+                value = raw_value.to_i
+              when "boolean"
+                value = raw_value == "true"
+              when "decimal"
+                value = raw_value.to_f
+              else
+                value = raw_value
+              end
+            end
+            values.push(value)
+          end
+
+          if (values.length == 1)
+            values = values[0]
+          end
+          output = values
+        else
+          output = body
+        end
+        response.body = output
+      end
+    end
+
+    def request(url, verb = 'get', headers = {}, body = nil, params = nil)
+      tries ||= request_retries
+
+      logger.debug "Retry #{request_retries - tries} of #{request_retries} for:\n#{body}" unless (tries == request_retries)
+      all_headers = {}
+
+      # configure headers
+      default_headers.merge(headers).each do |k, v|
+        all_headers[k] = v
+      end
+
+      request = Net::HTTP.const_get(verb.capitalize).new(url, all_headers)
+
+      # Send the auth info if we have it
+      if @auth
+        request.digest_auth(@username, @password, @auth)
+      end
+
+      request.set_form_data(params) if (params)
+      request.body = body if (body)
+
+      response = @http.request request
+
+      if (response.code.to_i == 401 and @username and @password)
+        auth_method = $1.downcase if response['www-authenticate'] =~ /^(\w+) (.*)/
+        if (auth_method == "basic")
+          request.basic_auth(@username, @password)
+        elsif (auth_method == "digest")
+          @auth = request.create_digest_auth(@username, @password, response)
+        end
+
+        response = @http.request request
+      end
+
+      # puts("#{response.code} : #{verb.upcase} => ://#{@host}:#{@port}#{url} :: #{body} #{params}")
+
+      split_multipart(response)
+      response
+    rescue Net::ReadTimeout => e
+      retry unless (tries -= 1).zero?
+    end
+  end
+end