right_link 5.9.0

data/lib/instance/multi_thread_bundle_queue.rb

@@ -0,0 +1,232 @@
+#
+# Copyright (c) 2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module RightScale
+
+  class MultiThreadBundleQueue < BundleQueue
+
+    THREAD_QUEUE_CLOSED_BUNDLE = 'thread queue closed'
+
+    # Set continuation block to be called after 'close' is called
+    #
+    # === Block
+    # continuation block
+    def initialize(&continuation)
+      super(&continuation)
+      @active = false
+      @thread = nil
+      @mutex = Mutex.new
+      @queue = Queue.new
+      @thread_name_to_queue = {}
+    end
+
+    # Determines if queue is active
+    #
+    # === Return
+    # active(Boolean):: true if queue is active
+    def active?
+      active = false
+      @mutex.synchronize { active = @active }
+      return active
+    end
+
+    # Activate queue for execution, idempotent
+    # Any pending bundle will be run sequentially in order
+    #
+    # === Return
+    # true:: Always return true
+    def activate
+      @mutex.synchronize do
+        unless @active
+          @thread = Thread.new { run }
+          @active = true
+        end
+      end
+      true
+    end
+
+    # Determines if queue is busy
+    #
+    # === Return
+    # active(Boolean):: true if queue is busy
+    def busy?
+      busy = false
+      @mutex.synchronize { busy = @thread_name_to_queue.any? { |_, q| q.busy? } }
+      busy
+    end
+
+    # Push new context to bundle queue and run next bundle
+    #
+    # === Return
+    # true:: Always return true
+    def push(context)
+      @queue << context
+      true
+    end
+
+    # Clear queue content
+    #
+    # === Return
+    # true:: Always return true
+    def clear
+      @queue.clear
+      @mutex.synchronize { @thread_name_to_queue.each_value { |queue| queue.clear } }
+      true
+    end
+
+    # Close queue so that further call to 'push' will be ignored
+    #
+    # === Return
+    # true:: Always return true
+    def close
+      push(FINAL_BUNDLE)
+    end
+
+    protected
+
+    # Run next bundle in the queue if active
+    # If bundle is FINAL_BUNDLE then call continuation block and deactivate
+    #
+    # === Return
+    # true:: Always return true
+    def run
+      close_requested = false
+      shutdown_requested = false
+      loop do
+        context = @queue.shift
+        if context == FINAL_BUNDLE
+          if close_thread_queues
+            close_requested = true
+          else
+            break
+          end
+        elsif context == THREAD_QUEUE_CLOSED_BUNDLE
+          unless groom_thread_queues
+            if shutdown_requested
+              # reset shutdown flag, push shutdown and wait for FINAL_BUNDLE
+              shutdown_requested = false
+              push_to_thread_queue(SHUTDOWN_BUNDLE)
+            else
+              break
+            end
+          end
+        elsif context == SHUTDOWN_BUNDLE
+          if close_thread_queues
+            # defer shutdown until all thread queues close (threads are
+            # uninterruptable but the user can always kick the plug out).
+            shutdown_requested = true
+          else
+            # push shutdown and wait for FINAL_BUNDLE
+            push_to_thread_queue(SHUTDOWN_BUNDLE)
+          end
+        elsif !context.decommission? && ShutdownRequest.instance.immediately?
+          # immediate shutdown pre-empts any futher attempts to run operational
+          # scripts but still allows the decommission bundle to run.
+          context.audit.update_status("Skipped bundle due to immediate shutdown: #{context.payload}")
+          # proceed ignoring bundles until final or shutdown are encountered.
+        else
+          push_to_thread_queue(context) unless close_requested
+        end
+      end
+      true
+    rescue Exception => e
+      Log.error(Log.format("MultiThreadBundleQueue.run failed", e, :trace))
+    ensure
+      # invoke continuation (off of this thread which is going away).
+      @mutex.synchronize { @active = false }
+      EM.next_tick { @continuation.call } if @continuation
+      @thread = nil
+    end
+
+    # Pushes a context to a thread based on a name determined from the context.
+    #
+    # === Parameters
+    # context(Object):: any kind of context object
+    #
+    # === Return
+    # true:: always true
+    def push_to_thread_queue(context)
+      thread_name = context.respond_to?(:thread_name) ? context.thread_name : ::RightScale::AgentConfig.default_thread_name
+      queue = nil
+      @mutex.synchronize do
+        queue = @thread_name_to_queue[thread_name]
+        unless queue
+          # continuation for when thread-named queue is finally closed.
+          queue = create_thread_queue(thread_name) { push(THREAD_QUEUE_CLOSED_BUNDLE) }
+          @thread_name_to_queue[thread_name] = queue
+        end
+      end
+
+      # push context to selected thread queue
+      queue.push(context)
+
+      # always (re)activate in case an individual thread queue died unexpectedly.
+      # has no effect if already active.
+      queue.activate
+      true
+    end
+
+    # Factory method for a thread-specific queue.
+    #
+    # === Parameters
+    # thread_name(String):: name of thread for queue being created
+    # continuation(Proc):: continuation run on thread termination
+    #
+    # === Return
+    # queue(BundleQueue):: a new thread-specific queue
+    def create_thread_queue(thread_name, &continuation)
+      return SingleThreadBundleQueue.new(thread_name, &continuation)
+    end
+
+    # Deletes any inactive queues from the hash of known queues.
+    #
+    # === Return
+    # still_active(Boolean):: true if any queues are still active
+    def groom_thread_queues
+      still_active = false
+      @mutex.synchronize do
+        @thread_name_to_queue.delete_if { |_, queue| false == queue.active? }
+        still_active = false == @thread_name_to_queue.empty?
+      end
+      return still_active
+    end
+
+    # Closes all thread queues.
+    #
+    # === Return
+    # result(Boolean):: true if any queues are still active (and stopping)
+    def close_thread_queues
+      still_active = false
+      @mutex.synchronize do
+        @thread_name_to_queue.each_value do |queue|
+          if queue.active?
+            queue.close
+            still_active = true
+          end
+        end
+      end
+      return still_active
+    end
+
+  end  # MultiThreadBundleQueue
+
+end  # RightScale

data/lib/instance/operation_context.rb

@@ -0,0 +1,60 @@
+#
+# Copyright (c) 2009-2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module RightScale
+
+  # Context required to run an operation
+  # Includes operation input and associated audit
+  class OperationContext
+
+    # @return [Object] payload associated with operation
+    attr_reader :payload
+
+    # @return [RightScale::AuditProxy] audit for execution
+    attr_reader :audit
+
+    # @return [TrueClass|FalseClass] true if bundle succeeded
+    attr_accessor :succeeded
+
+    # @return [TrueClass|FalseClass] true if a decommission bundle
+    def decommission?; !!@decommission_type; end
+
+    # @return [String] decommission_type or nil
+    attr_reader :decommission_type
+
+    # @return [String] thread name for context or default thread name
+    attr_reader :thread_name
+
+    # @param [Object] payload of any kind (but usually executable bundle)
+    # @param [RightScale::AuditProxy] audit for execution
+    # @param [Hash] options for context
+    # @option options [String] :decommission_type for decommission bundle
+    def initialize(payload, audit, options={})
+      @payload = payload
+      @audit = audit
+      @decommission_type = options[:decommission_type]
+      @thread_name = payload.respond_to?(:runlist_policy) && payload.runlist_policy ? payload.runlist_policy.thread_name : ::RightScale::AgentConfig.default_thread_name
+    end
+
+  end
+
+end

data/lib/instance/options_bag.rb

@@ -0,0 +1,65 @@
+#
+# Copyright (c) 2010-2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'json'
+
+module RightScale
+
+  # Store agent options in environment variable so child processes
+  # can access them too
+  class OptionsBag
+
+    # (String) Name of environment variable containing serialized options hash
+    OPTIONS_ENV = 'RS_OPTIONS'
+
+    # Store options
+    #
+    # === Parameters
+    # opts(Hash):: Options to be stored, override any options stored earlier
+    #
+    # === Result
+    # opts(Hash):: Options to be stored
+    def self.store(opts)
+      ENV[OPTIONS_ENV] = JSON.dump(opts)
+      opts
+    end
+
+    # Load previously stored options (may have been stored in a parent process)
+    #
+    # === Return
+    # opts(Hash):: Previously stored options, empty hash if there is none
+    def self.load
+      return {} unless serialized = ENV[OPTIONS_ENV]
+      begin
+        opts = JSON.load(serialized)
+        opts = SerializationHelper.symbolize_keys(opts)
+      rescue Exception => e
+        Log.warning("Failed to deserialize options", e)
+        opts = {}
+      end
+      opts
+    end
+
+  end
+
+end
+

data/lib/instance/payload_formatter.rb

@@ -0,0 +1,46 @@
+#
+# Copyright (c) 2010-2011 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module RightScale
+
+  # Extend PayloadFormatter for instance agent payloads
+  class PayloadFormatter
+
+    protected
+
+    # state_recorder/record request log message
+    # Payload :
+    # { :agent_identity => ..., :state => ..., :user_id => ..., :skip_db_update => ..., :kind => ... }
+    #
+    # === Parameters
+    # payload(Hash):: Request payload
+    #
+    # === Return
+    # true:: Always return true
+    def state_recorder_record(payload)
+      msg = get(payload, :state)
+    end
+
+  end
+
+end
+

data/lib/instance/policy.rb

@@ -0,0 +1,53 @@
+#
+# Copyright (c) 2009-2012 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module RightScale
+
+  class Policy
+    attr_accessor :policy_name, :audit_period, :audit, :count, :audit_timestamp
+    
+    def initialize(policy_name, audit_period, audit)
+      @policy_name = policy_name.to_s
+      @audit_period = audit_period.to_i
+      @audit = RightScale::PolicyAudit.new(audit)
+      @count = 0
+      @audit_timestamp = Time.now
+
+      @audit.audit.append_info("First run of Reconvergence Policy '#{policy_name}' at #{Time.at(@audit_timestamp).to_s}")
+    end
+
+    def success
+      @count += 1
+      timestamp = Time.now
+      if timestamp - @audit_timestamp >= @audit_period
+        @audit.audit.append_info("Reconvergence Policy '#{@policy_name}' has run successfully #{@count} time#{@count > 1 ? 's' : ''} since #{Time.at(@audit_timestamp).to_s}")
+        @audit_timestamp = timestamp
+        @count = 0
+      end
+    end
+
+    def fail
+      @count = 0
+    end
+  end
+  
+end

data/lib/instance/policy_audit.rb

@@ -0,0 +1,100 @@
+#
+# Copyright (c) 2009-2012 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module RightScale
+
+  class PolicyAudit
+    # AuditProxy
+    attr_accessor :audit
+
+    # Creates a PolicyAudit to wrap AuditProxy
+    #
+    # === Parameters
+    # audit(AuditProxy):: the audit that pertains to the bundle
+    def initialize(audit)
+      @audit = audit
+    end
+
+    # # See AuditProxy::update_status
+    #
+    # === Parameters
+    # status(String):: New audit entry status
+    # options[:category](String):: Optional, must be one of RightScale::EventCategories::CATEGORIES
+    #
+    # === Return
+    # true:: Always return true
+    def update_status(status, options={})
+      true
+    end
+
+    # See AuditProxy::append_create_new_section
+    #
+    # === Parameters
+    # title(String):: Title of new audit section, will replace audit status as well
+    # options[:category](String):: Optional, must be one of RightScale::EventCategories::CATEGORIES
+    #
+    # === Return
+    # true:: Always return true
+    def create_new_section(title, options={})
+      RightScale::Log.info title
+      true
+    end
+
+    # See AuditProxy::append_info
+    #
+    # === Parameters
+    # text(String):: Informational text to append to audit entry
+    # options[:category](String):: Optional, must be one of RightScale::EventCategories::CATEGORIES
+    #
+    # === Return
+    # true:: Always return true
+    def append_info(text, options={})
+      true
+    end
+
+    # See AuditProxy::append_error
+    #
+    # === Parameters
+    # text(String):: Error text to append to audit entry
+    # options[:category](String):: Optional, must be one of RightScale::EventCategories::CATEGORIES
+    #
+    # === Return
+    # true:: Always return true
+    def append_error(text, options={})
+      @audit.append_error(text, options)
+    end
+
+    # See AuditProxy::append_output
+    #
+    # === Parameters
+    # text(String):: Output to append to audit entry
+    #
+    # === Return
+    # true:: Always return true
+    def append_output(text)
+      RightScale::Log.info text
+      true
+    end
+
+  end
+
+end

data/lib/instance/policy_manager.rb

@@ -0,0 +1,146 @@
+#
+# Copyright (c) 2009-2012 RightScale Inc
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module RightScale
+
+  # Manages policies
+  class PolicyManager
+    # Policy hash keyed by policy name
+    @policies = Hash.new
+    @registrations = Hash.new
+
+    class << self
+      attr_reader :policy
+
+      def registered?(bundle)
+        @policies.has_key?(policy_name_from_bundle(bundle))
+      end
+
+      # Registers the bundle with the Manager and calls the passed in block when registration completes
+      # In a multithreaded environment, the
+      #
+      # === Parameters
+      # bundle(ExecutableBundle):: bundle containing a RunlistPolicy
+      # block(Block):: block to execute once registration is complete.  The block will be called with
+      #
+      # === Return
+      # result(Boolean):: Return false if the bundle fails to provide a valid runlist policy
+      def register(bundle, &block)
+        runlist_policy = runlist_policy_from_bundle(bundle)
+        if runlist_policy
+          if registering?(runlist_policy.policy_name)
+            # waiting for a new audit to be created, place the block to be called on the list of callbacks
+            @registrations[runlist_policy.policy_name] << block if block
+          else
+            # this is the first registration, add the callback to the list of callbacks to be executed after the audit has been created
+            @registrations[runlist_policy.policy_name] = (block) ? [block] : []
+            # request a new audit
+            RightScale::AuditProxy.create(RightScale::InstanceState.identity, "Reconvergence Policy '#{runlist_policy.policy_name}'") do |audit|
+              policy = Policy.new(runlist_policy.policy_name, runlist_policy.audit_period, audit)
+              @policies[policy.policy_name] = policy
+              # drain the pending registrations
+              @registrations[policy.policy_name].each { |blk| blk.call(bundle, policy.audit) }
+              @registrations.delete(policy.policy_name)
+            end
+          end
+          true
+        end
+        false
+      end
+
+      # Signals the successful execution of a right script or recipe with the given bundle
+      #
+      # === Parameters
+      # bundle(ExecutableBundle):: bundle containing a RunlistPolicy
+      #
+      # === Return
+      # result(Boolean):: Return false if the bundle fails to provide a valid runlist policy
+      def success(bundle)
+        policy = get_policy_from_bundle(bundle)
+        return false unless policy
+        policy.success
+        true
+      end
+
+      # Signals the failed execution of a recipe with the given bundle
+      #
+      # === Parameters
+      # bundle(ExecutableBundle):: bundle containing a RunlistPolicy
+      #
+      # === Return
+      # result(Boolean):: Return false if the bundle fails to provide a valid runlist policy
+      def fail(bundle)
+        policy = get_policy_from_bundle(bundle)
+        return false unless policy
+        policy.fail
+        true
+      end
+
+      # Returns the audit for the given policy of the bundle
+      #
+      # === Parameters
+      # bundle(ExecutableBundle):: An executable bundle
+      #
+      # === Return
+      # result(PolicyAudit):: a PolicyAudit instance that wraps AuditProxy
+      def get_audit(bundle)
+        policy = get_policy_from_bundle(bundle)
+        policy ? policy.audit : nil
+      end
+
+      private
+
+      # Returns the policy that matches the bundle or creates a new one
+      #
+      # === Parameters
+      # bundle(ExecutableBundle):: An executable bundle
+      #
+      # === Return
+      # result(Policy):: Policy based on the bundle's RunlistPolicy or nil
+      def get_policy_from_bundle(bundle)
+        @policies[policy_name_from_bundle(bundle)]
+      end
+
+      def registering?(policy_name)
+        return @registrations.has_key?(policy_name)
+      end
+
+      def policy_name_from_bundle(bundle)
+        runlist_policy = runlist_policy_from_bundle(bundle)
+        if runlist_policy
+          return runlist_policy.policy_name
+        else
+          return nil
+        end
+      end
+
+      def runlist_policy_from_bundle(bundle)
+        if bundle.respond_to?(:runlist_policy) && bundle.runlist_policy && bundle.runlist_policy.policy_name
+          return bundle.runlist_policy
+        else
+          return nil
+        end
+      end
+    end
+  end
+
+end