fleck 2.2.1 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db2ce9b82ecb8b531a9bddabc20b2eee9619358bcc7d2914954936a1de838d04
-  data.tar.gz: f74fff714edfca1e30c106031909a7d0bcef90535858c7e5abc04019b6f3c2f2
+  metadata.gz: 0d362b6a20a242296ef0697d57c31503067df64d05b3cee439f58449a7dbe732
+  data.tar.gz: 76f4a6b22cdfdff8a9826702073eae8866751e4c5446c1d7fdd1aaecd6341655
 SHA512:
-  metadata.gz: 79c6e83ca6f93e1377df5aaa318c22a650ccbd970120d490f60bd39316a19682a1638691794bd05acdc4a3cd95396e4f5553110c5df8f654ce727233e912c252
-  data.tar.gz: 7052ed477e244d917977e1872f089bc3d5e9f5b2e612e6e4bb5e77cb5e6883530e0fdf1c0f75e0502bb0756ef1669c53341198fc67e21f81134ce61026207984
+  metadata.gz: 794a481e65666fa6ac3be6bd7014d0a20a54819849f2be83402950778de70d24728d3bd283a1fb71332504acb501fe7323e315dbcf9f20f4fe8c229e74120611
+  data.tar.gz: 42c5b8f0dd478e595d47bde2250a5d01d4b81414ad9670288a1098bb6f7168b71949a8401e848b3f6d2e4d163d23babb70259695ccaa7314fad962b9084a0b1f

data/.gitignore

@@ -1,11 +1,11 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-/*.gem
-/.rubocop.yml
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/*.gem
+/.rubocop.yml

data/Gemfile

@@ -1,6 +1,6 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in fleck.gemspec
-gemspec
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fleck.gemspec
+gemspec

data/examples/actions.rb

@@ -1,60 +1,60 @@
-#!/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       = 'actions.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)
-
-class MyConsumer < Fleck::Consumer
-  configure queue: QUEUE, concurrency: CONCURRENCY.to_i
-
-  action 'hello', "An action which returns 'Hello'"
-  def hello
-    ok! result: 'Hello', message: 'Ciao'
-  end
-
-  action 'ciao', "An action which returns 'Ciao'"
-  param :world, type: 'boolean', required: true, default: false
-  def my_custom_method
-    ok! params[:world] ? 'Ciao, Mondo!' : 'Ciao!'
-  end
-
-  action :aloha
-  param :number, type: 'integer', clamp: [1, 10], required: true
-  param :name, type: 'string', default: 'John Doe', required: true
-  def my_aloha
-    ok! "#{params[:number]}. Aloha, #{params[:name]}!"
-  end
-
-  def not_an_action
-    logger.warn("I'm not an action, so you should not be able to call me!")
-  end
-end
-
-actions = %i[hello ciao aloha not_an_action]
-
-SAMPLES.to_i.times do |num|
-  action = actions.sample
-  name = ['John Doe', 'Willie Wonka', 'Billie Smith'].sample
-  client.request(action: action, params: { num: num, name: name, number: rand * 100, world: %w[yes no].sample }, timeout: 5) do |_, response|
-    if response.status == 200
-      Fleck.logger.info "ACTION: (#{action.inspect}) #{response.body.inspect}"
-    else
-      Fleck.logger.error "ACTION: (#{action.inspect}) #{response.errors.join(', ')} --- #{response.body.inspect}"
-    end
-  end
-end
+#!/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       = 'actions.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)
+
+class MyConsumer < Fleck::Consumer
+  configure queue: QUEUE, concurrency: CONCURRENCY.to_i
+
+  action 'hello', "An action which returns 'Hello'"
+  def hello
+    ok! result: 'Hello', message: 'Ciao'
+  end
+
+  action 'ciao', "An action which returns 'Ciao'"
+  param :world, type: 'boolean', required: true, default: false
+  def my_custom_method
+    ok! params[:world] ? 'Ciao, Mondo!' : 'Ciao!'
+  end
+
+  action :aloha
+  param :number, type: 'integer', clamp: [1, 10], required: true
+  param :name, type: 'string', default: 'John Doe', required: true
+  def my_aloha
+    ok! "#{params[:number]}. Aloha, #{params[:name]}!"
+  end
+
+  def not_an_action
+    logger.warn("I'm not an action, so you should not be able to call me!")
+  end
+end
+
+actions = %i[hello ciao aloha not_an_action]
+
+SAMPLES.to_i.times do |num|
+  action = actions.sample
+  name = ['John Doe', 'Willie Wonka', 'Billie Smith'].sample
+  client.request(action: action, params: { num: num, name: name, number: rand * 100, world: %w[yes no].sample }, timeout: 5) do |_, response|
+    if response.status == 200
+      Fleck.logger.info "ACTION: (#{action.inspect}) #{response.body.inspect}"
+    else
+      Fleck.logger.error "ACTION: (#{action.inspect}) #{response.errors.join(', ')} --- #{response.body.inspect}"
+    end
+  end
+end

data/examples/blocking_consumer.rb

@@ -1,42 +1,42 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require 'fleck'
-
-user        = ENV['USER']        || 'guest'
-pass        = ENV['PASS']        || 'guest'
-
-CONCURRENCY = (ENV['CONCURRENCY'] || 2).to_i
-SAMPLES     = (ENV['SAMPLES']     || 10).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, "blocking.consumer.example.queue")
-
-class MyConsumer < Fleck::Consumer
-  configure queue: 'blocking.consumer.example.queue', autostart: false
-  actions :quit
-
-  initialize do
-    @value = "MY CONSUMER :) #{object_id}"
-  end
-
-  def quit
-    logger.debug "Quit message received, but I'm goint to sleep for 2 seconds ..."
-    sleep 2
-    logger.debug "Let's terminate this example!"
-    Ztimer.async { self.class.terminate }
-  end
-end
-
-client.request(action: 'quit', timeout: 5, async: true)
-
-MyConsumer.start(block: true)
-
-puts "We did it :)"
-sleep 0.01 # Give some time to Bunny to cancel subscribtions and to close channels and connections
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'fleck'
+
+user        = ENV['USER']        || 'guest'
+pass        = ENV['PASS']        || 'guest'
+
+CONCURRENCY = (ENV['CONCURRENCY'] || 2).to_i
+SAMPLES     = (ENV['SAMPLES']     || 10).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, "blocking.consumer.example.queue")
+
+class MyConsumer < Fleck::Consumer
+  configure queue: 'blocking.consumer.example.queue', autostart: false
+  actions :quit
+
+  initialize do
+    @value = "MY CONSUMER :) #{object_id}"
+  end
+
+  def quit
+    logger.debug "Quit message received, but I'm goint to sleep for 2 seconds ..."
+    sleep 2
+    logger.debug "Let's terminate this example!"
+    Ztimer.async { self.class.terminate }
+  end
+end
+
+client.request(action: 'quit', timeout: 5, async: true)
+
+MyConsumer.start(block: true)
+
+puts "We did it :)"
+sleep 0.01 # Give some time to Bunny to cancel subscribtions and to close channels and connections

data/examples/consumer_initialization.rb

@@ -1,44 +1,44 @@
-#!/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 = 'consumer.initialization.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)
-
-class MyConsumer < Fleck::Consumer
-  configure queue: QUEUE, concurrency: CONCURRENCY.to_i
-  actions :hello
-
-  initialize do
-    @value = "MY CONSUMER :) #{object_id}"
-  end
-
-  def hello
-    logger.info '---------------- HELLO ----------------'
-    ok! "#{@value} Hello!"
-  end
-end
-
-SAMPLES.to_i.times do |num|
-  client.request(action: 'hello', params: {num: num}, timeout: 5) do |_, response|
-    if response.status == 200
-      Fleck.logger.info response.body
-    else
-      Fleck.logger.error response.errors.join(', ')
-    end
-  end
-end
+#!/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 = 'consumer.initialization.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)
+
+class MyConsumer < Fleck::Consumer
+  configure queue: QUEUE, concurrency: CONCURRENCY.to_i
+  actions :hello
+
+  initialize do
+    @value = "MY CONSUMER :) #{object_id}"
+  end
+
+  def hello
+    logger.info '---------------- HELLO ----------------'
+    ok! "#{@value} Hello!"
+  end
+end
+
+SAMPLES.to_i.times do |num|
+  client.request(action: 'hello', params: {num: num}, timeout: 5) do |_, response|
+    if response.status == 200
+      Fleck.logger.info response.body
+    else
+      Fleck.logger.error response.errors.join(', ')
+    end
+  end
+end

data/examples/deprecation.rb

@@ -1,50 +1,50 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-require 'fleck'
-
-user        = ENV['USER']        || 'guest'
-pass        = ENV['PASS']        || 'guest'
-
-CONCURRENCY = (ENV['CONCURRENCY'] || 2).to_i
-SAMPLES     = (ENV['SAMPLES']     || 10).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, "deprecation.example.queue", concurrency: CONCURRENCY.to_i)
-
-class MyConsumer < Fleck::Consumer
-  configure queue: 'deprecation.example.queue', concurrency: CONCURRENCY.to_i
-
-  action :hello
-  def hello
-    version = request.version || 'v1'
-    case version.to_s
-    when 'v1' then hello_v1
-    when 'v2' then hello_v2
-    else
-      not_found!
-    end
-  end
-
-  private
-
-  def hello_v1
-    deprecated!
-    ok! "#{request.params[:num]}. Hello V1!"
-  end
-
-  def hello_v2
-    ok! "#{request.params[:num] + 1}. Hello V2!"
-  end
-end
-
-SAMPLES.to_i.times do |num|
-  response = client.request(action: 'hello', version: (rand >= 0.5 ? 'v2' : 'v1'), params: {num: num}, timeout: 5)
-  puts (response.deprecated? ? "DEPRECATED: #{response.body}" : response.body)
-end
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'fleck'
+
+user        = ENV['USER']        || 'guest'
+pass        = ENV['PASS']        || 'guest'
+
+CONCURRENCY = (ENV['CONCURRENCY'] || 2).to_i
+SAMPLES     = (ENV['SAMPLES']     || 10).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, "deprecation.example.queue", concurrency: CONCURRENCY.to_i)
+
+class MyConsumer < Fleck::Consumer
+  configure queue: 'deprecation.example.queue', concurrency: CONCURRENCY.to_i
+
+  action :hello
+  def hello
+    version = request.version || 'v1'
+    case version.to_s
+    when 'v1' then hello_v1
+    when 'v2' then hello_v2
+    else
+      not_found!
+    end
+  end
+
+  private
+
+  def hello_v1
+    deprecated!
+    ok! "#{request.params[:num]}. Hello V1!"
+  end
+
+  def hello_v2
+    ok! "#{request.params[:num] + 1}. Hello V2!"
+  end
+end
+
+SAMPLES.to_i.times do |num|
+  response = client.request(action: 'hello', version: (rand >= 0.5 ? 'v2' : 'v1'), params: {num: num}, timeout: 5)
+  puts (response.deprecated? ? "DEPRECATED: #{response.body}" : response.body)
+end

data/examples/example.rb

@@ -1,76 +1,76 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'fleck'
-
-user        = ENV['USER']        || 'guest'
-pass        = ENV['PASS']        || 'guest'
-
-CONCURRENCY = (ENV['CONCURRENCY'] || 10).to_i
-SAMPLES     = (ENV['SAMPLES']     || 10_000).to_i
-QUEUE       = 'example.queue'
-
-Fleck.configure do |config|
-  config.default_user = user
-  config.default_pass = pass
-  config.loglevel     = Logger::DEBUG
-end
-
-client = Fleck::Client.new(Fleck.connection, QUEUE, concurrency: CONCURRENCY.to_i)
-
-count   = 0
-success = 0
-failure = 0
-
-mutex = Mutex.new
-lock  = Mutex.new
-condition = ConditionVariable.new
-
-class First < Fleck::Consumer
-  configure queue: QUEUE, concurrency: CONCURRENCY.to_i
-
-  action :incr, 'Returns a message with incremented number'
-  param :num, type: 'number', required: true
-  def incr
-    if rand > 0.1
-      not_found! if request.action != 'incr'
-
-      ok! "#{params[:num].to_i + 1}. Hello, World!"
-    else
-      logger.warn "REJECTING REQUEST {headers: #{headers}, params: #{params}"
-      request.reject!(requeue: true)
-    end
-  end
-end
-
-Thread.new do
-  SAMPLES.times do |i|
-    client.request(
-      action: 'incr',
-      params: { num: i, secret: 'supersecret' },
-      async: true,
-      timeout: 1,
-      rmq_options: { priority: (rand * 9).round(0), mandatory: false }
-    ) do |request, response|
-      if response.status == 200
-        request.logger.debug response.body
-      else
-        request.logger.error "#{response.status} #{response.errors.join(', ')}"
-      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
-end
-
-lock.synchronize { condition.wait(lock) }
-
-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'] || 10).to_i
+SAMPLES     = (ENV['SAMPLES']     || 10_000).to_i
+QUEUE       = 'example.queue'
+
+Fleck.configure do |config|
+  config.default_user = user
+  config.default_pass = pass
+  config.loglevel     = Logger::DEBUG
+end
+
+client = Fleck::Client.new(Fleck.connection, QUEUE, concurrency: CONCURRENCY.to_i)
+
+count   = 0
+success = 0
+failure = 0
+
+mutex = Mutex.new
+lock  = Mutex.new
+condition = ConditionVariable.new
+
+class First < Fleck::Consumer
+  configure queue: QUEUE, concurrency: CONCURRENCY.to_i
+
+  action :incr, 'Returns a message with incremented number'
+  param :num, type: 'number', required: true
+  def incr
+    if rand > 0.1
+      not_found! if request.action != 'incr'
+
+      ok! "#{params[:num].to_i + 1}. Hello, World!"
+    else
+      logger.warn "REJECTING REQUEST {headers: #{headers}, params: #{params}"
+      request.reject!(requeue: true)
+    end
+  end
+end
+
+Thread.new do
+  SAMPLES.times do |i|
+    client.request(
+      action: 'incr',
+      params: { num: i, secret: 'supersecret' },
+      async: true,
+      timeout: 1,
+      rmq_options: { priority: (rand * 9).round(0), mandatory: false }
+    ) do |request, response|
+      if response.status == 200
+        request.logger.debug response.body
+      else
+        request.logger.error "#{response.status} #{response.errors.join(', ')}"
+      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
+end
+
+lock.synchronize { condition.wait(lock) }
+
+puts "Total: #{count}, Success: #{success}, Failure: #{failure}"