timfel-active_cmis 0.3.1

data/lib/active_cmis/internal/connection.rb

@@ -0,0 +1,222 @@
+
+module ActiveCMIS
+  module Internal
+    class Connection
+      # @return [String, nil] The user that is used with the authentication to the server
+      attr_reader :user
+      # @return [Logger] A logger used to send debug and info messages
+      attr_reader :logger
+
+      # @param [Logger] Initialize with a logger of your choice
+      def initialize(logger)
+        @logger = logger || ActiveCMIS.default_logger
+      end
+
+      # Use authentication to access the CMIS repository
+      #
+      # @param method [Symbol] Currently only :basic is supported
+      # @param params The parameters that need to be sent to the Net::HTTP authentication method used, username and password for basic authentication
+      # @return [void]
+      # @example Basic authentication
+      #   repo.authenticate(:basic, "username", "password")
+      # @example NTLM authentication
+      #   repo.authenticate(:ntlm, "username", "password")
+      def authenticate(method, *params)
+        case method
+        when :basic, "basic"
+          @authentication = {:method => :basic_auth, :params => params}
+          @user = params.first
+        when :ntlm, "ntlm"
+          @authentication = {:method => :ntlm_auth, :params => params}
+          @user = params.first
+        else raise "Authentication method not supported"
+        end
+      end
+
+      # The return value is the unparsed body, unless an error occured
+      # If an error occurred, exceptions are thrown (see _ActiveCMIS::Exception
+      #
+      # @private
+      # @return [String] returns the body of the request, unless an error occurs
+      def get(url)
+        uri = normalize_url(url)
+
+        req = Net::HTTP::Get.new(uri.request_uri)
+        handle_request(uri, req)
+      end
+
+      # Does not throw errors, returns the full response (includes status code and headers)
+      # @private
+      # @return [Net::HTTP::Response]
+      def get_response(url)
+        logger.debug "GET (response) #{url}"
+        uri = normalize_url(url)
+
+        req = Net::HTTP::Get.new(uri.request_uri)
+        http = authenticate_request(uri, req)
+        response = http.request(req)
+        logger.debug "GOT (#{response.code}) #{url}"
+        response
+      end
+
+      # Returns the parsed body of the result
+      # @private
+      # @return [Nokogiri::XML::Document]
+      def get_xml(url)
+        Nokogiri::XML.parse(get(url), nil, nil, Nokogiri::XML::ParseOptions::STRICT)
+      end
+
+      # @private
+      # @return [Nokogiri::XML::Node]
+      def get_atom_entry(url)
+        # FIXME: add validation that first child is really an entry
+        get_xml(url).child
+      end
+
+      # @private
+      def put(url, body, headers = {})
+        uri = normalize_url(url)
+
+        req = Net::HTTP::Put.new(uri.request_uri)
+        headers.each {|k,v| req.add_field k, v}
+        assign_body(req, body)
+        handle_request(uri, req)
+      end
+
+      # @private
+      def delete(url, headers = {})
+        uri = normalize_url(url)
+
+        req = Net::HTTP::Put.new(uri.request_uri)
+        headers.each {|k,v| req.add_field k, v}
+        handle_request(uri, req)
+      end
+
+      # @private
+      def post(url, body, headers = {})
+        uri = normalize_url(url)
+
+        req = Net::HTTP::Post.new(uri.request_uri)
+        headers.each {|k,v| req.add_field k, v}
+        assign_body(req, body)
+        handle_request(uri, req)
+      end
+
+      # Does not throw errors, returns the full response (includes status code and headers)
+      # @private
+      def post_response(url, body, headers = {})
+        logger.debug "POST (response) #{url}"
+        uri = normalize_url(url)
+
+        req = Net::HTTP::Post.new(uri.request_uri)
+        headers.each {|k,v| req.add_field k, v}
+        assign_body(req, body)
+
+        http = authenticate_request(uri, req)
+        response = http.request(req)
+        logger.debug "POSTED (#{response.code}) #{url}"
+        response
+      end
+
+      # @private
+      def delete(url)
+        uri = normalize_url(url)
+
+        req = Net::HTTP::Delete.new(uri.request_uri)
+        handle_request(uri, req)
+      end
+
+      private
+      def normalize_url(url)
+        case url
+        when URI; url
+        else URI.parse(url.to_s)
+        end
+      end
+
+      def http_class
+        @http_class ||= begin
+                          if proxy = ENV['HTTP_PROXY'] || ENV['http_proxy'] then
+                            p_uri = URI.parse(proxy)
+                            p_user, p_pass = p_uri.user, p_uri.password if p_uri.user
+                            Net::HTTP::Proxy(p_uri.host, p_uri.port, p_user, p_pass)
+                          else
+                            Net::HTTP
+                          end
+                        end
+      end
+
+      def authenticate_request(uri, req)
+        http = http_class.new(uri.host, uri.port)
+        if uri.scheme == 'https'
+          http.use_ssl = true
+        end
+        if auth = @authentication
+          req.send(auth[:method], *auth[:params])
+        end
+        http
+      end
+
+      def assign_body(req, body)
+        if body.respond_to? :length
+          req.body = body
+        else
+          req.body_stream = body
+          if body.respond_to? :stat
+            req["Content-Length"] = body.stat.size.to_s
+          elsif req["Content-Size"].nil?
+            req["Transfer-Encoding"] = 'chunked'
+          end
+        end
+      end
+
+      def handle_request(uri, req, retry_count = 0)
+        logger.debug "#{req.method} #{uri}"
+        http = authenticate_request(uri, req)
+
+        status, body, headers = nil
+        http.request(req) { |resp|
+          status = resp.code.to_i
+          body = resp.body
+          headers = resp
+        }
+
+        logger.debug "RECEIVED #{status}"
+
+        if 200 <= status && status < 300
+          return body
+        elsif 300 <= status && status < 400
+          # follow the redirected a limited number of times
+          location = headers["location"]
+          logger.debug "REDIRECTING: #{location.inspect}"
+          if retry_count <= 3
+            new_uri = URI.parse(location)
+            if new_uri.relative?
+              new_uri = uri + location
+            end
+            new_req = req.class.new(uri.request_uri)
+            handle_request(new_uri, new_req, retry_count + 1)
+          else
+            raise HTTPError.new("Too many redirects")
+          end
+        elsif 400 <= status && status < 500
+          # Problem: some codes 400, 405, 403, 409, 500 have multiple meanings
+          logger.error "Error occurred when handling request:\n#{body}"
+          case status
+          when 400; raise Error::InvalidArgument.new(body)
+            # FIXME: can also be filterNotValid
+          when 401; raise HTTPError::AuthenticationError.new(body)
+          when 404; raise Error::ObjectNotFound.new(body)
+          when 403; raise Error::PermissionDenied.new(body)
+            # FIXME: can also be streamNotSupported (?? shouldn't that be 405??)
+          when 405; raise Error::NotSupported.new(body)
+          else
+            raise HTTPError::ClientError.new("A HTTP #{status} error occured, for more precision update the code:\n" + body)
+          end
+        elsif 500 <= status
+          raise HTTPError::ServerError.new("The server encountered an internal error #{status} (this could be a client error though):\n" + body)
+        end
+      end
+    end
+  end
+end

data/lib/active_cmis/internal/utils.rb

@@ -0,0 +1,82 @@
+module ActiveCMIS
+  module Internal
+    # @private
+    module Utils
+      # @private
+      def self.escape_url_parameter(parameter)
+        control = "\x00-\x1F\x7F"
+        space   = " "
+        delims  = "<>#%\""
+        unwise  = '{}|\\\\^\[\]`'
+        query   = ";/?:@&=+,$"
+        escape(parameter, /[#{control+space+delims+unwise+query}]/o)
+      end
+
+      # Given an url (string or URI) returns that url with the given parameters appended
+      #
+      # This method does not perform any encoding on the paramter or key values.
+      # This method does not check the existing parameters for duplication in keys
+      # @private
+      def self.append_parameters(uri, parameters)
+        uri       = case uri
+                    when String; string = true; URI.parse(uri)
+                    when URI;    uri.dup
+                    end
+        uri.query = [uri.query, *parameters.map {|key, value| "#{key}=#{value}"} ].compact.join "&"
+        if string
+          uri.to_s
+        else
+          uri
+        end
+      end
+
+      # FIXME?? percent_encode and escape_url_parameter serve nearly the same purpose, replace one?
+      # @private
+      def self.percent_encode(string)
+        escape(string, /[^#{URI::PATTERN::UNRESERVED}]/o)
+      end
+
+      def self.escape(string, pattern)
+        if defined?(URI::Parser)
+          parser = URI::Parser.new
+          parser.escape(string, pattern)
+        else
+          URI.escape(string, pattern)
+        end
+      end
+
+      # Returns id if id is already an object, object_by_id if id is a string, nil otherwise
+      # @private
+      def self.string_or_id_to_object(repository, id)
+        # FIXME: only used in lib/activecmis/relationship.rb, the repository parameter
+        # would be unnecessary if included.
+        # Should this be a generic method, or should this be moved to the Relationship class?
+        # Or should I start including this module in every place that needs it?
+        case id
+        when String; repository.object_by_id(id)
+        when ::ActiveCMIS::Object; id
+        end
+      end
+
+      # @private
+      def self.extract_links(xml, rel, type_main = nil, type_params = {})
+        links = xml.xpath("at:link[@rel = '#{rel}']", NS::COMBINED)
+
+        if type_main
+          type_main = Regexp.escape(type_main)
+          if type_params.empty?
+            regex = /#{type_main}/
+          else
+            parameters = type_params.map {|k,v| "#{Regexp.escape(k)}=#{Regexp.escape(v)}" }.join(";\s*")
+            regex = /#{type_main};\s*#{parameters}/
+          end
+          links = links.select do |node|
+             regex === node.attribute("type").to_s
+          end
+        end
+
+        links.map {|l| l.attribute("href").to_s}
+      end
+    end
+  end
+end

data/lib/active_cmis/ns.rb

@@ -0,0 +1,18 @@
+module ActiveCMIS
+  # This module defines namespaces that often occur in the REST/Atompub API to CMIS
+  module NS
+    CMIS_CORE = "http://docs.oasis-open.org/ns/cmis/core/200908/"
+    CMIS_REST = "http://docs.oasis-open.org/ns/cmis/restatom/200908/"
+    CMIS_MESSAGING = "http://docs.oasis-open.org/ns/cmis/messaging/200908/"
+    APP = "http://www.w3.org/2007/app"
+    ATOM = "http://www.w3.org/2005/Atom"
+
+    COMBINED = {
+      "xmlns:c" => CMIS_CORE,
+      "xmlns:cra" => CMIS_REST,
+      "xmlns:cm" => CMIS_MESSAGING,
+      "xmlns:app" => APP,
+      "xmlns:at" => ATOM
+    }
+  end
+end