hoodoo 2.11.1 → 2.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b398ad0969958b8875e89613be18132d57b06252e737e4f22a850fc434f01ad
-  data.tar.gz: ef72263c10725a1b0e02d4a7eb257960361b8cba419764be325b19bf1787a805
+  metadata.gz: a6cfaed24695383d45ef45ee57241f89f37ef6005247c613014238c59b57f158
+  data.tar.gz: 0547a5c355d815eaf6709f5023fa9878065f613d43c492fe781d87dbcb40b075
 SHA512:
-  metadata.gz: fc3745b2193c7c8b19026aca0e42d32a949afd995e392f4dda8bf1e305b8c1262513ddba39084473192661b66326b2e4fc10dde16906b6650e08a96df98e875f
-  data.tar.gz: c6421148241112d1016584043da0307e93c8dd243c3a1b9134b126ff7f5ff14010d123e704966ffccc9730479e130ab7d8f69cd9565d33ea484ea347ea801c86
+  metadata.gz: af7cd5e04e9ed36530627d80120a43a3f7e5569fda99969cf23c437edb98e509011cd00a83e720d67027bbfedd09a2b3cdc20cbcfcbd7b6d56dfb1a30152122a
+  data.tar.gz: a4cc5ef27dfb5ae7d8f3c8ad555fd96101ca0ac6b864055d4b37534a276ffb47856da28c9b7eacbe6fb93b766b9285c164ae338d76ed268998c209dc5b2446a6

data/lib/hoodoo/services/middleware/middleware.rb

@@ -243,15 +243,30 @@ module Hoodoo; module Services
       @@environment ||= Hoodoo::StringInquirer.new( ENV[ 'RACK_ENV' ] || 'development' )
     end
 
-    # Do we have Memcached available? If not, assume local development with
-    # higher level queue services not available. Most service authors should
-    # not ever need to check this.
+    # This method is deprecated. Use ::has_session_store? instead.
+    #
+    # Return a boolean value for whether Memcached is explicitly defined as
+    # the Hoodoo::TransientStore engine. In previous versions, a +nil+ response
+    # used to indicate local development without a queue available, but that is
+    # not a valid assumption in modern code.
     #
     def self.has_memcached?
+      $stderr.puts( 'Hoodoo::Services::Middleware::Middleware#has_memcached? is deprecated - use #has_session_store?' )
+
       m = self.memcached_host()
       m.nil? == false && m.empty? == false
     end
 
+    # Return a boolean value for whether an environment variable declaring
+    # Hoodoo::TransientStore engine URI(s) have been defined by service author.
+    #
+    def self.has_session_store?
+      config = self.session_store_uri()
+      config.nil? == false && config.empty? == false
+    end
+
+    # This method is deprecated. Use ::session_store_uri instead.
+    #
     # Return a Memcached host (IP address/port combination) as a String if
     # defined in environment variable MEMCACHED_HOST (with MEMCACHE_URL also
     # accepted as a legacy fallback).
@@ -274,6 +289,69 @@ module Hoodoo; module Services
       @@memcached_host = nil
     end
 
+    # Return configuration for the selected Hoodoo::TransientStore engine, as
+    # a flat String (IP address/ port combination) or a serialised JSON string
+    # with symbolised keys, defining a URI for each supported storage engine
+    # defined (required if <tt>ENV[ 'SESSION_STORE_ENGINE' ]</yy> defines a
+    # multi-engine strategy).
+    #
+    # Checks for the engine agnostic environment variable +SESSION_STORE_URI+
+    # first then uses #memcached_host as a legacy fallback.
+    #
+    def self.session_store_uri
+
+      # See also ::clear_session_store_configuration_cache!
+      #
+      @@session_store_uri ||= ( ENV[ 'SESSION_STORE_URI' ] || self.memcached_host() )
+
+    end
+
+    # Return a symbolised key for the transient storage engine as defined in
+    # the environment variable +SESSION_STORE_ENGINE+ (with +:memcached+ as a
+    # legacy fallback if ::has_memcached? is +true+, else default is +nil+).
+    #
+    # The +SESSION_STORE_ENGINE+ environment variable must contain an entry
+    # from Hoodoo::TransientStore::supported_storage_engines. This collection
+    # is initialised by either requiring the top-level +hoodoo+ file to pull
+    # in everything, requiring <tt>hoodoo/transient_store</tt> to pull in all
+    # currently defined transient store engines or requiring the following
+    # in order to pull in a specific engine - in this example, redis:
+    #
+    #         require 'hoodoo/transient_store/transient_store'
+    #         require 'hoodoo/transient_store/transient_store/base'
+    #         require 'hoodoo/transient_store/transient_store/redis'
+    #
+    # If the engine requested appears to be unsupported, this method returns
+    # +nil+.
+    #
+    def self.session_store_engine
+      if (
+        ! defined?( @@session_store_engine ) ||
+        @@session_store_engine.nil?          ||
+        @@session_store_engine.empty?
+      )
+        default = self.has_memcached? ? 'memcached' : ''
+        engine = ( ENV[ 'SESSION_STORE_ENGINE' ] || default ).to_sym()
+
+        if Hoodoo::TransientStore::supported_storage_engines.include?( engine )
+          @@session_store_engine = engine
+        else
+          @@session_store_engine = nil
+        end
+      end
+
+      @@session_store_engine
+    end
+
+    # This method is intended really just for testing purposes; it clears the
+    # internal cache of session storage engine data read from environment
+    # variables.
+    #
+    def self.clear_session_store_configuration_cache!
+      @@session_store_engine = nil
+      @@session_store_uri    = nil
+    end
+
     # Are we running on the queue, else (implied) a local HTTP server?
     #
     def self.on_queue?
@@ -423,9 +501,10 @@ module Hoodoo; module Services
     end
 
     # A Hoodoo::Services::Session instance to use for tests or when no
-    # local Memcached instance is known about (environment variable
-    # +MEMCACHED_HOST+ is not set). The session is (eventually) read each
-    # time a request is made via Rack (through #call).
+    # local Hoodoo::TransientStore instance is known about (environment
+    # variable +SESSION_STORE_ENGINE+ and +SESSION_STORE_URI+ are not set).
+    # The session is (eventually) read each time a request is made via
+    # Rack (through #call).
     #
     # "Out of the box", DEFAULT_TEST_SESSION is used.
     #
@@ -973,8 +1052,9 @@ module Hoodoo; module Services
 
       # If we get this far the interim session isn't needed. We might have
       # exited early due to errors above and left this behind, but that's not
-      # the end of the world - it'll expire out of Memcached eventually.
-
+      # the end of the world - it'll expire out of the Hoodoo::TransientStore
+      # eventually.
+      #
       if session &&
          source_interaction.context &&
          source_interaction.context.session &&
@@ -1647,8 +1727,8 @@ module Hoodoo; module Services
       end
     end
 
-    # Load a session from Memcached on the basis of a session ID header
-    # in the current interaction's Rack request data.
+    # Load a session from the selected Hoodoo::TransientStore on the basis of
+    # a session ID header in the current interaction's Rack request data.
     #
     # On exit, the interaction context may have been updated. Be sure to
     # check +interaction.context.response.halt_processing?+ to see if
@@ -1665,11 +1745,12 @@ module Hoodoo; module Services
 
       if session_id != nil && ( test_session.nil? || test_session.session_id != session_id )
         session = Hoodoo::Services::Session.new(
-          :memcached_host => self.class.memcached_host(),
-          :session_id     => session_id
+          :storage_engine   => self.class.session_store_engine(),
+          :storage_host_uri => self.class.session_store_uri(),
+          :session_id       => session_id
         )
 
-        result = session.load_from_store!( session_id )
+        result  = session.load_from_store!( session_id )
         session = nil if result != :ok
       elsif ( self.class.environment.test? || self.class.environment.development? )
         interaction.using_test_session()
@@ -1679,7 +1760,7 @@ module Hoodoo; module Services
       # If there's no session and no local interfaces have any public
       # methods (everything is protected) then bail out early, as the
       # request can't possibly succeed.
-
+      #
       if session.nil? && interfaces_have_public_methods? == false
         return interaction.context.response.add_error( 'platform.invalid_session' )
       end
@@ -1688,7 +1769,7 @@ module Hoodoo; module Services
       # the context data is exposed to service implementations, the
       # session reference is read-only; don't break that protection;
       # instead build and use a replacement context.
-
+      #
       if session != interaction.context.session
         updated_context = Hoodoo::Services::Context.new(
           session,

data/lib/hoodoo/services/services/session.rb

@@ -53,7 +53,7 @@ module Hoodoo
       #
       # If you _change_ a Caller version in a Session, you _really_ should
       # call #save_to_store as soon as possible afterwards so that the
-      # change gets recognised in the transient store.
+      # change gets recognised in the Hoodoo::TransientStore.
       #
       attr_accessor :caller_version
 
@@ -119,13 +119,17 @@ module Hoodoo
       #
       attr_reader :expires_at
 
-      # Connection IP address/port String for Memcached.
+      # Declares the transient storage engine this session will write to.
+      # Both this and +storage_host_uri+ are used within
+      # Hoodoo::TransientStore::new.
       #
-      # If you are using Memcached for a session store, you can set the
-      # Memcached connection host either through this accessor, or via the
+      attr_accessor :storage_engine
+
+      # Connection IP address/port String for the selected storage engine. The
+      # connection host can be set either through this accessor, or via the
       # object's constructor.
       #
-      attr_accessor :memcached_host
+      attr_accessor :storage_host_uri
 
       # Create a new instance.
       #
@@ -133,26 +137,35 @@ module Hoodoo
       #
       # Options are:
       #
-      # +session_id+::        UUID of this session. If unset, a new UUID is
-      #                       generated for you. You can read the UUID with
-      #                       the #session_id accessor method.
+      # +session_id+::         UUID of this session. If unset, a new UUID is
+      #                        generated for you. You can read the UUID with
+      #                        the #session_id accessor method.
+      #
+      # +caller_id+::          UUID of the Caller instance associated with this
+      #                        session. This can be set either now or later,
+      #                        but the session cannot be saved without it.
+      #
+      # +caller_version+::     Version of the Caller instance. Defaults to
+      #                        zero.
       #
-      # +caller_id+::         UUID of the Caller instance associated with this
-      #                       session. This can be set either now or later, but
-      #                       the session cannot be saved without it.
+      # +caller_fingerprint+:: Optional Caller fingerprint UUID. Defaults to
+      #                        +nil+.
       #
-      # +caller_version+::    Version of the Caller instance; defaults to zero.
+      # +storage_engine+::     An entry (Symbol) from
+      #                        Hoodoo::TransientStore::supported_storage_engines.
+      #                        Defaults to +:memcached+.
       #
-      # +caller_fingerprint:: Optional Caller fingerprint UUID. Default to
-      #                       +nil+.
+      # +storage_host_uri+::   URI for Hoodoo::TransientStore engine
+      #                        connections.
       #
-      # +memcached_host+:: Host for Memcached connections.
+      # +memcached_host+::     Host for Memcached connections (deprecated).
       #
       def initialize( options = {} )
         @created_at = Time.now.utc
 
         self.session_id         = options[ :session_id         ] || Hoodoo::UUID.generate()
-        self.memcached_host     = options[ :memcached_host     ]
+        self.storage_engine     = options[ :storage_engine     ] || :memcached
+        self.storage_host_uri   = options[ :storage_host_uri   ] || options[ :memcached_host ]
         self.caller_id          = options[ :caller_id          ]
         self.caller_version     = options[ :caller_version     ] || 0
         self.caller_fingerprint = options[ :caller_fingerprint ]
@@ -277,7 +290,7 @@ module Hoodoo
       # * +:not_found+: The session was not found.
       #
       # * +:fail+: The session data could not be loaded (unexpected storage
-      #            engine failure).
+      #   engine failure).
       #
       def load_from_store!( sid )
         begin
@@ -347,7 +360,7 @@ module Hoodoo
       #   local Caller data must therefore already be out of date.
       #
       # * +:fail+: The Caller could not be updated (unexpected storage engine
-      #            failure).
+      #   failure).
       #
       def update_caller_version_in_store( cid, cv, store = nil )
         begin
@@ -374,6 +387,45 @@ module Hoodoo
         return :fail
       end
 
+      # Deprecated interface (use #storage_host_uri instead),
+      # dating back to when the Session engine was hard-coded to Memcached.
+      #
+      # Supports backwards compatibility of options key +memcached_host+,
+      # aliases +storage_host_uri+.
+      #
+      # Provides same functionality as +alias_method+, however includes a
+      # deprecation warning.
+      #
+      # Similar to:
+      #
+      #   alias_method( :memcached_host, :storage_host_uri )
+      #
+      def memcached_host
+        Hoodoo::Services::Middleware.logger.warn(
+          'Hoodoo::Services::Session#memcached_host is deprecated - use #storage_host_uri'
+        )
+
+        storage_host_uri()
+      end
+
+      # Deprecated interface (use #storage_host_uri= instead),
+      # dating back to when the Session engine was hard-coded to Memcached.
+      #
+      # Provides same functionality as +alias_method+, however includes a
+      # deprecation warning.
+      #
+      # Similar to:
+      #
+      #   alias_method( :memcached_host=, :storage_host_uri= )
+      #
+      def memcached_host=( uri )
+        Hoodoo::Services::Middleware.logger.warn(
+          'Hoodoo::Services::Session#memcached_host= is deprecated - use #storage_host_uri='
+        )
+
+        self.storage_host_uri = uri
+      end
+
       # Deprecated interface (use #update_caller_version_in_store instead),
       # dating back to when the Session engine was hard-coded to Memcached.
       #
@@ -421,7 +473,7 @@ module Hoodoo
       # * +:ok+: The Session was deleted from the transient store successfully.
       #
       # * +:fail+: The session data could not be deleted (unexpected storage
-      #            engine failure).
+      #   engine failure).
       #
       def delete_from_store
         begin
@@ -641,16 +693,18 @@ module Hoodoo
 
     private
 
-      # Connect to the storage engine. Returns a Hoodoo:TransientStore
+      # Connect to the storage engine, using the +storage_engine+ and
+      # +storage_host_uri+ attributes. Returns a Hoodoo:TransientStore
       # instance. Raises an exception if no connection can be established.
       #
       def get_store
-        host = self.memcached_host()
+        engine = self.storage_engine()
+        host   = self.storage_host_uri()
 
         begin
           @@stores         ||= {}
           @@stores[ host ] ||= Hoodoo::TransientStore.new(
-            storage_engine:    :memcached,
+            storage_engine:    engine,
             storage_host_uri:  host,
             default_namespace: 'nz_co_loyalty_hoodoo_session_'
           )
@@ -658,7 +712,7 @@ module Hoodoo
           raise 'Unknown storage engine failure' if @@stores[ host ].nil?
 
         rescue => exception
-          raise "Hoodoo::Services::Session\#get_store: Cannot connect to Memcached at '#{ host }': #{ exception.to_s }"
+          raise "Hoodoo::Services::Session\#get_store: Cannot connect to #{ engine } at '#{ host }': #{ exception }"
 
         end
 

data/lib/hoodoo/transient_store/transient_store/memcached_redis_mirror.rb

@@ -61,8 +61,9 @@ module Hoodoo
       # Hoodoo::TransientStore::new.
       #
       # The +storage_host_uri+ parameter is necessarily unusual here. It must
-      # be _a Hash_ with Symbol keys +:memcached+ and +:redis+, those values
-      # giving the actual storage engine host URI for the respective engines.
+      # be either _a Hash_ with Symbol keys +:memcached+ and +:redis+, or a
+      # serialised JSON string representing the same information. These values
+      # define the actual storage engine host URI for the respective engines.
       # For example, to connect to locally running engines configured on their
       # default ports, pass this Hash in +storage_host_uri+:
       #
@@ -71,6 +72,13 @@ module Hoodoo
       #       :redis     => 'redis://localhost:6379'
       #     }
       #
+      # ...or:
+      #
+      #     "{
+      #       \"memcached\": \"localhost:11211\",
+      #       \"redis\":     \"redis://localhost:6379\"
+      #     }"
+      #
       # See Hoodoo::TransientStore::Memcached::new and
       # Hoodoo::TransientStore::Redis::new for details of connection URI
       # requirements for those engines.
@@ -80,6 +88,8 @@ module Hoodoo
       def initialize( storage_host_uri:, namespace: )
         super # Pass all arguments through -> *not* 'super()'
 
+        storage_host_uri = deserialize_and_symbolize( storage_host_uri ) if storage_host_uri.is_a?( String )
+
         unless storage_host_uri.is_a?( Hash ) &&
                storage_host_uri.has_key?( :memcached ) &&
                storage_host_uri.has_key?( :redis )
@@ -170,6 +180,18 @@ module Hoodoo
             @redis_store.close()
       end
 
+      private
+
+      # Helper method for deserialising JSON objects and enforcing hash
+      # keys are symbolised.
+      #
+      def deserialize_and_symbolize( serialized_string )
+        Hoodoo::Utilities.symbolize( JSON.parse( serialized_string ) )
+
+      rescue JSON::ParserError
+        raise 'Hoodoo::TransientStore::MemcachedRedisMirror: Bad storage host URI data passed to constructor'
+      end
+
     end
 
     Hoodoo::TransientStore.register(

data/lib/hoodoo/version.rb

@@ -12,11 +12,11 @@ module Hoodoo
   # The Hoodoo gem version. If this changes, be sure to re-run
   # <tt>bundle install</tt> or <tt>bundle update</tt>.
   #
-  VERSION = '2.11.1'
+  VERSION = '2.12.0'
 
   # The Hoodoo gem date. If this changes, be sure to re-run
   # <tt>bundle install</tt> or <tt>bundle update</tt>.
   #
-  DATE = '2018-12-12'
+  DATE = '2018-12-17'
 
 end

data/spec/services/middleware/middleware_spec.rb

@@ -179,11 +179,13 @@ describe Hoodoo::Services::Middleware do
 
   context 'utility methods' do
     before :each do
+      Hoodoo::Services::Middleware.clear_session_store_configuration_cache!
       Hoodoo::Services::Middleware.clear_memcached_configuration_cache!
       Hoodoo::Services::Middleware.clear_queue_configuration_cache!
     end
 
     after :each do
+      Hoodoo::Services::Middleware.clear_session_store_configuration_cache!
       Hoodoo::Services::Middleware.clear_memcached_configuration_cache!
       Hoodoo::Services::Middleware.clear_queue_configuration_cache!
     end
@@ -212,6 +214,42 @@ describe Hoodoo::Services::Middleware do
       end
     end
 
+    it 'should know about TransientStore configuration via environment variable' do
+      old_uri    = ENV[ 'SESSION_STORE_URI'    ]
+      old_engine = ENV[ 'SESSION_STORE_ENGINE' ]
+      ENV[ 'MEMCACHED_HOST'       ] = nil
+      ENV[ 'SESSION_STORE_URI'    ] = nil
+      ENV[ 'SESSION_STORE_ENGINE' ] = nil
+      Hoodoo::Services::Middleware.clear_session_store_configuration_cache!
+      expect( Hoodoo::Services::Middleware.has_session_store?   ).to eq( false )
+      expect( Hoodoo::Services::Middleware.session_store_engine ).to be_nil
+      expect( Hoodoo::Services::Middleware.session_store_uri    ).to be_nil
+      ENV[ 'SESSION_STORE_URI'    ] = 'foo'
+      ENV[ 'SESSION_STORE_ENGINE' ] = 'redis'
+      Hoodoo::Services::Middleware.clear_session_store_configuration_cache!
+      expect( Hoodoo::Services::Middleware.has_session_store?   ).to eq( true   )
+      expect( Hoodoo::Services::Middleware.session_store_uri    ).to eq( 'foo'  )
+      expect( Hoodoo::Services::Middleware.session_store_engine ).to eq( :redis )
+      ENV[ 'SESSION_STORE_URI'    ] = old_uri
+      ENV[ 'SESSION_STORE_ENGINE' ] = old_engine
+    end
+
+    it 'should know about Memcached via legacy environment variable' do
+      old_uri    = ENV[ 'MEMCACHED_HOST'       ]
+      old_engine = ENV[ 'SESSION_STORE_ENGINE' ]
+      ENV[ 'MEMCACHED_HOST'       ] = nil
+      ENV[ 'SESSION_STORE_ENGINE' ] = nil
+      Hoodoo::Services::Middleware.clear_session_store_configuration_cache!
+      expect( Hoodoo::Services::Middleware.has_memcached? ).to eq(false)
+      expect( Hoodoo::Services::Middleware.session_store_engine ).to be_nil
+      ENV[ 'MEMCACHED_HOST'       ] = 'foo'
+      Hoodoo::Services::Middleware.clear_session_store_configuration_cache!
+      expect( Hoodoo::Services::Middleware.has_memcached? ).to eq(true)
+      expect( Hoodoo::Services::Middleware.session_store_engine ).to eq(:memcached)
+      ENV[ 'MEMCACHED_HOST'       ] = old_uri
+      ENV[ 'SESSION_STORE_ENGINE' ] = old_engine
+    end
+
     it 'should know about Memcached via legacy environment variable' do
       spec_helper_change_environment( 'MEMCACHE_URL', nil ) do
         expect(Hoodoo::Services::Middleware.has_memcached?).to eq(false)

data/spec/services/services/session_spec.rb

@@ -11,30 +11,49 @@ describe Hoodoo::Services::Session do
   context 'basics' do
     it 'initialises with default options' do
       s = described_class.new()
-      expect( s.created_at ).to be_a( Time )
+      expect( s.created_at                        ).to be_a( Time )
       expect( Hoodoo::UUID.valid?( s.session_id ) ).to eq( true )
-      expect( s.memcached_host ).to be_nil
-      expect( s.caller_id ).to be_nil
-      expect( s.caller_version ).to eq( 0 )
-      expect( s.caller_fingerprint ).to be_nil
+      expect( s.memcached_host                    ).to be_nil
+      expect( s.storage_host_uri                  ).to eq( s.memcached_host )
+      expect( s.storage_engine                    ).to eq( :memcached )
+      expect( s.caller_id                         ).to be_nil
+      expect( s.caller_version                    ).to eq( 0 )
+      expect( s.caller_fingerprint                ).to be_nil
     end
 
     it 'initialises with given options' do
       s = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 2,
-        :caller_fingerprint => 'asdf'
+        :session_id           => '1234',
+        :storage_host_uri     => 'abcd',
+        :storage_engine       => :redis,
+        :caller_id            => '0987',
+        :caller_version       => 2,
+        :caller_fingerprint   => 'asdf'
       )
-      expect( s.created_at ).to be_a( Time )
-      expect( s.session_id ).to eq( '1234' )
-      expect( s.memcached_host ).to eq( 'abcd' )
-      expect( s.caller_id ).to eq( '0987' )
-      expect( s.caller_version ).to eq( 2 )
+      expect( s.created_at         ).to be_a( Time )
+      expect( s.session_id         ).to eq( '1234' )
+      expect( s.memcached_host     ).to eq( 'abcd' )
+      expect( s.storage_host_uri   ).to eq( 'abcd' )
+      expect( s.storage_engine     ).to eq( :redis )
+      expect( s.caller_id          ).to eq( '0987' )
+      expect( s.caller_version     ).to eq( 2      )
       expect( s.caller_fingerprint ).to eq( 'asdf' )
     end
 
+    it 'initialises with deprecated :memcached_host option' do
+      s = described_class.new(
+        :session_id         => '1234',
+        :memcached_host     => 'abcd',
+        :caller_id          => '0987',
+        :caller_version     => 2,
+        :caller_fingerprint => 'asdf'
+      )
+
+      expect( s.memcached_host   ).to eq( 'abcd'     )
+      expect( s.storage_host_uri ).to eq( 'abcd'     )
+      expect( s.storage_engine   ).to eq( :memcached )
+    end
+
     it 'reports not expired when it has no expiry' do
       s = described_class.new
       expect( s.expired? ).to eq( false )
@@ -48,10 +67,11 @@ describe Hoodoo::Services::Session do
 
     it 'converts to a Hash' do
       s = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 2,
+        :session_id         => '1234',
+        :storage_host_uri   => 'abcd',
+        :storage_engine     => :memcached,
+        :caller_id          => '0987',
+        :caller_version     => 2,
         :caller_fingerprint => 'asdf'
       )
       p = Hoodoo::Services::Permissions.new
@@ -109,12 +129,13 @@ describe Hoodoo::Services::Session do
       expect( s.permissions.to_h ).to eq( p.to_h )
     end
 
-    it 'saves/loads to/from Memcached' do
+    it 'saves/loads to/from transient store' do
       s1 = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 2,
+        :session_id         => '1234',
+        :storage_host_uri   => 'abcd',
+        :storage_engine     => :memcached,
+        :caller_id          => '0987',
+        :caller_version     => 2,
         :caller_fingerprint => 'asdf'
       )
 
@@ -142,7 +163,7 @@ describe Hoodoo::Services::Session do
       expect( s2.created_at ).to eq( Time.parse( Hoodoo::Utilities.standard_datetime( s1.created_at ) ) )
       expect( s2.expires_at ).to eq( Time.parse( Hoodoo::Utilities.standard_datetime( s1.expires_at ) ) )
       expect( s2.session_id ).to eq( s1.session_id )
-      expect( s2.memcached_host ).to be_nil
+      expect( s2.storage_host_uri ).to be_nil
       expect( s2.caller_id ).to eq( s1.caller_id )
       expect( s2.caller_version ).to eq( s1.caller_version )
       expect( s2.caller_fingerprint ).to eq( s1.caller_fingerprint )
@@ -150,10 +171,11 @@ describe Hoodoo::Services::Session do
 
     it 'can be deleted' do
       s = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 1
+        :session_id       => '1234',
+        :storage_host_uri => 'abcd',
+        :storage_engine   => :memcached,
+        :caller_id        => '0987',
+        :caller_version   => 1
       )
 
       s.save_to_store
@@ -163,10 +185,11 @@ describe Hoodoo::Services::Session do
 
     it 'handles attempts to delete not-found things' do
       s = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 1
+        :session_id       => '1234',
+        :storage_host_uri => 'abcd',
+        :storage_engine   => :memcached,
+        :caller_id        => '0987',
+        :caller_version   => 1
       )
 
       expect( s.delete_from_store ).to eq( :ok )
@@ -181,10 +204,10 @@ describe Hoodoo::Services::Session do
       # Save a session with a high caller version
 
       s1 = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 4
+        :session_id       => '1234',
+        :storage_host_uri => 'abcd',
+        :caller_id        => '0987',
+        :caller_version   => 4
       )
 
       expect( s1.save_to_store ).to eq( :ok )
@@ -193,10 +216,10 @@ describe Hoodoo::Services::Session do
       # is that session creation is underway when a caller gets updated.
 
       s2 = described_class.new(
-        :session_id => '2345',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 3
+        :session_id       => '2345',
+        :storage_host_uri => 'abcd',
+        :caller_id        => '0987',
+        :caller_version   => 3
       )
 
       expect( s2.save_to_store ).to eq( :outdated )
@@ -208,10 +231,10 @@ describe Hoodoo::Services::Session do
       # Save a session with a low caller version.
 
       s1 = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 1
+        :session_id       => '1234',
+        :storage_host_uri => 'abcd',
+        :caller_id        => '0987',
+        :caller_version   => 1
       )
 
       expect( s1.save_to_store ).to eq( :ok )
@@ -219,10 +242,10 @@ describe Hoodoo::Services::Session do
       # Save another with a higher caller version.
 
       s2 = described_class.new(
-        :session_id => '2345',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 2
+        :session_id       => '2345',
+        :storage_host_uri => 'abcd',
+        :caller_id        => '0987',
+        :caller_version   => 2
       )
 
       expect( s2.save_to_store ).to eq( :ok )
@@ -239,10 +262,10 @@ describe Hoodoo::Services::Session do
       # Save a session with a low caller version
 
       s1 = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 1
+        :session_id       => '1234',
+        :storage_host_uri => 'abcd',
+        :caller_id        => '0987',
+        :caller_version   => 1
       )
 
       expect( s1.save_to_store ).to eq( :ok )
@@ -254,10 +277,10 @@ describe Hoodoo::Services::Session do
       # Save another with a higher caller version.
 
       s2 = described_class.new(
-        :session_id => '2345',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 2
+        :session_id       => '2345',
+        :storage_host_uri => 'abcd',
+        :caller_id        => '0987',
+        :caller_version   => 2
       )
 
       expect( s2.save_to_store ).to eq( :ok )
@@ -277,10 +300,10 @@ describe Hoodoo::Services::Session do
       # Save a session for caller ID '0987'.
       #
       s1 = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 1
+        :session_id       => '1234',
+        :storage_host_uri => 'abcd',
+        :caller_id        => '0987',
+        :caller_version   => 1
       )
 
       expect( s1.save_to_store ).to eq( :ok )
@@ -299,10 +322,11 @@ describe Hoodoo::Services::Session do
       # caller IDs/versions.
 
       s2 = described_class.new(
-        :session_id => '2345',
-        :memcached_host => 'abcd',
-        :caller_id => Hoodoo::UUID.generate(),
-        :caller_version => 1
+        :session_id       => '2345',
+        :storage_host_uri => 'abcd',
+        :storage_engine   => :memcached,
+        :caller_id        => Hoodoo::UUID.generate(),
+        :caller_version   => 1
       )
 
       expect( s2.save_to_store ).to eq( :ok )
@@ -322,10 +346,11 @@ describe Hoodoo::Services::Session do
       # Save a session with a high caller version
 
       s = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 1
+        :session_id       => '1234',
+        :storage_host_uri => 'abcd',
+        :storage_engine   => :memcached,
+        :caller_id        => '0987',
+        :caller_version   => 1
       )
 
       expect( s ).to receive( :to_h ).and_wrap_original do | obj, args |
@@ -344,10 +369,11 @@ describe Hoodoo::Services::Session do
   context 'can explicitly update a caller' do
     before :each do
       @session = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 1
+        :session_id       => '1234',
+        :storage_host_uri => 'abcd',
+        :storage_engine   => :memcached,
+        :caller_id        => '0987',
+        :caller_version   => 1
       )
     end
 
@@ -463,10 +489,11 @@ describe Hoodoo::Services::Session do
 
     it 'handles unknown Hoodoo::TransientStore engine failures when saving' do
       s = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 1
+        :session_id       => '1234',
+        :storage_host_uri => 'abcd',
+        :storage_engine   => :memcached,
+        :caller_id        => '0987',
+        :caller_version   => 1
       )
 
       expect_any_instance_of( Hoodoo::TransientStore::Memcached ).to receive( :set ).once.and_call_original
@@ -484,10 +511,11 @@ describe Hoodoo::Services::Session do
 
     it 'handles unknown Hoodoo::TransientStore engine failures when deleting' do
       s = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 1
+        :session_id       => '1234',
+        :storage_host_uri => 'abcd',
+        :storage_engine   => :memcached,
+        :caller_id        => '0987',
+        :caller_version   => 1
       )
 
       s.save_to_store
@@ -502,10 +530,11 @@ describe Hoodoo::Services::Session do
 
     it 'handles unknown Hoodoo::TransientStore engine returned exceptions' do
       s = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 1
+        :session_id       => '1234',
+        :storage_host_uri => 'abcd',
+        :storage_engine   => :memcached,
+        :caller_id        => '0987',
+        :caller_version   => 1
       )
 
       s.save_to_store
@@ -520,10 +549,11 @@ describe Hoodoo::Services::Session do
 
     it 'logs and reports internal deletion exceptions' do
       s = described_class.new(
-        :session_id => '1234',
-        :memcached_host => 'abcd',
-        :caller_id => '0987',
-        :caller_version => 1
+        :session_id       => '1234',
+        :storage_host_uri => 'abcd',
+        :storage_engine   => :memcached,
+        :caller_id        => '0987',
+        :caller_version   => 1
       )
 
       s.save_to_store
@@ -549,9 +579,9 @@ describe Hoodoo::Services::Session do
         Hoodoo::Services::Session.class_variable_set( '@@stores', nil ) # Hack for test!
 
         @instance = described_class.new(
-          :session_id => '1234',
+          :session_id     => '1234',
           :memcached_host => 'abcd',
-          :caller_id => '0987',
+          :caller_id      => '0987',
           :caller_version => 1
         )
       end
@@ -605,16 +635,18 @@ describe Hoodoo::Services::Session do
 
       it 'via aliases for deprecated methods' do
         s = described_class.new(
-          :session_id => '1234',
+          :session_id     => '1234',
           :memcached_host => 'abcd',
-          :caller_id => '0987',
+          :caller_id      => '0987',
           :caller_version => 2
         )
 
-        expect( s ).to respond_to( :save_to_memcached )
-        expect( s ).to respond_to( :load_from_memcached! )
+        expect( s ).to respond_to( :save_to_memcached                  )
+        expect( s ).to respond_to( :load_from_memcached!               )
         expect( s ).to respond_to( :update_caller_version_in_memcached )
-        expect( s ).to respond_to( :delete_from_memcached )
+        expect( s ).to respond_to( :delete_from_memcached              )
+        expect( s ).to respond_to( :memcached_host                     )
+        expect( s ).to respond_to( :memcached_host=                    )
       end
     end
   end

data/spec/transient_store/transient_store/memcached_redis_mirror_spec.rb

@@ -15,10 +15,10 @@ describe Hoodoo::TransientStore::MemcachedRedisMirror do
     @memcached_uri      = 'localhost:11211'
     @redis_uri          = 'redis://localhost:6379'
     @namespace          = Hoodoo::UUID.generate()
-    @storage_engine_uri = {
+    @storage_engine_uri = JSON.generate({
       :memcached => @memcached_uri,
       :redis     => @redis_uri
-    }
+    })
 
     # Use pure mock back-ends behind the Memcached and Redis abstraction
     # layers; real back-end tests are done for them in their unit tests.
@@ -56,8 +56,15 @@ describe Hoodoo::TransientStore::MemcachedRedisMirror do
     end
 
     it 'creates Memcached and Redis instances' do
-      expect( Hoodoo::TransientStore::Memcached ).to receive( :new )
-      expect( Hoodoo::TransientStore::Redis     ).to receive( :new )
+      expect( Hoodoo::TransientStore::Memcached ).to receive( :new ).with(
+        namespace: @namespace,
+        storage_host_uri: @memcached_uri
+      )
+
+      expect( Hoodoo::TransientStore::Redis ).to receive( :new ).with(
+        namespace: @namespace,
+        storage_host_uri: @redis_uri
+      )
 
       Hoodoo::TransientStore::MemcachedRedisMirror.new(
         storage_host_uri: @storage_engine_uri,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hoodoo
 version: !ruby/object:Gem::Version
-  version: 2.11.1
+  version: 2.12.0
 platform: ruby
 authors:
 - Loyalty New Zealand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-12 00:00:00.000000000 Z
+date: 2018-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -599,7 +599,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Opinionated APIs