redlock 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f27e3a9be9009072c86f2f38a18bdfdcd2f177890aac365d981711dc040acd2e
-  data.tar.gz: efedd1080833cdee147afe6427878ad0df7c824e981e4e8a48c563ac68350d05
+  metadata.gz: a91b03cbb845e7b01556262e80e946e2d72980beeebce12d51380d7c57c57fb9
+  data.tar.gz: 73d38bac32a8003a556d3d8967155d15a8edbe988fc43387174ec506b21e8c99
 SHA512:
-  metadata.gz: aed115da4ab51ae932533d73e2f2f79d7722e6d77471028bb685d89149d6085fd395af368e9a143231b25b680a57c1ad4d236365396974c12416dac1131cabd8
-  data.tar.gz: 75b69cd60c2f562b087179dc939c2fb2bbf3514018dd8c302cf4bc2c4cfa4352a1310dd7cfc35042badcd8c86fc5d237d3a6bcafc57385ca2afcc5a2a280c7bf
+  metadata.gz: e55aa47e007175e619e22ec2b2ca996add245143290750c79a27fbafc8bb6bd32e5c02b07d9a9752c1ad8cb7f22a10a2b245c9b963c1b4f186427d6c7a987d3a
+  data.tar.gz: dd61e0d187a5972ecbe09bde3345c1a6174263f06fca6b7d1da3ce8be19fe5bb69ffca4cfc24073705c5b5a40551bb1a65ffba1358c5fbaf37f10ea46a15a929

data/.gitignore

@@ -1,3 +1,5 @@
 *.gem
 coverage/
 .bundle/
+Gemfile.lock
+dump.rdb

data/.travis.yml

@@ -1,10 +1,23 @@
 language: ruby
-services:
-    - redis-server
+cache: bundler
+sudo: false
+
 rvm:
-  - 2.2.2
-  - 2.5.6
-  - 2.6.4
+  - 2.4.9
+  - 2.5.7
+  - 2.6.5
+  - 2.7.0
+  - ruby-head
+
+before_install:
+  - yes | gem update --system
+  - gem install bundler -v "~> 2.0"
+
 script: bundle exec rspec spec
-sudo: false
-cache: bundler
+
+jobs:
+  allow_failures:
+    - rvm: ruby-head
+
+services:
+    - redis-server

data/README.md

@@ -112,6 +112,68 @@ The above code will also acquire the lock if the previous lock has expired and t
 lock_manager.lock("resource key", 3000, extend: lock_info, extend_only_if_locked: true)
 ```
 
+### Querying lock status
+
+You can check if a resource is locked:
+
+```ruby
+resource = "resource_key"
+lock_info = lock_manager.lock(resource, 2000)
+lock_manager.locked?(resource)
+#=> true
+
+lock_manager.unlock(lock_info)
+lock_manager.locked?(resource)
+#=> false
+```
+
+Any caller can call the above method to query the status. If you hold a lock and would like to check if it is valid, you can use the `valid_lock?` method:
+
+```ruby
+lock_info = lock_manager.lock("resource_key", 2000)
+lock_manager.valid_lock?(lock_info)
+#=> true
+
+lock_manager.unlock(lock_info)
+lock_manager.valid_lock?(lock_info)
+#=> false
+```
+
+The above methods **are not safe if you are using this to time critical code**, since they return true if the lock has not expired, even if there's only (for example) 1ms left on the lock. If you want to safely time the lock validity, you can use the `get_remaining_ttl_for_lock` and `get_remaining_ttl_for_resource` methods.
+
+Use `get_remaining_ttl_for_lock` if you hold a lock and want to check the TTL specifically for your lock:
+```ruby
+resource = "resource_key"
+lock_info = lock_manager.lock(resource, 2000)
+sleep 1
+
+lock_manager.get_remaining_ttl_for_lock(lock_info)
+#=> 986
+
+lock_manager.unlock(lock_info)
+lock_manager.get_remaining_ttl_for_lock(lock_info)
+#=> nil 
+```
+
+Use `get_remaining_ttl_for_resource` if you do not hold a lock, but want to know the remaining TTL on a locked resource:
+```ruby
+# Some part of the code
+resource = "resource_key"
+lock_info = lock_manager.lock(resource, 2000)
+
+# Some other part of the code
+lock_manager.locked?(resource)
+#=> true
+lock_manager.get_remaining_ttl_for_resource(resource)
+#=> 1975 
+
+# Sometime later
+lock_manager.locked?(resource)
+#=> false
+lock_manager.get_remaining_ttl_for_resource(resource)
+#=> nil 
+```
+
 ## Redis client configuration
 
 `Redlock::Client` expects URLs or Redis objects on initialization. Redis objects should be used for configuring the connection in more detail, i.e. setting username and password.

data/docker-compose.yml

@@ -11,17 +11,23 @@ services:
       - REDIS1_PORT=6379
       - REDIS2_HOST=redis2.local.com
       - REDIS2_PORT=6379
+      - REDIS3_HOST=redis3.local.com
+      - REDIS3_PORT=6379
       - DEFAULT_REDIS_HOST=redis1.local.com
       - DEFAULT_REDIS_PORT=6379
     links:
       - redis1:redis1.local.com
       - redis2:redis2.local.com
+      - redis3:redis3.local.com
     depends_on:
       - redis1
       - redis2
+      - redis3
 
   redis1:
     image: redis
   redis2:
     image: redis
+  redis3:
+    image: redis
 

data/lib/redlock/client.rb

@@ -102,6 +102,43 @@ module Redlock
       end
     end
 
+    # Gets remaining ttl of a resource. The ttl is returned if the holder
+    # currently holds the lock and it has not expired, otherwise the method
+    # returns nil.
+    # Params:
+    # +lock_info+:: the lock that has been acquired when you locked the resource
+    def get_remaining_ttl_for_lock(lock_info)
+      ttl_info = try_get_remaining_ttl(lock_info[:resource])
+      return nil if ttl_info.nil? || ttl_info[:value] != lock_info[:value]
+      ttl_info[:ttl]
+    end
+
+    # Gets remaining ttl of a resource. If there is no valid lock, the method
+    # returns nil.
+    # Params:
+    # +resource+:: the name of the resource (string) for which to check the ttl
+    def get_remaining_ttl_for_resource(resource)
+      ttl_info = try_get_remaining_ttl(resource)
+      return nil if ttl_info.nil?
+      ttl_info[:ttl]
+    end
+
+    # Checks if a resource is locked
+    # Params:
+    # +lock_info+:: the lock that has been acquired when you locked the resource
+    def locked?(resource)
+      ttl = get_remaining_ttl_for_resource(resource)
+      !(ttl.nil? || ttl.zero?)
+    end
+
+    # Checks if a lock is still valid
+    # Params:
+    # +lock_info+:: the lock that has been acquired when you locked the resource
+    def valid_lock?(lock_info)
+      ttl = get_remaining_ttl_for_lock(lock_info)
+      !(ttl.nil? || ttl.zero?)
+    end
+
     private
 
     class RedisInstance
@@ -122,6 +159,10 @@ module Redlock
         end
       eos
 
+      PTTL_SCRIPT = <<-eos
+        return { redis.call("get", KEYS[1]), redis.call("pttl", KEYS[1]) }
+      eos
+
       module ConnectionPoolLike
         def with
           yield self
@@ -159,11 +200,20 @@ module Redlock
         # Nothing to do, unlocking is just a best-effort attempt.
       end
 
+      def get_remaining_ttl(resource)
+        recover_from_script_flush do
+          @redis.with { |conn| conn.evalsha @pttl_script_sha, keys: [resource] }
+        end
+      rescue Redis::BaseConnectionError
+        nil
+      end
+
       private
 
       def load_scripts
         @unlock_script_sha = @redis.with { |conn| conn.script(:load, UNLOCK_SCRIPT) }
         @lock_script_sha = @redis.with { |conn| conn.script(:load, LOCK_SCRIPT) }
+        @pttl_script_sha = @redis.with { |conn| conn.script(:load, PTTL_SCRIPT) }
       end
 
       def recover_from_script_flush
@@ -228,6 +278,37 @@ module Redlock
       end
     end
 
+    def try_get_remaining_ttl(resource)
+      # Responses from the servers are a 2 tuple of format [lock_value, ttl].
+      # The lock_value is nil if it does not exist. Since servers may have
+      # different lock values, the responses are grouped by the lock_value and
+      # transofrmed into a hash: { lock_value1 => [ttl1, ttl2, ttl3],
+      # lock_value2 => [ttl4, tt5] }
+      ttls_by_value, time_elapsed = timed do
+        @servers.map { |s| s.get_remaining_ttl(resource) }
+          .select { |ttl_tuple| ttl_tuple&.first }
+          .group_by(&:first)
+          .transform_values { |ttl_tuples| ttl_tuples.map { |t| t.last } }
+      end
+
+      # Authoritative lock value is that which is returned by the majority of
+      # servers
+      authoritative_value, ttls =
+        ttls_by_value.max_by { |(lock_value, ttls)| ttls.length }
+
+      if ttls && ttls.size >= @quorum
+        # Return the  minimum TTL of an N/2+1 selection. It will always be
+        # correct (it will guarantee that at least N/2+1 servers have a TTL that
+        # value or longer)
+        min_ttl = ttls.sort.last(@quorum).first
+        min_ttl = min_ttl - time_elapsed - drift(min_ttl)
+        { value: authoritative_value, ttl: min_ttl }
+      else
+        # No lock_value is authoritatively held for the resource
+        nil
+      end
+    end
+
     def drift(ttl)
       # Add 2 milliseconds to the drift to account for Redis expires
       # precision, which is 1 millisecond, plus 1 millisecond min drift

data/lib/redlock/testing.rb

@@ -1,3 +1,5 @@
+require 'redlock'
+
 module Redlock
   class Client
     class << self

data/lib/redlock/version.rb

@@ -1,3 +1,3 @@
 module Redlock
-  VERSION = '1.2.0'
+  VERSION = '1.2.1'
 end

data/redlock.gemspec

@@ -1,27 +1,29 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'redlock/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "redlock"
+  spec.name          = 'redlock'
   spec.version       = Redlock::VERSION
-  spec.authors       = ["Leandro Moreira"]
-  spec.email         = ["leandro.ribeiro.moreira@gmail.com"]
-  spec.summary       = %q{Distributed lock using Redis written in Ruby.}
-  spec.description   = %q{Distributed lock using Redis written in Ruby. Highly inspired by https://github.com/antirez/redlock-rb.}
-  spec.homepage      = "https://github.com/leandromoreira/redlock-rb"
+  spec.authors       = ['Leandro Moreira']
+  spec.email         = ['leandro.ribeiro.moreira@gmail.com']
+  spec.summary       = 'Distributed lock using Redis written in Ruby.'
+  spec.description   = 'Distributed lock using Redis written in Ruby. Highly inspired by https://github.com/antirez/redlock-rb.'
+  spec.homepage      = 'https://github.com/leandromoreira/redlock-rb'
   spec.license       = 'BSD-2-Clause'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
   spec.add_dependency 'redis', '>= 3.0.0', '< 5.0'
 
-  spec.add_development_dependency "coveralls", "~> 0.8"
+  spec.add_development_dependency 'connection_pool', '~> 2.2'
+  spec.add_development_dependency 'coveralls', '~> 0.8'
+  spec.add_development_dependency 'json', '>= 2.3.0', '~> 2.3.1'
   spec.add_development_dependency 'rake', '>= 11.1.2', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3', '>= 3.0.0'
-  spec.add_development_dependency 'connection_pool', '~> 2.2'
 end

data/spec/client_spec.rb

@@ -7,13 +7,22 @@ RSpec.describe Redlock::Client do
   # It is recommended to have at least 3 servers in production
   let(:lock_manager_opts) { { retry_count: 3 } }
   let(:lock_manager) { Redlock::Client.new(Redlock::Client::DEFAULT_REDIS_URLS, lock_manager_opts) }
-  let(:redis_client) { Redis.new }
+  let(:redis_client) { Redis.new(url: "redis://#{redis1_host}:#{redis1_port}") }
   let(:resource_key) { SecureRandom.hex(3)  }
   let(:ttl) { 1000 }
   let(:redis1_host) { ENV["REDIS1_HOST"] || "localhost" }
   let(:redis1_port) { ENV["REDIS1_PORT"] || "6379" }
   let(:redis2_host) { ENV["REDIS2_HOST"] || "127.0.0.1" }
   let(:redis2_port) { ENV["REDIS2_PORT"] || "6379" }
+  let(:redis3_host) { ENV["REDIS3_HOST"] || "127.0.0.1" }
+  let(:redis3_port) { ENV["REDIS3_PORT"] || "6379" }
+  let(:unreachable_redis) {
+    redis = Redis.new(url: 'redis://localhost:46864')
+    def redis.with
+      yield self
+    end
+    redis
+  }
 
   describe 'initialize' do
     it 'accepts both redis URLs and Redis objects' do
@@ -212,14 +221,6 @@ RSpec.describe Redlock::Client do
       end
     end
 
-    def unreachable_redis
-      redis = Redis.new(url: 'redis://localhost:46864')
-      def redis.with
-        yield self
-      end
-      redis
-    end
-
     context 'when script cache has been flushed' do
       before(:each) do
         @manipulated_instance = lock_manager.instance_variable_get(:@servers).first
@@ -367,6 +368,154 @@ RSpec.describe Redlock::Client do
     end
   end
 
+  describe 'get_remaining_ttl_for_resource' do
+    context 'when lock is valid' do
+      after(:each) { lock_manager.unlock(@lock_info) if @lock_info }
+
+      it 'gets the remaining ttl of a lock' do
+        ttl = 20_000
+        @lock_info = lock_manager.lock(resource_key, ttl)
+        remaining_ttl = lock_manager.get_remaining_ttl_for_resource(resource_key)
+        expect(remaining_ttl).to be_within(300).of(ttl)
+      end
+
+      context 'when servers respond with varying ttls' do
+        let (:servers) {
+          [
+            "redis://#{redis1_host}:#{redis1_port}",
+            "redis://#{redis2_host}:#{redis2_port}",
+            "redis://#{redis3_host}:#{redis3_port}"
+          ]
+        }
+        let (:redlock) { Redlock::Client.new(servers) }
+        after(:each) { redlock.unlock(@lock_info) if @lock_info }
+
+        it 'returns the minimum ttl value' do
+          ttl = 20_000
+          @lock_info = redlock.lock(resource_key, ttl)
+
+          # Mock redis server responses to return different ttls
+          returned_ttls = [20_000, 15_000, 10_000]
+          redlock.instance_variable_get(:@servers).each_with_index do |server, index|
+            allow(server).to(receive(:get_remaining_ttl))
+              .with(resource_key)
+              .and_return([@lock_info[:value], returned_ttls[index]])
+          end
+
+          remaining_ttl = redlock.get_remaining_ttl_for_lock(@lock_info)
+
+          # Assert that the TTL is closest to the closest to the correct value
+          expect(remaining_ttl).to be_within(300).of(returned_ttls[1])
+        end
+      end
+    end
+
+    context 'when lock is not valid' do
+      it 'returns nil' do
+        lock_info = lock_manager.lock(resource_key, ttl)
+        lock_manager.unlock(lock_info)
+        remaining_ttl = lock_manager.get_remaining_ttl_for_resource(resource_key)
+        expect(remaining_ttl).to be_nil
+      end
+    end
+
+    context 'when server goes away' do
+      after(:each) { lock_manager.unlock(@lock_info) if @lock_info }
+
+      it 'does not raise an error on connection issues' do
+        @lock_info = lock_manager.lock(resource_key, ttl)
+
+        # Replace redis with unreachable instance
+        redis_instance = lock_manager.instance_variable_get(:@servers).first
+        old_redis = redis_instance.instance_variable_get(:@redis)
+        redis_instance.instance_variable_set(:@redis, unreachable_redis)
+
+        expect {
+          remaining_ttl = lock_manager.get_remaining_ttl_for_resource(resource_key)
+          expect(remaining_ttl).to be_nil
+        }.to_not raise_error
+      end
+    end
+
+    context 'when a server comes back' do
+      after(:each) { lock_manager.unlock(@lock_info) if @lock_info }
+
+      it 'recovers from connection issues' do
+        @lock_info = lock_manager.lock(resource_key, ttl)
+
+        # Replace redis with unreachable instance
+        redis_instance = lock_manager.instance_variable_get(:@servers).first
+        old_redis = redis_instance.instance_variable_get(:@redis)
+        redis_instance.instance_variable_set(:@redis, unreachable_redis)
+
+        expect(lock_manager.get_remaining_ttl_for_resource(resource_key)).to be_nil
+
+        # Restore redis
+        redis_instance.instance_variable_set(:@redis, old_redis)
+        expect(lock_manager.get_remaining_ttl_for_resource(resource_key)).to be_truthy
+      end
+    end
+  end
+
+  describe 'get_remaining_ttl_for_lock' do
+    context 'when lock is valid' do
+      it 'gets the remaining ttl of a lock' do
+        ttl = 20_000
+        lock_info = lock_manager.lock(resource_key, ttl)
+        remaining_ttl = lock_manager.get_remaining_ttl_for_lock(lock_info)
+        expect(remaining_ttl).to be_within(300).of(ttl)
+        lock_manager.unlock(lock_info)
+      end
+    end
+
+    context 'when lock is not valid' do
+      it 'returns nil' do
+        lock_info = lock_manager.lock(resource_key, ttl)
+        lock_manager.unlock(lock_info)
+        remaining_ttl = lock_manager.get_remaining_ttl_for_lock(lock_info)
+        expect(remaining_ttl).to be_nil
+      end
+    end
+  end
+
+  describe 'locked?' do
+    context 'when lock is available' do
+      after(:each) { lock_manager.unlock(@lock_info) if @lock_info }
+
+      it 'returns true' do
+        @lock_info = lock_manager.lock(resource_key, ttl)
+        expect(lock_manager).to be_locked(resource_key)
+      end
+    end
+
+    context 'when lock is not available' do
+      it 'returns false' do
+        lock_info = lock_manager.lock(resource_key, ttl)
+        lock_manager.unlock(lock_info)
+        expect(lock_manager).not_to be_locked(resource_key)
+      end
+    end
+  end
+
+  describe 'valid_lock?' do
+    context 'when lock is available' do
+      after(:each) { lock_manager.unlock(@lock_info) if @lock_info }
+
+      it 'returns true' do
+        @lock_info = lock_manager.lock(resource_key, ttl)
+        expect(lock_manager).to be_valid_lock(@lock_info)
+      end
+    end
+
+    context 'when lock is not available' do
+      it 'returns false' do
+        lock_info = lock_manager.lock(resource_key, ttl)
+        lock_manager.unlock(lock_info)
+        expect(lock_manager).not_to be_valid_lock(lock_info)
+      end
+    end
+  end
+
   describe '#default_time_source' do
     context 'when CLOCK_MONOTONIC is available (MRI, JRuby)' do
       it 'returns a callable using Process.clock_gettime()' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redlock
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Leandro Moreira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-29 00:00:00.000000000 Z
+date: 2020-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -30,6 +30,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -44,6 +58,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -84,20 +118,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
-- !ruby/object:Gem::Dependency
-  name: connection_pool
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.2'
 description: Distributed lock using Redis written in Ruby. Highly inspired by https://github.com/antirez/redlock-rb.
 email:
 - leandro.ribeiro.moreira@gmail.com
@@ -110,7 +130,6 @@ files:
 - ".travis.yml"
 - CONTRIBUTORS
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - Makefile
 - README.md
@@ -144,7 +163,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Distributed lock using Redis written in Ruby.

data/Gemfile.lock

@@ -1,56 +0,0 @@
-PATH
-  remote: .
-  specs:
-    redlock (1.2.0)
-      redis (>= 3.0.0, < 5.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    connection_pool (2.2.2)
-    coveralls (0.8.22)
-      json (>= 1.8, < 3)
-      simplecov (~> 0.16.1)
-      term-ansicolor (~> 1.3)
-      thor (~> 0.19.4)
-      tins (~> 1.6)
-    diff-lcs (1.3)
-    docile (1.3.1)
-    json (2.1.0)
-    rake (13.0.1)
-    redis (4.1.1)
-    rspec (3.5.0)
-      rspec-core (~> 3.5.0)
-      rspec-expectations (~> 3.5.0)
-      rspec-mocks (~> 3.5.0)
-    rspec-core (3.5.4)
-      rspec-support (~> 3.5.0)
-    rspec-expectations (3.5.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-mocks (3.5.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-support (3.5.0)
-    simplecov (0.16.1)
-      docile (~> 1.1)
-      json (>= 1.8, < 3)
-      simplecov-html (~> 0.10.0)
-    simplecov-html (0.10.2)
-    term-ansicolor (1.6.0)
-      tins (~> 1.0)
-    thor (0.19.4)
-    tins (1.16.3)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  connection_pool (~> 2.2)
-  coveralls (~> 0.8)
-  rake (~> 13.0, >= 11.1.2)
-  redlock!
-  rspec (~> 3, >= 3.0.0)
-
-BUNDLED WITH
-   1.17.2