amqp 0.8.0.rc13 → 0.8.0.rc14

data/examples/inspecting_server_information.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+
+require 'amqp'
+
+EventMachine.run do
+  AMQP.connect(:host => '127.0.0.1') do |connection|
+    puts
+    puts "Connected to #{connection.hostname}:#{connection.port}/#{connection.vhost}"
+    puts
+    puts "Client properties:"
+    puts
+    puts connection.client_properties.inspect
+
+    puts "Server properties:"
+    puts
+    puts connection.server_properties.inspect
+
+    puts "Server capabilities:"
+    puts
+    puts connection.server_capabilities.inspect
+
+    puts "Broker product: #{connection.broker.product}, version: #{connection.broker.version}"
+    puts "Connected to RabbitMQ? #{connection.broker.rabbitmq?}"
+
+    puts
+    puts "Broker supports publisher confirms? #{connection.broker.supports_publisher_confirmations?}"
+
+    puts
+    puts "Broker supports basic.nack? #{connection.broker.supports_basic_nack?}"
+
+    puts
+    puts "Broker supports consumer cancel notifications? #{connection.broker.supports_consumer_cancel_notifications?}"
+
+    puts
+    puts "Broker supports exchange-to-exchange bindings? #{connection.broker.supports_exchange_to_exchange_bindings?}"
+
+    connection.disconnect { EventMachine.stop }
+  end # AMQP.connect
+end # EventMachine.run

data/examples/issues/issue_93.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "rubygems"
+require 'amqp'
+
+puts "Running amqp gem #{AMQP::VERSION}"
+
+
+AMQP.start("amqp://guest:guest@localhost:5672") do |connection, open_ok|
+  ch = AMQP::Channel.new(connection)
+  ch.direct("amqpgem.issues.93.1")
+  ch.direct("amqpgem.issues.93.2", :auto_delete => false)
+  ch.direct("amqpgem.issues.93.3") do |ex, declare_ok|
+  end
+  ch.direct("amqpgem.issues.93.4", :auto_delete => false) do |ex, declare_ok|
+  end
+  ch.direct("amqpgem.issues.93.5", :auto_delete => true)
+  ch.direct("amqpgem.issues.93.6", :auto_delete => true) do |ex, declare_ok|
+  end
+
+  puts "Done"
+end

data/examples/issues/issue_94.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+if defined?(Bundler)
+  Bundler.setup
+else
+  require "rubygems"
+end
+require "amqp"
+
+puts "Running amqp gem #{AMQP::VERSION}"
+
+AMQP.start(:host => '127.0.0.1') do |connection|
+  channel  = AMQP::Channel.new(connection)
+  exchange = channel.direct("")
+  queue    = channel.queue("indexer_queue", { :durable => true })
+
+  EM.add_periodic_timer(1) {
+    queue.status do |num_messages, num_consumers|
+      puts "msgs:#{num_messages}"
+    end
+  }
+end

data/examples/patterns/command/consumer.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+$LOAD_PATH.unshift File.expand_path("../../../../lib", __FILE__)
+
+require "amqp"
+require "yaml"
+
+t = Thread.new { EventMachine.run }
+sleep(0.5)
+
+
+connection = AMQP.connect
+channel    = AMQP::Channel.new(connection, :auto_recovery => true)
+
+channel.prefetch(1)
+
+# Acknowledgements are good for letting the server know
+# that the task is finished. If the consumer doesn't send
+# the acknowledgement, then the task is considered to be unfinished
+# and will be requeued when consumer closes AMQP connection (because of a crash, for example).
+channel.queue("amqpgem.examples.patterns.command", :durable => true, :auto_delete => false).subscribe(:ack => true) do |metadata, payload|
+  case metadata.type
+  when "gems.install"
+    data = YAML.load(payload)
+    puts "[gems.install] Received a 'gems.install' request with #{data.inspect}"
+
+    # just to demonstrate a realistic example
+    shellout = "gem install #{data[:gem]} --version '#{data[:version]}'"
+    puts "[gems.install] Executing #{shellout}"; system(shellout)
+
+    puts
+    puts "[gems.install] Done"
+    puts
+  else
+    puts "[commands] Unknown command: #{metadata.type}"
+  end
+
+  # message is processed, acknowledge it so that broker discards it
+  metadata.ack
+end
+
+puts "[boot] Ready"
+Signal.trap("INT") { connection.close { EventMachine.stop } }
+t.join
+

data/examples/patterns/command/producer.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+$LOAD_PATH.unshift File.expand_path("../../../../lib", __FILE__)
+
+require "amqp"
+require "yaml"
+
+t = Thread.new { EventMachine.run }
+sleep(0.5)
+
+connection = AMQP.connect
+channel    = AMQP::Channel.new(connection)
+
+# publish new commands every 3 seconds
+EventMachine.add_periodic_timer(10.0) do
+  puts "Publishing a command (gems.install)"
+  payload = { :gem => "rack", :version => "~> 1.3.0" }.to_yaml
+
+  channel.default_exchange.publish(payload,
+                                   :type        => "gems.install",
+                                   :routing_key => "amqpgem.examples.patterns.command")
+end
+
+puts "[boot] Ready. Will be publishing commands every 10 seconds."
+Signal.trap("INT") { connection.close { EventMachine.stop } }
+t.join

data/examples/patterns/request_reply/client.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+$LOAD_PATH.unshift File.expand_path("../../../../lib", __FILE__)
+
+require "amqp"
+
+EventMachine.run do
+  connection = AMQP.connect
+  channel    = AMQP::Channel.new(connection)
+
+  replies_queue = channel.queue("", :exclusive => true, :auto_delete => true)
+  replies_queue.subscribe do |metadata, payload|
+    puts "[response] Response for #{metadata.correlation_id}: #{payload.inspect}"
+  end
+
+  # request time from a peer every 3 seconds
+  EventMachine.add_periodic_timer(3.0) do
+    puts "[request] Sending a request..."
+    channel.default_exchange.publish("get.time",
+                                     :routing_key => "amqpgem.examples.services.time",
+                                     :message_id  => Kernel.rand(10101010).to_s,
+                                     :reply_to    => replies_queue.name,
+                                     :immediate   => true)
+  end
+
+
+
+  Signal.trap("INT") { connection.close { EventMachine.stop } }
+end

data/examples/patterns/request_reply/server.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+$LOAD_PATH.unshift File.expand_path("../../../../lib", __FILE__)
+
+require "amqp"
+
+EventMachine.run do
+  connection = AMQP.connect
+  channel    = AMQP::Channel.new(connection)
+
+  requests_queue = channel.queue("amqpgem.examples.services.time", :exclusive => true, :auto_delete => true)
+  requests_queue.subscribe(:ack => true) do |metadata, payload|
+    puts "[requests] Got a request #{metadata.message_id}. Sending a reply..."
+    channel.default_exchange.publish(Time.now.to_s,
+                                     :routing_key    => metadata.reply_to,
+                                     :correlation_id => metadata.message_id,
+                                     :immediate      => true,
+                                     :mandatory      => true)
+
+    metadata.ack
+  end
+
+
+
+  Signal.trap("INT") { connection.close { EventMachine.stop } }
+end

data/examples/publishing/publishing_a_one_off_message.rb

@@ -24,11 +24,13 @@ EventMachine.run do
     connection.close { EventMachine.stop }
   end
 
-  queue    = channel.queue("some_topic", :auto_delete => true)
-  exchange = channel.topic("foo", :durable => true, :auto_delete => true)
+  # topic exchange is used just as example. Often it is more convenient to use default exchange,
+  # see http://bit.ly/amqp-gem-default-exchange
+  exchange = channel.topic("a.topic", :durable => true, :auto_delete => true)
+  queue    = channel.queue("a.queue", :auto_delete => true).bind(exchange, :routing_key => "events.#")
 
-  exchange.publish('hello world', :routing_key => "some_topic", :persistent => true, :nowait => false ) do
-    puts 'About to disconnect'
+  exchange.publish('hello world', :routing_key => "events.hits.homepage", :persistent => true, :nowait => false) do
+    puts "About to disconnect..."
     connection.close { EventMachine.stop }
   end
 end

data/examples/publishing/returned_messages.rb

@@ -8,13 +8,7 @@ $:.unshift(File.expand_path("../../../lib", __FILE__))
 
 require 'amqp'
 
-if RUBY_VERSION == "1.8.7"
-  class Array
-    alias sample choice
-  end
-end
-
-puts "=> Handling message returns"
+puts "=> Handling returned messages"
 puts
 
 AMQP.start(:host => '127.0.0.1') do |connection|
@@ -33,8 +27,6 @@ AMQP.start(:host => '127.0.0.1') do |connection|
   }
 
   EventMachine.add_timer(2) {
-    connection.close {
-      EventMachine.stop
-    }
+    connection.close { EventMachine.stop }
   }
 end

data/examples/queues/accessing_message_metadata.rb

@@ -16,7 +16,7 @@ EventMachine.run do
   queue    = channel.queue("amqpgem.examples.hello_world", :auto_delete => true)
   exchange = channel.direct("amq.direct")
 
-  queue.bind(exchange)
+  queue.bind(exchange, :routing_key => "amqpgem.key")
 
   channel.on_error do |ch, channel_close|
     puts channel_close.reply_text
@@ -30,25 +30,26 @@ EventMachine.run do
     puts "metadata.headers     : #{metadata.headers.inspect}"
     puts "metadata.timestamp   : #{metadata.timestamp.inspect}"
     puts "metadata.type        : #{metadata.type}"
+    puts "metadata.consumer_tag: #{metadata.consumer_tag}"
     puts "metadata.delivery_tag: #{metadata.delivery_tag}"
-    puts "metadata.redelivered : #{metadata.redelivered}"
+    puts "metadata.redelivered : #{metadata.redelivered?}"
 
-    puts "metadata.app_id      : #{metadata.app_id}"
-    puts "metadata.exchange    : #{metadata.exchange}"
+    puts "metadata.app_id        : #{metadata.app_id}"
+    puts "metadata.correlation_id: #{metadata.correlation_id}"
+    puts "metadata.exchange      : #{metadata.exchange}"
     puts
     puts "Received a message: #{payload}. Disconnecting..."
 
-    connection.close {
-      EventMachine.stop { exit }
-    }
+    connection.close { EventMachine.stop }
   end
 
-  exchange.publish("Hello, world!",
-                   :app_id      => "amqpgem.example",
-                   :priority    => 8,
-                   :type        => "kinda.checkin",
+  exchange.publish("Hey, what a great view!",
+                   :app_id         => "amqpgem.example",
+                   :priority       => 8,
+                   :type           => "kinda.checkin",
+                   :correlation_id => "b907b65a4876fc0d4b12fbdef1b41fb0a9876a94",
                    # headers table keys can be anything
-                   :headers     => {
+                   :headers        => {
                      :coordinates => {
                        :latitude  => 59.35,
                        :longitude => 18.066667
@@ -56,5 +57,6 @@ EventMachine.run do
                      :participants => 11,
                      :venue        => "Stockholm"
                    },
-                   :timestamp   => Time.now.to_i)
+                   :timestamp   => Time.now.to_i,
+                   :routing_key => "amqpgem.key")
 end

data/examples/queues/queue_status.rb

@@ -11,36 +11,33 @@ require 'amqp'
 puts "=> Queue#status example"
 puts
 AMQP.start(:host => 'localhost') do |connection|
-  channel   = AMQP::Channel.new
+  channel   = AMQP::Channel.new(connection)
 
   queue_name = "amqpgem.integration.queue.status.queue"
+  exchange   = channel.fanout("amqpgem.integration.queue.status.fanout", :auto_delete => true)
+  queue      = channel.queue(queue_name, :auto_delete => true).bind(exchange)
 
-  exchange = channel.fanout("amqpgem.integration.queue.status.fanout", :auto_delete => true)
-  queue    = channel.queue(queue_name, :auto_delete => true)
-
-  queue.bind(exchange) do
-    puts "Bound #{exchange.name} => #{queue.name}"
-  end
   100.times do |i|
     print "."
     exchange.publish(Time.now.to_i.to_s + "_#{i}", :key => queue_name)
   end
   $stdout.flush
 
-  sleep 1
-
-  queue.status do |number_of_messages, number_of_consumers|
-    puts "# of messages on status = #{number_of_messages}"
+  EventMachine.add_timer(0.5) do
+    queue.status do |number_of_messages, number_of_consumers|
+      puts
+      puts "# of messages on status = #{number_of_messages}"
+      puts
+      queue.purge
+    end
   end
 
 
   show_stopper = Proc.new do
     $stdout.puts "Stopping..."
-    connection.close {
-      EM.stop { exit }
-    }
+    connection.close { EventMachine.stop }
   end
 
   Signal.trap "INT", show_stopper
-  EM.add_timer(2, show_stopper)
+  EventMachine.add_timer(2, show_stopper)
 end

data/examples/routing/fanout_routing.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../../lib", __FILE__))
+
+require "amqp"
+
+EventMachine.run do
+  AMQP.connect("amqp://dev.rabbitmq.com") do |connection|
+    channel  = AMQP::Channel.new(connection)
+    exchange = channel.topic("amqpgem.examples.routing.fanout_routing", :auto_delete => true)
+
+    # Subscribers.
+    10.times do
+      q = channel.queue("", :exclusive => true, :auto_delete => true).bind(exchange)
+      q.subscribe do |payload|
+        puts "Queue #{q.name} received #{payload}"
+      end
+    end
+
+    # Publish some test data in a bit, after all queues are declared & bound
+    EventMachine.add_timer(1.2) { exchange.publish "Hello, fanout exchanges world!" }
+
+
+    show_stopper = Proc.new { connection.close { EventMachine.stop } }
+
+    Signal.trap "TERM", show_stopper
+    EM.add_timer(3, show_stopper)
+  end
+end

data/examples/routing/headers_routing.rb

@@ -18,35 +18,37 @@ AMQP.start do |connection|
 
   exchange = channel.headers("amq.match", :durable => true)
 
-  channel.queue("", :auto_delete => true).bind(exchange, :arguments => { 'x-match' => 'all', :arch => "x64", :os => 'linux' }).subscribe do |metadata, payload|
-    puts "[linux/x64] Got a message: #{payload}"
+  channel.queue("", :auto_delete => true).bind(exchange, :arguments => { 'x-match' => 'all', :arch => "ia64", :os => 'linux' }).subscribe do |metadata, payload|
+    puts "[linux/ia64] Got a message: #{payload}"
   end
-  channel.queue("", :auto_delete => true).bind(exchange, :arguments => { 'x-match' => 'all', :arch => "x32", :os => 'linux' }).subscribe do |metadata, payload|
-    puts "[linux/x32] Got a message: #{payload}"
+  channel.queue("", :auto_delete => true).bind(exchange, :arguments => { 'x-match' => 'all', :arch => "x86", :os => 'linux' }).subscribe do |metadata, payload|
+    puts "[linux/x86] Got a message: #{payload}"
   end
-  channel.queue("", :auto_delete => true).bind(exchange, :arguments => { 'x-match' => 'any', :os => 'linux', :arch => "__any__" }).subscribe do |metadata, payload|
+  channel.queue("", :auto_delete => true).bind(exchange, :arguments => { :os => 'linux'}).subscribe do |metadata, payload|
     puts "[linux] Got a message: #{payload}"
   end
   channel.queue("", :auto_delete => true).bind(exchange, :arguments => { 'x-match' => 'any', :os => 'macosx', :cores => 8 }).subscribe do |metadata, payload|
     puts "[macosx|octocore] Got a message: #{payload}"
   end
-
+  channel.queue("", :auto_delete => true).bind(exchange, :arguments => { :package => { :name => 'riak', :version => '0.14.2' } }).subscribe do |metadata, payload|
+    puts "[riak/0.14.2] Got a message: #{payload}"
+  end
 
   EventMachine.add_timer(0.5) do
-    exchange.publish "For linux/x64",   :headers => { :arch => "x64", :os => 'linux' }
-    exchange.publish "For linux/x32",   :headers => { :arch => "x32", :os => 'linux' }
-    exchange.publish "For linux",       :headers => { :os => 'linux'  }
-    exchange.publish "For OS X",        :headers => { :os => 'macosx' }
-    exchange.publish "For solaris/x64", :headers => { :os => 'solaris', :arch => 'x64' }
-    exchange.publish "For ocotocore",   :headers => { :cores => 8  }
+    exchange.publish "For linux/ia64",   :headers => { :arch => "ia64", :os => 'linux' }
+    exchange.publish "For linux/x86",    :headers => { :arch => "x86", :os => 'linux'  }
+    exchange.publish "For linux",        :headers => { :os => 'linux'  }
+    exchange.publish "For OS X",         :headers => { :os => 'macosx' }
+    exchange.publish "For solaris/ia64", :headers => { :os => 'solaris', :arch => 'ia64' }
+    exchange.publish "For ocotocore",    :headers => { :cores => 8  }
+
+    exchange.publish "For nodes with Riak 0.14.2", :headers => { :package => { :name => 'riak', :version => '0.14.2' } }
   end
 
 
   show_stopper = Proc.new do
     $stdout.puts "Stopping..."
-    connection.close {
-      EventMachine.stop { exit }
-    }
+    connection.close { EventMachine.stop }
   end
 
   Signal.trap "INT", show_stopper