cli-proton-ruby 1.0.0

data/lib/formatters/interop_formatter.rb

@@ -0,0 +1,88 @@
+#--
+# Copyright 2018 Red Hat Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+require_relative 'dict_formatter'
+
+module Formatters
+
+  # Formatter of message into interop dictionary format
+  class InteropFormatter < Formatters::DictFormatter
+
+    # Initialization of interop dictionary formatter
+    # ==== Interop dictionary formatter arguments
+    # message:: message to format
+    def initialize(message, msg_content_hashed=false)
+      super(message, msg_content_hashed)
+    end # initialize(message)
+
+    # Format value according to type
+    # ==== Parameters
+    # value:: value to format
+    # ==== Returns
+    # value formatted as string
+    def format_value(value)
+      case value
+      when Float
+        # ab_diff = [{'content': [[-1.3, -1.2999999523162842]]}]
+        value.round(5)
+      else
+        super
+      end
+    end
+
+    # Format message as interop dictionary
+    # ==== Returns
+    # message formatted as interop dictionary
+    def get_as_interop_dictionary()
+      dict_to_return = "" \
+      + "'redelivered': #{format_value(
+        @message.delivery_count == 0 ? false : true
+      )}, "\
+      + "'reply-to': #{format_value(@message.reply_to)}, "\
+      + "'subject': #{format_value(@message.subject)}, "\
+      + "'content-type': #{format_value(@message.content_type)}, "\
+      + "'id': #{format_value(@message.id)}, "\
+      + "'group-id': #{format_value(@message.group_id)}, "\
+      + "'user-id': #{format_value(@message.user_id)}, "\
+      + "'correlation-id': #{format_value(@message.correlation_id)}, "\
+      + "'priority': #{format_value(@message.priority)}, "\
+      + "'durable': #{format_value(@message.durable)}, "\
+      + "'ttl': #{format_value(@message.ttl)}, "\
+      + "'absolute-expiry-time': #{format_value(@message.expires)}, "\
+      + "'address': #{format_value(@message.address.nil? ? nil : @message.address.sub(%r{^topic://}, ''))}, "\
+      + "'content-encoding': #{format_value(@message.content_encoding)}, "\
+      + "'delivery-count': #{format_value(@message.delivery_count)}, "\
+      + "'first-acquirer': #{format_value(@message.first_acquirer?)}, "\
+      + "'group-sequence': #{format_value(@message.group_sequence)}, "\
+      + "'reply-to-group-id': #{format_value(@message.reply_to_group_id)}, "\
+      + "'to': #{format_value(@message.to)}, "\
+      + "'properties': #{format_value(@message.properties)}, "\
+      + "'content': #{
+        format_value(@msg_content_hashed ? StringUtils.sha1_hash(@message.body) : @message.body)
+      }"
+      return self.class.escape_chars("{#{dict_to_return}}")
+    end # get_as_interop_dictionary()
+
+    # Prints message formatted as interop dictionary to stdout
+    def print()
+      # Print formatted message to stdout
+      puts get_as_interop_dictionary()
+    end # print()
+
+  end # class InteropFormatter
+
+end # module Formatters
+

data/lib/handlers.rb

@@ -0,0 +1,34 @@
+#--
+# Copyright 2017 Red Hat Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+require 'handlers/basic_handler'
+require 'handlers/connector_handler'
+require 'handlers/sr_common_handler'
+require 'handlers/sender_handler'
+require 'handlers/receiver_handler'
+
+# Module containing event handlers for cli-proton-ruby clients
+# ==== Handlers
+# * Handlers::BasicHandler for all clients
+# * Handlers::ConnectorHandler for connector client
+# * Handlers::SRCommonHandler for sender and receiver client
+# * Handlers::SenderHandler for sender client
+# * Handlers::ReceiverHandler for receiver client
+module Handlers
+
+end # module Handlers
+
+# eof

data/lib/handlers/basic_handler.rb

@@ -0,0 +1,79 @@
+#--
+# Copyright 2017 Red Hat Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+require 'qpid_proton'
+require_relative '../utils/env_utils'
+
+module Handlers
+
+  # Basic events handler for all clients
+  class BasicHandler < Qpid::Proton::MessagingHandler
+
+    # Exit timer limits the run-time of the application
+    attr_accessor :exit_timer
+    # URI of broker
+    attr_accessor :broker
+    # Allowed SASL mechs
+    attr_accessor :sasl_mechs
+    # Idle timeout
+    attr_accessor :idle_timeout
+    # Max frame size
+    attr_accessor :max_frame_size
+    # SASL enabled
+    attr_accessor :sasl_enabled
+    # Client library logging
+    attr_accessor :log_lib
+
+    # Initialization of basic events handler for all clients
+    # ==== Basic events handler arguments
+    # broker:: URI of broker
+    # sasl_mechs: allowed SASL mechanisms
+    def initialize(
+      broker,
+      sasl_mechs,
+      idle_timeout,
+      max_frame_size,
+      sasl_enabled,
+      log_lib,
+      exit_timer
+    )
+      super()
+      @exit_timer = exit_timer
+      # Save URI of broker
+      if broker.is_a? URI::AMQP or broker.is_a? URI::AMQPS
+        @broker = broker
+      else
+        @broker = Qpid::Proton.uri(broker)
+      end
+      # Save allowed SASL mechanisms
+      @sasl_mechs = sasl_mechs
+      # Save idle timeout
+      @idle_timeout = idle_timeout
+      # Save max frame size
+      @max_frame_size = max_frame_size
+      # Save SASL enabled
+      @sasl_enabled = sasl_enabled
+      # Save client library logging
+      @log_lib = log_lib
+      # Set environment variable for client library logging
+      EnvUtils.set_log_lib_env(@log_lib)
+    end
+
+  end # class BasicHandler
+
+end # module Handlers
+
+# eof

data/lib/handlers/connector_handler.rb

@@ -0,0 +1,90 @@
+#--
+# Copyright 2017 Red Hat Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+require_relative 'basic_handler'
+
+module Handlers
+
+  # Connector events handler for connector client
+  class ConnectorHandler < Handlers::BasicHandler
+
+    # Count of connections
+    attr_accessor :count
+    # Array of connections
+    attr_accessor :connections
+
+    # Initialization of events handler for connector client
+    # ==== Connector events handler arguments
+    # broker:: URI of broker
+    # count:: Number of connections to create
+    # sasl_mechs:: Allowed SASL mechanisms
+    def initialize(
+      broker,
+      count,
+      sasl_mechs,
+      idle_timeout,
+      max_frame_size,
+      sasl_enabled,
+      log_lib,
+      exit_timer
+    )
+      super(
+        broker,
+        sasl_mechs,
+        idle_timeout,
+        max_frame_size,
+        sasl_enabled,
+        log_lib,
+        exit_timer
+      )
+      # Save count of connections
+      @count = count
+      # Initialize array of connections
+      @connections = []
+    end
+
+    # Called when the event loop starts,
+    # connecting ConnectorHandler#count number of connections
+    def on_container_start(container)
+      # Connecting count number of connections
+      @count.times do
+        # Save created connection(s) into array
+        @connections.push(container.connect(
+          # Set broker URI
+          @broker,
+          # Enable SASL authentication
+          sasl_enabled: @sasl_enabled,
+          # Enable insecure SASL mechanisms
+          sasl_allow_insecure_mechs: true,
+          # Set allowed SASL mechanisms
+          sasl_allowed_mechs: @sasl_mechs,
+          # Set idle timeout
+          idle_timeout: @idle_timeout,
+          # Set max frame size
+          max_frame_size: @max_frame_size,
+        ))
+      end
+    end
+
+    def on_connection_open(_c)
+      exit_timer.reset if exit_timer
+    end
+
+  end # class ConnectorHandler
+
+end # module Handlers
+
+# eof

data/lib/handlers/receiver_handler.rb

@@ -0,0 +1,230 @@
+#--
+# Copyright 2017 Red Hat Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+require_relative '../utils/duration'
+require_relative 'sr_common_handler'
+
+module Handlers
+
+  # Receiver events handler for receiver client
+  class ReceiverHandler < Handlers::SRCommonHandler
+
+    # Count of expected messages to be received
+    attr_accessor :count
+    # Credit for messages to be pre-fetched
+    attr_accessor :prefetch
+    # Process reply to
+    attr_accessor :process_reply_to
+    # Browse
+    attr_accessor :browse
+    # Selector
+    attr_accessor :selector
+    # Receiver listen
+    attr_accessor :recv_listen
+    # Receiver listen port
+    attr_accessor :recv_listen_port
+
+    # Initialization of receiver events handler
+    # ==== Receiver events handler arguments
+    # broker:: URI of broker
+    # log_msgs:: format of message(s) log
+    # count:: number of messages to receive
+    # process-reply-to:: send message to reply-to address if enabled
+    #                    and message got reply-to address
+    # browse:: browse messages instead of reading
+    # sasl_mechs:: allowed SASL mechanisms
+    def initialize(
+      broker,
+      log_msgs,
+      msg_content_hashed,
+      count,
+      prefetch,
+      process_reply_to,
+      browse,
+      selector,
+      sasl_mechs,
+      idle_timeout,
+      max_frame_size,
+      sasl_enabled,
+      log_lib,
+      recv_listen,
+      recv_listen_port,
+      auto_settle_off,
+      exit_timer,
+      duration,
+      duration_mode
+    )
+      super(
+        broker,
+        log_msgs,
+        msg_content_hashed,
+        sasl_mechs,
+        idle_timeout,
+        max_frame_size,
+        sasl_enabled,
+        log_lib,
+        auto_settle_off,
+        exit_timer
+      )
+      # Save count of expected messages to be received
+      @count = count
+      # Save credit for messages to be pre-fetched
+      @prefetch = prefetch
+      # Save process reply to
+      @process_reply_to = process_reply_to
+      # Save browse
+      @browse = browse
+      # Save selector
+      @selector = selector
+      # Save recv-listen value
+      @recv_listen = recv_listen
+      # Save recv-listen port value
+      @recv_listen_port = recv_listen_port
+      # Number of received messages
+      @received = 0
+      # Flag indicating that all expected messages were received
+      @all_received = false
+      # Hash with senders for replying
+      @senders = {}
+      # Counter of sent messages when processing reply-to
+      @sent = 0
+      # Counter of accepted messages
+      @accepted = 0
+      # Duration
+      @duration = Duration.new(duration, count, duration_mode)
+    end
+
+    # Called when the event loop starts,
+    # connects receiver client to SRCommonHandler#broker
+    # and creates receiver
+    def on_container_start(container)
+      if @recv_listen # P2P
+        @listener = container.listen("0.0.0.0:#{@recv_listen_port}")
+      else # Broker
+        # Prepare source options
+        source = {}
+        source[:address] = @broker.amqp_address
+        source[:filter] = { :selector => make_apache_selector(@selector)} if @selector
+        # Connecting to broker and creating receiver
+        @receiver = container.connect(
+          # Set broker URI
+          @broker,
+          # Enabled SASL authentication
+          sasl_enabled: @sasl_enabled,
+          # Enabled insecure SASL mechanisms
+          sasl_allow_insecure_mechs: true,
+          # Set allowed SASL mechanisms
+          sasl_allowed_mechs: @sasl_mechs,
+          # Set idle timeout
+          idle_timeout: @idle_timeout,
+          # Set max frame size
+          max_frame_size: @max_frame_size,
+        ).open_receiver(
+          # Set source options
+          :source => source,
+          # Set prefetch
+          :credit_window => @prefetch,
+        )
+        # If browse messages instead of reading
+        if browse
+          # Set browsing mode
+          @receiver.source.distribution_mode = \
+            Qpid::Proton::Terminus::DIST_MODE_COPY
+        end
+      end
+    end
+
+    # Called when a message is received,
+    # receiving ReceiverHandler#count messages
+    def on_message(delivery, message)
+      @duration.delay("before-receive") { |d| sleep d }
+      exit_timer.reset if exit_timer
+      # Print received message
+      print_message(message)
+      # If process reply to
+      if @process_reply_to and !message.reply_to.nil?
+        self.do_process_reply_to(message)
+      end
+      # Increase number of received messages
+      @received = @received + 1
+      # If expected count of messages to be received is not zero
+      # and all expected messages are received
+      if @count > 0 and @received == @count
+        # Set flag indicating that all expected messages were received to true
+        @all_received = true
+        # Close listener when listening
+        if recv_listen
+          # Close listener if not processing reply-to
+          @listener.close unless process_reply_to
+        # Close receiver when not listening, but receiving
+        else
+          # Close receiver
+          delivery.receiver.close 
+          # Close connection if not processing reply-to
+          delivery.receiver.connection.close unless process_reply_to
+        end
+      end # if
+      @duration.delay("after-receive") { |d| sleep d }
+    end
+
+    # Processing reply to reply-to address of message
+    def do_process_reply_to(message)
+      # If sender for actual reply-to address does not exist
+      unless @senders.include?(message.reply_to)
+        # Create new sender for reply-to address
+        @senders[message.reply_to] = @receiver.connection.open_sender({
+          # Set target address
+          :target => message.reply_to,
+          # Set auto settle
+          :auto_settle => @auto_settle_off ? false : true,
+        })
+      end
+      # Set target address of message to be send to reply-to address
+      message.address = message.reply_to
+      # Increase number of sent messages
+      @sent = @sent + 1
+      # Send message to reply-to address
+      @senders[message.reply_to].send(message)
+    end
+
+    # Called when the remote peer accepts an outgoing message,
+    # accepting ReceiverHandler#sent messages
+    def on_tracker_accept(_tracker)
+      # Increase number of accepted messages
+      @accepted = @accepted + 1
+      # If all expected messages were received
+      # and all sent messages were accepted
+      if @all_received and @accepted == @sent
+        # Close all senders and their connections
+        @senders.each do |_, i_sender|
+          # Close sender
+          i_sender.close
+          # Close connection of sender
+          i_sender.connection.close
+        end
+      end # if
+    end
+
+    private
+    def make_apache_selector(selector)
+      Qpid::Proton::Types::Described.new(:"apache.org:selector-filter:string", selector)
+    end
+
+  end # class ReceiverHandler
+
+end # module Handlers
+
+# eof