- Fixed problem with connections not being released once all data is read (closes jgaa#24)

- Refactored a few tests to avoid error-indicators in kdevelop
- Added more fine-graded time outs

Author: jgaa

externals/lest

@@ -55,9 +55,7 @@ class DataReaderStream : public DataReader {
         --getc_bytes_;
     }
 
-    void SetEof() {
-        eof_ = true;
-    }
+    void SetEof();
 
     char GetCurrentCh() const {
         assert(curr_ != nullptr);

externals/rapidjson

@@ -113,11 +113,11 @@ class IoTimer : public std::enable_shared_from_this<IoTimer>
             [weak_connection, timerName]() {
                 if (auto connection = weak_connection.lock()) {
                     if (connection->GetSocket().GetSocket().is_open()) {
-                        RESTC_CPP_LOG_WARN
+                        RESTC_CPP_LOG_TRACE
                             << "Timer " << timerName << ": "
                             << *connection
                             << " timed out.";
-                        connection->GetSocket().GetSocket().close();
+                        connection->GetSocket().Close(Socket::Reason::TIME_OUT);
                     }
                 }
             }));

include/restc-cpp/DataReaderStream.h

@@ -172,7 +172,8 @@ class IteratorFromJsonSerializer
                     state_ = State::DONE;
                     break;
                 } else {
-                    throw ParseException("Unexpected character in input stream");
+                    static const std::string err_msg{"IteratorFromJsonSerializer: Unexpected character in input stream: "};
+                    throw ParseException(err_msg + std::string(1, ch));
                 }
             }
         }

include/restc-cpp/IoTimer.h

@@ -68,7 +68,7 @@ class RapidJsonReader {
     //! \return The begin writer pointer.
     Ch* PutBegin() {
         assert(false);
-		return nullptr;
+        return nullptr;
     }
 
     //! Write a character.
@@ -86,7 +86,7 @@ class RapidJsonReader {
     //! \return Number of characters written.
     size_t PutEnd(Ch* begin) {
         assert(false);
-		return 0;
+        return 0;
     }
 
 private:

include/restc-cpp/IteratorFromJsonSerializer.h

@@ -16,8 +16,21 @@
 #include "rapidjson/writer.h"
 #include "rapidjson/stringbuffer.h"
 
+// If enabled, 'localhost' is mapped to the content of the
+// environment variable RESTC_CPP_TEST_DOCKER_ADDRESS
+
 namespace restc_cpp {
 
+#ifdef RESTC_CPP_ENABLE_URL_TEST_MAPPING
+#   ifndef RESTC_CPP_TEST_HELPER_H_
+#       error "Include "restc-cpp/test_helper.h" first"
+#   endif
+#   define MAP_URL_FOR_TESTING(url) url = GetDockerUrl(url);
+#else
+#   define MAP_URL_FOR_TESTING(url)
+#endif
+
+
 /*! Convenience class for building requests */
 class RequestBuilder
 {
@@ -30,6 +43,7 @@ class RequestBuilder
     RequestBuilder& Get(std::string url) {
         assert(url_.empty());
         url_ = std::move(url);
+        MAP_URL_FOR_TESTING(url_);
         type_ = Request::Type::GET;
         return *this;
     }
@@ -38,6 +52,7 @@ class RequestBuilder
     RequestBuilder& Post(std::string url) {
         assert(url_.empty());
         url_ = std::move(url);
+        MAP_URL_FOR_TESTING(url_);
         type_ = Request::Type::POST;
         return *this;
     }
@@ -46,6 +61,7 @@ class RequestBuilder
     RequestBuilder& Put(std::string url) {
         assert(url_.empty());
         url_ = std::move(url);
+        MAP_URL_FOR_TESTING(url_);
         type_ = Request::Type::PUT;
         return *this;
     }
@@ -54,6 +70,7 @@ class RequestBuilder
     RequestBuilder& Delete(std::string url) {
         assert(url_.empty());
         url_ = std::move(url);
+        MAP_URL_FOR_TESTING(url_);
         type_ = Request::Type::DELETE;
         return *this;
     }
@@ -76,7 +93,7 @@ class RequestBuilder
         headers_->insert({std::move(name), std::move(value)});
         return *this;
     }
-    
+
     RequestBuilder& AddHeaders(const Request::headers_t& headers) {
         if (!headers_) {
             headers_ = Request::headers_t();
@@ -87,15 +104,15 @@ class RequestBuilder
         }
         return *this;
     }
-    
+
     RequestBuilder& AddHeaders(
         boost::optional<Request::headers_t> headers) {
         if (headers) {
             return AddHeaders(*headers);
         }
         return *this;
     }
-    
+
 
     /*! Add a request argument
      *
@@ -295,6 +312,5 @@ class RequestBuilder
 
 } // restc_cpp
 
-
 #endif // RESTC_CPP_REQUEST_BUILDER_H_
 

include/restc-cpp/RapidJsonReader.h

@@ -8,11 +8,21 @@
 
 #include <vector>
 
+#include <boost/system/error_code.hpp>
+
+#include "restc-cpp/typename.h"
+#include "error.h"
+
 namespace restc_cpp {
 
 class Socket
 {
 public:
+    enum class Reason {
+      DONE,
+      TIME_OUT
+    };
+
     virtual ~Socket() = default;
 
     virtual boost::asio::ip::tcp::socket& GetSocket() = 0;
@@ -36,7 +46,7 @@ class Socket
 
     virtual void AsyncShutdown(boost::asio::yield_context& yield) = 0;
 
-    virtual void Close() = 0;
+    virtual void Close(Reason reoson = Reason::DONE) = 0;
 
     virtual bool IsOpen() const noexcept = 0;
 
@@ -49,6 +59,25 @@ class Socket
 };
 
 
+class ExceptionWrapper {
+protected:
+    template <typename Tret, typename Tfn>
+    Tret WrapException(Tfn fn) {
+        try {
+            return fn();
+        } catch (const boost::system::system_error& ex) {
+            if (ex.code().value() == boost::system::errc::operation_canceled) {
+                if (reason_ == Socket::Reason::TIME_OUT) {
+                    throw RequestTimeOutException();
+                }
+            }
+            throw;
+        }
+    }
+
+    boost::optional<Socket::Reason> reason_;
+};
+
 } // restc_cpp
 
 

include/restc-cpp/RequestBuilder.h

@@ -149,6 +149,12 @@ struct ObjectExpiredException : public RestcCppException
     : RestcCppException(cause) {}
 };
 
+struct RequestTimeOutException : public RestcCppException
+{
+    RequestTimeOutException()
+    : RestcCppException("Request Timed Out") {}
+};
+
 } // namespace
 #endif // RESTC_CPP_ERROR_H_
 

include/restc-cpp/Socket.h

@@ -1,13 +1,22 @@
 #pragma once
 
+#define RESTC_CPP_TEST_HELPER_H_
+
 #include <cstdlib>
 #include <boost/algorithm/string.hpp>
 
+
 namespace restc_cpp {
 namespace {
 
-#define STARTCASE(name) { CASE(#name)
-#define ENDCASE },
+#define STARTCASE(name) { CASE(#name) { \
+    RESTC_CPP_LOG_DEBUG << "================================"; \
+    RESTC_CPP_LOG_INFO << "Test case: " << #name; \
+    RESTC_CPP_LOG_DEBUG << "================================";
+
+#define ENDCASE \
+    RESTC_CPP_LOG_DEBUG << "============== ENDCASE ============="; \
+}},
 
 template<typename T1, typename T2>
 bool compare(const T1& left, const T2& right) {

include/restc-cpp/error.h

@@ -1,4 +1,6 @@
 #include <assert.h>
+#include <locale.h>
+#include <ios>
 
 #include "restc-cpp/restc-cpp.h"
 #include "restc-cpp/DataReader.h"
@@ -23,24 +25,35 @@ class ChunkedReaderImpl : public DataReader {
         return stream_->IsEof();
     }
 
-    void Log(const boost::asio::const_buffers_1 buffers, const char *tag) {
-        size_t seg = 0;
+    string ToPrintable(boost::string_ref buf) const {
+        ostringstream out;
+        locale loc;
+        auto pos = 0;
+        out << endl;
 
-        // At the time of the implementation, there are never multiple buffers.
-        // However, if this change in the future, this logging will still be correct.
-        // It may save some time if other propbels occur.
-        for(const auto buffer : buffers) {
+        for(const auto ch : buf) {
+            if (!(++pos % 80)) {
+                out << endl;
+            }
+            if (std::isprint(ch, loc)) {
+                out << ch;
+            } else {
+                out << '.';
+            }
+        }
 
-            boost::string_ref sr {
-                boost::asio::buffer_cast<const char *>(buffer),
-                boost::asio::buffer_size(buffer)
-            };
+        return out.str();
+    }
 
-            RESTC_CPP_LOG_TRACE << tag << ' ' << seg << "# "
-                << boost::asio::buffer_size(buffer) << " bytes: "  << sr;
+    void Log(const boost::asio::const_buffers_1 buffers, const char *tag) {
+        const auto buf_len = boost::asio::buffer_size(*buffers.begin());
 
-            ++seg;
-        }
+        // At the time of the implementation, there are never multiple buffers.
+        RESTC_CPP_LOG_TRACE << tag << ' ' << "# " << buf_len
+            << " bytes: "
+            << ToPrintable({
+                boost::asio::buffer_cast<const char *>(*buffers.begin()),
+                           buf_len});
     }
 
     boost::asio::const_buffers_1 ReadSome() override {
@@ -54,6 +67,9 @@ class ChunkedReaderImpl : public DataReader {
         if (chunk_len_ == 0) {
             RESTC_CPP_LOG_TRACE << "ChunkedReaderImpl::ReadSome(): Need new chunk.";
             chunk_len_ = GetNextChunkLen();
+            RESTC_CPP_LOG_TRACE << "ChunkedReaderImpl::ReadSome(): "
+                << "Next chunk is " << chunk_len_ << " bytes ("
+                << hex << chunk_len_ << " hex)";
             if (chunk_len_ == 0) {
                 // Read the trailer
                 RESTC_CPP_LOG_TRACE << "ChunkedReaderImpl::ReadSome(): End of chunked stream - reading headers";
@@ -130,8 +146,6 @@ class ChunkedReaderImpl : public DataReader {
             throw ParseException("Missing LF in first chunk line");
         }
 
-        RESTC_CPP_LOG_TRACE << "ChunkedReaderImpl::GetNextChunkLen(): " << chunk_len;
-
         return chunk_len;
     }
 

include/restc-cpp/test_helper.h

@@ -22,24 +22,30 @@ void DataReaderStream::Fetch() {
         RESTC_CPP_LOG_TRACE << "DataReaderStream::Fetch: Fetched buffer with "
             << boost::asio::buffer_size(buf) << " bytes.";
 
-        curr_ = boost::asio::buffer_cast<const char *>(buf);
-        end_ = curr_ + boost::asio::buffer_size(buf);
-        eof_ = curr_ == end_;
-        if (eof_) {
+        const auto bytes = boost::asio::buffer_size(buf);
+        if (bytes == 0) {
             RESTC_CPP_LOG_TRACE << "DataReaderStream::Fetch: EOF";
             throw ProtocolException("Fetch(): EOF");
         }
+        curr_ = boost::asio::buffer_cast<const char *>(buf);
+        end_ = curr_ + boost::asio::buffer_size(buf);
     }
 }
 
 boost::asio::const_buffers_1
 DataReaderStream::ReadSome() {
     Fetch();
+
     boost::asio::const_buffers_1 rval = {curr_,
         static_cast<size_t>(end_ - curr_)};
     curr_ = end_;
     RESTC_CPP_LOG_TRACE << "DataReaderStream::ReadSome: Returning buffer with "
         << boost::asio::buffer_size(rval) << " bytes.";
+
+    if (source_->IsEof()) {
+        SetEof();
+    }
+
     return rval;
 }
 
@@ -218,4 +224,9 @@ std::string DataReaderStream::GetHeaderValue() {
 }
 
 
+void DataReaderStream::SetEof() {
+    RESTC_CPP_LOG_TRACE << "Reached EOF";
+    eof_ = true;
+}
+
 } // namespace