amqp 0.7.5 → 0.8.0.beta1

data/examples/issues/issue_94.rb

@@ -1,23 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require "bundler"
-Bundler.setup
-
-$:.unshift(File.expand_path("../../../lib", __FILE__))
-
-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/pingpong.rb

@@ -1,54 +0,0 @@
-# encoding: utf-8
-
-$:.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
-
-  def log(*args)
-    p [ Time.now, *args ]
-  end
-
-  # AMQP.logging = true
-
-  amq = AMQP::Channel.new
-  EM.add_periodic_timer(1) {
-    puts
-
-    log :sending, 'ping'
-    amq.queue('one').publish('ping')
-  }
-
-  amq = AMQP::Channel.new
-  amq.queue('one').subscribe { |msg|
-    log 'one', :received, msg, :sending, 'pong'
-    amq.queue('two').publish('pong')
-  }
-
-  amq = AMQP::Channel.new
-  amq.queue('two').subscribe { |msg|
-    log 'two', :received, msg
-  }
-
-end
-
-__END__
-
-[Sun Jul 20 03:52:24 -0700 2008, :sending, "ping"]
-[Sun Jul 20 03:52:24 -0700 2008, "one", :received, "ping", :sending, "pong"]
-[Sun Jul 20 03:52:24 -0700 2008, "two", :received, "pong"]
-
-[Sun Jul 20 03:52:25 -0700 2008, :sending, "ping"]
-[Sun Jul 20 03:52:25 -0700 2008, "one", :received, "ping", :sending, "pong"]
-[Sun Jul 20 03:52:25 -0700 2008, "two", :received, "pong"]
-
-[Sun Jul 20 03:52:26 -0700 2008, :sending, "ping"]
-[Sun Jul 20 03:52:26 -0700 2008, "one", :received, "ping", :sending, "pong"]
-[Sun Jul 20 03:52:26 -0700 2008, "two", :received, "pong"]

data/examples/pop.rb

@@ -1,45 +0,0 @@
-# encoding: utf-8
-
-$:.unshift(File.expand_path("../../lib", __FILE__))
-require 'amqp'
-require 'pp'
-
-Signal.trap('INT') { AMQP.stop { EM.stop } }
-Signal.trap('TERM') { AMQP.stop { EM.stop } }
-
-AMQP.start do
-  queue = AMQP::Channel.queue('awesome')
-
-  queue.publish('Totally rad 1')
-  queue.publish('Totally rad 2')
-  EM.add_timer(5) { queue.publish('Totally rad 3') }
-
-  queue.pop { |msg|
-    unless msg
-      # queue was empty
-      p [Time.now, :queue_empty!]
-
-      # try again in 1 second
-      EM.add_timer(1) { queue.pop }
-    else
-      # process this message
-      p [Time.now, msg]
-
-      # get the next message in the queue
-      queue.pop
-    end
-  }
-end
-
-__END__
-
-[Wed Oct 15 15:24:30 -0700 2008, "Totally rad 1"]
-[Wed Oct 15 15:24:30 -0700 2008, "Totally rad 2"]
-[Wed Oct 15 15:24:30 -0700 2008, :queue_empty!]
-[Wed Oct 15 15:24:31 -0700 2008, :queue_empty!]
-[Wed Oct 15 15:24:32 -0700 2008, :queue_empty!]
-[Wed Oct 15 15:24:33 -0700 2008, :queue_empty!]
-[Wed Oct 15 15:24:34 -0700 2008, :queue_empty!]
-[Wed Oct 15 15:24:35 -0700 2008, "Totally rad 3"]
-[Wed Oct 15 15:24:35 -0700 2008, :queue_empty!]
-[Wed Oct 15 15:24:36 -0700 2008, :queue_empty!]

data/examples/primes-simple.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-MAX = 1000
-
-class Fixnum
-  def prime?
-    ('1' * self) !~ /^1?$|^(11+?)\1+$/
-  end
-end
-
-class PrimeChecker
-  def is_prime? number
-    number.prime?
-  end
-end
-
-prime_checker = PrimeChecker.new
-
-(10_000...(10_000+MAX)).each do |n|
-  prime_checker.is_prime? n
-end

data/examples/primes.rb

@@ -1,101 +0,0 @@
-# encoding: utf-8
-
-$:.unshift(File.expand_path("../../lib", __FILE__))
-require 'amqp'
-
-# check MAX numbers for prime-ness
-MAX = 1000
-
-# logging
-def log(*args)
-  p args
-end
-
-# spawn workers
-workers = ARGV[0] ? (Integer(ARGV[0]) rescue 1) : 1
-AMQP.fork(workers) do
-
-  log AMQP::Channel.id, :started
-
-  class Fixnum
-    def prime?
-      ('1' * self) !~ /^1?$|^(11+?)\1+$/
-    end
-  end
-
-  class PrimeChecker
-    def is_prime? number
-      log "prime checker #{AMQP::Channel.id}", :prime?, number
-      number.prime?
-    end
-  end
-
-  AMQP::Channel.rpc('prime checker', PrimeChecker.new)
-
-end
-
-# use workers to check which numbers are prime
-AMQP.start(:host => 'localhost') do
-
-  prime_checker = AMQP::Channel.rpc('prime checker')
-
-  (10_000...(10_000+MAX)).each do |num|
-    log :checking, num
-
-    prime_checker.is_prime?(num) { |is_prime|
-      log :prime?, num, is_prime
-      (@primes||=[]) << num if is_prime
-
-      if (@responses = (@responses || 0) + 1) == MAX
-        log :primes=, @primes
-        EM.stop_event_loop
-      end
-    }
-
-  end
-
-end
-
-__END__
-
-$ uname -a
-Linux gc 2.6.24-ARCH #1 SMP PREEMPT Sun Mar 30 10:50:22 CEST 2008 x86_64 Intel(R) Xeon(R) CPU X3220 @ 2.40GHz GenuineIntel GNU/Linux
-
-$ cat /proc/cpuinfo | grep processor | wc -l
-4
-
-$ time ruby primes-simple.rb
-
-real  0m16.055s
-user  0m16.052s
-sys 0m0.000s
-
-$ time ruby primes.rb 1 >/dev/null
-
-real  0m18.278s
-user  0m0.993s
-sys 0m0.027s
-
-$ time ruby primes.rb 2 >/dev/null
-
-real  0m17.316s
-user  0m0.967s
-sys 0m0.053s
-
-$ time ruby primes.rb 4 >/dev/null
-
-real  0m8.229s
-user  0m1.010s
-sys 0m0.030s
-
-$ time ruby primes.rb 8 >/dev/null
-
-real  0m5.893s
-user  0m1.023s
-sys 0m0.050s
-
-$ time ruby primes.rb 16 >/dev/null
-
-real  0m5.601s
-user  0m0.990s
-sys 0m0.043s

data/examples/simple.rb

@@ -1,81 +0,0 @@
-# encoding: utf-8
-
-$:.unshift(File.expand_path("../../lib", __FILE__))
-require 'amqp'
-
-module SimpleClient
-  def process_frame(frame)
-    case frame
-    when Frame::Body
-      EM.stop_event_loop
-
-    when Frame::Method
-      case method = frame.payload
-      when Protocol::Connection::Start
-        send Protocol::Connection::StartOk.new({:platform => 'Ruby/EventMachine',
-                                                :product => 'AMQP',
-                                                :information => 'http://github.com/ruby-amqp/amqp',
-                                                :version => '0.1.0'},
-                                               'AMQPLAIN',
-                                               {:LOGIN => 'guest',
-                                                :PASSWORD => 'guest'},
-                                               'en_US')
-
-      when Protocol::Connection::Tune
-        send Protocol::Connection::TuneOk.new(:channel_max => 0,
-                                              :frame_max => 131072,
-                                              :heartbeat => 0)
-
-        send Protocol::Connection::Open.new(:virtual_host => '/',
-                                            :capabilities => '',
-                                            :insist => false)
-
-      when Protocol::Connection::OpenOk
-        send Protocol::Channel::Open.new, :channel => 1
-
-      when Protocol::Channel::OpenOk
-        send Protocol::Access::Request.new(:realm => '/data',
-                                           :read => true,
-                                           :write => true,
-                                           :active => true), :channel => 1
-
-      when Protocol::Access::RequestOk
-        @ticket = method.ticket
-        send Protocol::Queue::Declare.new(:ticket => @ticket,
-                                          :queue => '',
-                                          :exclusive => false,
-                                          :auto_delete => true), :channel => 1
-
-      when Protocol::Queue::DeclareOk
-        @queue = method.queue
-        send Protocol::Queue::Bind.new(:ticket => @ticket,
-                                       :queue => @queue,
-                                       :exchange => '',
-                                       :routing_key => 'test_route'), :channel => 1
-
-      when Protocol::Queue::BindOk
-        send Protocol::Basic::Consume.new(:ticket => @ticket,
-                                          :queue => @queue,
-                                          :no_local => false,
-                                          :no_ack => true), :channel => 1
-
-      when Protocol::Basic::ConsumeOk
-        data = "this is a test!"
-
-        send Protocol::Basic::Publish.new(:ticket => @ticket,
-                                          :exchange => '',
-                                          :routing_key => 'test_route'), :channel => 1
-        send Protocol::Header.new(Protocol::Basic, data.length, :content_type => 'application/octet-stream',
-                                                                :delivery_mode => 1,
-                                                                :priority => 0), :channel => 1
-        send Frame::Body.new(data), :channel => 1
-      end
-    end
-  end
-end
-
-EM.run {
-  AMQP.logging = true
-  AMQP.client = SimpleClient
-  AMQP.start
-}

data/examples/stocks.rb

@@ -1,67 +0,0 @@
-# encoding: utf-8
-
-$:.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
-
-  def log(*args)
-    p [ Time.now, *args ]
-  end
-
-  def publish_stock_prices
-    mq = AMQP::Channel.new
-    EM.add_periodic_timer(1) {
-      puts
-
-      { :appl => 170+rand(1000)/100.0,
-        :msft => 22+rand(500)/100.0
-      }.each do |stock, price|
-        stock = "usd.#{stock}"
-
-        log :publishing, stock, price
-        mq.topic('stocks').publish(price, :key => stock)
-      end
-    }
-  end
-
-  def watch_appl_stock
-    mq = AMQP::Channel.new
-    mq.queue('apple stock').bind(mq.topic('stocks'), :key => 'usd.appl').subscribe { |price|
-      log 'apple stock', price
-    }
-  end
-
-  def watch_us_stocks
-    mq = AMQP::Channel.new
-    mq.queue('us stocks').bind(mq.topic('stocks'), :key => 'usd.*').subscribe { |info, price|
-      log 'us stock', info.routing_key, price
-    }
-  end
-
-  publish_stock_prices
-  watch_appl_stock
-  watch_us_stocks
-
-end
-
-__END__
-
-[Fri Aug 15 01:39:00 -0700 2008, :publishing, "usd.appl", 173.45]
-[Fri Aug 15 01:39:00 -0700 2008, :publishing, "usd.msft", 26.98]
-[Fri Aug 15 01:39:00 -0700 2008, "apple stock", "173.45"]
-[Fri Aug 15 01:39:00 -0700 2008, "us stock", "usd.appl", "173.45"]
-[Fri Aug 15 01:39:00 -0700 2008, "us stock", "usd.msft", "26.98"]
-
-[Fri Aug 15 01:39:01 -0700 2008, :publishing, "usd.appl", 179.72]
-[Fri Aug 15 01:39:01 -0700 2008, :publishing, "usd.msft", 26.56]
-[Fri Aug 15 01:39:01 -0700 2008, "apple stock", "179.72"]
-[Fri Aug 15 01:39:01 -0700 2008, "us stock", "usd.appl", "179.72"]
-[Fri Aug 15 01:39:01 -0700 2008, "us stock", "usd.msft", "26.56"]

data/gemfiles/eventmachine-pre

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-source :rubygems
-
-# Use local clones if possible.
-# If you want to use your local copy, just symlink it to vendor.
-def custom_gem(name, options = Hash.new)
-  local_path = File.expand_path("../vendor/#{name}", __FILE__)
-  if File.exist?(local_path)
-    gem name, options.merge(:path => local_path).delete_if { |key, _| [:git, :branch].include?(key) }
-  else
-    gem name, options
-  end
-end
-
-
-gem "eventmachine", "~> 1.0.0.beta3"
-
-group(:test) do
-  gem "rspec", ">=2.0.0"
-  gem "rake"
-  # gem "amqp-spec", :git => "git://github.com/ruby-amqp/amqp-spec.git", :branch => "master"
-  custom_gem "evented-spec", :git => "git://github.com/ruby-amqp/evented-spec.git", :branch => "master"
-end

data/lib/amqp/buffer.rb

@@ -1,272 +0,0 @@
-# encoding: utf-8
-
-if [].map.respond_to? :with_index
-  class Array #:nodoc:
-    def enum_with_index
-      each.with_index
-    end
-  end
-else
-  require 'enumerator'
-end
-
-module AMQP
-  class Buffer #:nodoc: all
-    class Overflow < StandardError; end
-    class InvalidType < StandardError; end
-
-    def initialize(data = '')
-      @data = data
-      @pos = 0
-    end
-
-    attr_reader :pos
-
-    def data
-      @data.clone
-    end
-    alias :contents :data
-    alias :to_s :data
-
-    def << data
-      @data << data.to_s
-      self
-    end
-
-    def length
-      @data.bytesize
-    end
-
-    def empty?
-      pos == length
-    end
-
-    def rewind
-      @pos = 0
-    end
-
-    def read_properties(*types)
-      types.shift if types.first == :properties
-
-      i = 0
-      values = []
-
-      while props = read(:short)
-        (0..14).each do |n|
-          # no more property types
-          break unless types[i]
-
-          # if flag is set
-          if props & (1 << (15-n)) != 0
-            if types[i] == :bit
-              # bit values exist in flags only
-              values << true
-            else
-              # save type name for later reading
-              values << types[i]
-            end
-          else
-            # property not set or is false bit
-            values << (types[i] == :bit ? false : nil)
-          end
-
-          i += 1
-        end
-
-        # bit(0) == 0 means no more property flags
-        break unless props & 1 == 1
-      end
-
-      values.map do |value|
-        value.is_a?(Symbol) ? read(value) : value
-      end
-    end
-
-    def read(*types)
-      if types.first == :properties
-        return read_properties(*types)
-      end
-
-      values = types.map do |type|
-        case type
-        when :octet
-          _read(1, 'C')
-        when :short
-          _read(2, 'n')
-        when :long
-          _read(4, 'N')
-        when :longlong
-          upper, lower = _read(8, 'NN')
-          upper << 32 | lower
-        when :shortstr
-          _read read(:octet)
-        when :longstr
-          _read read(:long)
-        when :timestamp
-          Time.at read(:longlong)
-        when :table
-          t = Hash.new
-
-          table = Buffer.new(read(:longstr))
-          until table.empty?
-            key, type = table.read(:shortstr, :octet)
-            key = key.intern
-            t[key] ||= case type
-                       when 83 # 'S'
-                         table.read(:longstr)
-                       when 73 # 'I'
-                         table.read(:long)
-                       when 68 # 'D'
-                         exp = table.read(:octet)
-                         num = table.read(:long)
-                         num / 10.0**exp
-                       when 84 # 'T'
-                         table.read(:timestamp)
-                       when 70 # 'F'
-                         table.read(:table)
-                       end
-          end
-
-          t
-        when :bit
-          if (@bits ||= []).empty?
-            val = read(:octet)
-            @bits = (0..7).map { |i| (val & 1 << i) != 0 }
-          end
-
-          @bits.shift
-        else
-          raise InvalidType, "Cannot read data of type #{type}"
-        end
-      end
-
-      types.size == 1 ? values.first : values
-    end
-
-    def write(type, data)
-      case type
-      when :octet
-        _write(data, 'C')
-      when :short
-        _write(data, 'n')
-      when :long
-        _write(data, 'N')
-      when :longlong
-        lower =  data & 0xffffffff
-        upper = (data & ~0xffffffff) >> 32
-        _write([upper, lower], 'NN')
-      when :shortstr
-        data = (data || '').to_s
-        _write([data.bytesize, data], 'Ca*')
-      when :longstr
-        if data.is_a? Hash
-          write(:table, data)
-        else
-          data = (data || '').to_s
-          _write([data.bytesize, data], 'Na*')
-        end
-      when :timestamp
-        write(:longlong, data.to_i)
-      when :table
-        data ||= {}
-        write :longstr, (data.inject(Buffer.new) do |table, (key, value)|
-                          table.write(:shortstr, key.to_s)
-
-                          case value
-                          when String
-                            table.write(:octet, 83) # 'S'
-                            table.write(:longstr, value.to_s)
-                          when Fixnum
-                            table.write(:octet, 73) # 'I'
-                            table.write(:long, value)
-                          when Float
-                            table.write(:octet, 68) # 'D'
-                            # XXX there's gotta be a better way to do this..
-                            exp = value.to_s.split('.').last.bytesize
-                            num = value * 10**exp
-                            table.write(:octet, exp)
-                            table.write(:long, num)
-                          when Time
-                            table.write(:octet, 84) # 'T'
-                            table.write(:timestamp, value)
-                          when Hash
-                            table.write(:octet, 70) # 'F'
-                            table.write(:table, value)
-                          end
-
-                          table
-                        end)
-      when :bit
-        [*data].to_enum(:each_slice, 8).each { |bits|
-          write(:octet, bits.enum_with_index.inject(0) { |byte, (bit, i)|
-            byte |= 1 << i if bit
-            byte
-           })
-         }
-      when :properties
-        values = []
-        data.enum_with_index.inject(0) do |short, ((type, value), i)|
-          n = i % 15
-          last = i+1 == data.size
-
-          if (n == 0 and i != 0) or last
-            if data.size > i+1
-              short |= 1 << 0
-            elsif last and value
-              values << [type, value]
-              short |= 1 << (15-n)
-            end
-
-            write(:short, short)
-            short = 0
-          end
-
-          if value and !last
-            values << [type, value]
-            short |= 1 << (15-n)
-          end
-
-          short
-        end
-
-        values.each do |type, value|
-          write(type, value) unless type == :bit
-        end
-      else
-        raise InvalidType, "Cannot write data of type #{type}"
-      end
-
-      self
-    end
-
-    def extract
-      begin
-        cur_data, cur_pos = @data.clone, @pos
-        yield self
-      rescue Overflow
-        @data, @pos = cur_data, cur_pos
-        nil
-      end
-    end
-
-    def _read(size, pack = nil)
-      if @pos + size > length
-        raise Overflow
-      else
-        data = @data[@pos, size]
-        @data[@pos, size] = ''
-        if pack
-          data = data.unpack(pack)
-          data = data.pop if data.size == 1
-        end
-        data
-      end
-    end
-
-    def _write(data, pack = nil)
-      data = [*data].pack(pack) if pack
-      @data[@pos, 0] = data
-      @pos += data.bytesize
-    end
-  end
-end