libusb 0.2.2 → 0.3.0

data/lib/libusb/compat.rb

@@ -37,7 +37,15 @@ require 'forwardable'
 # * Exceptions are different between ruby-usb and libusb and they don't get converted
 # * libusb-1.0 doesn't explicitly manage USB-buses, so only one Bus is used currently
 module USB
-  DefaultContext = LIBUSB::Context.new
+  @default_context = nil
+  def self.default_context
+    @default_context ||= LIBUSB::Context.new
+  end
+
+  @default_bus = nil
+  def self.default_bus
+    @default_bus ||= Bus.new(default_context)
+  end
 
   USB_CLASS_PER_INTERFACE = LIBUSB::CLASS_PER_INTERFACE
   USB_CLASS_AUDIO = LIBUSB::CLASS_AUDIO
@@ -108,21 +116,21 @@ module USB
 
 
   def USB.busses
-    [DefaultBus]
+    [default_bus]
   end
 
-  def USB.devices; DefaultContext.devices.map{|c| Device.new(c) }; end
+  def USB.devices; default_context.devices.map{|c| Device.new(c) }; end
   def USB.configurations() USB.devices.map {|d| d.configurations }.flatten end
   def USB.interfaces() USB.configurations.map {|d| d.interfaces }.flatten end
   def USB.settings() USB.interfaces.map {|d| d.settings }.flatten end
   def USB.endpoints() USB.settings.map {|d| d.endpoints }.flatten end
 
   def USB.find_bus(n)
-    DefaultBus
+    default_bus
   end
 
   def USB.each_device_by_class(devclass, subclass=nil, protocol=nil)
-    devs = DefaultContext.devices :bClass=>devclass, :bSubClass=>subclass, :bProtocol=>protocol
+    devs = default_context.devices :bClass=>devclass, :bSubClass=>subclass, :bProtocol=>protocol
     devs.each do |dev|
       yield Device.new(dev)
     end
@@ -147,8 +155,6 @@ module USB
     end
   end
 
-  DefaultBus = Bus.new(DefaultContext)
-
   def USB.dev_string(base_class, sub_class, protocol)
     LIBUSB.dev_string(base_class, sub_class, protocol)
   end
@@ -184,7 +190,7 @@ module USB
       end
     end
 
-    def bus; DefaultBus; end
+    def bus; default_bus; end
     def configurations; @dev.configurations.map{|c| Configuration.new(c) }; end
     def interfaces; @dev.interfaces.map{|c| Interface.new(c) }; end
     def settings; @dev.settings.map{|c| Setting.new(c) }; end
@@ -207,7 +213,7 @@ module USB
       @cd<=>o.instance_variable_get(:@cd)
     end
 
-    def bus; DefaultBus; end
+    def bus; default_bus; end
     def device() Device.new(@cd.device) end
     def interfaces; @cd.interfaces.map{|c| Interface.new(c) }; end
     def settings() self.interfaces.map {|d| d.settings }.flatten end

data/lib/libusb/configuration.rb

@@ -69,10 +69,23 @@ module LIBUSB
     # * Bit 4..0: Reserved, set to 0.
     #
     # @return [Integer]
+    #
+    # @see #self_powered?
+    # @see #remote_wakeup?
     def bmAttributes
       self[:bmAttributes]
     end
 
+    # @return [Boolean]
+    def self_powered?
+      bmAttributes & 0b1000000 != 0
+    end
+
+    # @return [Boolean]
+    def remote_wakeup?
+      bmAttributes & 0b100000 != 0
+    end
+
     # Maximum power consumption of the USB device from this bus in this configuration when the device is fully opreation.
     #
     # @return [Integer] Maximum Power Consumption in 2mA units
@@ -115,9 +128,8 @@ module LIBUSB
     def inspect
       attrs = []
       attrs << self.bConfigurationValue.to_s
-      bits = self.bmAttributes
-      attrs << "SelfPowered" if (bits & 0b1000000) != 0
-      attrs << "RemoteWakeup" if (bits & 0b100000) != 0
+      attrs << "SelfPowered" if self_powered?
+      attrs << "RemoteWakeup" if remote_wakeup?
       desc = self.description
       attrs << desc if desc != '?'
       "\#<#{self.class} #{attrs.join(' ')}>"

data/lib/libusb/constants.rb

@@ -29,7 +29,17 @@ module LIBUSB
 
   # Base class of libusb errors
   class Error < RuntimeError
+    # The data already transferred before the exception was raised
+    # @return [Fixnum] Number of bytes sent for an outgoing transfer
+    # @return [String] Received data for an ingoing transfer
+    attr_reader :transferred
+
+    def initialize(msg=nil, transferred=nil)
+      super(msg)
+      @transferred = transferred
+    end
   end
+
   # @private
   ErrorClassForResult = {}
 
@@ -60,6 +70,9 @@ module LIBUSB
   ISO_SYNC_TYPE_MASK = 0x0C
   ISO_USAGE_TYPE_MASK = 0x30
 
+  POLLIN = 1
+  POLLOUT = 4
+
 
   # http://www.usb.org/developers/defined_class
   # @private
@@ -71,12 +84,12 @@ module LIBUSB
     [0x06, 0x01, 0x01, "StillImaging"],
     [0x06, nil, nil, "Image"],
     [0x07, nil, nil, "Printer"],
-    [0x08, 0x01, nil, "MassStorage RBC Bluk-Only"],
-    [0x08, 0x02, 0x50, "MassStorage ATAPI Bluk-Only"],
-    [0x08, 0x03, 0x50, "MassStorage QIC-157 Bluk-Only"],
+    [0x08, 0x01, nil, "MassStorage RBC Bulk-Only"],
+    [0x08, 0x02, 0x50, "MassStorage ATAPI Bulk-Only"],
+    [0x08, 0x03, 0x50, "MassStorage QIC-157 Bulk-Only"],
     [0x08, 0x04, nil, "MassStorage UFI"],
-    [0x08, 0x05, 0x50, "MassStorage SFF-8070i Bluk-Only"],
-    [0x08, 0x06, 0x50, "MassStorage SCSI Bluk-Only"],
+    [0x08, 0x05, 0x50, "MassStorage SFF-8070i Bulk-Only"],
+    [0x08, 0x06, 0x50, "MassStorage SCSI Bulk-Only"],
     [0x08, nil, nil, "MassStorage"],
     [0x09, 0x00, 0x00, "Full speed Hub"],
     [0x09, 0x00, 0x01, "Hi-speed Hub with single TT"],
@@ -132,7 +145,7 @@ module LIBUSB
     elsif desc = CLASS_CODES_HASH1[base_class]
       desc + " (%02x,%02x)" % [sub_class, protocol]
     else
-      "Unkonwn(%02x,%02x,%02x)" % [base_class, sub_class, protocol]
+      "Unknown(%02x,%02x,%02x)" % [base_class, sub_class, protocol]
     end
   end
 end

data/lib/libusb/context.rb

@@ -18,11 +18,64 @@ require 'libusb/call'
 module LIBUSB
   # Class representing a libusb session.
   class Context
+    class Pollfd
+      include Comparable
+
+      def initialize(fd, events=0)
+        @fd, @events = fd, events
+      end
+
+      def <=>(other)
+        @fd <=> other.fd
+      end
+
+      # @return [IO]  IO object bound to the file descriptor.
+      def io
+        IO.new @fd
+      end
+
+      # @return [Integer]  Numeric file descriptor
+      attr_reader :fd
+
+      # @return [Integer]  Event flags to poll for
+      attr_reader :events
+
+      # @return [Boolean] True if the file descriptor has to be observed for incoming/readable data
+      def pollin?
+        @events & POLLIN != 0
+      end
+
+      # @return [Boolean] True if the file descriptor has to be observed for outgoing/writeable data
+      def pollout?
+        @events & POLLOUT != 0
+      end
+
+      def inspect
+        "\#<#{self.class} fd:#{@fd}#{' POLLIN' if pollin?}#{' POLLOUT' if pollout?}>"
+      end
+    end
+
+    class CompletionFlag < FFI::Struct
+      layout :completed,  :int
+
+      def completed?
+        self[:completed] != 0
+      end
+
+      def completed=(flag)
+        self[:completed] = flag ? 1 : 0
+      end
+    end
+
+
     # Initialize libusb context.
     def initialize
       m = FFI::MemoryPointer.new :pointer
-      Call.libusb_init(m)
+      res = Call.libusb_init(m)
+      LIBUSB.raise_error res, "in libusb_init" if res!=0
       @ctx = m.read_pointer
+      @on_pollfd_added = nil
+      @on_pollfd_removed = nil
     end
 
     # Deinitialize libusb.
@@ -66,6 +119,7 @@ module LIBUSB
     def device_list
       pppDevs = FFI::MemoryPointer.new :pointer
       size = Call.libusb_get_device_list(@ctx, pppDevs)
+      LIBUSB.raise_error size, "in libusb_get_device_list" if size<0
       ppDevs = pppDevs.read_pointer
       pDevs = []
       size.times do |devi|
@@ -82,8 +136,41 @@ module LIBUSB
     # This method must be called when libusb is running asynchronous transfers.
     # This gives libusb the opportunity to reap pending transfers,
     # invoke callbacks, etc.
-    def handle_events
-      res = Call.libusb_handle_events(@ctx)
+    #
+    # If a zero timeout is passed, this function will handle any already-pending
+    # events and then immediately return in non-blocking style.
+    #
+    # If a non-zero timeout is passed and no events are currently pending, this
+    # method will block waiting for events to handle up until the specified timeout.
+    # If an event arrives or a signal is raised, this method will return early.
+    #
+    # If the parameter completion_flag is used, then after obtaining the event
+    # handling lock this function will return immediately if the flag is set to completed.
+    # This allows for race free waiting for the completion of a specific transfer.
+    # See source of {Transfer#submit_and_wait} for a use case of completion_flag.
+    #
+    # @param [Integer, nil] timeout  the maximum time (in millseconds) to block waiting for
+    #                                events, or 0 for non-blocking mode
+    # @param [Context::CompletionFlag, nil] completion_flag  CompletionFlag to check
+    def handle_events(timeout=nil, completion_flag=nil)
+      if completion_flag && !completion_flag.is_a?(Context::CompletionFlag)
+        raise ArgumentError, "completion_flag is not a CompletionFlag"
+      end
+      if timeout
+        timeval = Call::Timeval.new
+        timeval.in_ms = timeout
+        res = if Call.respond_to?(:libusb_handle_events_timeout_completed)
+          Call.libusb_handle_events_timeout_completed(@ctx, timeval, completion_flag)
+        else
+          Call.libusb_handle_events_timeout(@ctx, timeval)
+        end
+      else
+        res = if Call.respond_to?(:libusb_handle_events_completed)
+          Call.libusb_handle_events_completed(@ctx, completion_flag )
+        else
+          Call.libusb_handle_events(@ctx)
+        end
+      end
       LIBUSB.raise_error res, "in libusb_handle_events" if res<0
     end
 
@@ -123,5 +210,96 @@ module LIBUSB
         ( !filter_hash[:bcdDevice] || [filter_hash[:bcdDevice]].flatten.include?(dev.bcdDevice) )
       end
     end
+
+
+    # Retrieve a list of file descriptors that should be polled by your main
+    # loop as libusb event sources.
+    #
+    # As file descriptors are a Unix-specific concept, this function is not
+    # available on Windows and will always return +nil+.
+    #
+    # @return [Array<Pollfd>]  list of Pollfd objects,
+    #   +nil+ on error,
+    #   +nil+ on platforms where the functionality is not available
+    def pollfds
+      ppPollfds = Call.libusb_get_pollfds(@ctx)
+      return nil if ppPollfds.null?
+      offs = 0
+      pollfds = []
+      while !(pPollfd=ppPollfds.get_pointer(offs)).null?
+        pollfd = Call::Pollfd.new pPollfd
+        pollfds << Pollfd.new(pollfd[:fd], pollfd[:events])
+        offs += FFI.type_size :pointer
+      end
+      # ppPollfds has to be released by free() -> give the GC this job
+      ppPollfds.autorelease = true
+      pollfds
+    end
+
+    # Determine the next internal timeout that libusb needs to handle.
+    #
+    # You only need to use this function if you are calling poll() or select() or
+    # similar on libusb's file descriptors yourself - you do not need to use it if
+    # you are calling {#handle_events} directly.
+    #
+    # You should call this function in your main loop in order to determine how long
+    # to wait for select() or poll() to return results. libusb needs to be called
+    # into at this timeout, so you should use it as an upper bound on your select() or
+    # poll() call.
+    #
+    # When the timeout has expired, call into {#handle_events} (perhaps
+    # in non-blocking mode) so that libusb can handle the timeout.
+    #
+    # This function may return zero. If this is the
+    # case, it indicates that libusb has a timeout that has already expired so you
+    # should call {#handle_events} immediately. A return code
+    # of +nil+ indicates that there are no pending timeouts.
+    #
+    # On some platforms, this function will always returns +nil+ (no pending timeouts).
+    # See libusb's notes on time-based events.
+    #
+    # @return [Float, nil]  the timeout in seconds
+    def next_timeout
+      timeval = Call::Timeval.new
+      res = Call.libusb_get_next_timeout @ctx, timeval
+      LIBUSB.raise_error res, "in libusb_get_next_timeout" if res<0
+      res == 1 ? timeval.in_s : nil
+    end
+
+    # Register a notification block for file descriptor additions.
+    #
+    # This block will be invoked for every new file descriptor that
+    # libusb uses as an event source.
+    #
+    # Note that file descriptors may have been added even before you register these
+    # notifiers (e.g. at {Context#initialize} time).
+    #
+    # @yieldparam [Pollfd] pollfd  The added file descriptor is yielded to the block
+    def on_pollfd_added &block
+      @on_pollfd_added = proc do |fd, events, _|
+        pollfd = Pollfd.new fd, events
+        block.call pollfd
+      end
+      Call.libusb_set_pollfd_notifiers @ctx, @on_pollfd_added, @on_pollfd_removed, nil
+    end
+
+    # Register a notification block for file descriptor removals.
+    #
+    # This block will be invoked for every removed file descriptor that
+    # libusb uses as an event source.
+    #
+    # Note that the removal notifier may be called during {Context#exit}
+    # (e.g. when it is closing file descriptors that were opened and added to the poll
+    # set at {Context#initialize} time). If you don't want this, overwrite the notifier
+    # immediately before calling {Context#exit}.
+    #
+    # @yieldparam [Pollfd] pollfd  The removed file descriptor is yielded to the block
+    def on_pollfd_removed &block
+      @on_pollfd_removed = proc do |fd, _|
+        pollfd = Pollfd.new fd
+        block.call pollfd
+      end
+      Call.libusb_set_pollfd_notifiers @ctx, @on_pollfd_added, @on_pollfd_removed, nil
+    end
   end
 end

data/lib/libusb/dev_handle.rb

@@ -228,6 +228,14 @@ module LIBUSB
 
     # Perform a USB bulk transfer.
     #
+    # When called without a block, the transfer is done synchronously - so all events are handled
+    # internally and the sent/received data will be returned after completion or an exception will be raised.
+    #
+    # When called with a block, the method returns immediately after submitting the transfer.
+    # You then have to ensure, that {Context#handle_events} is called properly. As soon as the
+    # transfer is completed, the block is called with the sent/received data in case of success
+    # or the exception instance in case of failure.
+    #
     # The direction of the transfer is inferred from the direction bits of the
     # endpoint address.
     #
@@ -235,25 +243,31 @@ module LIBUSB
     # expecting to receive. If less data arrives than expected, this function will
     # return that data.
     #
-    # You should also check the returned number of bytes for bulk writes. Not all of the
+    # You should check the returned number of bytes for bulk writes. Not all of the
     # data may have been written.
     #
-    # Also check transferred bytes when dealing with a timeout error code. libusb may have
+    # Also check {Error#transferred} when dealing with a timeout exception. libusb may have
     # to split your transfer into a number of chunks to satisfy underlying O/S
     # requirements, meaning that the timeout may expire after the first few chunks
     # have completed. libusb is careful not to lose any data that may have been
     # transferred; do not assume that timeout conditions indicate a complete lack of
     # I/O.
     #
-    # @param [Endpoint, Fixnum] :endpoint  the (address of a) valid endpoint to communicate with
-    # @param [String] :dataOut  the data to send with an outgoing transfer
-    # @param [Fixnum] :dataIn   the number of bytes expected to receive with an ingoing transfer
-    # @param [Fixnum] :timeout   timeout (in millseconds) that this function should wait before giving
+    # @param [Hash] args
+    # @option args [Endpoint, Fixnum] :endpoint  the (address of a) valid endpoint to communicate with
+    # @option args [String] :dataOut  the data to send with an outgoing transfer
+    # @option args [Fixnum] :dataIn   the number of bytes expected to receive with an ingoing transfer
+    # @option args [Fixnum] :timeout   timeout (in millseconds) that this function should wait before giving
     #   up due to no response being received. For an unlimited timeout, use value 0. Defaults to 1000 ms.
     #
     # @return [Fixnum] Number of bytes sent for an outgoing transfer
     # @return [String] Received data for an ingoing transfer
-    def bulk_transfer(args={})
+    # @return [self]  When called with a block
+    #
+    # @yieldparam [String, Integer, LIBUSB::Error] result  result of the transfer is yielded to the block,
+    #   when the asynchronous transfer has finished
+    # @raise [ArgumentError, LIBUSB::Error] in case of failure
+    def bulk_transfer(args={}, &block)
       timeout = args.delete(:timeout) || 1000
       endpoint = args.delete(:endpoint) || raise(ArgumentError, "no endpoint given")
       endpoint = endpoint.bEndpointAddress if endpoint.respond_to? :bEndpointAddress
@@ -275,17 +289,19 @@ module LIBUSB
         tr.alloc_buffer(dataIn)
       end
 
-      tr.submit_and_wait!
-
-      if dataOut
-        tr.actual_length
-      else
-        tr.actual_buffer
-      end
+      submit_transfer(tr, dataIn, 0, &block)
     end
 
     # Perform a USB interrupt transfer.
     #
+    # When called without a block, the transfer is done synchronously - so all events are handled
+    # internally and the sent/received data will be returned after completion or an exception will be raised.
+    #
+    # When called with a block, the method returns immediately after submitting the transfer.
+    # You then have to ensure, that {Context#handle_events} is called properly. As soon as the
+    # transfer is completed, the block is called with the sent/received data in case of success
+    # or the exception instance in case of failure.
+    #
     # The direction of the transfer is inferred from the direction bits of the
     # endpoint address.
     #
@@ -293,10 +309,10 @@ module LIBUSB
     # are expecting to receive. If less data arrives than expected, this function will
     # return that data.
     #
-    # You should also check the returned number of bytes for interrupt writes. Not all of
+    # You should check the returned number of bytes for interrupt writes. Not all of
     # the data may have been written.
     #
-    # Also check transferred when dealing with a timeout error code. libusb may have
+    # Also check {Error#transferred} when dealing with a timeout exception. libusb may have
     # to split your transfer into a number of chunks to satisfy underlying O/S
     # requirements, meaning that the timeout may expire after the first few chunks
     # have completed. libusb is careful not to lose any data that may have been
@@ -305,15 +321,21 @@ module LIBUSB
     #
     # The default endpoint bInterval value is used as the polling interval.
     #
-    # @param [Endpoint, Fixnum] :endpoint  the (address of a) valid endpoint to communicate with
-    # @param [String] :dataOut  the data to send with an outgoing transfer
-    # @param [Fixnum] :dataIn   the number of bytes expected to receive with an ingoing transfer
-    # @param [Fixnum] :timeout   timeout (in millseconds) that this function should wait before giving
+    # @param [Hash] args
+    # @option args [Endpoint, Fixnum] :endpoint  the (address of a) valid endpoint to communicate with
+    # @option args [String] :dataOut  the data to send with an outgoing transfer
+    # @option args [Fixnum] :dataIn   the number of bytes expected to receive with an ingoing transfer
+    # @option args [Fixnum] :timeout   timeout (in millseconds) that this function should wait before giving
     #   up due to no response being received. For an unlimited timeout, use value 0. Defaults to 1000 ms.
     #
     # @return [Fixnum] Number of bytes sent for an outgoing transfer
     # @return [String] Received data for an ingoing transfer
-    def interrupt_transfer(args={})
+    # @return [self]  When called with a block
+    #
+    # @yieldparam [String, Integer, LIBUSB::Error] result  result of the transfer is yielded to the block,
+    #   when the asynchronous transfer has finished
+    # @raise [ArgumentError, LIBUSB::Error] in case of failure
+    def interrupt_transfer(args={}, &block)
       timeout = args.delete(:timeout) || 1000
       endpoint = args.delete(:endpoint) || raise(ArgumentError, "no endpoint given")
       endpoint = endpoint.bEndpointAddress if endpoint.respond_to? :bEndpointAddress
@@ -335,34 +357,42 @@ module LIBUSB
         tr.alloc_buffer(dataIn)
       end
 
-      tr.submit_and_wait!
-
-      if dataOut
-        tr.actual_length
-      else
-        tr.actual_buffer
-      end
+      submit_transfer(tr, dataIn, 0, &block)
     end
 
     # Perform a USB control transfer.
     #
+    # When called without a block, the transfer is done synchronously - so all events are handled
+    # internally and the sent/received data will be returned after completion or an exception will be raised.
+    #
+    # When called with a block, the method returns immediately after submitting the transfer.
+    # You then have to ensure, that {Context#handle_events} is called properly. As soon as the
+    # transfer is completed, the block is called with the sent/received data in case of success
+    # or the exception instance in case of failure.
+    #
     # The direction of the transfer is inferred from the +:bmRequestType+ field of the
     # setup packet.
     #
-    # @param [Fixnum] :bmRequestType   the request type field for the setup packet
-    # @param [Fixnum] :bRequest  the request field for the setup packet
-    # @param [Fixnum] :wValue  the value field for the setup packet
-    # @param [Fixnum] :wIndex  the index field for the setup packet
-    # @param [String] :dataOut  the data to send with an outgoing transfer, it
+    # @param [Hash] args
+    # @option args [Fixnum] :bmRequestType   the request type field for the setup packet
+    # @option args [Fixnum] :bRequest  the request field for the setup packet
+    # @option args [Fixnum] :wValue  the value field for the setup packet
+    # @option args [Fixnum] :wIndex  the index field for the setup packet
+    # @option args [String] :dataOut  the data to send with an outgoing transfer, it
     #   is appended to the setup packet
-    # @param [Fixnum] :dataIn   the number of bytes expected to receive with an ingoing transfer
+    # @option args [Fixnum] :dataIn   the number of bytes expected to receive with an ingoing transfer
     #   (excluding setup packet)
-    # @param [Fixnum] :timeout   timeout (in millseconds) that this function should wait before giving
+    # @option args [Fixnum] :timeout   timeout (in millseconds) that this function should wait before giving
     #   up due to no response being received. For an unlimited timeout, use value 0. Defaults to 1000 ms.
     #
     # @return [Fixnum] Number of bytes sent (excluding setup packet) for outgoing transfer
     # @return [String] Received data (without setup packet) for ingoing transfer
-    def control_transfer(args={})
+    # @return [self]  When called with a block
+    #
+    # @yieldparam [String, Integer, LIBUSB::Error] result  result of the transfer is yielded to the block,
+    #   when the asynchronous transfer has finished
+    # @raise [ArgumentError, LIBUSB::Error] in case of failure
+    def control_transfer(args={}, &block)
       bmRequestType = args.delete(:bmRequestType) || raise(ArgumentError, "param :bmRequestType not given")
       bRequest = args.delete(:bRequest) || raise(ArgumentError, "param :bRequest not given")
       wValue = args.delete(:wValue) || raise(ArgumentError, "param :wValue not given")
@@ -387,12 +417,33 @@ module LIBUSB
         tr.buffer = [bmRequestType, bRequest, wValue, wIndex, dataOut.bytesize, dataOut].pack('CCvvva*')
       end
 
-      tr.submit_and_wait!
+      submit_transfer(tr, dataIn, CONTROL_SETUP_SIZE, &block)
+    end
 
-      if dataIn
-        tr.actual_buffer(CONTROL_SETUP_SIZE)
+    private
+    def submit_transfer(tr, dataIn, offset)
+      if block_given?
+        tr.submit! do
+          res = dataIn ? tr.actual_buffer(offset) : tr.actual_length
+
+          if tr.status==:TRANSFER_COMPLETED
+            yield res
+          else
+            exception = Transfer::TransferStatusToError[tr.status] || ERROR_OTHER
+
+            yield exception.new("error #{tr.status}", res)
+          end
+        end
+        self
       else
-        tr.actual_length
+        tr.submit_and_wait
+
+        res = dataIn ? tr.actual_buffer(offset) : tr.actual_length
+
+        unless tr.status==:TRANSFER_COMPLETED
+          raise((Transfer::TransferStatusToError[tr.status] || ERROR_OTHER).new("error #{tr.status}", res))
+        end
+        res
       end
     end
   end