Fixed comilation.

Author: jgaa

CMakeLists.txt

@@ -260,7 +260,6 @@ if (NOT EMBEDDED_RESTC_CPP)
     endif()
 
     find_package(Boost ${RESTC_BOOST_VERSION} REQUIRED ${restc_cpp_boost_find_config} COMPONENTS
-        system
         program_options
         filesystem
         date_time

include/restc-cpp/IoTimer.h

@@ -145,8 +145,7 @@ class IoTimer : public std::enable_shared_from_this<IoTimer>
 
     void Start(int millisecondsTimeOut)
     {
-        timer_.expires_from_now(
-            boost::posix_time::milliseconds(millisecondsTimeOut));
+        timer_.expires_after(std::chrono::milliseconds{millisecondsTimeOut});
         is_active_ = true;
         try {
             timer_.async_wait(std::bind(
@@ -162,7 +161,7 @@ class IoTimer : public std::enable_shared_from_this<IoTimer>
     bool is_active_ = false;
     bool is_expiered_ = false;
     close_t close_;
-    boost::asio::deadline_timer timer_;
+    boost::asio::steady_timer timer_;
     const std::string timer_name_;
 };
 

include/restc-cpp/restc-cpp.h

@@ -335,15 +335,14 @@ class Context {
     /*! Asynchronously sleep for a period */
     template<class Rep, class Period>
     void Sleep(const std::chrono::duration<Rep, Period>& duration) {
-        const auto microseconds =
+        const uint64_t microseconds =
             std::chrono::duration_cast<std::chrono::microseconds>(
                 duration).count();
-        ::boost::posix_time::microseconds ms(microseconds);
-        Sleep(ms);
+        Sleep(microseconds);
     }
 
     /*! Asynchronously sleep for a period */
-    virtual void Sleep(const ::boost::posix_time::microseconds& ms) = 0;
+    virtual void Sleep(const uint64_t microseconds) = 0;
 
     static std::unique_ptr<Context>
         Create(::boost::asio::yield_context& yield,

src/ConnectionPoolImpl.cpp

@@ -250,8 +250,8 @@ class ConnectionPoolImpl
 private:
     void ScheduleNextCacheCleanup() {
         LOCK_ALWAYS_;
-        cache_cleanup_timer_.expires_from_now(
-            boost::posix_time::seconds(properties_->cacheCleanupIntervalSeconds));
+        cache_cleanup_timer_.expires_after(
+            std::chrono::seconds(properties_->cacheCleanupIntervalSeconds));
         cache_cleanup_timer_.async_wait([capture0 = shared_from_this()](auto &&PH1) {
             capture0->OnCacheCleanup(std::forward<decltype(PH1)>(PH1));
         });
@@ -452,7 +452,7 @@ class ConnectionPoolImpl
 #endif
     const Request::Properties::ptr_t properties_;
     ConnectionWrapper::release_callback_t on_release_;
-    boost::asio::deadline_timer cache_cleanup_timer_;
+    boost::asio::steady_timer cache_cleanup_timer_;
 
     mutable std::mutex mutex_;
 }; // ConnectionPoolImpl

src/RestClientImpl.cpp

@@ -113,11 +113,10 @@ class  RestClientImpl final : public RestClient {
             return req.Execute(*this);
         }
 
-        void Sleep(const boost::posix_time::microseconds& ms) override {
-            boost::asio::deadline_timer timer(
+        void Sleep(const uint64_t microseconds) override {
+            boost::asio::steady_timer timer(
                 GetClient().GetIoService(),
-                boost::posix_time::microseconds(ms));
-
+                boost::asio::chrono::microseconds(microseconds));
             timer.async_wait(GetYield());
         }
 

tests/functional/CRUD_test.cpp

@@ -67,6 +67,11 @@ TEST(CRUD, Crud) {
     // Get the reply before we validate the operation. Else it may run in parallel
     reply->fetchAndIgnore();
 
+    // This test fails randomly on fast machines.
+    // I believe the problem is a race condition in the test container.
+    // Adding sleeps is generally the worst possible way to "fix" such errors, but it may work in this case.
+    std::this_thread::sleep_for(1s);
+
     // Fetch again
     reply = RequestBuilder(ctx)
         .Get(GetDockerUrl(http_url) + "/" + post.id) // URL

tests/functional/ManyConnectionsTest.cpp

@@ -118,8 +118,7 @@ TEST(ManyConnections, CRUD) {
                 // We can't just wait on the lock since we are in a co-routine.
                 // So we use the async_wait() to poll in stead.
                 while(!locker.try_lock()) {
-                    boost::asio::deadline_timer timer(rest_client->GetIoService(),
-                        boost::posix_time::milliseconds(1));
+                    boost::asio::steady_timer timer(rest_client->GetIoService(), 1ms);
                     timer.async_wait(ctx.GetYield());
                 }
                 locker.unlock();

tests/functional/OwnIoserviceTests.cpp

@@ -75,8 +75,7 @@ TEST(OwnIoservice, All)
                 // We can't just wait on the lock since we are in a co-routine.
                 // So we use the async_wait() to poll in stead.
                 while(!mutex.try_lock()) {
-                    boost::asio::deadline_timer timer(rest_client->GetIoService(),
-                        boost::posix_time::milliseconds(1));
+                    boost::asio::steady_timer timer(rest_client->GetIoService(), 1ms);
                     timer.async_wait(ctx.GetYield());
                 }
                 mutex.unlock();