account manager: avoid blocking on CSR generation

Change-Id: I2457c29fce6c54295aba9ebe6b059f066a6f80a0

src/jamidht/server_account_manager.cpp

@@ -22,6 +22,7 @@
 
 #include <opendht/http.h>
 #include <opendht/log.h>
+#include <opendht/thread_pool.h>
 
 #include "manager.h"
 
@@ -77,13 +78,17 @@ ServerAccountManager::initAuthentication(
     }
 
     onChange_ = std::move(onChange);
-
     const std::string url = managerHostname_ + PATH_DEVICE;
     JAMI_WARN("[Auth] authentication with: %s to %s", ctx->credentials->username.c_str(), url.c_str());
     auto request = std::make_shared<Request>(*Manager::instance().ioContext(), url, logger_);
     auto reqid = request->id();
     request->set_method(restinio::http_method_post());
     request->set_auth(ctx->credentials->username, ctx->credentials->password);
+    requests_[reqid] = request;
+
+    dht::ThreadPool::computation().run([onAsync = onAsync_, ctx, request, reqid]{
+        onAsync([ctx, request, reqid, onAsync](AccountManager& accountManager){
+            auto& this_ = *static_cast<ServerAccountManager*>(&accountManager);
             {
                 std::stringstream ss;
                 auto csr = ctx->request.get()->toString();
@@ -93,20 +98,20 @@ ServerAccountManager::initAuthentication(
                 JAMI_WARN("[Auth] Sending request: %s", csr.c_str());
                 request->set_body(ss.str());
             }
-    setHeaderFields(*request);
-    request->add_on_state_change_callback([reqid, ctx, onAsync = onAsync_]
+            this_.setHeaderFields(*request);
+            request->add_on_state_change_callback([reqid, request, ctx, onAsync]
                                                 (Request::State state, const dht::http::Response& response){
                 JAMI_DBG("[Auth] Got request callback with state=%d", (int)state);
                 if (state != Request::State::DONE)
                     return;
-        if (response.status_code == 0) {
-            ctx->onFailure(AuthError::SERVER_ERROR, "Invalid server provided");
-            return;
-        } else if (response.status_code >= 400 && response.status_code < 500)
+                if (response.status_code == 0)
+                    ctx->onFailure(AuthError::SERVER_ERROR, "Can't connect to server");
+                else if (response.status_code >= 400 && response.status_code < 500)
                     ctx->onFailure(AuthError::INVALID_ARGUMENTS, "");
                 else if (response.status_code < 200 || response.status_code > 299)
                     ctx->onFailure(AuthError::INVALID_ARGUMENTS, "");
                 else {
+                    do {
                         try {
                             Json::Value json;
                             std::string err;
@@ -115,7 +120,7 @@ ServerAccountManager::initAuthentication(
                             if (!reader->parse(response.body.data(), response.body.data() + response.body.size(), &json, &err)){
                                 JAMI_ERR("[Auth] Can't parse server response: %s", err.c_str());
                                 ctx->onFailure(AuthError::SERVER_ERROR, "Can't parse server response");
-                    return;
+                                break;
                             }
                             JAMI_WARN("[Auth] Got server response: %s", response.body.c_str());
 
@@ -128,7 +133,7 @@ ServerAccountManager::initAuthentication(
                             if (not accountCert) {
                                 JAMI_ERR("[Auth] Can't parse certificate: no issuer");
                                 ctx->onFailure(AuthError::SERVER_ERROR, "Invalid certificate from server");
-                    return;
+                                break;
                             }
                             auto receipt = json["deviceReceipt"].asString();
                             Json::Value receiptJson;
@@ -136,7 +141,7 @@ ServerAccountManager::initAuthentication(
                             if (!receiptReader->parse(receipt.data(), receipt.data() + receipt.size(), &receiptJson, &err)){
                                 JAMI_ERR("[Auth] Can't parse receipt from server: %s", err.c_str());
                                 ctx->onFailure(AuthError::SERVER_ERROR, "Can't parse receipt from server");
-                    return;
+                                break;
                             }
                             onAsync([reqid, ctx,
                                         json=std::move(json),
@@ -183,17 +188,22 @@ ServerAccountManager::initAuthentication(
 
                                 ctx->onSuccess(*this_.info_, std::move(config), std::move(receipt), std::move(receiptSignature));
                                 this_.syncDevices();
-                    this_.requests_.erase(reqid);
                             });
                         }
                         catch (const std::exception& e) {
                             JAMI_ERR("Error when loading account: %s", e.what());
                             ctx->onFailure(AuthError::NETWORK, "");
                         }
+                    } while (false);
                 }
+                onAsync([reqid](AccountManager& accountManager){
+                    auto& this_ = *static_cast<ServerAccountManager*>(&accountManager);
+                    this_.requests_.erase(reqid);
+                });
             });
             request->send();
-    requests_[reqid] = std::move(request);
+        });
+    });
 }
 
 void