fleck 2.2.1 → 2.2.3

data/examples/expired.rb

@@ -1,72 +1,72 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'fleck'
-
-user        = ENV['USER']        || 'guest'
-pass        = ENV['PASS']        || 'guest'
-
-CONCURRENCY = (ENV['CONCURRENCY'] || 2).to_i
-SAMPLES     = (ENV['SAMPLES']     || 10).to_i
-QUEUE       = 'expiration.example.queue'
-
-Fleck.configure do |config|
-  config.default_user = user
-  config.default_pass = pass
-  config.loglevel     = Logger::DEBUG
-end
-
-connection = Fleck.connection(host: '127.0.0.1', port: 5672, user: user, pass: pass, vhost: '/')
-client = Fleck::Client.new(connection, QUEUE, concurrency: CONCURRENCY.to_i)
-success_probability = 0.8
-
-count   = 0
-success = 0
-failure = 0
-
-mutex = Mutex.new
-lock  = Mutex.new
-condition = ConditionVariable.new
-
-class MyConsumer < Fleck::Consumer
-  configure queue: QUEUE, concurrency: CONCURRENCY.to_i
-
-  action :hello
-  def hello
-    sleep rand
-    ok! "#{params[:num] + 1}. Hello!"
-  end
-end
-
-SAMPLES.to_i.times do |num|
-  client.request(
-    action: 'hello',
-    params: { num: num },
-    async: true,
-    timeout: (success_probability * SAMPLES.to_f) / CONCURRENCY
-  ) do |request, response|
-    if request.expired?
-      puts "EXPIRED: #{response.inspect}"
-    elsif response.status == 200
-      puts "SUCCESS: #{response.body}"
-    else
-      puts "ERROR: #{response.inspect}"
-    end
-
-    mutex.synchronize do
-      count += 1
-      if response.status == 200
-        success += 1
-      else
-        failure += 1
-      end
-
-      lock.synchronize { condition.signal } if count >= SAMPLES
-    end
-  end
-end
-
-lock.synchronize { condition.wait(lock) }
-
-puts "Ztimer: (count: #{Ztimer.count}, jobs: #{Ztimer.jobs_count})"
-puts "Total: #{count}, Success: #{success}, Failure: #{failure}"
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fleck'
+
+user        = ENV['USER']        || 'guest'
+pass        = ENV['PASS']        || 'guest'
+
+CONCURRENCY = (ENV['CONCURRENCY'] || 2).to_i
+SAMPLES     = (ENV['SAMPLES']     || 10).to_i
+QUEUE       = 'expiration.example.queue'
+
+Fleck.configure do |config|
+  config.default_user = user
+  config.default_pass = pass
+  config.loglevel     = Logger::DEBUG
+end
+
+connection = Fleck.connection(host: '127.0.0.1', port: 5672, user: user, pass: pass, vhost: '/')
+client = Fleck::Client.new(connection, QUEUE, concurrency: CONCURRENCY.to_i)
+success_probability = 0.8
+
+count   = 0
+success = 0
+failure = 0
+
+mutex = Mutex.new
+lock  = Mutex.new
+condition = ConditionVariable.new
+
+class MyConsumer < Fleck::Consumer
+  configure queue: QUEUE, concurrency: CONCURRENCY.to_i
+
+  action :hello
+  def hello
+    sleep rand
+    ok! "#{params[:num] + 1}. Hello!"
+  end
+end
+
+SAMPLES.to_i.times do |num|
+  client.request(
+    action: 'hello',
+    params: { num: num },
+    async: true,
+    timeout: (success_probability * SAMPLES.to_f) / CONCURRENCY
+  ) do |request, response|
+    if request.expired?
+      puts "EXPIRED: #{response.inspect}"
+    elsif response.status == 200
+      puts "SUCCESS: #{response.body}"
+    else
+      puts "ERROR: #{response.inspect}"
+    end
+
+    mutex.synchronize do
+      count += 1
+      if response.status == 200
+        success += 1
+      else
+        failure += 1
+      end
+
+      lock.synchronize { condition.signal } if count >= SAMPLES
+    end
+  end
+end
+
+lock.synchronize { condition.wait(lock) }
+
+puts "Ztimer: (count: #{Ztimer.count}, jobs: #{Ztimer.jobs_count})"
+puts "Total: #{count}, Success: #{success}, Failure: #{failure}"

data/examples/fanout.rb

@@ -1,62 +1,62 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require 'fleck'
-
-user        = ENV['USER']        || 'guest'
-pass        = ENV['PASS']        || 'guest'
-
-CONCURRENCY = (ENV['CONCURRENCY'] || 10).to_i
-SAMPLES     = (ENV['SAMPLES']     || 1_000).to_i
-
-Fleck.configure do |config|
-  config.default_user = user
-  config.default_pass = pass
-  config.loglevel     = Logger::DEBUG
-end
-
-connection = Fleck.connection(host: "127.0.0.1", port: 5672, user: user, pass: pass, vhost: "/")
-client = Fleck::Client.new(connection, "example.queue", concurrency: CONCURRENCY.to_i, exchange_type: :fanout, exchange_name: 'fanout.example.queue', multiple_responses: true)
-
-count   = 0
-success = 0
-failure = 0
-
-mutex = Mutex.new
-lock  = Mutex.new
-condition = ConditionVariable.new
-
-class First < Fleck::Consumer
-  configure queue: "example.queue", concurrency: CONCURRENCY.to_i, exchange_type: :fanout, exchange_name: 'fanout.example.queue'
-
-  action :incr
-  def incr
-    if request.action == 'incr'
-      ok! "#{request.params[:num].to_i + 1}. Hello, World!"
-    else
-      not_found!
-    end
-  end
-end
-
-Thread.new do
-  SAMPLES.times do |i|
-    client.request(action: 'incr', params: { num: i }, timeout: 60) do |request, response|
-      request.logger.debug response.body
-      mutex.synchronize do
-        count += 1
-        if response.status == 200
-          success += 1
-        else
-          failure += 1
-        end
-
-        lock.synchronize { condition.signal } if count >= SAMPLES
-      end
-    end
-  end
-end
-
-lock.synchronize { condition.wait(lock) }
-
-puts "Total: #{count}, Success: #{success}, Failure: #{failure}"
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'fleck'
+
+user        = ENV['USER']        || 'guest'
+pass        = ENV['PASS']        || 'guest'
+
+CONCURRENCY = (ENV['CONCURRENCY'] || 10).to_i
+SAMPLES     = (ENV['SAMPLES']     || 1_000).to_i
+
+Fleck.configure do |config|
+  config.default_user = user
+  config.default_pass = pass
+  config.loglevel     = Logger::DEBUG
+end
+
+connection = Fleck.connection(host: "127.0.0.1", port: 5672, user: user, pass: pass, vhost: "/")
+client = Fleck::Client.new(connection, "example.queue", concurrency: CONCURRENCY.to_i, exchange_type: :fanout, exchange_name: 'fanout.example.queue', multiple_responses: true)
+
+count   = 0
+success = 0
+failure = 0
+
+mutex = Mutex.new
+lock  = Mutex.new
+condition = ConditionVariable.new
+
+class First < Fleck::Consumer
+  configure queue: "example.queue", concurrency: CONCURRENCY.to_i, exchange_type: :fanout, exchange_name: 'fanout.example.queue'
+
+  action :incr
+  def incr
+    if request.action == 'incr'
+      ok! "#{request.params[:num].to_i + 1}. Hello, World!"
+    else
+      not_found!
+    end
+  end
+end
+
+Thread.new do
+  SAMPLES.times do |i|
+    client.request(action: 'incr', params: { num: i }, timeout: 60) do |request, response|
+      request.logger.debug response.body
+      mutex.synchronize do
+        count += 1
+        if response.status == 200
+          success += 1
+        else
+          failure += 1
+        end
+
+        lock.synchronize { condition.signal } if count >= SAMPLES
+      end
+    end
+  end
+end
+
+lock.synchronize { condition.wait(lock) }
+
+puts "Total: #{count}, Success: #{success}, Failure: #{failure}"

data/lib/fleck/client.rb

@@ -1,124 +1,147 @@
-
-module Fleck
-  class Client
-    include Fleck::Loggable
-
-    attr_reader :local_ip, :remote_ip
-
-    def initialize(connection, queue_name = "", exchange_type: :direct, exchange_name: "", multiple_responses: false, concurrency: 1)
-      @connection         = connection
-      @queue_name         = queue_name
-      @multiple_responses = multiple_responses
-      @default_timeout    = multiple_responses ? 60 : nil
-      @concurrency        = [concurrency.to_i, 1].max
-      @requests           = ThreadSafe::Hash.new
-      @subscriptions      = ThreadSafe::Array.new
-      @terminated         = false
-      @mutex              = Mutex.new
-      @local_ip           = @connection.transport.socket.local_address.ip_address
-      @remote_ip          = @connection.transport.socket.remote_address.ip_address
-
-      @channel     = @connection.create_channel
-      @exchange    = Bunny::Exchange.new(@channel, :direct, 'fleck')
-      @publisher   = Bunny::Exchange.new(@connection.create_channel, exchange_type, exchange_name)
-      @reply_queue = @channel.queue("", exclusive: true, auto_delete: true)
-      @reply_queue.bind(@exchange, routing_key: @reply_queue.name)
-
-      handle_returned_messages!
-      @concurrency.times { handle_responses! }
-
-      logger.debug("Client initialized!")
-
-      at_exit do
-        terminate
-      end
-    end
-
-    def request(action: nil, version: nil, headers: {}, params: {}, async: @multiple_responses || false, timeout: @default_timeout, queue: @queue_name, rmq_options: {}, &block)
-
-      if @terminated
-        return Fleck::Client::Response.new(Oj.dump({status: 503, errors: ['Service Unavailable'], body: nil} , mode: :compat))
-      end
-
-      request = Fleck::Client::Request.new(
-        self, queue, @reply_queue.name,
-        action:             action,
-        version:            version,
-        headers:            headers,
-        params:             params,
-        timeout:            timeout,
-        multiple_responses: @multiple_responses,
-        rmq_options:        rmq_options,
-        &block
-      )
-
-      @requests[request.id] = request
-      request.send!(async)
-
-      return request.response
-    end
-
-
-    def publish(data, options)
-      return if @terminated
-      @mutex.synchronize { @publisher.publish(data, options) }
-    end
-
-
-    def remove_request(request_id)
-      @requests.delete request_id
-    end
-
-
-    def terminate
-      @terminated = true
-      logger.info "Unsubscribing from #{@reply_queue.name}"
-      @subscriptions.map(&:cancel) # stop receiving new messages
-      logger.info "Canceling pending requests"
-      # cancel pending requests
-      while item = @requests.shift do
-        begin
-          item[1].cancel!
-        rescue => e
-          logger.error e.inspect + "\n" + e.backtrace.join("\n")
-        end
-      end
-    end
-
-
-    protected
-
-    def handle_returned_messages!
-      @exchange.on_return do |return_info, metadata, content|
-        begin
-          logger.warn "Request #{metadata[:correlation_id]} returned"
-          request = @requests[metadata[:correlation_id]]
-          if request
-            request.cancel!
-          end
-        rescue => e
-          logger.error e.inspect + "\n" + e.backtrace.join("\n")
-        end
-      end
-    end
-
-    def handle_responses!
-      @subscriptions << @reply_queue.subscribe do |delivery_info, metadata, payload|
-        begin
-          logger.debug "Response received: #{payload}"
-          request = @requests[metadata[:correlation_id]]
-          if request
-            request.response = Fleck::Client::Response.new(payload)
-          else
-            logger.warn "Request #{metadata[:correlation_id]} not found!"
-          end
-        rescue => e
-          logger.error e.inspect + "\n" + e.backtrace.join("\n")
-        end
-      end
-    end
-  end
-end
-
-require "fleck/client/request"
-require "fleck/client/response"
+
+module Fleck
+  class Client
+    include Fleck::Loggable
+
+    @instances = ThreadSafe::Array.new
+
+    def self.<<(new_instance)
+      @instances << new_instance
+    end
+
+    def self.remove_instance(instance)
+      @instances.delete(instance)
+    end
+
+    def self.terminate_all
+      @instances.map(&:terminate)
+    end
+
+    attr_reader :local_ip, :remote_ip, :terminated
+
+    def initialize(connection, queue_name = "", exchange_type: :direct, exchange_name: "", multiple_responses: false, concurrency: 1)
+      @connection         = connection
+      @queue_name         = queue_name
+      @multiple_responses = multiple_responses
+      @default_timeout    = multiple_responses ? 60 : nil
+      @concurrency        = [concurrency.to_i, 1].max
+      @requests           = ThreadSafe::Hash.new
+      @subscriptions      = ThreadSafe::Array.new
+      @terminated         = false
+      @mutex              = Mutex.new
+      @local_ip           = @connection.transport.socket.local_address.ip_address
+      @remote_ip          = @connection.transport.socket.remote_address.ip_address
+
+      @channel     = @connection.create_channel
+      @exchange    = Bunny::Exchange.new(@channel, :direct, 'fleck')
+      @publisher   = Bunny::Exchange.new(@connection.create_channel, exchange_type, exchange_name)
+      @reply_queue = @channel.queue("", exclusive: true, auto_delete: true)
+      @reply_queue.bind(@exchange, routing_key: @reply_queue.name)
+
+      handle_returned_messages!
+      @concurrency.times { handle_responses! }
+
+      logger.debug("Client initialized!")
+
+      Fleck::Client << self
+
+      # at_exit do
+      #   terminate
+      # end
+    end
+
+    def request(action: nil, version: nil, headers: {}, params: {}, async: @multiple_responses || false, timeout: @default_timeout, queue: @queue_name, rmq_options: {}, &block)
+
+      if @terminated
+        return Fleck::Client::Response.new(Oj.dump({status: 503, errors: ['Service Unavailable'], body: nil} , mode: :compat))
+      end
+
+      request = Fleck::Client::Request.new(
+        self, queue, @reply_queue.name,
+        action:             action,
+        version:            version,
+        headers:            headers,
+        params:             params,
+        timeout:            timeout,
+        multiple_responses: @multiple_responses,
+        rmq_options:        rmq_options,
+        &block
+      )
+
+      @requests[request.id] = request
+      request.send!(async)
+
+      return request.response
+    end
+
+
+    def publish(data, options)
+      return if @terminated
+      @mutex.synchronize { @publisher.publish(data, options) }
+    end
+
+
+    def remove_request(request_id)
+      @requests.delete request_id
+    end
+
+
+    def terminate
+      @terminated = true
+      logger.info "Unsubscribing from #{@reply_queue.name}"
+      # @subscriptions.map(&:cancel) # stop receiving new messages
+      @channel&.close unless @channel&.closed?
+      logger.info "Canceling pending requests"
+      # cancel pending requests
+      while item = @requests.shift do
+        begin
+          item[1].cancel!
+        rescue => e
+          logger.error e.inspect + "\n" + e.backtrace.join("\n")
+        end
+      end
+
+      Fleck::Client.remove_instance(self)
+    end
+
+
+    protected
+
+    def handle_returned_messages!
+      @exchange.on_return do |return_info, metadata, content|
+        begin
+          logger.warn "Request #{metadata[:correlation_id]} returned"
+          request = @requests[metadata[:correlation_id]]
+          if request
+            request.cancel!
+          end
+        rescue => e
+          logger.error e.inspect + "\n" + e.backtrace.join("\n")
+        end
+      end
+    end
+
+    def handle_responses!
+      @subscriptions << @reply_queue.subscribe do |delivery_info, metadata, payload|
+        begin
+          logger.debug "Response received: #{payload}"
+          request = @requests[metadata[:correlation_id]]
+          if request
+            request.response = Fleck::Client::Response.new(payload)
+          else
+            logger.warn "Request #{metadata[:correlation_id]} not found!"
+          end
+        rescue => e
+          logger.error e.inspect + "\n" + e.backtrace.join("\n")
+        end
+      end
+    end
+  end
+end
+
+at_exit do
+  Fleck::Client.terminate_all
+end
+
+require 'fleck/client/request'
+require 'fleck/client/response'