redis_queued_locks 1.12.1 → 1.14.0

data/lib/redis_queued_locks/{acquier → acquirer}/acquire_lock/try_to_lock.rb

@@ -3,8 +3,8 @@
 # @api private
 # @since 1.0.0
 # @version 1.7.0
-# rubocop:disable Metrics/ModuleLength, Metrics/BlockNesting
-module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
+# rubocop:disable Metrics/ModuleLength
+module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
   require_relative 'try_to_lock/log_visitor'
 
   # @return [String]
@@ -20,10 +20,13 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
   # @param logger [::Logger,#debug]
   # @param log_lock_try [Boolean]
   # @param lock_key [String]
+  # @param read_write_mode [Symbol]
   # @param lock_key_queue [String]
-  # @param acquier_id [String]
+  # @param read_lock_key_queue [String]
+  # @param write_lock_key_queue [String]
+  # @param acquirer_id [String]
   # @param host_id [String]
-  # @param acquier_position [Numeric]
+  # @param acquirer_position [Numeric]
   # @param ttl [Integer]
   # @param queue_ttl [Integer]
   # @param fail_fast [Boolean]
@@ -36,17 +39,20 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
   #
   # @api private
   # @since 1.0.0
-  # @version 1.9.0
+  # @version 1.13.0
   # rubocop:disable Metrics/MethodLength
   def try_to_lock(
     redis,
     logger,
     log_lock_try,
     lock_key,
+    read_write_mode,
     lock_key_queue,
-    acquier_id,
+    read_lock_key_queue,
+    write_lock_key_queue,
+    acquirer_id,
     host_id,
-    acquier_position,
+    acquirer_position,
     ttl,
     queue_ttl,
     fail_fast,
@@ -57,25 +63,28 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
     instr_sampled
   )
     # Step X: intermediate invocation results
+    # @type var inter_result: Symbol?
     inter_result = nil
+    # @type var timestamp: Float?
     timestamp = nil
+    # @type var spc_processed_timestamp: Float?
     spc_processed_timestamp = nil
 
     LogVisitor.start(
       logger, log_sampled, log_lock_try, lock_key,
-      queue_ttl, acquier_id, host_id, access_strategy
+      queue_ttl, acquirer_id, host_id, access_strategy
     )
 
     # Step X: start to work with lock acquiring
     result = redis.with do |rconn|
       LogVisitor.rconn_fetched(
         logger, log_sampled, log_lock_try, lock_key,
-        queue_ttl, acquier_id, host_id, access_strategy
+        queue_ttl, acquirer_id, host_id, access_strategy
       )
 
       # Step 0:
       #   watch the lock key changes (and discard acquirement if lock is already
-      #   obtained by another acquier during the current lock acquiremntt)
+      #   obtained by another acquirer during the current lock acquiremntt)
       rconn.multi(watch: [lock_key]) do |transact|
         # SP-Conflict status PREPARING: get the current lock obtainer
         current_lock_obtainer = rconn.call('HGET', lock_key, 'acq_id')
@@ -83,15 +92,14 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
         sp_conflict_status = nil
 
         # SP-Conflict Step X1: calculate the current deadlock status
-        if current_lock_obtainer != nil && acquier_id == current_lock_obtainer
+        if current_lock_obtainer != nil && acquirer_id == current_lock_obtainer
           LogVisitor.same_process_conflict_detected(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquier_id, host_id, access_strategy
+            queue_ttl, acquirer_id, host_id, access_strategy
           )
 
           # SP-Conflict Step X2: self-process dead lock moment started.
           # SP-Conflict CHECK (Step CHECK): check chosen strategy and flag the current status
-          # rubocop:disable Lint/DuplicateBranch
           case conflict_strategy
           when :work_through
             # <SP-Conflict Moment>: work through => exit
@@ -112,11 +120,9 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
             #     but is forgotten to be added here;
             sp_conflict_status = :conflict_wait_for_lock
           end
-          # rubocop:enable Lint/DuplicateBranch
-
           LogVisitor.same_process_conflict_analyzed(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquier_id, host_id, access_strategy, sp_conflict_status
+            queue_ttl, acquirer_id, host_id, access_strategy, sp_conflict_status
           )
         end
 
@@ -150,14 +156,16 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           transact.call(
             'HSET',
             lock_key,
-            'l_spc_ext_ts', (spc_processed_timestamp = Time.now.to_f),
+            'l_spc_ext_ts', spc_processed_timestamp = Time.now.to_f,
             'l_spc_ext_ini_ttl', ttl
           )
           inter_result = :extendable_conflict_work_through
 
+          # @type var sp_conflict_status: Symbol
+          # @type var spc_processed_timestamp: Float
           LogVisitor.reentrant_lock__extend_and_work_through(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquier_id, host_id, access_strategy,
+            queue_ttl, acquirer_id, host_id, access_strategy,
             sp_conflict_status, ttl, spc_processed_timestamp
           )
         # SP-Conflict-Step X2: switch to dead lock logic or not
@@ -177,12 +185,14 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           transact.call(
             'HSET',
             lock_key,
-            'l_spc_ts', (spc_processed_timestamp = Time.now.to_f)
+            'l_spc_ts', spc_processed_timestamp = Time.now.to_f
           )
 
+          # @type var sp_conflict_status: Symbol
+          # @type var spc_processed_timestamp: Float
           LogVisitor.reentrant_lock__work_through(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquier_id, host_id, access_strategy,
+            queue_ttl, acquirer_id, host_id, access_strategy,
             sp_conflict_status, spc_processed_timestamp
           )
         # SP-Conflict-Step X2: switch to dead lock logic or not
@@ -190,9 +200,11 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           inter_result = :conflict_dead_lock
           spc_processed_timestamp = Time.now.to_f
 
+          # @type var sp_conflict_status: Symbol
+          # @type var spc_processed_timestamp: Float
           LogVisitor.single_process_lock_conflict__dead_lock(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquier_id, host_id, access_strategy,
+            queue_ttl, acquirer_id, host_id, access_strategy,
             sp_conflict_status, spc_processed_timestamp
           )
         # Reached the SP-Non-Conflict Mode (NOTE):
@@ -202,87 +214,94 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           # Fast-Step X1: lock is already obtained. fail fast leads to "no try".
           inter_result = :fail_fast_no_try
         else
-          # Step 1: add an acquier to the lock acquirement queue
-          rconn.call('ZADD', lock_key_queue, 'NX', acquier_position, acquier_id)
+          # Step 1: add an acquirer to the lock acquirement queue
+          # NOTE:
+          #   'NX' means "Only add new elements. Don't update already existing elements."
+          #   that works as:
+          #     1. (enqueue) <<if you are already in the queue - do nothing and wait your time>>
+          #     2. (requeue) or <<add to the right pre-calculated position if you are
+          #       not in the queue now>>;
+          rconn.call('ZADD', lock_key_queue, 'NX', acquirer_position, acquirer_id)
 
           LogVisitor.acq_added_to_queue(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquier_id, host_id, access_strategy
+            queue_ttl, acquirer_id, host_id, access_strategy
           )
 
-          # Step 2.1: drop expired acquiers from the lock queue
+          # Step 2.1: drop expired acquirers from the lock queue
           rconn.call(
             'ZREMRANGEBYSCORE',
             lock_key_queue,
             '-inf',
-            RedisQueuedLocks::Resource.acquier_dead_score(queue_ttl)
+            RedisQueuedLocks::Resource.acquirer_dead_score(queue_ttl)
           )
 
           LogVisitor.remove_expired_acqs(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquier_id, host_id, access_strategy
+            queue_ttl, acquirer_id, host_id, access_strategy
           )
 
-          # Step 3: get the actual acquier waiting in the queue
-          waiting_acquier = Array(rconn.call('ZRANGE', lock_key_queue, '0', '0')).first
+          # Step 3: get the actual acquirer waiting in the queue
+          waiting_acquirer = Array(rconn.call('ZRANGE', lock_key_queue, '0', '0')).first
 
           LogVisitor.get_first_from_queue(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquier_id, host_id, access_strategy, waiting_acquier
+            queue_ttl, acquirer_id, host_id, access_strategy, waiting_acquirer
           )
 
           # Step PRE-4.x: check if the request time limit is reached
           #   (when the current try self-removes itself from queue (queue ttl has come))
-          if waiting_acquier == nil
+          if waiting_acquirer == nil
             LogVisitor.exit__queue_ttl_reached(
               logger, log_sampled, log_lock_try, lock_key,
-              queue_ttl, acquier_id, host_id, access_strategy
+              queue_ttl, acquirer_id, host_id, access_strategy
             )
 
             inter_result = :dead_score_reached
             # Step STRATEGY: check the stragegy and corresponding preventing factor
-            # Step STRATEGY (queued): check the actual acquier: is it ours? are we aready to lock?
-          elsif access_strategy == :queued && waiting_acquier != acquier_id
+            # Step STRATEGY (queued): check the actual acquirer: is it ours? are we aready to lock?
+          elsif access_strategy == :queued && waiting_acquirer != acquirer_id
             # Step ROLLBACK 1.1: our time hasn't come yet. retry!
+
             LogVisitor.exit__no_first(
               logger, log_sampled, log_lock_try, lock_key,
-              queue_ttl, acquier_id, host_id, access_strategy, waiting_acquier,
+              queue_ttl, acquirer_id, host_id, access_strategy, waiting_acquirer,
               rconn.call('HGETALL', lock_key).to_h
             )
-            inter_result = :acquier_is_not_first_in_queue
+            inter_result = :acquirer_is_not_first_in_queue
             # Step STRAGEY: successfull (:queued OR :random)
-          elsif (access_strategy == :queued && waiting_acquier == acquier_id) ||
+          elsif (access_strategy == :queued && waiting_acquirer == acquirer_id) ||
                 (access_strategy == :random)
             # NOTE: our time has come! let's try to acquire the lock!
 
             # Step 5: find the lock -> check if the our lock is already acquired
-            locked_by_acquier = rconn.call('HGET', lock_key, 'acq_id')
+            locked_by_acquirer = rconn.call('HGET', lock_key, 'acq_id')
 
-            if locked_by_acquier
+            if locked_by_acquirer
               # Step ROLLBACK 2: required lock is stil acquired. retry!
 
               LogVisitor.exit__lock_still_obtained(
                 logger, log_sampled, log_lock_try, lock_key,
-                queue_ttl, acquier_id, host_id, access_strategy,
-                waiting_acquier, locked_by_acquier,
+                queue_ttl, acquirer_id, host_id, access_strategy,
+                waiting_acquirer, locked_by_acquirer,
                 rconn.call('HGETALL', lock_key).to_h
               )
               inter_result = :lock_is_still_acquired
             else
               # NOTE: required lock is free and ready to be acquired! acquire!
 
-              # Step 6.1: remove our acquier from waiting queue
-              transact.call('ZREM', lock_key_queue, acquier_id)
+              # Step 6.1: remove our acquirer from waiting queue
+              transact.call('ZREM', lock_key_queue, acquirer_id)
 
-              # Step 6.2: acquire a lock and store an info about the acquier and host
+              # Step 6.2: acquire a lock and store an info about the acquirer and host
               transact.call(
                 'HSET',
                 lock_key,
-                'acq_id', acquier_id,
+                'acq_id', acquirer_id,
                 'hst_id', host_id,
-                'ts', (timestamp = Time.now.to_f),
+                'ts', timestamp = Time.now.to_f,
                 'ini_ttl', ttl,
-                *(meta.to_a if meta != nil)
+                *(meta.to_a if meta != nil) # steep:ignore
               )
 
               # Step 6.3: set the lock expiration time in order to prevent "infinite locks"
@@ -290,7 +309,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
 
               LogVisitor.obtain__free_to_acquire(
                 logger, log_sampled, log_lock_try, lock_key,
-                queue_ttl, acquier_id, host_id, access_strategy
+                queue_ttl, acquirer_id, host_id, access_strategy
               )
             end
           end
@@ -316,62 +335,74 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
         #   3. HINCRBY (increased spc count) (OK for != nil)
         #   4. HSET (store the last spc time and ttl data) (OK for == 2 or != nil)
         if result[0] != nil && result[1] != nil && result[2] != nil && result[3] != nil
-          RedisQueuedLocks::Data[ok: true, result: {
-            process: :extendable_conflict_work_through,
-            lock_key: lock_key,
-            acq_id: acquier_id,
-            hst_id: host_id,
-            ts: spc_processed_timestamp,
-            ttl: ttl
-          }]
+          {
+            ok: true,
+            result: {
+              process: :extendable_conflict_work_through,
+              lock_key: lock_key,
+              acq_id: acquirer_id,
+              hst_id: host_id,
+              ts: spc_processed_timestamp,
+              ttl: ttl
+            }
+          }
         elsif result[0] != nil
           # NOTE: that is enough to the fact that the lock is extended but <TODO>
           # TODO: add detalized overview (log? some in-line code clarifications?) of the result
-          RedisQueuedLocks::Data[ok: true, result: {
-            process: :extendable_conflict_work_through,
-            lock_key: lock_key,
-            acq_id: acquier_id,
-            hst_id: host_id,
-            ts: spc_processed_timestamp,
-            ttl: ttl
-          }]
+          {
+            ok: true,
+            result: {
+              process: :extendable_conflict_work_through,
+              lock_key: lock_key,
+              acq_id: acquirer_id,
+              hst_id: host_id,
+              ts: spc_processed_timestamp,
+              ttl: ttl
+            }
+          }
         else
           # NOTE: unknown behaviour :thinking:
-          RedisQueuedLocks::Data[ok: false, result: :unknown]
+          { ok: false, result: :unknown }
         end
       elsif result == nil || (result.is_a?(::Array) && result.empty?)
         # NOTE: the lock key was changed durign an SPC logic execution
-        RedisQueuedLocks::Data[ok: false, result: :lock_is_acquired_during_acquire_race]
+        { ok: false, result: :lock_is_acquired_during_acquire_race }
       else
         # NOTE: unknown behaviour :thinking:. this part is not reachable at the moment.
-        RedisQueuedLocks::Data[ok: false, result: :unknown]
+        { ok: false, result: :unknown }
       end
     when inter_result == :conflict_work_through
       # Step 7.same_process_conflict.B:
       #   - conflict_work_through case => yield <block> without lock realesing/extending
-      RedisQueuedLocks::Data[ok: true, result: {
-        process: :conflict_work_through,
-        lock_key: lock_key,
-        acq_id: acquier_id,
-        hst_id: host_id,
-        ts: spc_processed_timestamp,
-        ttl: ttl
-      }]
+      {
+        ok: true,
+        result: {
+          process: :conflict_work_through,
+          lock_key: lock_key,
+          acq_id: acquirer_id,
+          hst_id: host_id,
+          ts: spc_processed_timestamp,
+          ttl: ttl
+        }
+      }
     when inter_result == :conflict_dead_lock
       # Step 7.same_process_conflict.C:
       #  - deadlock. should fail in acquirement logic;
-      RedisQueuedLocks::Data[ok: false, result: inter_result]
+      { ok: false, result: :conflict_dead_lock }
     when fail_fast && inter_result == :fail_fast_no_try
       # Step 7.a: lock is still acquired and we should exit from the logic as soon as possible
-      RedisQueuedLocks::Data[ok: false, result: inter_result]
+      { ok: false, result: :fail_fast_no_try }
     when inter_result == :dead_score_reached
-      RedisQueuedLocks::Data[ok: false, result: inter_result]
-    when inter_result == :lock_is_still_acquired || inter_result == :acquier_is_not_first_in_queue
+      { ok: false, result: :dead_score_reached }
+    when inter_result == :lock_is_still_acquired
       # Step 7.b: lock is still acquired by another process => failed to acquire
-      RedisQueuedLocks::Data[ok: false, result: inter_result]
+      { ok: false, result: :lock_is_still_acquired }
+    when inter_result == :acquirer_is_not_first_in_queue
+      # Step 7.c: lock is still acquired by another process => failed to acquire
+      { ok: false, result: :acquirer_is_not_first_in_queue }
     when result == nil || (result.is_a?(::Array) && result.empty?)
-      # Step 7.c: lock is already acquired durign the acquire race => failed to acquire
-      RedisQueuedLocks::Data[ok: false, result: :lock_is_acquired_during_acquire_race]
+      # Step 7.d: lock is already acquired durign the acquire race => failed to acquire
+      { ok: false, result: :lock_is_acquired_during_acquire_race }
     when result.is_a?(::Array) && result.size == 3 # NOTE: 3 is a count of redis lock commands
       # TODO:
       #   => (!) analyze the command result and do actions with the depending on it;
@@ -383,20 +414,23 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
       #   3. pexpire should return 1 (expiration time is successfully applied)
 
       # Step 7.d: locked! :) let's go! => successfully acquired
-      RedisQueuedLocks::Data[ok: true, result: {
-        process: :lock_obtaining,
-        lock_key: lock_key,
-        acq_id: acquier_id,
-        hst_id: host_id,
-        ts: timestamp,
-        ttl: ttl
-      }]
+      {
+        ok: true,
+        result: {
+          process: :lock_obtaining,
+          lock_key: lock_key,
+          acq_id: acquirer_id,
+          hst_id: host_id,
+          ts: timestamp,
+          ttl: ttl
+        }
+      }
     else
       # Ste 7.3: unknown behaviour :thinking:
-      RedisQueuedLocks::Data[ok: false, result: :unknown]
+      { ok: false, result: :unknown }
     end
     # rubocop:enable Lint/DuplicateBranch
   end
   # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
 end
-# rubocop:enable Metrics/ModuleLength, Metrics/BlockNesting
+# rubocop:enable Metrics/ModuleLength

data/lib/redis_queued_locks/{acquier → acquirer}/acquire_lock/with_acq_timeout.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.0.0
-module RedisQueuedLocks::Acquier::AcquireLock::WithAcqTimeout
+module RedisQueuedLocks::Acquirer::AcquireLock::WithAcqTimeout
   # @param redis [RedisClient]
   #   Redis connection manager required for additional data extraction for error message.
   # @param timeout [NilClass,Integer]
@@ -17,9 +17,11 @@ module RedisQueuedLocks::Acquier::AcquireLock::WithAcqTimeout
   #   Add additional error data about lock queue and required lock to the timeout error or not.
   # @option on_timeout [Proc,NilClass]
   #   Callback invoked on Timeout::Error.
+  # @param block [Block] Custom logic that should be invoked under the obtained lock.
   # @return [Any]
   #
-  # @raise [RedisQueuedLocks::LockAcquiermentIntermediateTimeoutError]
+  # @raise [RedisQueuedLocks::LockAcquirementIntermediateTimeoutError]
+  # @raise [RedisQueuedLocks::LockAcquirementTimeoutError]
   #
   # @api private
   # @since 1.0.0
@@ -34,21 +36,24 @@ module RedisQueuedLocks::Acquier::AcquireLock::WithAcqTimeout
     on_timeout: nil,
     &block
   )
-    ::Timeout.timeout(timeout, RedisQueuedLocks::LockAcquiermentIntermediateTimeoutError, &block)
-  rescue RedisQueuedLocks::LockAcquiermentIntermediateTimeoutError
-    on_timeout.call unless on_timeout == nil
+    ::Timeout.timeout(timeout, RedisQueuedLocks::LockAcquirementIntermediateTimeoutError, &block)
+  rescue RedisQueuedLocks::LockAcquirementIntermediateTimeoutError
+    if on_timeout != nil
+      # @type var on_timeout: Proc
+      on_timeout.call
+    end
 
     if raise_errors
       if detailed_acq_timeout_error
         # TODO: rewrite these invocations to separated inner-AcquireLock-related modules
         #   in order to remove any dependencies from the other public RQL commands cuz
         #   all AcquireLock logic elements should be fully independent from others as a core;
-        lock_info = RedisQueuedLocks::Acquier::LockInfo.lock_info(redis, lock_name)
-        queue_info = RedisQueuedLocks::Acquier::QueueInfo.queue_info(redis, lock_name)
+        lock_info = RedisQueuedLocks::Acquirer::LockInfo.lock_info(redis, lock_name)
+        queue_info = RedisQueuedLocks::Acquirer::QueueInfo.queue_info(redis, lock_name)
 
         # rubocop:disable Metrics/BlockNesting
         raise(
-          RedisQueuedLocks::LockAcquiermentTimeoutError,
+          RedisQueuedLocks::LockAcquirementTimeoutError,
           "Failed to acquire the lock \"#{lock_key}\" " \
           "for the given <#{timeout} seconds> timeout. Details: " \
           "<Lock Data> => #{lock_info ? lock_info.inspect : '<no_data>'}; " \
@@ -57,7 +62,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::WithAcqTimeout
         # rubocop:enable Metrics/BlockNesting
       else
         raise(
-          RedisQueuedLocks::LockAcquiermentTimeoutError,
+          RedisQueuedLocks::LockAcquirementTimeoutError,
           "Failed to acquire the lock \"#{lock_key}\" " \
           "for the given <#{timeout} seconds> timeout."
         )

data/lib/redis_queued_locks/acquirer/acquire_lock/yield_expire/log_visitor.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 1.7.0
+module RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire::LogVisitor
+  class << self
+    # @param logger [::Logger,#debug]
+    # @param log_sampled [Boolean]
+    # @param lock_key [String]
+    # @param queue_ttl [Integer]
+    # @param acquirer_id [String]
+    # @param host_id [String]
+    # @param access_strategy [Symbol]
+    # @return [void]
+    #
+    # @api private
+    # @since 1.7.0
+    # @version 1.9.0
+    def expire_lock(
+      logger,
+      log_sampled,
+      lock_key,
+      queue_ttl,
+      acquirer_id,
+      host_id,
+      access_strategy
+    )
+      return unless log_sampled
+
+      logger.debug do
+        "[redis_queued_locks.expire_lock] " \
+        "lock_key => '#{lock_key}' " \
+        "queue_ttl => #{queue_ttl} " \
+        "acq_id => '#{acquirer_id}' " \
+        "hst_id => '#{host_id}' " \
+        "acs_strat => '#{access_strategy}'"
+      end rescue nil
+    end
+
+    # @param logger [::Logger,#debug]
+    # @param log_sampled [Boolean]
+    # @param lock_key [String]
+    # @param decreased_ttl [Integer]
+    # @param queue_ttl [Integer]
+    # @param acquirer_id [String]
+    # @param host_id [String]
+    # @param access_strategy [Symbol]
+    # @return [void]
+    #
+    # @api private
+    # @since 1.7.0
+    # @version 1.9.0
+    def decrease_lock(
+      logger,
+      log_sampled,
+      lock_key,
+      decreased_ttl,
+      queue_ttl,
+      acquirer_id,
+      host_id,
+      access_strategy
+    )
+      return unless log_sampled
+
+      logger.debug do
+        "[redis_queued_locks.decrease_lock] " \
+        "lock_key => '#{lock_key}' " \
+        "decreased_ttl => #{decreased_ttl} " \
+        "queue_ttl => #{queue_ttl} " \
+        "acq_id => '#{acquirer_id}' " \
+        "hst_id => '#{host_id}' " \
+        "acs_strat => '#{access_strategy}'"
+      end rescue nil
+    end
+  end
+end