amqp 0.7.5 → 0.8.0.beta1

data/examples/extensions/rabbitmq/publisher_confirmations_with_transient_messages.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../../../lib", __FILE__))
+require 'amqp'
+require "amqp/extensions/rabbitmq"
+
+AMQP.start do |connection|
+  puts "Connected!"
+  AMQP::Channel.new(connection) do |channel|
+    puts "Channel #{channel.id} is now open"
+
+    channel.confirmations
+    channel.on_error do
+      puts "Oops, there is a channel-levle exceptions!"
+    end
+
+
+    channel.confirm do |basic_ack|
+      puts "Received basic_ack: multiple = #{basic_ack.multiple}, delivery_tag = #{basic_ack.delivery_tag}"
+    end
+
+    x = channel.fanout("amq.fanout")
+    channel.queue("", :auto_delete => true) do |q|
+      puts "Declared a new server-named qeueue: #{q.name}"
+
+      q.bind(x, :no_ack => true).subscribe(:ack => true) do |header, payload|
+        puts "Received #{payload}"
+      end
+    end
+
+    EventMachine.add_timer(0.5) do
+      10.times do |i|
+        puts "Publishing message ##{i}"
+        x.publish("Message ##{i}")
+      end
+    end
+  end
+
+  show_stopper = Proc.new {
+    AMQP.stop do
+      EM.stop
+    end
+  }
+
+
+  EM.add_timer(3, show_stopper)
+  Signal.trap('INT',  show_stopper)
+  Signal.trap('TERM', show_stopper)
+end

data/examples/hello_world.rb

@@ -0,0 +1,29 @@
+#!/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 => 'localhost') do |connection|
+    puts "Connected to AMQP broker"
+
+    channel  = AMQP::Channel.new(connection)
+    queue    = channel.queue("amqpgem.examples.hello_world")
+    exchange = channel.default_exchange
+
+    queue.subscribe do |payload|
+      puts "Received a message: #{payload}. Disconnecting..."
+
+      connection.close {
+        EM.stop { exit }
+      }
+    end
+
+    exchange.publish "Hello, world!", :routing_key => queue.name
+  end  
+end

data/examples/real-world/task-queue/README.textile

@@ -0,0 +1,3 @@
+h1. Task Queue
+
+In task queue we have only one queue with many consumers (for example servers which will run given task)

data/examples/real-world/task-queue/consumer.rb

@@ -0,0 +1,27 @@
+# encoding: utf - 8
+
+$LOAD_PATH.unshift File.expand_path("../../../../lib", __FILE__)
+
+require "amqp"
+
+# Imagine we have for example 10 servers, on each of them runs this
+# script, just the server_name variable will be different on each of them.
+server_name = "server - 1"
+
+AMQP.start do
+  amq = AMQP::Channel.new
+
+  # Tasks distribution has to be based on load on each clients rather
+  # than on the number of distributed messages. (The default behaviour
+  # is to dispatches every n - th message to the n - th consumer.
+  amq.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.
+  amq.queue(server_name).subscribe(:ack => true) do |h, message|
+    puts message
+    puts system(message)
+    h.ack
+  end
+end

data/examples/real-world/task-queue/producer.rb

@@ -0,0 +1,22 @@
+# encoding: utf - 8
+
+$LOAD_PATH.unshift File.expand_path("../../../../lib", __FILE__)
+
+require "amqp"
+
+# Imagine the command is something
+# CPU - intensive like image processing.
+command = "sleep 0.1"
+
+AMQP.start(port: 1112) do
+  amq = AMQP::Channel.new
+  exchange = amq.direct("tasks")
+  queue = amq.queue("tasks")
+
+  # And this is user - input simulation,
+  # which can be a user uploading an image.
+  EM.add_periodic_timer(1) do
+    puts "~ publishing #        {command}"
+    exchange.publish(command, :routing_key => "tasks")
+  end
+end

data/examples/various/ack.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../../lib", __FILE__))
+require 'amqp'
+
+
+AMQP.start do |connection|
+  puts "Connected!"
+  channel = AMQP::Channel.new(connection)
+  e       = channel.fanout("amqp-gem.examples.ack")
+  q       = channel.queue('amqp-gem.examples.q1').bind(e) { puts "Bound #{e.name} to the queue" }
+
+  q.status do |message_count, consumer_count|
+    puts "Queue #{q.name} has #{message_count} messages and #{consumer_count} consumers"
+  end
+
+  i = 0
+
+  # Stopping after the second item was acked will keep the 3rd item in the queue
+  q.subscribe(:ack => true) do |h, m|
+    puts "Got a message"
+
+    if AMQP.closing?
+      puts "#{m} (ignored, redelivered later)"
+    else
+      puts m
+      h.ack
+    end
+  end # channel.queue
+
+
+  10.times do |i|
+    puts "Publishing message ##{i}"
+    e.publish("Totally rad #{i}")
+  end
+
+
+  show_stopper = Proc.new {
+    q.status do |message_count, consumer_count|
+      puts "Queue #{q.name} has #{message_count} messages and #{consumer_count} consumers"
+    end
+
+    q.unbind(e) do
+      puts "Unbound #{q.name} from #{e.name}"
+
+      e.delete do
+        puts "Just deleted #{e.name}"
+      end
+
+      q.delete do
+        puts "Just deleted #{q.name}"
+        AMQP.stop do
+          puts "About to stop EM reactor"
+          EM.stop
+        end
+      end
+    end
+  }
+
+  EM.add_timer(3, show_stopper)
+
+  # For ack to work appropriately you must shutdown AMQP gracefully,
+  # otherwise all items in your queue will be returned
+  Signal.trap('INT',  show_stopper)
+  Signal.trap('TERM', show_stopper)
+end # AMQP.start

data/examples/various/automatic_binding_for_default_direct_exchange.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../../lib", __FILE__))
+
+require 'amqp'
+
+if RUBY_VERSION == "1.8.7"
+  class Array
+   alias sample choice
+  end
+end
+
+puts "=> Default exchange example"
+puts
+AMQP.start(:host => 'localhost') do |connection|
+  ch        = AMQP::Channel.new(connection)
+
+  queue1    = ch.queue("queue1").subscribe do |payload|
+    puts "[#{queue1.name}] => #{payload}"
+  end
+  queue2    = ch.queue("queue2").subscribe do |payload|
+    puts "[#{queue2.name}] => #{payload}"
+  end
+  queue3    = ch.queue("queue3").subscribe do |payload|
+    puts "[#{queue3.name}] => #{payload}"
+  end
+  queues    = [queue1, queue2, queue3]
+
+  # Rely on default direct exchange binding, see section 2.1.2.4 Automatic Mode in AMQP 0.9.1 spec.
+  exchange = AMQP::Exchange.default
+  EM.add_periodic_timer(1) do
+    q = queues.sample
+
+    $stdout.puts "Publishing to default exchange with routing key = #{q.name}..."
+    exchange.publish "Some payload from #{Time.now.to_i}", :routing_key => q.name
+  end
+
+
+  show_stopper = Proc.new do
+    $stdout.puts "Stopping..."
+    connection.close {
+      EM.stop { exit }
+    }
+  end
+
+  Signal.trap "INT",  &show_stopper
+  Signal.trap "TERM", &show_stopper
+  EM.add_timer(7, show_stopper)
+end

data/examples/various/basic_get.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift(File.expand_path("../../../lib", __FILE__))
+
+require 'amqp'
+
+if RUBY_VERSION == "1.8.7"
+  class Array
+    alias sample choice
+  end
+end
+
+
+puts "=> basic.get example"
+puts
+AMQP.start(:host => 'localhost') do |connection|
+  channel   = AMQP::Channel.new
+  
+  queue_name = "amqpgem.integration.basic.get.queue"
+  expected_number_of_messages = 50
+  
+  exchange = channel.fanout("amqpgem.integration.basic.get.fanout", :auto_delete => true)
+  queue    = channel.queue(queue_name, :auto_delete => true)
+  
+  queue.bind(exchange) do
+    puts "Bound #{exchange.name} => #{queue.name}"
+  end
+  expected_number_of_messages.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}"
+  end
+
+  queue.status do |number_of_messages, number_of_consumers|
+    puts "# of messages on status = #{number_of_messages}"
+    expected_number_of_messages.times do
+      queue.pop do |headers, payload|
+        puts "=> With payload #{payload.inspect}, routing key: #{headers.routing_key}, #{headers.message_count} message(s) left in the queue"
+      end # pop
+    end
+  end
+
+
+  show_stopper = Proc.new do
+    $stdout.puts "Stopping..."
+    # now change this to just EM.stop and it
+    # unbinds instantly
+    connection.close {
+      EM.stop { exit }
+    }
+  end
+
+  Signal.trap "INT", show_stopper
+  EM.add_timer(2, show_stopper)
+end

data/examples/various/callbacks.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "amqp"
+
+AMQP.start(:host => "localhost") do |connection|
+
+  # Send Connection.Close on Ctrl+C
+  trap(:INT) do
+    unless connection.closing?
+      connection.close { exit! }
+    end
+  end
+
+  @counter = 0
+  amq = AMQP::Channel.new
+
+  amq.prefetch(64, false) do
+    puts "basic.qos callback has fired"
+  end
+
+  amq.recover do
+    puts "basic.recover callback has fired"
+  end
+
+  10.times do
+    amq.queue("") do |queue|
+      puts "Queue #{queue.name} is now declared."
+      puts "All queues: #{amq.queues.map { |q| q.name }.join(', ')}"
+
+      @counter += 1
+    end
+  end
+
+  EM.add_timer(0.3) do
+    connection.disconnect do
+      puts "AMQP connection is now closed."
+      EM.stop
+    end
+  end
+end

data/examples/various/clock.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require "bundler"
+Bundler.setup
+Bundler.require :default
+
+$:.unshift(File.expand_path("../../../lib", __FILE__))
+require 'amqp'
+
+puts "=> Clock example"
+puts
+AMQP.start(:host => 'localhost') do |connection|
+  puts "Connected!"
+
+  def log(*args)
+    p args
+  end
+
+  # AMQP.logging = true
+
+  channel = AMQP::Channel.new(connection)
+  puts "Channel #{channel.id} is now open"
+  producer   = channel.fanout('clock')
+  EM.add_periodic_timer(1) {
+    puts
+
+    log :publishing, time = Time.now
+    producer.publish(Marshal.dump(time))
+  }
+
+  channel2 = AMQP::Channel.new(connection)
+  exchange = channel2.fanout('clock')
+
+  q1       = channel2.queue('every second')
+  q1.bind(exchange).subscribe(:confirm => proc { puts "Subscribed!" }) { |time|
+      log 'every second', :received, Marshal.load(time)
+  }
+
+  puts "channel #{channel2.id} consumer tags: #{channel2.consumers.keys.join(', ')}"
+
+  # channel3 = AMQP::Channel.new
+  channel3 = AMQP::Channel.new(connection)
+  q2 = channel3.queue('every 5 seconds')
+  q2.bind(exchange).subscribe { |time|
+    time = Marshal.load(time)
+    log 'every 5 seconds', :received, time if time.strftime('%S').to_i % 5 == 0
+  }
+
+  show_stopper = Proc.new {
+    q1.unbind(exchange)
+    q2.unbind(exchange) do
+      puts "Unbound #{q2.name}."
+
+      q1.purge do |message_count|
+        puts "Purged #{q1.name}, there were #{message_count} messages"
+        puts "Deleting #{q1.name}…"
+        q1.delete(:if_empty => true, :nowait => true)
+      end
+
+      q2.delete do |message_count|
+        puts "Deleted #{q2.name}. There were #{message_count} messages"
+      end
+
+      puts " About to close AMQP connection…"
+      connection.close { exit! } unless connection.closing?
+    end
+  }
+
+  Signal.trap "INT",  show_stopper
+  Signal.trap "TERM", show_stopper
+
+  EM.add_timer(7, show_stopper)
+end