fleck 0.7.0 → 2.1.0

data/examples/example.rb

@@ -1,74 +1,76 @@
-#!/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']     || 10_000).to_i
-
-Fleck.configure do |config|
-  config.default_user = user
-  config.default_pass = pass
-  config.loglevel     = Logger::DEBUG
-end
-
-client = Fleck::Client.new(Fleck.connection, "example.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: "example.queue", concurrency: CONCURRENCY.to_i
-
-  def on_message(request, response)
-    if rand > 0.1
-      if request.action == "incr"
-        response.body = "#{request.params[:num].to_i + 1}. Hello, World!"
-      else
-        response.not_found
-      end
-    else
-      logger.warn "REJECTING REQUEST {headers: #{request.headers}, params: #{request.params}"
-      response.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
-
-at_exit do
-  puts "Total: #{count}, Success: #{success}, Failure: #{failure}"
-end
-
-lock.synchronize { condition.wait(lock) }
-exit
-
-#First.consumers.map(&:terminate)
+#!/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}"

data/examples/expired.rb

@@ -1,76 +1,72 @@
-#!/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, "expiration.example.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: 'expiration.example.queue', concurrency: CONCURRENCY.to_i
-
-  def on_message(request, response)
-    case request.action
-    when 'hello' then hello
-    else
-      response.not_found!
-    end
-  end
-
-  def hello
-    sleep rand
-    response.body = "#{request.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.to_f) 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
-
-at_exit do
-  puts "Ztimer: (count: #{Ztimer.count}, jobs: #{Ztimer.jobs_count})"
-  puts "Total: #{count}, Success: #{success}, Failure: #{failure}"
-end
-
-lock.synchronize { condition.wait(lock) }
-exit
+#!/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,64 +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'
-
-  def on_message(request, response)
-    if request.action == "incr"
-      response.body = "#{request.params[:num].to_i + 1}. Hello, World!"
-    else
-      response.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
-
-at_exit do
-  puts "Total: #{count}, Success: #{success}, Failure: #{failure}"
-end
-
-lock.synchronize { condition.wait(lock) }
-exit
+#!/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/fleck.gemspec

@@ -1,36 +1,37 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'fleck/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "fleck"
-  spec.platform      = "ruby"
-  spec.version       = Fleck::VERSION
-  spec.authors       = ["Groza Sergiu"]
-  spec.email         = ["serioja90@gmail.com"]
-
-  spec.summary       = %q{A Ruby gem for syncronous and asyncronous communication via Message Queue services.}
-  spec.description   = %q{
-    Fleck is a library for syncronous and asyncronous communication over Message Queues services. Unlike a common
-    HTTP communication, Fleck requests and responses are pure JSON messages.
-  }
-  spec.homepage      = "https://github.com/serioja90/fleck"
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.required_ruby_version = "~> 2.0"
-
-  spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3"
-  spec.add_dependency             "rainbow", "~> 2.0"
-  spec.add_dependency             "bunny", "~> 2.2"
-  spec.add_dependency             "thread_safe", "~> 0.3"
-  spec.add_dependency             "oj", "~> 2.14"
-  spec.add_dependency             "ztimer", "~> 0.4"
-end
+# frozen_string_literal: true
+
+lib = File.expand_path(__dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lib/fleck/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'fleck'
+  spec.platform      = 'ruby'
+  spec.version       = Fleck::VERSION
+  spec.authors       = ['Groza Sergiu']
+  spec.email         = ['serioja90@gmail.com']
+
+  spec.summary       = %(A Ruby gem for syncronous and asyncronous communication via Message Queue services.)
+  spec.description   = %(
+    Fleck is a library for syncronous and asyncronous communication over Message Queues services. Unlike a common
+    HTTP communication, Fleck requests and responses are pure JSON messages.
+  )
+  spec.homepage      = 'https://github.com/serioja90/fleck'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.5'
+
+  spec.add_development_dependency 'bundler', '>= 2.2.33'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.9'
+  spec.add_dependency             'bunny', '~> 2.14'
+  spec.add_dependency             'oj', '~> 3.10'
+  spec.add_dependency             'rainbow', '~> 2.2'
+  spec.add_dependency             'thread_safe', '~> 0.3'
+  spec.add_dependency             'ztimer', '~> 0.6'
+end