zm-ruby-client 3.0.1 → 3.1.0

data/lib/zm/{client/connector → connector}/rest_connector.rb

@@ -4,20 +4,17 @@ require 'faraday/multipart'
 require 'uri'
 
 module Zm
-  module Client
+  module Connector
     class RestConnector
+      include NetworkErrorHandler
+
       attr_reader :verbose, :timeout
       attr_writer :cookies
 
-      def initialize(verbose: false, timeout: 300)
+      def initialize(verbose: false, timeout: 300, ssl_options: SSL_VERIFY_NONE)
         @verbose = verbose
         @timeout = timeout
-
-        @ssl_options = {
-          verify: false,
-          verify_hostname: false,
-          verify_mode: OpenSSL::SSL::VERIFY_NONE
-        }
+        @ssl_options = ssl_options
 
         @cookies = nil
 
@@ -27,41 +24,21 @@ module Zm
       def download(download_url, dest_file_path)
         url, path = split_url(download_url)
 
-        conn = conn_get(url)
-
-        response = nil
-
         File.open(dest_file_path, 'wb') do |f|
-          response = conn.get(path) do |request|
-            request.options.on_data = proc do |chunk, _, _|
-              f.write chunk
-            end
-          end
+          stream_get(url, path) { |chunk| f.write(chunk) }
         end
 
-        return unless response.status >= 400
-
+        nil
+      rescue Zm::Error::ConnectionError, Zm::Error::RestError
         FileUtils.rm_f(dest_file_path)
-        raise RestError, "Download failure: #{response.body} (status=#{response.status})"
+        raise
       end
 
       def read(download_url)
         url, path = split_url(download_url)
 
-        conn = conn_get(url)
-
         data = +''
-
-        response = conn.get(path) do |request|
-          request.options.on_data = Proc.new do |chunk, _, _|
-            data.concat(chunk)
-          end
-        end
-
-        if response.status >= 400
-          raise RestError, "Download failure: #{response.body} (status=#{response.status})"
-        end
-
+        stream_get(url, path) { |chunk| data.concat(chunk) }
         data
       end
 
@@ -70,20 +47,49 @@ module Zm
 
         conn = Faraday.new(**http_options(url)) do |faraday|
           faraday.request :multipart
-          faraday.response :logger, nil, { headers: true, bodies: true, errors: true } if @verbose
+          add_logger(faraday)
         end
 
         payload = { file: Faraday::Multipart::FilePart.new(src_file_path, nil) }
-        response = conn.post(path, payload)
+        response = handle_network_errors { conn.post(path, payload) }
 
         upload_return(response, failure_message: "Upload failure ! #{src_file_path}")
       end
 
       private
 
+      def stream_get(url, path)
+        error_body = +''
+
+        response = handle_network_errors do
+          conn_get(url).get(path) do |request|
+            request.options.on_data = proc do |chunk, _, env|
+              env.status.to_i >= 400 ? error_body.concat(chunk) : yield(chunk)
+            end
+          end
+        end
+
+        return response if response.status < 400
+
+        raise Zm::Error::RestError, download_failure_message(response, error_body)
+      end
+
+      def download_failure_message(response, error_body)
+        body = error_body.empty? ? response.body.to_s : error_body
+        "Download failure: #{extract_title(body) || body[0, 200]} (status=#{response.status})"
+      end
+
       def conn_get(url)
         Faraday.new(**http_options(url)) do |faraday|
-          faraday.response :logger, nil, { headers: true, bodies: true, errors: true } if @verbose
+          add_logger(faraday)
+        end
+      end
+
+      def add_logger(faraday)
+        return unless @verbose
+
+        faraday.response(:logger, nil, { headers: true, bodies: true, errors: true }) do |formatter|
+          Zm::Utils::LogFilter.apply(formatter)
         end
       end
 
@@ -94,7 +100,7 @@ module Zm
             extract_title(response.body)
           ].compact
 
-          raise RestError, messages.join("\n")
+          raise Zm::Error::RestError, messages.join("\n")
         end
 
         response.body
@@ -103,7 +109,7 @@ module Zm
       def split_url(url)
         uri = URI(url)
         url = "#{uri.scheme}://#{uri.host}:#{uri.port}"
-        path = [uri.path, uri.query].join('?')
+        path = uri.query ? "#{uri.path}?#{uri.query}" : uri.path
 
         [url, path]
       end
@@ -114,8 +120,8 @@ module Zm
 
       def http_options(url)
         {
-          url: url,
-          headers: headers,
+          url:,
+          headers:,
           request: {
             timeout: @timeout
           },

data/lib/zm/{client/connector/soap_account.rb → connector/soap_account_connector.rb}

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'soap_base'
-require_relative 'soap_error'
-
 module Zm
-  module Client
+  module Connector
     class SoapAccountConnector < SoapBaseConnector
       class << self
         def create(config)
@@ -14,6 +11,7 @@ module Zm
             trans.logger = config.logger
             trans.cache = config.cache
             trans.timeout = config.timeout
+            trans.ssl_options = config.ssl_options
           end
         end
       end
@@ -27,32 +25,32 @@ module Zm
       end
 
       def initialize(url)
-        super(url, SoapAccountConstants::ACCOUNT_SERVICE_URI)
+        super(url, SoapRequest::SoapAccountConstants::ACCOUNT_SERVICE_URI)
       end
 
       def auth_preauth(content, by, expires, domainkey)
         ts = (Time.now.to_i * 1000)
         preauth = compute_preauth(content, by, ts, expires, domainkey)
 
-        soap_request = SoapElement.account(SoapAccountConstants::AUTH_REQUEST)
-        node_account = SoapElement.create(SoapConstants::ACCOUNT)
-                                  .add_attribute(SoapConstants::BY, by)
-                                  .add_content(content)
+        soap_request = SoapRequest::SoapElement.account(Zm::SoapRequest::SoapAccountConstants::AUTH_REQUEST)
+        node_account = SoapRequest::SoapElement.create(SoapRequest::SoapConstants::ACCOUNT)
+                                               .add_attribute(SoapRequest::SoapConstants::BY, by)
+                                               .add_content(content)
         soap_request.add_node(node_account)
-        node_preauth = SoapElement.create(SoapConstants::PREAUTH)
-                                  .add_attribute(SoapConstants::TIMESTAMP, ts)
-                                  .add_attribute(SoapConstants::EXPIRES, expires)
-                                  .add_content(preauth)
+        node_preauth = SoapRequest::SoapElement.create(SoapRequest::SoapConstants::PREAUTH)
+                                               .add_attribute(SoapRequest::SoapConstants::TIMESTAMP, ts)
+                                               .add_attribute(SoapRequest::SoapConstants::EXPIRES, expires)
+                                               .add_content(preauth)
         soap_request.add_node(node_preauth)
 
         do_login(soap_request)
       end
 
       def auth_password(content, by, password)
-        soap_request = SoapElement.account(SoapAccountConstants::AUTH_REQUEST)
-        node_account = SoapElement.create(SoapConstants::ACCOUNT)
-                                  .add_attribute(SoapConstants::BY, by)
-                                  .add_content(content)
+        soap_request = SoapRequest::SoapElement.account(Zm::SoapRequest::SoapAccountConstants::AUTH_REQUEST)
+        node_account = SoapRequest::SoapElement.create(SoapRequest::SoapConstants::ACCOUNT)
+                                               .add_attribute(SoapRequest::SoapConstants::BY, by)
+                                               .add_content(content)
         soap_request.add_node(node_account)
         soap_request.add_attribute('password', password)
 

data/lib/zm/{client/connector/soap_admin.rb → connector/soap_admin_connector.rb}

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'soap_base'
-require_relative 'soap_error'
-
 module Zm
-  module Client
+  module Connector
     class SoapAdminConnector < SoapBaseConnector
       class << self
         def create(config)
@@ -14,6 +11,7 @@ module Zm
             trans.logger = config.logger
             trans.cache = config.cache
             trans.timeout = config.timeout
+            trans.ssl_options = config.ssl_options
           end
         end
       end
@@ -27,7 +25,7 @@ module Zm
       end
 
       def initialize(url)
-        super(url, SoapAdminConstants::ADMIN_SERVICE_URI)
+        super(url, Zm::SoapRequest::SoapAdminConstants::ADMIN_SERVICE_URI)
       end
     end
   end

data/lib/zm/connector/soap_base_connector.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Zm
+  module Connector
+    class SoapBaseConnector
+      include NetworkErrorHandler
+
+      BASESPACE = 'urn:zimbra'
+      HTTP_HEADERS = {
+        'Content-Type' => 'application/json; charset=utf-8',
+        'User-Agent' => 'ZmRubyClient'
+      }.freeze
+      CACHEABLE_REQUEST_REGEX = /\A(?:Get|Search|Count)\w*Request\z/
+
+      attr_reader :context
+      attr_writer :logger, :cache, :timeout, :ssl_options
+
+      def initialize(url, soap_path)
+        @verbose = false
+        @timeout = 300
+
+        @ssl_options = SSL_VERIFY_NONE
+
+        @url = url
+        @soap_path = soap_path
+
+        @context = Zm::SoapRequest::SoapContext.new
+      end
+
+      def initialize_copy(source)
+        super
+        @context = @context.dup
+      end
+
+      def verbose!
+        @verbose = true
+      end
+
+      def invoke(soap_element, error_handler = Zm::Error::SoapError)
+        do_request(envelope(soap_element), error_handler, cacheable: cacheable?(soap_element))[:Body]
+      end
+
+      def target_invoke(soap_element, target_id, error_handler = Zm::Error::SoapError)
+        @context.target_server(target_id)
+        invoke(soap_element, error_handler)
+      ensure
+        @context.target_server(nil)
+      end
+
+      def http_client!
+        @http_client = Faraday.new(
+          url: @url,
+          headers: HTTP_HEADERS,
+          request: {
+            timeout: @timeout
+          },
+          ssl: @ssl_options
+        ) do |faraday|
+          faraday.request :json
+          if @verbose
+            faraday.response(:logger, nil, { headers: true, bodies: true, errors: true }) do |formatter|
+              Zm::Utils::LogFilter.apply(formatter)
+            end
+          end
+        end
+      end
+
+      private
+
+      def cacheable?(soap_element)
+        CACHEABLE_REQUEST_REGEX.match?(soap_element.name)
+      end
+
+      def http_client
+        @http_client || http_client!
+      end
+
+      def do_request(body, error_handler = Zm::Error::SoapError, cacheable: false)
+        json_body = body.to_json
+        @logger.debug { Zm::Utils::LogFilter.filter(json_body) }
+
+        json_response = if cacheable
+                          @cache.fetch(json_body) { post(json_body, error_handler) }
+                        else
+                          post(json_body, error_handler)
+                        end
+
+        JSON.parse(json_response, symbolize_names: true)
+      end
+
+      def post(json_body, error_handler)
+        @logger.debug 'Load from remote'
+        response = handle_network_errors { http_client.post(@soap_path, json_body) }
+        @logger.debug { Zm::Utils::LogFilter.filter(response.body) }
+
+        raise(error_handler, error_body(response)) if response.status >= 400
+
+        response.body
+      end
+
+      def error_body(response)
+        JSON.parse(response.body, symbolize_names: true)
+      rescue JSON::ParserError, TypeError
+        { Body: { Fault: { Reason: { Text: "HTTP #{response.status}" }, Detail: { Error: { Code: 'HTTP_ERROR' } } } } }
+      end
+
+      def envelope(soap_element)
+        {
+          Body: soap_element.to_hash,
+          Header: { context: context.to_hash, _jsns: BASESPACE }
+        }
+      end
+    end
+  end
+end

data/lib/zm/connector.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Zm
+  module Connector
+    SSL_VERIFY_NONE = { verify: false, verify_hostname: false, verify_mode: OpenSSL::SSL::VERIFY_NONE }.freeze
+
+    autoload :SoapBaseConnector, 'zm/connector/soap_base_connector'
+    autoload :SoapAdminConnector, 'zm/connector/soap_admin_connector'
+    autoload :SoapAccountConnector, 'zm/connector/soap_account_connector'
+    autoload :RestConnector, 'zm/connector/rest_connector'
+    autoload :NetworkErrorHandler, 'zm/connector/network_error_handler'
+  end
+end

data/lib/zm/error/auth_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Zm
+  module Error
+    class AuthError < SoapError
+    end
+  end
+end

data/lib/zm/error/connection_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Zm
+  module Error
+    class ConnectionError < ZmError
+    end
+  end
+end

data/lib/zm/error/rest_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Zm
+  module Error
+    class RestError < StandardError
+    end
+  end
+end

data/lib/zm/{client/connector → error}/soap_error.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
 module Zm
-  module Client
-    class ZmError < StandardError
-    end
-
+  module Error
     class SoapError < StandardError
       attr_reader :reason, :code
 
@@ -14,11 +11,5 @@ module Zm
         super("[#{@code}] [#{@reason}]")
       end
     end
-
-    class AuthError < SoapError
-    end
-
-    class RestError < StandardError
-    end
   end
 end

data/lib/zm/error/zm_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Zm
+  module Error
+    class ZmError < StandardError
+    end
+  end
+end

data/lib/zm/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Zm
+  module Error
+    autoload :ZmError, 'zm/error/zm_error'
+    autoload :SoapError, 'zm/error/soap_error'
+    autoload :AuthError, 'zm/error/auth_error'
+    autoload :RestError, 'zm/error/rest_error'
+    autoload :ConnectionError, 'zm/error/connection_error'
+  end
+end

data/lib/zm/relationship/has_many.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Zm
+  module Relationship
+    class HasMany
+      def initialize(name:, klass:)
+        @name = name
+        @klass = klass
+      end
+
+      attr_reader :name, :klass
+
+      def generate_relation_method(buffer = +'')
+        buffer <<
+          'def ' << @name.name << "\n" \
+          'return @' << @name.name << ' if defined? @' << @name.name << "\n" \
+          '@' << @name.name << ' = ' << @klass.name << '.new(self)' << "\n" \
+          "end\n"
+      end
+    end
+  end
+end

data/lib/zm/relationship/jsns_builder.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Zm
+  module Relationship
+    class JsnsBuilder
+      def initialize(klass:)
+        @klass = klass
+      end
+
+      attr_reader :name, :klass
+
+      def generate_relation_method(buffer = +'')
+        buffer <<
+          'def jsns_builder' << "\n" \
+          'return @jsns_builder if defined? @jsns_builder' << "\n" \
+          '@jsns_builder = ' << @klass.name << '.new(self)' << "\n" \
+          "end\n"
+      end
+    end
+  end
+end

data/lib/zm/relationship/relationship.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Zm
+  module Relationship
+    autoload :Schema, 'zm/relationship/schema'
+    autoload :HasMany, 'zm/relationship/has_many'
+    autoload :JsnsBuilder, 'zm/relationship/jsns_builder'
+
+    def has_many(name, klass: nil)
+      klass ||= find_has_many_klass(name.name)
+
+      new_relation = __relationship_has_many_class__.new(name:, klass:)
+
+      relationships << new_relation
+      __define_relationship_methods__(new_relation)
+      include(__relationship_extension__)
+    end
+
+    def has_jsns_builder(klass: nil)
+      klass ||= find_jsns_builder_klass(self.name)
+
+      new_relation = __relationship_jsns_buidler_class__.new(klass:)
+
+      relationships << new_relation
+      __define_relationship_methods__(new_relation)
+      include(__relationship_extension__)
+    end
+
+    def __generate_relationship_methods__(new_relation, buffer = +'')
+      buffer << "# frozen_string_philosophal: true\n"
+
+      new_relation.generate_relation_method(buffer)
+
+      buffer
+    end
+
+    def relationships
+      return @relationships if defined?(@relationships)
+
+      @relationships = if defined?(superclass) && superclass.is_a?(Zm::Relationship)
+                         superclass.relationships.dup
+                       else
+                         Zm::Relationship::Schema.new
+                       end
+    end
+
+    private
+
+    def find_has_many_klass(name)
+      parts = name.split('_').map(&:capitalize)
+      parts << 'Collection'
+      parts.unshift 'Zm::Client::'
+      parts.join.to_sym
+    end
+
+    def find_jsns_builder_klass(name)
+      (name.dup << 'JsnsBuilder').to_sym
+    end
+
+    def __relationship_has_many_class__
+      Zm::Relationship::HasMany
+    end
+
+    def __relationship_jsns_buidler_class__
+      Zm::Relationship::JsnsBuilder
+    end
+
+    def __define_relationship_methods__(new_relation)
+      code =	__generate_relationship_methods__(new_relation)
+      __relationship_extension__.module_eval(code)
+    end
+
+    def __relationship_extension__
+      if defined?(@__relationship_extension__)
+        @__relationship_extension__
+      else
+        @__relationship_extension__ = Module.new do
+          # def cprop?(property_name, klass)
+          #   property = self.class.philosophal_properties.properties_index[property_name.to_sym]
+          #   return false unless property
+          #
+          #   klass = klass.class unless klass.is_a?(Class)
+          #   property.type == klass
+          # end
+
+          # def philosophal_inspect(light = false)
+          #   keys_map = philosophal_inspect_map
+          #
+          #   if light
+          #     keys_map.reject! do |_, v|
+          #       v.nil? || (v.respond_to?(:empty?) && v.empty?)
+          #     end
+          #   end
+          #
+          #   keys_str = keys_map.map { |k, v| [k, v.inspect].join(': ') }.join(', ')
+          #   "#{self.class}:#{format('0x00%x', (object_id << 1))} #{keys_str}"
+          # end
+          # alias cprop_inspect philosophal_inspect
+
+          # def philosophal_inspect_map
+          #   self.class.philosophal_properties.properties_index.values.to_h do |property|
+          #     [
+          #       property.name,
+          #       send(property.name)
+          #     ]
+          #   end
+          # end
+          # alias cprop_inspect_map philosophal_inspect_map
+        end
+      end
+    end
+  end
+end

data/lib/zm/relationship/schema.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Zm
+  module Relationship
+    class Schema
+      include Enumerable
+
+      def initialize(properties_index: {})
+        @properties_index = properties_index
+        @mutex = Mutex.new
+      end
+
+      attr_reader :properties_index
+
+      def [](key)
+        @properties_index[key]
+      end
+
+      def keys
+        @properties_index.keys
+      end
+
+      def <<(value)
+        @mutex.synchronize do
+          @properties_index[value.name] = value
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/zm/relationship.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Zm
+  autoload :Relationship, 'zm/relationship/relationship'
+end