remove v8 dependency for arangoimp

arangosh/CMakeLists.txt

@@ -97,16 +97,13 @@ add_executable(
     ${BIN_ARANGOIMP}
     ArangoShell/ArangoClient.cpp
     V8Client/ImportHelper.cpp
-    V8Client/V8ClientConnection.cpp
     V8Client/arangoimp.cpp
 )
 
 target_link_libraries(
     ${BIN_ARANGOIMP}
-    ${LIB_ARANGO_V8}
     ${LIB_ARANGO_CLIENT}
     ${LIB_ARANGO}
-    ${V8_LIBS}
     ${ICU_LIBS}
     ${BT_LIBS}
     ${ZLIB_LIBS}

arangosh/Makefile.files

@@ -47,16 +47,13 @@ bin_arangoimp_CPPFLAGS = \
 	$(AM_CPPFLAGS) 
 
 bin_arangoimp_LDADD = \
-	lib/libarango_v8.a \
 	lib/libarango_client.a \
 	lib/libarango.a \
-	$(LIBS) \
+	$(LIBS) 
-	@V8_LIBS@
 
 bin_arangoimp_SOURCES = \
 	arangosh/ArangoShell/ArangoClient.cpp \
 	arangosh/V8Client/ImportHelper.cpp \
-	arangosh/V8Client/V8ClientConnection.cpp \
 	arangosh/V8Client/arangoimp.cpp
 
 ################################################################################

arangosh/V8Client/arangodump.cpp

@@ -304,7 +304,7 @@ static string GetArangoVersion () {
 
   SimpleHttpResult* response = Client->request(HttpRequest::HTTP_REQUEST_GET,
                                                "/_api/version",
-                                               0,
+                                               nullptr,
                                                0,
                                                headers);
 

arangosh/V8Client/arangoimp.cpp

@@ -43,16 +43,14 @@
 #include "Rest/Endpoint.h"
 #include "Rest/InitialiseRest.h"
 #include "Rest/HttpResponse.h"
+#include "SimpleHttpClient/GeneralClientConnection.h"
 #include "SimpleHttpClient/SimpleHttpClient.h"
 #include "SimpleHttpClient/SimpleHttpResult.h"
-#include "V8Client/V8ClientConnection.h"
-
 
 using namespace std;
 using namespace triagens::basics;
 using namespace triagens::httpclient;
 using namespace triagens::rest;
-using namespace triagens::v8client;
 using namespace triagens::arango;
 
 // -----------------------------------------------------------------------------
@@ -65,12 +63,6 @@ using namespace triagens::arango;
 
 ArangoClient BaseClient("arangoimp");
 
-////////////////////////////////////////////////////////////////////////////////
-/// @brief the initial default connection
-////////////////////////////////////////////////////////////////////////////////
-
-V8ClientConnection* ClientConnection = nullptr;
-
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief max size body size (used for imports)
 ////////////////////////////////////////////////////////////////////////////////
@@ -254,6 +246,23 @@ static void arangoimpExitFunction(int exitCode, void* data) {
 
 #endif
 
+////////////////////////////////////////////////////////////////////////////////
+/// @brief request location rewriter (injects database name)
+////////////////////////////////////////////////////////////////////////////////
+
+static string RewriteLocation (void* data, const std::string& location) {
+  if (location.substr(0, 5) == "/_db/") {
+    // location already contains /_db/
+    return location;
+  }
+
+  if (location[0] == '/') {
+    return "/_db/" + BaseClient.databaseName() + location;
+  }
+  else {
+    return "/_db/" + BaseClient.databaseName() + "/" + location;
+  }
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief main
@@ -288,27 +297,40 @@ int main (int argc, char* argv[]) {
     TRI_EXIT_FUNCTION(EXIT_FAILURE, nullptr);
   }
 
-  ClientConnection = new V8ClientConnection(BaseClient.endpointServer(),
+  // create a connection 
-                                            BaseClient.databaseName(),
+  { 
-                                            BaseClient.username(),
+    std::unique_ptr<triagens::httpclient::GeneralClientConnection> connection;
-                                            BaseClient.password(),
+    
+    connection.reset(GeneralClientConnection::factory(BaseClient.endpointServer(),
                                                       BaseClient.requestTimeout(),
                                                       BaseClient.connectTimeout(),
                                                       ArangoClient::DEFAULT_RETRIES,
-                                            BaseClient.sslProtocol(),
+                                                      BaseClient.sslProtocol()));
-                                            false);
     
-  if (! ClientConnection->isConnected() ||
+    if (connection == nullptr) {
-      ClientConnection->getLastHttpReturnCode() != HttpResponse::OK) {
+      cerr << "out of memory" << endl;
-    cerr << "Could not connect to endpoint '" << BaseClient.endpointServer()->getSpecification()
+      TRI_EXIT_FUNCTION(EXIT_FAILURE, nullptr);
-         << "', database: '" << BaseClient.databaseName() << "'" << endl;
+    }
-    cerr << "Error message: '" << ClientConnection->getErrorMessage() << "'" << endl;
+
+    // simple http client is only valid inside this scope 
+    { 
+      SimpleHttpClient client(connection.get(), BaseClient.requestTimeout(), false);
+      
+      client.setLocationRewriter(nullptr, &RewriteLocation);
+      client.setUserNamePassword("/", BaseClient.username(), BaseClient.password());
+
+      std::string const versionString = client.getServerVersion();
+
+      if (! connection->isConnected()) {
+        cerr << "Could not connect to endpoint '" << BaseClient.endpointString()
+            << "', database: '" << BaseClient.databaseName() << "', username: '" << BaseClient.username() << "'" << endl;
+        cerr << "Error message: '" << client.getErrorMessage() << "'" << endl;
         TRI_EXIT_FUNCTION(EXIT_FAILURE, nullptr);
       }
 
       // successfully connected
       cout << "Connected to ArangoDB '" << BaseClient.endpointServer()->getSpecification()
-       << "', version " << ClientConnection->getVersion() << ", database: '"
+          << "', version " << client.getServerVersion() << ", database: '"
           << BaseClient.databaseName() << "', username: '" << BaseClient.username() << "'" << endl;
 
       cout << "----------------------------------------" << endl;
@@ -327,7 +349,7 @@ int main (int argc, char* argv[]) {
       cout << "request timeout:  " << BaseClient.requestTimeout() << endl;
       cout << "----------------------------------------" << endl;
 
-  ImportHelper ih(ClientConnection->getHttpClient(), ChunkSize);
+      triagens::v8client::ImportHelper ih(&client, ChunkSize);
 
       // create colletion
       if (CreateCollection) {
@@ -402,14 +424,14 @@ int main (int argc, char* argv[]) {
         // import type
         if (TypeImport == "csv") {
           cout << "Starting CSV import..." << endl;
-      ok = ih.importDelimited(CollectionName, FileName, ImportHelper::CSV);
+          ok = ih.importDelimited(CollectionName, FileName, triagens::v8client::ImportHelper::CSV);
         }
 
         else if (TypeImport == "tsv") {
           cout << "Starting TSV import..." << endl;
           ih.setQuote("");
           ih.setSeparator("\\t");
-      ok = ih.importDelimited(CollectionName, FileName, ImportHelper::TSV);
+          ok = ih.importDelimited(CollectionName, FileName, triagens::v8client::ImportHelper::TSV);
         }
 
         else if (TypeImport == "json") {
@@ -446,8 +468,10 @@ int main (int argc, char* argv[]) {
       catch (...) {
         cerr << "Got an unknown exception during import" << endl;
       }
+    }
+
+  }
 
-  delete ClientConnection;
 
   TRIAGENS_REST_SHUTDOWN;
 

lib/SimpleHttpClient/SimpleHttpClient.cpp

@@ -29,10 +29,9 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 #include "SimpleHttpClient.h"
-
+#include "Basics/JsonHelper.h"
-#include "Basics/StringUtils.h"
 #include "Basics/logging.h"
-
+#include "Basics/StringUtils.h"
 #include "GeneralClientConnection.h"
 #include "SimpleHttpResult.h"
 
@@ -768,6 +767,79 @@ namespace triagens {
         processChunkedHeader();
       }
     }
+
+////////////////////////////////////////////////////////////////////////////////
+/// @brief extract an error message from a response
+////////////////////////////////////////////////////////////////////////////////
+
+    std::string SimpleHttpClient::getHttpErrorMessage (SimpleHttpResult* result) {
+      triagens::basics::StringBuffer const& body = result->getBody();
+      std::string details;
+
+      std::unique_ptr<TRI_json_t> json(triagens::basics::JsonHelper::fromString(body.c_str(), body.length()));
+
+      if (json != nullptr) {
+        std::string const errorMessage = triagens::basics::JsonHelper::getStringValue(json.get(), "errorMessage", "");
+        int errorNum = triagens::basics::JsonHelper::getNumericValue<int>(json.get(), "errorNum", 0);
+
+        if (errorMessage != "" && errorNum > 0) {
+          details = ": ArangoError " + StringUtils::itoa(errorNum) + ": " + errorMessage;
+        }
+      }
+
+      return "got error from server: HTTP " +
+            triagens::basics::StringUtils::itoa(result->getHttpReturnCode()) +
+            " (" + result->getHttpReturnMessage() + ")" +
+            details;
+    }
+
+////////////////////////////////////////////////////////////////////////////////
+/// @brief fetch the version from the server
+////////////////////////////////////////////////////////////////////////////////
+
+    std::string SimpleHttpClient::getServerVersion () {
+      std::map<string, string> headers;
+
+      std::unique_ptr<SimpleHttpResult> response(request(HttpRequest::HTTP_REQUEST_GET,
+                                                          "/_api/version",
+                                                          nullptr,
+                                                          0,
+                                                          headers));
+
+      if (response == nullptr || ! response->isComplete()) {
+        return "";
+      }
+
+      std::string version;
+
+      if (response->getHttpReturnCode() == HttpResponse::OK) {
+        // default value
+        version = "arango";
+
+        // convert response body to json
+        std::unique_ptr<TRI_json_t> json(TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, response->getBody().c_str()));
+
+        if (json != nullptr) {
+          // look up "server" value
+          std::string const server = triagens::basics::JsonHelper::getStringValue(json.get(), "server", "");
+
+          // "server" value is a string and content is "arango"
+          if (server == "arango") {
+            // look up "version" value
+            version = triagens::basics::JsonHelper::getStringValue(json.get(), "version", "");
+          }
+        }
+      }
+      else {
+        if (response->wasHttpError()) {
+          setErrorMessage(getHttpErrorMessage(response.get()), false);
+        }
+        _connection->disconnect();
+      }
+
+      return version;
+    }
+
   }
 }
 

lib/SimpleHttpClient/SimpleHttpClient.h

@@ -190,7 +190,21 @@ namespace triagens {
 /// @brief checks whether an error message is already there
 ////////////////////////////////////////////////////////////////////////////////
 
-      bool haveErrorMessage () { return _errorMessage.size() > 0;}
+      bool haveErrorMessage () const { 
+        return _errorMessage.size() > 0;
+      }
+
+////////////////////////////////////////////////////////////////////////////////
+/// @brief fetch the version from the server
+////////////////////////////////////////////////////////////////////////////////
+
+      std::string getServerVersion ();
+
+////////////////////////////////////////////////////////////////////////////////
+/// @brief extract an error message from a response
+////////////////////////////////////////////////////////////////////////////////
+
+      std::string getHttpErrorMessage (SimpleHttpResult*);
 
     private: