promiscuous 0.90.0 → 0.91.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b84ccb396c096ef9d2164d4400356606f90c3954
+  data.tar.gz: 31da27f6d1163623df3014dc15a0641d6e93c0c3
+SHA512:
+  metadata.gz: 2cec057b926337d6940a8d3144b88ccc3dcf200a35dc74d88f69bf4ad388d034b6e68a04dd2f270f5c581382bef3ae5985b6e4ad9e7d9cfe44babf6cdacabd02
+  data.tar.gz: d84a82ecdcb22041d72c08e8c9fb443e77c2c9a74c49589a6d209079df7055f1adc484ca12b32d6f75f9a04e8f66bcfbaefeff020eb47b38c6fecbe3e1bc0c0b

data/lib/promiscuous/amqp/bunny.rb

@@ -6,7 +6,7 @@ class Promiscuous::AMQP::Bunny
 
       def handle_network_failure(e)
         Promiscuous.warn "[amqp] #{e}. Reconnecting..."
-        Promiscuous::Config.error_notifier.try(:call, e)
+        Promiscuous::Config.error_notifier.call(e)
         handle_network_failure_without_promiscuous(e)
       end
     end
@@ -27,21 +27,40 @@ class Promiscuous::AMQP::Bunny
     @callback_mapping = {}
   end
 
-  def connect
-    @connection, @channel = new_connection
-    @exchange = exchange(@channel, :pub)
-    confirm_select(@channel, &method(:on_confirm))
+  def raw_new_connection(options={})
+    connection = ::Bunny.new(options[:url], :heartbeat_interval => Promiscuous::Config.heartbeat,
+                                            :socket_timeout     => Promiscuous::Config.socket_timeout,
+                                            :connect_timeout    => Promiscuous::Config.socket_timeout)
+    connection.start
+    connection
   end
 
-  def new_connection
-    connection = ::Bunny.new(Promiscuous::Config.amqp_url,
-                             :heartbeat_interval => Promiscuous::Config.heartbeat,
-                             :socket_timeout     => Promiscuous::Config.socket_timeout,
-                             :connect_timeout    => Promiscuous::Config.socket_timeout)
-    connection.start
+  def raw_confirm_select(channel, &callback)
+    channel.confirm_select(callback)
+  end
 
+  def new_connection(options={})
+    connection = raw_new_connection(options)
     channel = connection.create_channel
-    [connection, channel]
+    channel.basic_qos(options[:prefetch]) if options[:prefetch]
+    raw_confirm_select(channel, &method(:on_confirm)) if options[:confirm]
+
+    if options[:exchanges]
+      exchanges = options[:exchanges].map do |exchange_name|
+        channel.exchange(exchange_name, :type => :topic, :durable => true)
+      end
+      [connection, channel, exchanges]
+    else
+      exchange = channel.exchange(options[:exchange], :type => :topic, :durable => true)
+      [connection, channel, exchange]
+    end
+  end
+
+  def connect
+    connection_options = { :url      => Promiscuous::Config.publisher_amqp_url,
+                           :exchange => Promiscuous::Config.publisher_exchange,
+                           :confirm  => true }
+    @connection, @channel, @exchange = new_connection(connection_options)
   end
 
   def disconnect
@@ -57,16 +76,13 @@ class Promiscuous::AMQP::Bunny
   end
 
   def raw_publish(options)
-    @exchange.publish(options[:payload], :key => options[:key], :persistent => true)
-  end
-
-  def exchange(channel, which)
-    exchange_name = which == :pub ? Promiscuous::AMQP::PUB_EXCHANGE :
-                                    Promiscuous::AMQP::SUB_EXCHANGE
-    channel.exchange(exchange_name, :type => :topic, :durable => true)
+    options[:exchange].publish(options[:payload], :key => options[:key], :persistent => true)
   end
 
   def publish(options={})
+    options[:exchange] ||= @exchange
+    Promiscuous.debug "[publish] #{options[:exchange].name}/#{options[:key]} #{options[:payload]}"
+
     @connection_lock.synchronize do
       tag = @channel.next_publish_seq_no if options[:on_confirm]
       raw_publish(options)
@@ -74,12 +90,8 @@ class Promiscuous::AMQP::Bunny
     end
   rescue Exception => e
     e = Promiscuous::Error::Publisher.new(e, :payload => options[:payload])
-    Promiscuous.warn "[publish] #{e} #{e.backtrace.join("\n")}"
-    Promiscuous::Config.error_notifier.try(:call, e)
-  end
-
-  def confirm_select(channel, &callback)
-    channel.confirm_select(callback)
+    Promiscuous.warn "[publish] #{e}\n#{e.backtrace.join("\n")}"
+    Promiscuous::Config.error_notifier.call(e)
   end
 
   def on_confirm(tag, multiple, nack=false)
@@ -96,18 +108,20 @@ class Promiscuous::AMQP::Bunny
 
   module Subscriber
     def subscribe(options={}, &block)
-      queue_name    = options[:queue_name]
-      bindings      = options[:bindings]
-      Promiscuous::AMQP.ensure_connected
-
       @lock = Mutex.new
-      @connection, @channel = Promiscuous::AMQP.backend.new_connection
-      @channel.basic_qos(Promiscuous::Config.prefetch)
-      exchange = Promiscuous::AMQP.backend.exchange(@channel, :sub)
-      @queue = @channel.queue(queue_name, Promiscuous::Config.queue_options)
-      bindings.each do |binding|
-        @queue.bind(exchange, :routing_key => binding)
-        Promiscuous.debug "[bind] #{queue_name} -> #{binding}"
+      @prefetch = Promiscuous::Config.prefetch
+
+      connection_options = { :url       => Promiscuous::Config.subscriber_amqp_url,
+                             :exchanges => options[:bindings].keys,
+                             :prefetch  => @prefetch }
+      @connection, @channel, exchanges = Promiscuous::AMQP.new_connection(connection_options)
+
+      @queue = @channel.queue(Promiscuous::Config.queue_name, Promiscuous::Config.queue_options)
+      exchanges.zip(options[:bindings].values).each do |exchange, bindings|
+        bindings.each do |binding|
+          @queue.bind(exchange, :routing_key => binding)
+          Promiscuous.debug "[bind] #{exchange.name}/#{binding}/#{Promiscuous::Config.queue_name}"
+        end
       end
 
       @subscription = subscribe_queue(@queue, &block)
@@ -128,12 +142,25 @@ class Promiscuous::AMQP::Bunny
       def ack
         @subscriber.ack_message(@delivery_info.delivery_tag)
       end
+
+      def postpone
+        @subscriber.postpone_message
+      end
     end
 
     def ack_message(tag)
       @lock.synchronize { @channel.ack(tag) } if @channel
     end
 
+    def postpone_message
+      # Not using nacks, because the message gets sent back right away so this
+      # is a no-op.
+
+      # TODO: Even though the prefetch window is set to 10mil we should still
+      # check that the unacked messages doesn't exceed this limit and increase
+      # the prefetch window.
+    end
+
     def recover
       @lock.synchronize { @channel.basic_recover(true) } if @channel
     end

data/lib/promiscuous/amqp/fake.rb

@@ -20,6 +20,7 @@ class Promiscuous::AMQP::Fake
   end
 
   def publish(options={})
+    Promiscuous.debug "[publish (fake)] #{options[:exchange].try(:name) || "default"}/#{options[:key]} #{options[:payload]}"
     @messages << options
     options[:on_confirm].try(:call)
   end
@@ -33,7 +34,8 @@ class Promiscuous::AMQP::Fake
   end
 
   def get_next_payload
-    JSON.parse(get_next_message[:payload])
+    msg = get_next_message
+    msg && JSON.parse(msg[:payload])
   end
 
   def open_queue(options={}, &block)

data/lib/promiscuous/amqp/hot_bunnies.rb

@@ -7,13 +7,19 @@ class Promiscuous::AMQP::HotBunnies < Promiscuous::AMQP::Bunny
 
   # TODO auto reconnect
 
-  def new_connection
-    connection = ::HotBunnies.connect(:uri => Promiscuous::Config.amqp_url,
-                                      :heartbeat_interval => Promiscuous::Config.heartbeat,
-                                      :connection_timeout => Promiscuous::Config.socket_timeout)
+  def raw_new_connection(options={})
+    ::HotBunnies.connect(:uri => options[:url],
+                         :heartbeat_interval => Promiscuous::Config.heartbeat,
+                         :connection_timeout => Promiscuous::Config.socket_timeout)
+  end
+
+  def raw_confirm_select(channel, &callback)
+    channel.add_confirm_listener(&callback)
+    channel.confirm_select
+  end
 
-    channel = connection.create_channel
-    [connection, channel]
+  def raw_publish(options={})
+    options[:exchange].publish(options[:payload], :routing_key => options[:key], :persistent => true)
   end
 
   def disconnect
@@ -29,20 +35,24 @@ class Promiscuous::AMQP::HotBunnies < Promiscuous::AMQP::Bunny
     !!@connection.try(:is_open)
   end
 
-  def raw_publish(options={})
-    @exchange.publish(options[:payload], :routing_key => options[:key], :persistent => true)
-  end
-
-  def confirm_select(channel, &callback)
-    channel.add_confirm_listener(&callback)
-    channel.confirm_select
-  end
-
   module Subscriber
     include Promiscuous::AMQP::Bunny::Subscriber
 
     def subscribe_queue(queue, &block)
-      queue.subscribe(:ack => true, :blocking => false, &block)
+      queue.subscribe(:ack => true, :blocking => false) do |metadata, payload|
+        block.call(MetaData.new(self, metadata), payload)
+      end
+    end
+
+    class MetaData < Promiscuous::AMQP::Bunny::Subscriber::MetaData
+      def initialize(subscriber, metadata)
+        @subscriber = subscriber
+        @metadata = metadata
+      end
+
+      def ack
+        @metadata.ack
+      end
     end
 
     def disconnect

data/lib/promiscuous/amqp/null.rb

@@ -10,6 +10,7 @@ class Promiscuous::AMQP::Null
   end
 
   def publish(options={})
+    options[:on_confirm].try(:call)
   end
 
   def open_queue(options={}, &block)

data/lib/promiscuous/amqp.rb

@@ -2,8 +2,8 @@ module Promiscuous::AMQP
   extend Promiscuous::Autoload
   autoload :HotBunnies, :Bunny, :Null, :Fake
 
-  PUB_EXCHANGE = ENV['PUB_EXCHANGE'] || 'promiscuous'
-  SUB_EXCHANGE = ENV['SUB_EXCHANGE'] || 'promiscuous'
+  LIVE_EXCHANGE      = 'promiscuous'
+  BOOTSTRAP_EXCHANGE = 'promiscuous.bootstrap'
 
   class << self
     attr_accessor :backend
@@ -12,21 +12,16 @@ module Promiscuous::AMQP
     def backend=(value)
       disconnect
       @backend_class = value.nil? ? nil : "Promiscuous::AMQP::#{value.to_s.camelize.gsub(/amqp/, 'AMQP')}".constantize
-      connect if @backend_class
     end
 
-    def lost_connection_exception
-      Promiscuous::Error::Connection.new(:service => :amqp)
+    def lost_connection_exception(options={})
+      Promiscuous::Error::Connection.new(Promiscuous::Config.publisher_amqp_url, options)
     end
 
     def ensure_connected
-      raise lost_connection_exception unless connected?
-    end
+      Promiscuous.ensure_connected
 
-    def publish(options={})
-      ensure_connected
-      Promiscuous.debug "[publish] #{options[:key]} -> #{options[:payload]}"
-      backend.respond_to?(:async) ? backend.async.publish(options) : backend.publish(options)
+      raise lost_connection_exception unless connected?
     end
 
     def connect
@@ -42,7 +37,12 @@ module Promiscuous::AMQP
       @backend = nil
     end
 
-    delegate :connected?, :to => :backend
+    def new_connection(*args)
+      ensure_connected
+      backend.new_connection(*args)
+    end
+
+    delegate :publish, :connected?, :to => :backend
 
     def const_missing(sym)
       backend_class.const_get(sym)

data/lib/promiscuous/cli.rb

@@ -18,7 +18,7 @@ class Promiscuous::CLI
           print_status  '----[ Pending Dependencies ]----' + '-' * (100-32)
           blocked_messages.reverse_each { |msg| print_status msg }
         end
-        print_status  '-' * 80
+        print_status  '-' * 100
       end
     end
   end
@@ -26,11 +26,14 @@ class Promiscuous::CLI
   def trap_exit_signals
     %w(SIGTERM SIGINT).each do |signal|
       Signal.trap(signal) do
-        exit 1 if @stop
         print_status "Exiting..."
-        @worker.try(:stop)
-        @worker = nil
-        @stop = true
+        if @stop
+          @worker.try(:show_stop_status)
+        else
+          @stop = true
+          @worker.try(:stop)
+          @worker = nil
+        end
       end
     end
   end
@@ -46,7 +49,7 @@ class Promiscuous::CLI
       title = criteria.name
       title = "#{title}#{' ' * [0, 20 - title.size].max}"
       bar = ProgressBar.create(:format => '%t |%b>%i| %c/%C %e', :title => title, :total => criteria.count)
-      criteria.unscoped.each do |doc|
+      criteria.each do |doc|
         break if @stop
         Promiscuous.context("cli/sync") { doc.promiscuous.sync }
         bar.increment
@@ -84,13 +87,25 @@ class Promiscuous::CLI
       end
     end
 
-    puts "Replayed #{@num_msg} messages"
+    print_status "Replayed #{@num_msg} messages"
+  end
+
+  def bootstrap
+    phase = options[:criterias][0].to_sym
+    raise "Subscriber bootstrap must be one of [setup|run|finalize|status]" unless [:setup, :run, :finalize, :status].include?(phase)
+    if phase == :setup && criteria = options[:bootstrap_criteria]
+      Promiscuous::Publisher::Bootstrap.setup(:models => eval(criteria).to_a)
+    else
+      Promiscuous::Publisher::Bootstrap.__send__(phase)
+    end
   end
 
   def subscribe
     @worker = Promiscuous::Subscriber::Worker.new
     @worker.start
-    print_status "Replicating..."
+    Promiscuous::Config.subscriber_threads.tap do |threads|
+      print_status "Replicating [#{threads} thread#{'s' if threads > 1}]..."
+    end
     sleep 0.2 until !@worker
   end
 
@@ -115,17 +130,18 @@ class Promiscuous::CLI
 
       opts.separator ""
       opts.separator "Actions:"
-      opts.separator "    promiscuous publish \"Model1.where(:updated_at.gt => 1.day.ago)\" Model2 Model3..."
+      opts.separator "    promiscuous publish \"Model1.where(:updated_at.gt => 1.day.ago)\" [Model2 Model3...]"
+      opts.separator "    promiscuous publisher_recovery"
       opts.separator "    promiscuous subscribe"
+      opts.separator "    promiscuous bootstrap phase"
       opts.separator "    promiscuous mocks"
       opts.separator "    promiscuous record logfile"
       opts.separator "    promiscuous replay logfile"
-      opts.separator "    promiscuous publisher_recovery"
       opts.separator ""
       opts.separator "Options:"
 
-      opts.on "-b", "--bareback", "Bareback mode aka no dependencies. Use with extreme caution" do
-        Promiscuous::Config.bareback = true
+      opts.on "-d", "--no-deps", "Skip dependency tracking (subscribe only option)" do
+        Promiscuous::Config.no_deps = true
       end
 
       opts.on "-l", "--require FILE", "File to require to load your app. Don't worry about it with rails" do |file|
@@ -149,9 +165,26 @@ class Promiscuous::CLI
         Promiscuous::Config.stats_interval = duration.to_f
       end
 
-      opts.on("-h", "--help", "Show this message") do
-        puts opts
-        exit
+      opts.on "-b", "--bootstrap [pass1|pass2]", "Run subscriber in bootstrap mode" do |mode|
+        mode = mode.to_sym
+        raise "Subscriber bootstrap must be run in pass1 or pass2 mode" unless [:pass1, :pass2].include?(mode)
+        Promiscuous::Config.bootstrap = mode.to_sym
+      end
+
+      opts.on "-t", "--threads [NUM]", "Number of subscriber worker threads to run. Defaults to 10." do |threads|
+        Promiscuous::Config.subscriber_threads = threads.to_i
+      end
+
+      opts.on "-c", "--criteria FILE", "Criteria to bootstrap a subset of data" do |criteria|
+        options[:bootstrap_criteria] = criteria
+      end
+
+      opts.on "-D", "--daemonize", "Daemonize process" do
+        options[:daemonize] = true
+      end
+
+      opts.on "-P", "--pid-file [pid_file]", "Set a pid-file" do |pid_file|
+        options[:pid_file] = pid_file
       end
 
       opts.on("-V", "--version", "Show version") do
@@ -167,12 +200,15 @@ class Promiscuous::CLI
     options[:action] = args.shift.try(:to_sym)
     options[:criterias] = args
     options[:log_file] = args.first
+    options[:publisher_bootstrap] = args.first
 
     case options[:action]
-    when :publish   then raise "Please specify one or more criterias" unless options[:criterias].present?
-    when :subscribe then raise "Why are you specifying a criteria?"   if     options[:criterias].present?
-    when :record    then raise "Please specify a log file to record"  unless options[:log_file].present?
-    when :replay    then raise "Please specify a log file to replay"  unless options[:log_file].present?
+    when :publish             then raise "Please specify one or more criterias" unless options[:criterias].present?
+    when :subscribe           then raise "Why are you specifying a criteria?"   if     options[:criterias].present?
+    when :bootstrap           then raise "You must specify one of [setup|start|finalize]" unless options[:criterias].present?
+    when :record              then raise "Please specify a log file to record"  unless options[:log_file].present?
+    when :replay              then raise "Please specify a log file to replay"  unless options[:log_file].present?
+    when :publisher_bootstrap then raise "Please specify 'on' or 'off'" unless options[:publisher_bootstrap].present?
     when :publisher_recovery
     when :mocks
     else puts parser; exit 1
@@ -203,28 +239,33 @@ class Promiscuous::CLI
 
   def boot
     self.options = parse_args(ARGV)
+    daemonize if options[:daemonize]
+    write_pid if options[:pid_file]
     load_app
-    show_bareback_warnings
     run
   end
 
+  def daemonize
+    Process.daemon(true)
+  end
+
+  def write_pid
+    File.open(options[:pid_file], 'w') do |f|
+      f.puts Process.pid
+    end
+  end
+
   def run
     trap_signals
     case options[:action]
     when :publish   then publish
     when :subscribe then subscribe
+    when :bootstrap then bootstrap
     when :record    then record
     when :replay    then replay
     when :mocks     then generate_mocks
-    when :publisher_recovery then publisher_recovery
-    end
-  end
-
-  def show_bareback_warnings
-    if Promiscuous::Config.bareback == true
-      print_status "WARNING: --- BAREBACK MODE ----"
-      print_status "WARNING: You are replicating without protection, you can get out of sync in no time"
-      print_status "WARNING: --- BAREBACK MODE ----"
+    when :publisher_recovery  then publisher_recovery
+    when :publisher_bootstrap then set_publisher_bootstrap
     end
   end
 

data/lib/promiscuous/config.rb

@@ -1,9 +1,11 @@
 module Promiscuous::Config
-  mattr_accessor :app, :logger, :error_notifier, :backend, :amqp_url,
-                 :redis_url, :redis_urls, :redis_slave_url, :redis_stats_url,
-                 :stats_interval, :queue_options, :heartbeat, :bareback,
-                 :hash_size, :recovery, :prefetch, :recovery_timeout,
-                 :socket_timeout, :subscriber_threads
+  mattr_accessor :app, :bootstrap, :bootstrap_chunk_size, :backend, :amqp_url,
+                 :publisher_amqp_url, :subscriber_amqp_url, :publisher_exchange,
+                 :subscriber_exchanges, :queue_name, :queue_options, :redis_url,
+                 :redis_urls, :redis_stats_url, :stats_interval,
+                 :socket_timeout, :heartbeat, :no_deps, :hash_size, :recovery,
+                 :prefetch, :recovery_timeout, :logger, :subscriber_threads,
+                 :version_field, :error_notifier, :recovery_on_boot
 
   def self.backend=(value)
     @@backend = value
@@ -31,36 +33,45 @@ module Promiscuous::Config
   def self._configure(&block)
     block.call(self) if block
 
-    self.app              ||= Rails.application.class.parent_name.underscore rescue nil if defined?(Rails)
-    self.amqp_url         ||= 'amqp://guest:guest@localhost:5672'
-    self.redis_url        ||= 'redis://localhost/'
-    self.redis_urls       ||= [self.redis_url]
-    #self.redis_slave_url  ||= nil
-    self.redis_stats_url  ||= self.redis_urls.first
-    self.stats_interval   ||= 0
-    self.socket_timeout   ||= 10
-    self.backend          ||= best_amqp_backend
-    self.queue_options    ||= {:durable => true, :arguments => {'x-ha-policy' => 'all'}}
-    self.heartbeat        ||= 60
-    self.bareback         ||= false
-    self.hash_size        ||= 2**20 # one million keys ~ 200Mb.
-    self.recovery         ||= false
-    self.prefetch         ||= 1000
-    self.recovery_timeout ||= 10
-    self.logger           ||= defined?(Rails) ? Rails.logger : Logger.new(STDERR).tap { |l| l.level = Logger::WARN }
-    self.subscriber_threads ||= 10
+    self.app                  ||= Rails.application.class.parent_name.underscore rescue nil if defined?(Rails)
+    self.bootstrap            ||= false
+    self.bootstrap_chunk_size ||= 10000
+    self.backend              ||= best_amqp_backend
+    self.amqp_url             ||= 'amqp://guest:guest@localhost:5672'
+    self.publisher_amqp_url   ||= self.amqp_url
+    self.subscriber_amqp_url  ||= self.amqp_url
+    self.publisher_exchange   ||= Promiscuous::AMQP::LIVE_EXCHANGE
+    self.subscriber_exchanges ||= [Promiscuous::AMQP::LIVE_EXCHANGE]
+    self.queue_name           ||= "#{self.app}.promiscuous"
+    self.queue_options        ||= {:durable => true, :arguments => {'x-ha-policy' => 'all'}}
+    self.redis_url            ||= 'redis://localhost/'
+    self.redis_urls           ||= [self.redis_url]
+    # TODO self.redis_slave_url ||= nil
+    self.redis_stats_url      ||= self.redis_urls.first
+    self.stats_interval       ||= 0
+    self.socket_timeout       ||= 10
+    self.heartbeat            ||= 60
+    self.no_deps              ||= false
+    self.hash_size            ||= 2**20 # one million keys ~ 200Mb.
+    self.recovery             ||= false
+    self.prefetch             ||= self.bootstrap ? 10000000 : 1000
+    self.recovery_timeout     ||= 10
+    self.logger               ||= defined?(Rails) ? Rails.logger : Logger.new(STDERR).tap { |l| l.level = Logger::WARN }
+    self.subscriber_threads   ||= 10
+    self.error_notifier       ||= proc {}
+    self.version_field        ||= '_v'
+    self.recovery_on_boot     = true if self.recovery_on_boot.nil?
   end
 
   def self.configure(&block)
-    self._configure(&block)
+    reconnect_if_connected do
+      self._configure(&block)
 
-    unless self.app
-      raise "Promiscuous.configure: please give a name to your app with \"config.app = 'your_app_name'\""
+      unless self.app
+        raise "Promiscuous.configure: please give a name to your app with \"config.app = 'your_app_name'\""
+      end
     end
 
-    # amqp connection is done in when setting the backend
-    Promiscuous::Redis.connect
-
     hook_fork
   end
 
@@ -71,6 +82,8 @@ module Promiscuous::Config
       alias_method :fork_without_promiscuous, :fork
 
       def fork(&block)
+        return fork_without_promiscuous(&block) unless Promiscuous.should_be_connected?
+
         Promiscuous.disconnect
         pid = if block
           fork_without_promiscuous do
@@ -97,4 +110,16 @@ module Promiscuous::Config
   def self.configured?
     self.app != nil
   end
+
+  private
+
+  def self.reconnect_if_connected(&block)
+    if Promiscuous.should_be_connected?
+      Promiscuous.disconnect
+      yield
+      Promiscuous.connect
+    else
+      yield
+    end
+  end
 end

data/lib/promiscuous/convenience.rb

@@ -3,7 +3,7 @@ module Promiscuous::Convenience
 
   def without_promiscuous
     raise "No block given" unless block_given?
-    old_disabled, Promiscuous.disabled = Promiscuous.disabled, true
+    old_disabled, Promiscuous.disabled = Promiscuous.disabled?, true
     yield
   ensure
     Promiscuous.disabled = old_disabled

data/lib/promiscuous/dependency.rb

@@ -1,9 +1,14 @@
 require 'fnv'
 
 class Promiscuous::Dependency
-  attr_accessor :internal_key, :version
+  attr_accessor :internal_key, :version, :type
 
   def initialize(*args)
+    options = args.extract_options!
+    @type = options[:type]
+    @owner = options[:owner]
+    @dont_hash = options[:dont_hash]
+
     @internal_key = args.join('/')
 
     if @internal_key =~ /^[0-9]+$/
@@ -16,10 +21,24 @@ class Promiscuous::Dependency
         # We hash dependencies to have a O(1) memory footprint in Redis.
         # The hashing needs to be deterministic across instances in order to
         # function properly.
-        @internal_key = @hash % Promiscuous::Config.hash_size.to_i
-        @hash = @internal_key
+        @hash = @hash % Promiscuous::Config.hash_size.to_i
+        @internal_key = @hash unless @dont_hash
       end
     end
+
+    if @owner
+      @internal_key = "#{@owner}:#{@internal_key}"
+    end
+  end
+
+  def read?
+    raise "Type not set" unless @type
+    @type == :read
+  end
+
+  def write?
+    raise "Type not set" unless @type
+    @type == :write
   end
 
   def key(role)
@@ -35,10 +54,10 @@ class Promiscuous::Dependency
     @version ? [@internal_key, @version].join(':') : @internal_key
   end
 
-  def self.parse(payload)
+  def self.parse(payload, options={})
     case payload
-    when /^(.+):([0-9]+)$/ then new($1).tap { |d| d.version = $2.to_i }
-    when /^(.+)$/          then new($1)
+    when /^(.+):([0-9]+)$/ then new($1, options).tap { |d| d.version = $2.to_i }
+    when /^(.+)$/          then new($1, options)
     end
   end