Update test and make lookup and update more thread-safe.

deanberris · deanberris · commit f452c87df4d6 · 2013-04-07T01:53:19.000+11:00
diff --git a/http/src/http/server/simple_sessions.cpp b/http/src/http/server/simple_sessions.cpp
@@ -10,7 +10,7 @@
 namespace network {
 namespace http {
 
-session& simple_sessions::lookup(boost::string_ref session_id) {
+session simple_sessions::lookup(boost::string_ref session_id) {
   std::string real_session_id =
       session_id.empty() ? std::to_string(next_session_id_.fetch_add(
           1, std::memory_order::memory_order_seq_cst)) :
@@ -26,5 +26,23 @@ session& simple_sessions::lookup(boost::string_ref session_id) {
   return result.first->second;
 }
 
+void simple_sessions::update(boost::string_ref session_id, session&& session) {
+  std::string real_session_id =
+      session_id.empty() ? std::to_string(next_session_id_.fetch_add(
+          1, std::memory_order::memory_order_seq_cst)) :
+      static_cast<std::string>(session_id);
+  assert(real_session_id != "");
+  std::lock_guard<std::mutex> lock_sessions(sessions_mutex_);
+  auto it = sessions_.find(real_session_id);
+  if (it != sessions_.end()) {
+    it->second = session;
+  } else {
+    bool added = false;
+    std::tie(it, added) = sessions_.insert(make_pair(std::move(real_session_id),
+                                                     session));
+    assert(added && " -- for some reason we cannot add here.");
+  }
+}
+
 }  // namespace http
 }  // namespace network
diff --git a/http/src/http/server/simple_sessions.hpp b/http/src/http/server/simple_sessions.hpp
@@ -23,7 +23,8 @@ struct simple_sessions {
   simple_sessions& operator=(const simple_sessions&) = delete;
   simple_sessions& operator=(simple_sessions&) = delete;
 
-  session &lookup(boost::string_ref session_id);
+  session lookup(boost::string_ref session_id);
+  void update(boost::string_ref session_id, session&& session);
  private:
   typedef std::unordered_map<std::string, session> session_map_type;
   std::mutex sessions_mutex_;
diff --git a/http/test/server_simple_sessions_test.cpp b/http/test/server_simple_sessions_test.cpp
@@ -7,6 +7,7 @@
 #include <gtest/gtest.h>
 #include <http/server/simple_sessions.hpp>
 #include <future>
+#include <map>
 
 namespace http = network::http;
 namespace net = network;
@@ -20,42 +21,39 @@ TEST(simple_sessions_test, constructor) {
 
 TEST(simple_sessions_test, lookup) {
   http::simple_sessions simple_sessions;
-  http::session &session = simple_sessions.lookup("sessionid");
+  http::session session = simple_sessions.lookup("sessionid");
   (void) session;
 }
 
 TEST(simple_sessions_test, update) {
   http::simple_sessions simple_sessions;
   {
-    http::session &session = simple_sessions.lookup("sessionid");
+    http::session session = simple_sessions.lookup("sessionid");
     session.set("user", "some-user");
+    simple_sessions.update("sessionid", std::move(session));
   }
   {
-    http::session &session = simple_sessions.lookup("sessionid");
+    http::session session = simple_sessions.lookup("sessionid");
     EXPECT_EQ("some-user", session["user"]);
   }
 }
 
 TEST(simple_sessions_test, threaded_sessions) {
   http::simple_sessions simple_sessions;
-  auto f0 = std::async([&]() {
-    http::session &session = simple_sessions.lookup("");
-    return session["id"];
-  });
-  auto f1 = std::async([&]() {
-    http::session &session = simple_sessions.lookup("");
-    return session["id"];
-  });
-  auto f2 = std::async([&]() {
-    http::session &session = simple_sessions.lookup("");
-    return session["id"];
-  });
-  std::string session0 = f0.get(),
-    session1 = f1.get(),
-    session2 = f2.get();
-  EXPECT_NE(session0, session1);
-  EXPECT_NE(session1, session2);
-  EXPECT_NE(session0, session2);
+  // Run many asynchronous functions (hoping that there will be many threads
+  // created) so that we may be able to exercise the atomics and the
+  // concurrency of the simple session manager.
+  std::vector<std::future<std::string>> futures;
+  constexpr size_t max_sessions = 1000;
+  for (size_t counter = 0; counter < max_sessions; ++counter) {
+    futures.emplace_back(std::async(std::launch::async, [&]() {
+      return simple_sessions.lookup("")["id"];
+    }));
+  }
+  std::set<std::string> ids;
+  for (auto &future : futures)
+    ids.emplace(future.get());
+  EXPECT_EQ(max_sessions, ids.size());
 }
 
 }  // namespace
