event_source should handle errors properly

and error_handler should take HIJACKING into consideration,
that would make things more consistent and therefore easier to
handle for event_source. add two tests to make sure it would
never deadlock and all errors are handled properly.

also, if we're signaling the mutex, that always means we are not
going to connect again. therefore whether the socket is closed or
not doesn't really matter. all we care is that it's done, and
should let go.

lib/rest-core/event_source.rb

@@ -27,7 +27,7 @@ def close
 
   def wait
     raise RC::Error.new("Not yet started for: #{self}") unless mutex
-    mutex.synchronize{ condv.wait(mutex) until closed? } unless closed?
+    mutex.synchronize{ condv.wait(mutex) unless closed? } unless closed?
     self
   end
 
@@ -110,6 +110,12 @@ def onmessage_for sock
   def reconnect
     o = {REQUEST_HEADERS => {'Accept' => 'text/event-stream'},
          HIJACK          => true}.merge(opts)
-    client.get(path, query, o){ |sock| onopen(sock) }
+    client.get(path, query, o) do |sock|
+      if sock.nil? || sock.kind_of?(Exception)
+        onerror(sock)
+      else
+        onopen(sock)
+      end
+    end
   end
 end

lib/rest-core/middleware/error_handler.rb

@@ -32,7 +32,11 @@ def call env
   def process res, err
     RC::Promise.set_backtrace(err)
     if res[ASYNC]
-      res.merge(RESPONSE_BODY => err)
+      if res[HIJACK]
+        res.merge(RESPONSE_SOCKET => err)
+      else
+        res.merge(RESPONSE_BODY => err)
+      end
     else
       raise err
     end

test/test_event_source.rb

@@ -131,4 +131,25 @@
     end.start.wait
     m.should.empty?
   end
+
+  def mock_warning
+    mock(any_instance_of(RC::Promise)).warn(is_a(String)) do |msg|
+      msg.should.include?(Errno::ECONNREFUSED.new.message)
+    end
+  end
+
+  would 'not deadlock without ErrorHandler' do
+    mock_warning
+    client = RC::Simple.new.event_source('http://localhost:1')
+    client.onerror{ |e| e.should.eq nil }
+    client.start.wait
+  end
+
+  would 'not deadlock with ErrorHandler' do
+    mock_warning
+    client = RC::Universal.new(:log_method => false).
+               event_source('http://localhost:1')
+    client.onerror{ |e| e.should.kind_of?(Errno::ECONNREFUSED) }
+    client.start.wait
+  end
 end