zm-ruby-client 2.2.7 → 3.0.0

data/lib/zm/client/zm_logger.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Zm
+  module Client
+    class ZmLogger < ::Logger
+      def initialize(*args, **kwargs)
+        super
+        @formatter ||= ZmFormatter.new
+      end
+
+      def colorize!
+        extend(ZmLoggerColorized)
+      end
+
+      class ZmFormatter < ::Logger::Formatter
+        Format = "[%s] %5s : %s\n"
+
+        def call(severity, time, _, msg)
+          format(Format, format_datetime(time), severity, msg2str(msg))
+        end
+      end
+
+      module ZmLoggerColorized
+        # ANSI sequence modes
+        MODES = {
+          clear: 0,
+          bold: 1,
+          italic: 3,
+          underline: 4
+        }.freeze
+
+        # ANSI sequence colors
+        BLACK   = "\e[30m"
+        RED     = "\e[31m"
+        GREEN   = "\e[32m"
+        YELLOW  = "\e[33m"
+        BLUE    = "\e[34m"
+        MAGENTA = "\e[35m"
+        CYAN    = "\e[36m"
+        WHITE   = "\e[37m"
+
+        def severity_color(severity)
+          case severity
+          when 'DEBUG'
+            CYAN
+          when 'INFO'
+            GREEN
+          when 'WARN'
+            YELLOW
+          when 'ERROR'
+            RED
+          when 'FATAL'
+            mode_code(:bold)
+          when 'ANY'
+            mode_code(:clear)
+          else
+            mode_code(:clear)
+          end
+        end
+
+        def mode_code(mode)
+          mode = mode.to_sym if mode.is_a?(String)
+          return unless (value = MODES[mode])
+
+          "\e[#{value}m"
+        end
+
+        def colorize_message(severity, str)
+          "#{severity_color(severity)}#{str}#{mode_code(:clear)}"
+        end
+
+        def format_message(severity, datetime, progname, msg)
+          colorize_message(
+            severity,
+            super
+          )
+        end
+      end
+    end
+  end
+end

data/lib/zm/client.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
+require 'date'
+
+require 'zm/client/soap_request'
 require 'zm/modules/inspector'
+require 'zm/support/cache'
+require 'zm/client/zm_logger'
 require 'zm/client/version'
 require 'zm/client/constant'
+require 'zm/client/token'
 require 'zm/client/base'
 require 'zm/client/cluster'
-require 'zm/client/soap_request'

data/lib/zm/modules/base.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'zm/modules/zm_logger'
 require 'zm/modules/zm_model'
 require 'zm/modules/missing_method_static_collection'
 

data/lib/zm/modules/belongs_to_folder.rb

@@ -3,11 +3,8 @@
 module Zm
   module Client
     module BelongsToFolder
-      def folder_id
-        @l
-      end
-
       def folder=(folder)
+        return if folder.nil?
         return unless @l != folder.id
 
         @l = folder.id
@@ -24,13 +21,15 @@ module Zm
 
       def move!(new_folder_id)
         new_folder_id = new_folder_id.id if new_folder_id.is_a?(Zm::Client::Folder)
-        @parent.sacc.invoke(jsns_builder.to_move(new_folder_id))
+        return if new_folder_id == @l
+
+        @parent.soap_connector.invoke(jsns_builder.to_move(new_folder_id))
+        @folder = nil
         @l = new_folder_id
-        folder!
       end
 
       def trash!
-        @parent.sacc.invoke(jsns_builder.to_trash)
+        @parent.soap_connector.invoke(jsns_builder.to_trash)
       end
     end
   end

data/lib/zm/modules/belongs_to_tag.rb

@@ -4,7 +4,9 @@ module Zm
   module Client
     module BelongsToTag
       def tags
-        @tags ||= AccountObject::TagsCollection.new(self)
+        return @tags if defined? @tags
+
+        @tags = AccountObject::TagsCollection.new(self)
       end
     end
   end

data/lib/zm/modules/common/zimbra-attrs.csv

@@ -700,9 +700,9 @@ zimbraDomainAggregateQuota,,,domain,single,,,cstring,,,,
 zimbraDomainAggregateQuotaPolicy,,,domain,single,,,cstring,,,,
 zimbraDomainAggregateQuotaWarnPercent,,,domain,single,,,cstring,,,,
 zimbraDomainMandatoryMailSignatureEnabled,,,domain,single,,,cstring,,,,
-zimbraDomainName,,,domain,single,,,cstring,,,,
+zimbraDomainName,,,domain,single,,1,cstring,,,,
 zimbraDomainStatus,,,domain,single,,,cstring,,,,
-zimbraDomainType,,,domain,single,,,cstring,,,,
+zimbraDomainType,,,domain,single,,1,cstring,,,,
 zimbraExternalShareInvitationUrlExpiration,,,domain,single,,,cstring,,,,
 zimbraFreebusyExchangeServerType,,,domain,single,,,cstring,,,,
 zimbraInternalSharingCrossDomainEnabled,,,domain,single,,,cstring,,,,
@@ -734,5 +734,4 @@ zimbraRecoveryAccountCodeValidity,"account,cos,calendarResource",,,single,,,cstr
 zimbraResetPasswordRecoveryCodeExpiry,"account,cos,calendarResource",,,single,,,cstring,,,,
 zimbraShowClientTOS,"account,domain,cos,calendarResource",,,single,,,cstring,,,,
 zimbraDistributionListSendShareMessageToNewMembers,distributionList,,,single,,,boolean,,,,
-zimbraServiceEnabled,,,server,multi,,,cstring,,,,
-zimbraVirtualHostname,domain,,,single,,,cstring,,,,
+zimbraServiceEnabled,,,server,multi,,,cstring,,,,

data/lib/zm/modules/inspector.rb

@@ -7,12 +7,12 @@ module Zm
     end
 
     def to_h
-      Hash[instance_variables_map]
+      instance_variables_map.to_h
     end
 
     def inspect
       keys_str = to_h.map { |k, v| "#{k}: #{v}" }.join(', ')
-      "#{self.class}:#{format('0x00%x', (object_id << 1))} #{keys_str}"
+      "#{self.class}:#{format('0x00%x', object_id << 1)} #{keys_str}"
     end
 
     def instance_variables_map

data/lib/zm/modules/missing_method_static_collection.rb

@@ -3,9 +3,9 @@
 module MissingMethodStaticCollection
   attr_reader :all
 
-  def method_missing(method, *args, &block)
+  def method_missing(method, *, &)
     if @all.respond_to?(method)
-      @all.send(method, *args, &block)
+      @all.send(method, *, &)
     else
       super
     end

data/lib/zm/support/cache/entry.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'msgpack'
+
+module Zm
+  module Support
+    module Cache
+      class Entry
+        class << self
+          def factory
+            @factory ||= MessagePack::Factory.new.tap do |msgpack_factory|
+              msgpack_factory.register_type(
+                0x01,
+                self,
+                packer: ->(entry) { entry.pack.to_msgpack },
+                unpacker: lambda { |data|
+                  value, expires_at, version = MessagePack.unpack(data)
+                  new(Marshal.load(value), version: version, expires_at: expires_at)
+                }
+              )
+            end
+          end
+        end
+
+        attr_reader :value, :version, :expires_at
+
+        def initialize(value, version: 1, expires_in: nil, expires_at: nil)
+          @value      = value
+          @version    = version.to_i
+          @expires_at = expires_at&.to_f || (expires_in && (expires_in.to_f + Time.now.to_f))
+        end
+
+        def to_s
+          inspect
+        end
+
+        def inspect # :nodoc:
+          "#<#{self.class.name} value=#{@value}, version=#{@version}, expires_at=#{@expires_at}>"
+        end
+
+        def mismatched?(version)
+          version && @version != version
+        end
+
+        def expired?
+          return false unless @expires_at
+
+          @expires_at <= Time.now.to_f
+        end
+
+        def pack
+          members = [Marshal.dump(@value), @expires_at, @version]
+          members.pop while !members.empty? && members.last.nil?
+          members
+        end
+
+        def dump
+          self.class.factory.dump self
+        end
+      end
+    end
+  end
+end

data/lib/zm/support/cache/file_store.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Zm
+  module Support
+    module Cache
+      class FileStore < Store
+        Cache.register_storage(:file_store, self)
+
+        class << self
+          def test_required_options(options)
+            options.key?(:cache_path)
+          end
+        end
+
+        attr_reader :cache_path
+
+        GITKEEP_FILES = %w[.gitkeep .keep].freeze
+
+        def initialize(**options)
+          @cache_path = options.delete(:cache_path).to_s
+          super(options)
+        end
+
+        def clear(_options = nil)
+          root_dirs = (Dir.children(cache_path) - GITKEEP_FILES)
+          FileUtils.rm_r(root_dirs.collect { |f| File.join(cache_path, f) })
+        rescue Errno::ENOENT, Errno::ENOTEMPTY => e
+          @logger&.error "FileStoreError (#{e}): #{e.message}"
+        end
+
+        def cleanup(options = nil)
+          options = merged_options(options)
+          search_dir(cache_path) do |fname|
+            entry = read_entry(fname, **options)
+            delete_entry(fname, **options) if entry&.expired?
+          end
+        end
+
+        def inspect # :nodoc:
+          "#<#{self.class.name} cache_path=#{@cache_path}, options=#{@options.inspect}>"
+        end
+
+        private
+
+        def read_entry(key, **)
+          if (payload = read_serialized_entry(key, **))
+            entry = deserialize_entry(payload)
+            entry if entry.is_a?(Cache::Entry)
+          end
+        end
+
+        def read_serialized_entry(key, **)
+          File.binread(key) if File.exist?(key)
+        rescue StandardError => e
+          warn "FileStoreError (#{e}): #{e.message}"
+          nil
+        end
+
+        def write_entry(key, entry, **)
+          write_serialized_entry(key, serialize_entry(entry), **)
+        end
+
+        def write_serialized_entry(key, payload, **)
+          ensure_cache_path(File.dirname(key))
+          File.write(key, payload)
+          true
+        end
+
+        def delete_entry(key, **_options)
+          if File.exist?(key)
+            begin
+              File.delete(key)
+              delete_empty_directories(File.dirname(key))
+              true
+            rescue StandardError
+              # Just in case the error was caused by another process deleting the file first.
+              raise if File.exist?(key)
+
+              false
+            end
+          else
+            false
+          end
+        end
+
+        # Translate a key into a file path.
+        def normalize_key(key, options)
+          key = super
+
+          fpaths = []
+
+          while key.length > 8
+            chars = key.chars
+            fpaths << chars.shift(8).join
+            key = chars.join
+          end
+
+          File.join(cache_path, *fpaths, key)
+        end
+
+        # Translate a file path into a key.
+        # def file_path_key(path)
+        #   fname = path[cache_path.to_s.size..-1].split(File::SEPARATOR, 4).last.delete(File::SEPARATOR)
+        #   URI.decode_www_form_component(fname, Encoding::UTF_8)
+        # end
+
+        def delete_empty_directories(dir)
+          return if File.realpath(dir) == File.realpath(cache_path)
+
+          return unless Dir.empty?(dir)
+
+          begin
+            Dir.delete(dir)
+          rescue StandardError
+            nil
+          end
+          delete_empty_directories(File.dirname(dir))
+        end
+
+        def ensure_cache_path(path)
+          FileUtils.makedirs(path)
+        end
+
+        def search_dir(dir, &callback)
+          return unless File.exist?(dir)
+
+          Dir.each_child(dir) do |d|
+            name = File.join(dir, d)
+            if File.directory?(name)
+              search_dir(name, &callback)
+            else
+              callback.call name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zm/support/cache/null_store.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Zm
+  module Support
+    module Cache
+      class NullStore < Store
+        Cache.register_storage(:null_store, self)
+
+        def fetch(_name, _options = nil, &block)
+          block.call
+        end
+
+        def read(_name, _options = nil)
+          nil
+        end
+
+        def write(_name, _value, _options = nil)
+          nil
+        end
+
+        def delete(_name, _options = nil)
+          nil
+        end
+
+        def exist?(_name, _options = nil)
+          false
+        end
+
+        def clear(_options = nil)
+          nil
+        end
+
+        def cleanup(_options = nil)
+          nil
+        end
+
+        def inspect # :nodoc:
+          "#<#{self.class.name} options=#{@options.inspect}>"
+        end
+      end
+    end
+  end
+end

data/lib/zm/support/cache/request_strategy.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Zm
+  module Support
+    module Cache
+      class RequestStrategy < Strategy
+      end
+    end
+  end
+end

data/lib/zm/support/cache/store.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Zm
+  module Support
+    module Cache
+      class Store
+        attr_reader :options
+        attr_writer :logger
+
+        def initialize(options = {})
+          @options = options
+          @coder = Cache::Entry.factory
+          @digest = OpenSSL::Digest.new('sha256')
+          @logger = nil
+        end
+
+        def fetch(name, options = nil, &)
+          if block_given?
+            options = merged_options(options)
+            key = normalize_key(name, options)
+
+            entry = nil
+
+            unless options[:force]
+              cached_entry = read_entry(key, **options)
+              entry = handle_expired_entry(cached_entry, key, options)
+
+              entry = nil if entry&.mismatched?(normalize_version(options))
+            end
+
+            if entry
+              @logger&.info 'Load from cache'
+              entry.value
+            else
+              save_block_result_to_cache(key, options, &)
+            end
+          elsif options && options[:force]
+            raise ArgumentError, 'Missing block: Calling `Cache#fetch` with `force: true` requires a block.'
+          else
+            read(name, options)
+          end
+        end
+
+        def read(name, options = nil)
+          options = merged_options(options)
+          key     = normalize_key(name, options)
+          version = normalize_version(options)
+
+          entry = read_entry(key, **options)
+
+          return unless entry
+
+          if entry.expired? || entry.mismatched?(version)
+            delete_entry(key, **options)
+            nil
+          else
+            @logger&.info 'Load from cache'
+            entry.value
+          end
+        end
+
+        def write(name, value, options = nil)
+          options = merged_options(options)
+          key = normalize_key(name, options)
+          version = normalize_version(options)
+
+          entry = Entry.new(value, **options, version: version)
+          write_entry(key, entry, **options)
+        end
+
+        def delete(name, options = nil)
+          options = merged_options(options)
+          key = normalize_key(name, options)
+
+          delete_entry(key, **options)
+        end
+
+        def exist?(name, options = nil)
+          options = merged_options(options)
+          key = normalize_key(name, options)
+          version = normalize_version(options)
+
+          entry = read_entry(key, **options)
+          (entry && !entry.expired? && !entry.mismatched?(version)) || false
+        end
+
+        def clear(_options = nil)
+          raise NotImplementedError
+        end
+
+        def cleanup(_options = nil)
+          raise NotImplementedError
+        end
+
+        private
+
+        def normalize_options(call_options)
+          options.merge(call_options)
+        end
+
+        def normalize_version(call_options = nil)
+          if call_options&.key?(:version)
+            call_options[:version]
+          else
+            options[:version]
+          end
+        end
+
+        def normalize_key(key, call_options = nil)
+          namespace = if call_options&.key?(:namespace)
+                        call_options[:namespace]
+                      else
+                        options[:namespace]
+                      end
+
+          if namespace
+            @digest.hexdigest("#{namespace}:#{key}")
+          else
+            @digest.hexdigest(key)
+          end
+        end
+
+        def read_entry(_key, **_options)
+          raise NotImplementedError
+        end
+
+        def write_entry(_key, _entry, **_options)
+          raise NotImplementedError
+        end
+
+        def delete_entry(_key, **_options)
+          raise NotImplementedError
+        end
+
+        def merged_options(call_options)
+          if call_options
+            call_options = normalize_options(call_options)
+            if call_options.key?(:expires_in) && call_options.key?(:expires_at)
+              raise ArgumentError, 'Either :expires_in or :expires_at can be supplied, but not both'
+            end
+
+            expires_at = call_options.delete(:expires_at)
+            call_options[:expires_in] = (expires_at - Time.now) if expires_at
+
+            if call_options[:expires_in].is_a?(Time)
+              expires_in = call_options[:expires_in]
+              raise ArgumentError,
+                    "expires_in parameter should not be a Time. Did you mean to use expires_at? Got: #{expires_in}"
+            end
+
+            if call_options[:expires_in]&.negative?
+              expires_in = call_options.delete(:expires_in)
+              raise ArgumentError, "Cache expiration time is invalid, cannot be negative: #{expires_in}"
+            end
+
+            if options.empty?
+              call_options
+            else
+              options.merge(call_options)
+            end
+          else
+            options
+          end
+        end
+
+        def handle_expired_entry(entry, key, options)
+          if entry&.expired?
+            delete_entry(key, **options)
+            entry = nil
+          end
+
+          entry
+        end
+
+        def save_block_result_to_cache(key, options)
+          version = normalize_version(options)
+
+          value = yield
+
+          entry = Entry.new(value, **options, version: version)
+          write_entry(key, entry, **options)
+          value
+        end
+
+        def serialize_entry(entry, **)
+          @coder.dump(entry)
+        end
+
+        def deserialize_entry(payload, **)
+          @coder.load(payload)
+        rescue DeserializationError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/zm/support/cache/strategy.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Zm
+  module Support
+    module Cache
+      class Strategy
+        def initialize(expires_in: 300)
+          @expires_in = expires_in
+        end
+      end
+    end
+  end
+end

data/lib/zm/support/cache.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Zm
+  module Support
+    module Cache
+      DeserializationError = Class.new(StandardError)
+
+      class << self
+        def registered_storage
+          @registered_storage ||= {}
+        end
+
+        def register_storage(key, klass)
+          registered_storage[key] = klass
+        end
+      end
+    end
+  end
+end
+
+require 'zm/support/cache/entry'
+require 'zm/support/cache/strategy'
+require 'zm/support/cache/request_strategy'
+require 'zm/support/cache/store'
+require 'zm/support/cache/null_store'
+require 'zm/support/cache/file_store'