zm-ruby-client 2.2.7 → 3.0.0

data/lib/zm/client/base/zimbra_attributes_collection.rb

@@ -14,8 +14,15 @@ module Zm
         def initialize(parent)
           @parent = parent
 
-          @all = CSV.open(File.expand_path(@parent.config.zimbra_attributes_path), headers: true, skip_blanks: true, strip: true, header_converters: lambda { |h| h.to_sym }).map do |attr|
-            attr_h = attr.to_h.delete_if { |_, v| v.nil? }
+          @all = CSV.open(
+            File.expand_path(@parent.config.zimbra_attributes_path),
+            headers: true,
+            skip_blanks: true,
+            strip: true,
+            header_converters: lambda { |header| header.to_sym }
+          ).map do |attr|
+            attr_h = attr.to_h
+            attr_h.compact!
             ZimbraAttribute.new(**attr_h)
           end.freeze
         end
@@ -46,7 +53,7 @@ module Zm
         end
 
         def all_cos_attr_types_h
-          @all_cos_attr_types_h ||= Hash[all_cos_attrs.map { |attr| [attr.name, attr.type] }].freeze
+          @all_cos_attr_types_h ||= all_cos_attrs.map { |attr| [attr.name, attr.type] }.to_h.freeze
         end
 
         def set_cos_methods
@@ -70,7 +77,7 @@ module Zm
         end
 
         def all_server_attr_types_h
-          @all_server_attr_types_h ||= Hash[all_server_attrs.map { |attr| [attr.name, attr.type] }].freeze
+          @all_server_attr_types_h ||= all_server_attrs.map { |attr| [attr.name, attr.type] }.to_h.freeze
         end
 
         def set_server_methods
@@ -94,7 +101,7 @@ module Zm
         end
 
         def all_domain_attr_types_h
-          @all_domain_attr_types_h ||= Hash[all_domain_attrs.map { |attr| [attr.name, attr.type] }].freeze
+          @all_domain_attr_types_h ||= all_domain_attrs.map { |attr| [attr.name, attr.type] }.to_h.freeze
         end
 
         def set_domain_methods
@@ -118,7 +125,7 @@ module Zm
         end
 
         def all_account_attr_types_h
-          @all_account_attr_types_h ||= Hash[all_account_attrs.map { |attr| [attr.name, attr.type] }].freeze
+          @all_account_attr_types_h ||= all_account_attrs.map { |attr| [attr.name, attr.type] }.to_h.freeze
         end
 
         def set_account_methods
@@ -144,9 +151,9 @@ module Zm
         end
 
         def all_distributionlist_attrs_types_h
-          @all_distributionlist_attrs_types_h ||= Hash[all_distributionlist_attrs.map do |attr|
+          @all_distributionlist_attrs_types_h ||= all_distributionlist_attrs.map do |attr|
                                                          [attr.name, attr.type]
-                                                       end].freeze
+                                                       end.to_h.freeze
         end
 
         def set_distributionlist_methods
@@ -170,7 +177,7 @@ module Zm
         end
 
         def all_resource_attrs_types_h
-          @all_resource_attrs_types_h ||= Hash[all_resource_attrs.map { |attr| [attr.name, attr.type] }].freeze
+          @all_resource_attrs_types_h ||= all_resource_attrs.map { |attr| [attr.name, attr.type] }.to_h.freeze
         end
 
         def set_resource_methods

data/lib/zm/client/base.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'faraday'
-require 'logger'
 require 'openssl'
 
 require 'zm/modules/base'

data/lib/zm/client/cluster/batch_request.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Zm
+  module Client
+    class BatchRequest
+      ONERRORS = %w[continue stop].freeze
+
+      attr_reader :requests
+
+      def initialize(connector)
+        @connector = connector
+        @requests = []
+      end
+
+      def invoke(onerror: ONERRORS.first)
+        return [] if @requests.empty?
+
+        onerror = ONERRORS.first unless ONERRORS.include?(onerror)
+
+        soap_resp = @connector.invoke(build(onerror))[:BatchResponse]
+        @requests.clear
+        format_response(soap_resp)
+      end
+
+      private
+
+      def build(onerror)
+        soap_request = SoapElement.new(SoapConstants::BATCH_REQUEST, SoapConstants::NAMESPACE_STR)
+        soap_request.add_attribute(:onerror, onerror)
+
+        @requests.each_with_index do |request, index|
+          request.add_attribute(:requestId, index + 1)
+          soap_request.add_node(request)
+        end
+
+        soap_request
+      end
+
+      def format_response(soap_resp)
+        soap_resp.delete(:_jsns)
+        responses = soap_resp.values
+        responses.flatten!
+        responses.each do |response|
+          response[:requestId] = response[:requestId].to_i
+        end
+        responses
+      end
+    end
+  end
+end

data/lib/zm/client/cluster/cluster.rb

@@ -10,6 +10,7 @@ require 'zm/client/domain'
 require 'zm/client/server'
 require 'zm/client/cos'
 require 'zm/client/license'
+require 'zm/client/cluster/batch_request'
 
 module Zm
   module Client
@@ -19,8 +20,6 @@ module Zm
                   :majorversion, :minorversion, :microversion
 
       def initialize(config)
-        # extend(ZmLogger)
-
         @config = config
         @version = config.zimbra_version
 
@@ -35,11 +34,13 @@ module Zm
       end
 
       def token
-        @soap_admin_connector.token
+        return @token if defined? @token
+
+        @token = (Token.new(@soap_admin_connector.token) if @soap_admin_connector.token)
       end
 
       def token=(value)
-        @soap_admin_connector.token= value
+        @token = Token.new(@soap_admin_connector.token = value)
       end
 
       def login
@@ -52,11 +53,12 @@ module Zm
         soap_request = SoapElement.admin(SoapAdminConstants::AUTH_REQUEST)
         soap_request.add_attributes(name: @config.zimbra_admin_login, password: @config.zimbra_admin_password)
         soap_resp = @soap_admin_connector.invoke(soap_request, Zm::Client::AuthError)
-        @soap_admin_connector.context.token(soap_resp[:AuthResponse][:authToken].first[:_content])
+        soap_resp_token = soap_resp[:AuthResponse][:authToken].first[:_content]
+        self.token = soap_resp_token
       end
 
       def logged?
-        !@soap_admin_connector.token.nil?
+        !token.nil? && !token.expired?
       end
 
       def alive?
@@ -68,39 +70,53 @@ module Zm
         false
       end
 
-      def token_metadata
-        @token_metadata ||= TokenMetaData.new(@soap_admin_connector.token)
+      def logged_and_alive?
+        logged? && alive?
       end
 
       def license
-        @license ||= LicensesCollection.new(self).find
+        return @license if defined? @license
+
+        @license = LicensesCollection.new(self).find
       rescue Zm::Client::SoapError => e
         logger.error "Get License info #{e.message}"
         nil
       end
 
       def domains
-        @domains ||= DomainsCollection.new self
+        return @domains if defined? @domains
+
+        @domains = DomainsCollection.new self
       end
 
       def accounts
-        @accounts ||= AccountsCollection.new self
+        return @accounts if defined? @accounts
+
+        @accounts = AccountsCollection.new self
       end
 
       def resources
-        @resources ||= ResourcesCollection.new self
+        return @resources if defined? @resources
+
+        @resources = ResourcesCollection.new self
       end
 
       def servers
-        @servers ||= ServersCollection.new self
+        return @servers if defined? @servers
+
+        @servers = ServersCollection.new self
       end
 
       def coses
-        @coses ||= CosesCollection.new self
+        return @coses if defined? @coses
+
+        @coses = CosesCollection.new self
       end
 
       def distributionlists
-        @distributionlists ||= DistributionListsCollection.new self
+        return @distributionlists if defined? @distributionlists
+
+        @distributionlists = DistributionListsCollection.new self
       end
 
       alias distribution_lists distributionlists
@@ -141,14 +157,24 @@ module Zm
 
         json = soap_response[:GetVersionInfoResponse][:info].first
 
-        instance_variable_set(:@type, json[:type])
-        instance_variable_set(:@version, json[:version])
-        instance_variable_set(:@release, json[:release])
-        instance_variable_set(:@buildDate, json[:buildDate])
-        instance_variable_set(:@host, json[:host])
-        instance_variable_set(:@majorversion, json[:majorversion])
-        instance_variable_set(:@minorversion, json[:minorversion])
-        instance_variable_set(:@microversion, json[:microversion])
+        instance_variable_set(:@type, json.delete(:type))
+        instance_variable_set(:@version, json.delete(:version))
+        instance_variable_set(:@release, json.delete(:release))
+        instance_variable_set(:@buildDate, json.delete(:buildDate))
+        instance_variable_set(:@host, json.delete(:host))
+        instance_variable_set(:@majorversion, json.delete(:majorversion))
+        instance_variable_set(:@minorversion, json.delete(:minorversion))
+        instance_variable_set(:@microversion, json.delete(:microversion))
+      end
+
+      def logger
+        @config.logger
+      end
+
+      def batch
+        return @batch if defined? @batch
+
+        @batch = BatchRequest.new(@soap_admin_connector)
       end
 
       private
@@ -156,10 +182,6 @@ module Zm
       def find_domain_key(domain_name)
         domains.attrs('zimbraPreAuthKey').find_by(name: domain_name).zimbraPreAuthKey
       end
-
-      def logger
-        @config.logger
-      end
     end
   end
 end

data/lib/zm/client/cluster/cluster_config.rb

@@ -6,30 +6,65 @@ module Zm
   module Client
     # class config for cluster connection
     class ClusterConfig
-      include ZmLogger
+      BASE_URL_REGEX = %r{\A(https?://[^/?#]+).*}
 
-      attr_reader :to_h
-      attr_accessor :zimbra_admin_host, :zimbra_admin_scheme, :zimbra_admin_port, :zimbra_admin_login,
-                    :zimbra_admin_password, :zimbra_public_host, :zimbra_public_scheme, :zimbra_public_port,
-                    :domains, :zimbra_version
+      attr_reader :zimbra_admin_url, :zimbra_public_url
+      attr_writer :logger, :colorize_logging
+      attr_accessor :zimbra_admin_login, :zimbra_admin_password,
+                    :domains, :zimbra_version, :log_path, :timeout
 
       def initialize(parameters = nil)
         @domains = []
         @zimbra_version = '8.8.15'
+        @log_path = $stdout
+        @log_level = Logger::INFO
+        @colorize_logging = false
+        @timeout = 300
 
+        init_from_parameters(parameters)
+
+        yield(self) if block_given?
+      end
+
+      def cache
+        @cache = Zm::Support::Cache.registered_storage[cache_store_key]
+                                   .new(**cache_store_options)
+                                   .tap do |store|
+                                     store.logger = logger
+                                   end
+      end
+
+      def cache_store_key
+        cache_store.first
+      end
+
+      def cache_store_options
+        cache_store.last
+      end
+
+      def cache_store
+        @cache_store ||= [:null_store, {}]
+      end
+
+      def cache_store=(options)
+        store_key = options.shift
+        store_options = options.last
+        store_class = Zm::Support::Cache.registered_storage[store_key]
+
+        unless store_class || store_class.test_required_options(store_options)
+          raise ClusterConfigError, 'invalid cache_store'
+        end
+
+        @cache_store = [store_key, store_options]
+      end
+
+      def init_from_parameters(parameters)
         case parameters
         when String
-          init_from_file(parameters)
+          init_from_h(init_from_file(parameters))
         when Hash
-          @to_h = parameters
+          init_from_h(parameters)
         end
-
-        unless @to_h.nil?
-          init_from_h
-          make_config_domain
-        end
-
-        yield(self) if block_given?
       end
 
       def init_from_file(file_config_path)
@@ -42,34 +77,80 @@ module Zm
         end
       end
 
-      def init_from_h
-        @zimbra_admin_host = @to_h.fetch(:zimbra_admin_host, nil)
-        @zimbra_admin_scheme = @to_h.fetch(:zimbra_admin_scheme, 'https')
-        @zimbra_admin_port = @to_h.fetch(:zimbra_admin_port, 7071)
-        @zimbra_admin_login = @to_h.fetch(:zimbra_admin_login, nil)
-        @zimbra_admin_password = @to_h.fetch(:zimbra_admin_password, nil)
-        @zimbra_public_host = @to_h.fetch(:zimbra_public_host, nil)
-        @zimbra_public_scheme = @to_h.fetch(:zimbra_public_scheme, 'https')
-        @zimbra_public_port = @to_h.fetch(:zimbra_public_port, 443)
-        @zimbra_version = @to_h.fetch(:zimbra_version, @zimbra_version)
-      end
-
       def init_from_yml(file_config_path)
-        @to_h = YAML.safe_load(File.read(file_config_path), symbolize_names: true)
+        YAML.safe_load_file(file_config_path, symbolize_names: true)
       end
 
       def init_from_json(file_config_path)
-        @to_h = JSON.parse(File.read(file_config_path), symbolize_names: true)
+        JSON.parse(File.read(file_config_path), symbolize_names: true)
+      end
+
+      def init_from_h(parameters)
+        @zimbra_admin_login = parameters.delete(:zimbra_admin_login)
+        @zimbra_admin_password = parameters.delete(:zimbra_admin_password)
+
+        init_admin_url_from_parameters(parameters)
+
+        init_public_url_from_parameters(parameters)
+
+        if (version = parameters.delete(:zimbra_version))
+          @zimbra_version = version
+        end
+
+        if (p_timeout = parameters.delete(:timeout))
+          @timeout = p_timeout.to_i
+        end
+
+        init_domains_from_parameters(parameters)
+      end
+
+      def init_domains_from_parameters(parameters)
+        if (config_domains = parameters.delete(:domains))
+          @domains = config_domains.map do |h|
+            ClusterConfigDomain.new(h[:name], h[:key])
+          end
+        end
       end
 
-      def make_config_domain
-        return if @to_h[:domains].nil?
+      def init_public_url_from_parameters(parameters)
+        if (url = parameters.delete(:zimbra_public_url))
+          self.zimbra_public_url = url
+        elsif (host = parameters.delete(:zimbra_public_host))
+          scheme = parameters.delete(:zimbra_public_scheme) || 'https'
+          port = parameters.delete(:zimbra_public_port) || 443
 
-        @domains = @to_h[:domains].map do |h|
-          ClusterConfigDomain.new(h[:name], h[:key])
+          self.zimbra_public_url = "#{scheme}://#{host}:#{port}"
         end
       end
 
+      def init_admin_url_from_parameters(parameters)
+        if (url = parameters.delete(:zimbra_admin_url))
+          self.zimbra_admin_url = url
+        else
+          scheme = parameters.delete(:zimbra_admin_scheme) || 'https'
+          host = parameters.delete(:zimbra_admin_host)
+          port = parameters.delete(:zimbra_admin_port) || 7071
+
+          self.zimbra_admin_url = "#{scheme}://#{host}:#{port}"
+        end
+      end
+
+      def zimbra_admin_url=(url)
+        match_data = BASE_URL_REGEX.match(url)
+
+        raise ClusterConfigError, 'no valid zimbra_admin_url configuration' unless match_data
+
+        @zimbra_admin_url = match_data[1]
+      end
+
+      def zimbra_public_url=(url)
+        match_data = BASE_URL_REGEX.match(url)
+
+        raise ClusterConfigError, 'no valid zimbra_public_url configuration' unless match_data
+
+        @zimbra_public_url = match_data[1]
+      end
+
       def find_domain(domain_name)
         @domains.find { |d| d.name == domain_name }
       end
@@ -82,7 +163,7 @@ module Zm
       end
 
       def has_admin_credentials?
-        !@zimbra_admin_host.nil? && !@zimbra_admin_login.nil? && !@zimbra_admin_password.nil?
+        !@zimbra_admin_url.nil? && !@zimbra_admin_login.nil? && !@zimbra_admin_password.nil?
       end
 
       def zimbra_attributes_path
@@ -94,18 +175,26 @@ module Zm
 
         @zimbra_attributes_path = path
       end
-    end
 
-    # class config for connection
-    class ClusterConfigDomain
-      attr_reader :name, :key
+      def logger
+        return @logger if defined? @logger
 
-      def initialize(name, key)
-        @name = name
-        @key = key
+        @logger = ZmLogger.new(@log_path).tap do |log|
+          log.level = @log_level
+          log.colorize! if @colorize_logging
+        end
+      end
+
+      def log_level=(level)
+        return if level == @log_level
+
+        logger.level = @log_level = level
       end
     end
 
+    # class config for connection
+    ClusterConfigDomain = Data.define(:name, :key)
+
     # class error for config
     class ClusterConfigError < StandardError; end
   end

data/lib/zm/client/common/recipients.rb

@@ -8,8 +8,8 @@ module Zm
         @recipients = []
       end
 
-      def map(&block)
-        @recipients.map(&block)
+      def map(&)
+        @recipients.map(&)
       end
 
       def add(recipient)

data/lib/zm/client/common/utils.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'addressable/uri'
-
 module Zm
   module Client
     module Utils
@@ -17,17 +15,7 @@ module Zm
           email
         end
 
-        def format_url_path(path)
-          Addressable::URI.escape path
-        end
-
-        def format_url_params(hash)
-          uri = Addressable::URI.new
-          uri.query_values = hash
-          uri.query
-        end
-
-        # TODO: chercher - remplacer toutes les occurences dans le code
+        # TODO: chercher - remplacer toutes les occurrences dans le code
         def arrow_name(name)
           return name if name.to_s.start_with?(ARROW)
 

data/lib/zm/client/common.rb

@@ -3,4 +3,3 @@
 require 'zm/client/common/utils'
 require 'zm/client/common/recipients'
 require 'zm/client/common/message'
-require 'zm/client/common/token_metadata'

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

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
 require 'faraday/multipart'
+require 'uri'
 
 module Zm
   module Client
-    class RestAccountConnector
-      attr_reader :verbose, :follow_location
+    class RestConnector
+      attr_reader :verbose, :timeout
+      attr_writer :cookies
 
-      def initialize
-        @verbose = false
-        @timeout = 300
+      def initialize(verbose: false, timeout: 300)
+        @verbose = verbose
+        @timeout = timeout
 
         @ssl_options = {
           verify: false,
@@ -18,14 +20,29 @@ module Zm
         }
 
         @cookies = nil
-      end
 
-      def verbose!
-        @verbose = true
+        yield(self) if block_given?
       end
 
-      def cookies(cookies)
-        @cookies = cookies
+      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
+        end
+
+        return unless response.status >= 400
+
+        FileUtils.rm_f(dest_file_path)
+        raise RestError, "Download failure: #{response.body} (status=#{response.status})"
       end
 
       def read(download_url)
@@ -48,32 +65,18 @@ module Zm
         data
       end
 
-      def download(download_url, dest_file_path)
-        url, path = split_url(download_url)
-
-        conn = conn_get(url)
-
-        write_downloaded_file(dest_file_path, conn, path)
-      end
-
       def upload(upload_url, src_file_path)
         url, path = split_url(upload_url)
 
-        conn = conn_multipart(url)
+        conn = Faraday.new(**http_options(url)) do |faraday|
+          faraday.request :multipart
+          faraday.response :logger, nil, { headers: true, bodies: true, errors: true } if @verbose
+        end
 
         payload = { file: Faraday::Multipart::FilePart.new(src_file_path, nil) }
         response = conn.post(path, payload)
 
-        if response.status >= 400
-          messages = [
-            "Upload failure ! #{src_file_path}",
-            extract_title(response.body)
-          ].compact
-
-          raise RestError, messages.join("\n")
-        end
-
-        response.body
+        upload_return(response, failure_message: "Upload failure ! #{src_file_path}")
       end
 
       private
@@ -84,30 +87,17 @@ module Zm
         end
       end
 
-      def conn_multipart(url)
-        Faraday.new(**http_options(url)) do |faraday|
-          faraday.request :multipart
-          faraday.response :logger, nil, { headers: true, bodies: true, errors: true } if @verbose
-        end
-      end
-
-      def write_downloaded_file(dest_file_path, conn, path)
-        response = nil
-
-        File.open(dest_file_path, 'wb') do |f|
-          response = conn.get(path) do |request|
-            request.options.on_data = Proc.new do |chunk, _, _|
-              f.write chunk
-            end
-          end
-        end
-
+      def upload_return(response, failure_message: 'Upload failure')
         if response.status >= 400
-          File.unlink(dest_file_path) if File.exist?(dest_file_path)
-          raise RestError, "Download failure: #{response.body} (status=#{response.status})"
+          messages = [
+            failure_message,
+            extract_title(response.body)
+          ].compact
+
+          raise RestError, messages.join("\n")
         end
 
-        response
+        response.body
       end
 
       def split_url(url)