Abstracting Services In Ruby C0 Coverage Information - RCov

       @verbose = 0

       super

     end

       @request_count ||= 0; @request_count += 1

       request.create_timestamp! if needs_request_timestamp?

       request.create_identifier! if needs_request_identifier?

       @before_send_request.call(self, request) if @before_send_request

       relative_request_delay! request

       request_payload = encoder.dup.encode(request)

       opaque_response = _send_request(request, request_payload)

       receive_response(request, opaque_response)

     end

       @request_count ||= 0; @request_count += 1

       additional_data = { }

       if req_and_state = _receive_request(stream, additional_data)

         # $stderr.puts "req_and_state = #{req_and_state.inspect}"

         request = req_and_state[0] = encoder.dup.decode(req_and_state.first)

         # $stderr.puts "req_and_state AFTER DECODE = #{req_and_state.inspect}"

         request.additional_data!.update(additional_data) if request

         if @after_receive_request

           begin

             @after_receive_request.call(self, request)

           rescue ::Exception => exc

             _log { [ :receive_request, :after_receive_request, :exception, exc ] }

           end

         end

       end

       req_and_state

     end

       request = response.request

       if @on_response_exception && response.exception

         begin

           @on_response_exception.call(self, response)

         rescue ::Exception => exc

           _log { [ :send_response, :response, response, :on_response_exception, exc ] }

         end

       end

       if @one_way && request.block

         request.block.call(response)

       else

         response.request = nil # avoid sending back entire Request.

         response_payload = decoder.dup.encode(response)

         _send_response(request, response, response_payload, stream, request_state)

       end

     end

       response_payload = _receive_response(request, opaque_response)

       response = decoder.dup.decode(response_payload)

       if response

         if exc = response.exception

           exc.invoke!

         else

           if ! @one_way && request.block

             request.block.call(response)

           end

           response.result

         end

       end

     end

       raise Error::SubclassResponsibility "subclass responsibility"

     end

       request = request_state = request_ok = response = response_ok = nil

       exception = original_exception = unforwardable_exception = nil

       request, request_state = receive_request(in_stream)

       if request

         request_ok = true

         response = invoke_request!(request)

         response_ok = true

         self

       else

         nil

       end

     rescue ::Exception => exc

       exception = original_exception = exc

       _log [ :request_error, exc ]

       @on_exception.call(self, exc, :request, request) if @on_exception

     ensure

       begin

         if request_ok

           if exception && ! response_ok

             case exception

             when *Error::Unforwardable.unforwardable

               unforwardable_exception = exception = Error::Unforwardable.new(exception)

             end

             response = Response.new(request, nil, exception)

           end

           if out_stream

             send_response(response, out_stream, request_state)

           end

         end

       rescue ::Exception => exc

         _log [ :response_error, exc ]

         @on_exception.call(self, exc, :response, response) if @on_exception

       end

       raise original_exception if unforwardable_exception

     end

       old_trap = { }

       [ "TERM", "HUP" ].each do | sig |

         trap = proc do | *args |

           @running = false

           unless @processing_request

             raise ::ASIR::Error::Terminate, "#{self} by SIG#{sig} #{args.inspect} in #{__FILE__}:#{__LINE__}"

           end

         end

         old_trap[sig] = Signal.trap(sig, trap)

       end

       yield

     ensure

       # $stderr.puts "old_trap = #{old_trap.inspect}"

       old_trap.each do | sig, trap |

         Signal.trap(sig, trap) rescue nil

       end

     end

       @encoder ||=

         Coder::Identity.new

     end

       @decoder ||= 

         encoder

     end

       _processing_request = @processing_request

       @processing_request = true

       wait_for_delay! request

       request.invoke!

     ensure

       @processing_request = _processing_request

     end

       case delay = request.delay

       when nil

       when Numeric

         now ||= Time.now

         delay = delay.to_f

         request.delay = (now + delay).utc

       when Time

         now ||= Time.now

         delay = (delay - now).to_f

         delay = 0 if delay < 0

       else

         raise TypeError, "Expected request.delay to be Numeric or Time, given #{delay.class}"

       end

       delay

     end

       while (delay = relative_request_delay!(request)) && delay > 0 

         sleep delay

       end

       self

     end

       @running = false

       raise Error::Terminate if force

       self

     end

   end

   # !SLIDE END

 end