static void ParseProgramOptions (int argc, char* argv[]) { ProgramOptionsDescription description("STANDARD options"); description ("async", &Async, "send asynchronous requests") ("concurrency", &ThreadConcurrency, "number of parallel connections") ("requests", &Operations, "total number of operations") ("batch-size", &BatchSize, "number of operations in one batch (0 disables batching)") ("keep-alive", &KeepAlive, "use HTTP keep-alive") ("collection", &Collection, "collection name to use in tests") ("test-case", &TestCase, "test case to use (possible values: version, document, collection, import-document, hash, skiplist, edge, shapes, shapes-append, random-shapes, crud, crud-append, crud-write-read, aqltrx, counttrx, multitrx, multi-collection, aqlinsert, aqlv8)") ("complexity", &Complexity, "complexity parameter for the test") ("delay", &Delay, "use a startup delay (necessary only when run in series)") ("progress", &Progress, "show progress") ("verbose", &verbose, "print out replies if the http-header indicates db-errors") ; BaseClient.setupGeneral(description); BaseClient.setupServer(description); vector<string> arguments; description.arguments(&arguments); ProgramOptions options; BaseClient.parse(options, description, "--concurrency <concurrency> --requests <request> --test-case <case> ...", argc, argv, "arangob.conf"); }
static void ParseProgramOptions (int argc, char* argv[]) { ProgramOptionsDescription description("STANDARD options"); description ("async", &Async, "send asychronous requests") ("concurrency", &Concurrency, "number of parallel connections") ("requests", &Operations, "total number of operations") ("batch-size", &BatchSize, "number of operations in one batch (0 disables batching)") ("keep-alive", &KeepAlive, "use HTTP keep-alive") ("collection", &Collection, "collection name to use in tests") ("test-case", &TestCase, "test case to use") ("complexity", &Complexity, "complexity parameter for the test") ("delay", &Delay, "use a startup delay (necessary only when run in series)") ("progress", &Progress, "show progress") ; BaseClient.setupGeneral(description); BaseClient.setupServer(description); vector<string> arguments; description.arguments(&arguments); ProgramOptions options; BaseClient.parse(options, description, "--concurrency <concurrency> --requests <request> --test-case <case> ...", argc, argv, "arangob.conf"); }
static void ParseProgramOptions (int argc, char* argv[]) { ProgramOptionsDescription description("STANDARD options"); description ("collection", &Collections, "restrict to collection name (can be specified multiple times)") ("create-database", &CreateDatabase, "create the target database if it does not exist") ("batch-size", &ChunkSize, "maximum size for individual data batches (in bytes)") ("import-data", &ImportData, "import data into collection") ("recycle-ids", &RecycleIds, "recycle collection and revision ids from dump") ("force", &Force, "continue restore even in the face of some server-side errors") ("create-collection", &ImportStructure, "create collection structure") ("include-system-collections", &IncludeSystemCollections, "include system collections") ("input-directory", &InputDirectory, "input directory") ("overwrite", &Overwrite, "overwrite collections if they exist") ("progress", &Progress, "show progress") ; BaseClient.setupGeneral(description); BaseClient.setupServer(description); vector<string> arguments; description.arguments(&arguments); ProgramOptions options; BaseClient.parse(options, description, "", argc, argv, "arangorestore.conf"); if (1 == arguments.size()) { InputDirectory = arguments[0]; } }
static void ParseProgramOptions (int argc, char* argv[]) { ProgramOptionsDescription description("STANDARD options"); description ("collection", &Collections, "restrict to collection name (can be specified multiple times)") ("batch-size", &ChunkSize, "maximum size for individual data batches (in bytes)") ("dump-data", &DumpData, "dump collection data") ("include-system-collections", &IncludeSystemCollections, "include system collections") ("output-directory", &OutputDirectory, "output directory") ("overwrite", &Overwrite, "overwrite data in output directory") ("progress", &Progress, "show progress") ("tick-start", &TickStart, "only include data after this tick") ("tick-end", &TickEnd, "last tick to be included in data dump") ; BaseClient.setupGeneral(description); BaseClient.setupServer(description); vector<string> arguments; description.arguments(&arguments); ProgramOptions options; BaseClient.parse(options, description, argc, argv, "arangodump.conf"); if (1 == arguments.size()) { OutputDirectory = arguments[0]; } }
static void ParseProgramOptions (int argc, char* argv[]) { ProgramOptionsDescription description("STANDARD options"); ProgramOptionsDescription ruby("RUBY options"); ruby ("ruby.directory", &StartupPath, "startup paths containing the Ruby files; multiple directories can be separated by cola") ("ruby.modules-path", &StartupModules, "one or more directories separated by cola") ; description (ruby, false) ; // fill in used options BaseClient.setupGeneral(description); BaseClient.setupServer(description); // and parse the command line and config file ProgramOptions options; BaseClient.parse(options, description, argc, argv, "arangoirb.conf"); // check module path if (StartupModules.empty()) { LOGGER_FATAL_AND_EXIT("module path not known, please use '--ruby.modules-path'"); } }
static void ParseProgramOptions (int argc, char* argv[]) { ProgramOptionsDescription deprecatedOptions("DEPRECATED options"); deprecatedOptions ("max-upload-size", &ChunkSize, "size for individual data batches (in bytes)") ; ProgramOptionsDescription description("STANDARD options"); description ("file", &FileName, "file name (\"-\" for STDIN)") ("batch-size", &ChunkSize, "size for individual data batches (in bytes)") ("collection", &CollectionName, "collection name") ("create-collection", &CreateCollection, "create collection if it does not yet exist") ("type", &TypeImport, "type of file (\"csv\", \"tsv\", or \"json\")") ("quote", &Quote, "quote character(s)") ("separator", &Separator, "separator") ("progress", &Progress, "show progress") (deprecatedOptions, true) ; BaseClient.setupGeneral(description); BaseClient.setupServer(description); vector<string> arguments; description.arguments(&arguments); ProgramOptions options; BaseClient.parse(options, description, "--file <file> --type <type> --collection <collection>", argc, argv, "arangoimp.conf"); if (FileName == "" && arguments.size() > 0) { FileName = arguments[0]; } }
static MRubyClientConnection* createConnection (mrb_state* mrb) { return new MRubyClientConnection(mrb, BaseClient.endpointServer(), BaseClient.username(), BaseClient.password(), BaseClient.requestTimeout(), BaseClient.connectTimeout(), ArangoClient::DEFAULT_RETRIES, false); }
static string rewriteLocation (void* data, const 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; } }
static int TryCreateDatabase (std::string const& name) { triagens::basics::Json json(triagens::basics::Json::Object); json("name", triagens::basics::Json(name)); triagens::basics::Json user(triagens::basics::Json::Object); user("username", triagens::basics::Json(BaseClient.username())); user("passwd", triagens::basics::Json(BaseClient.password())); triagens::basics::Json users(triagens::basics::Json::Array); users.add(user); json("users", users); std::string const body(triagens::basics::JsonHelper::toString(json.json())); std::unique_ptr<SimpleHttpResult> response(Client->request(HttpRequest::HTTP_REQUEST_POST, "/_api/database", body.c_str(), body.size())); if (response == nullptr || ! response->isComplete()) { return TRI_ERROR_INTERNAL; } auto returnCode = response->getHttpReturnCode(); if (returnCode == HttpResponse::OK || returnCode == HttpResponse::CREATED) { // all ok return TRI_ERROR_NO_ERROR; } else if (returnCode == HttpResponse::UNAUTHORIZED || returnCode == HttpResponse::FORBIDDEN) { // invalid authorization Client->setErrorMessage(GetHttpErrorMessage(response.get()), false); return TRI_ERROR_FORBIDDEN; } // any other error Client->setErrorMessage(GetHttpErrorMessage(response.get()), false); return TRI_ERROR_INTERNAL; }
static void RunShell (mrb_state* mrb) { MRLineEditor console(mrb, ".arangoirb.history"); console.open(false /*! NoAutoComplete*/); while (true) { char* input = console.prompt("arangoirb> "); if (input == 0) { break; } if (*input == '\0') { TRI_FreeString(TRI_CORE_MEM_ZONE, input); continue; } console.addHistory(input); struct mrb_parser_state* p = mrb_parse_nstring(mrb, input, strlen(input), NULL); TRI_FreeString(TRI_CORE_MEM_ZONE, input); if (p == 0 || p->tree == 0 || 0 < p->nerr) { cout << "UPPS!\n"; continue; } int n = mrb_generate_code(mrb, p); if (n < 0) { cout << "UPPS: " << n << " returned by mrb_generate_code\n"; continue; } mrb_value result = mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb)); if (mrb->exc) { cout << "Caught exception:\n"; mrb_p(mrb, mrb_obj_value(mrb->exc)); mrb->exc = 0; } else if (! mrb_nil_p(result)) { mrb_p(mrb, result); } } console.close(); cout << endl; BaseClient.printByeBye(); }
int main (int argc, char* argv[]) { int ret = EXIT_SUCCESS; arangodumpEntryFunction(); TRIAGENS_C_INITIALISE(argc, argv); TRIAGENS_REST_INITIALISE(argc, argv); TRI_InitialiseLogging(false); // ............................................................................. // set defaults // ............................................................................. int err = 0; OutputDirectory = FileUtils::currentDirectory(&err).append(TRI_DIR_SEPARATOR_STR).append("dump"); BaseClient.setEndpointString(Endpoint::getDefaultEndpoint()); // ............................................................................. // parse the program options // ............................................................................. ParseProgramOptions(argc, argv); // use a minimum value for batches if (ChunkSize < 1024 * 128) { ChunkSize = 1024 * 128; } if (TickStart < TickEnd) { cerr << "invalid values for --tick-start or --tick-end" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } // ............................................................................. // create output directory // ............................................................................. bool isDirectory = false; if (OutputDirectory != "") { isDirectory = TRI_IsDirectory(OutputDirectory.c_str()); } if (OutputDirectory == "" || (TRI_ExistsFile(OutputDirectory.c_str()) && ! isDirectory)) { cerr << "cannot write to output directory '" << OutputDirectory << "'" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } if (isDirectory && ! Overwrite) { cerr << "output directory '" << OutputDirectory << "' already exists. use --overwrite to overwrite data in in it" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } // ............................................................................. // set-up client connection // ............................................................................. BaseClient.createEndpoint(); if (BaseClient.endpointServer() == 0) { cerr << "invalid value for --server.endpoint ('" << BaseClient.endpointString() << "')" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } Connection = GeneralClientConnection::factory(BaseClient.endpointServer(), BaseClient.requestTimeout(), BaseClient.connectTimeout(), ArangoClient::DEFAULT_RETRIES, BaseClient.sslProtocol()); if (Connection == 0) { cerr << "out of memory" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } Client = new SimpleHttpClient(Connection, BaseClient.requestTimeout(), false); if (Client == 0) { cerr << "out of memory" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } Client->setLocationRewriter(0, &rewriteLocation); Client->setUserNamePassword("/", BaseClient.username(), BaseClient.password()); const string versionString = GetArangoVersion(); if (! Connection->isConnected()) { cerr << "Could not connect to endpoint '" << BaseClient.endpointString() << "', database: '" << BaseClient.databaseName() << "', username: '******'" << endl; cerr << "Error message: '" << Client->getErrorMessage() << "'" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } // successfully connected // validate server version int major = 0; int minor = 0; if (sscanf(versionString.c_str(), "%d.%d", &major, &minor) != 2) { cerr << "Invalid server version '" << versionString << "'" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } if (major != 1 || (major == 1 && minor < 4)) { // we can connect to 1.4 and higher only cerr << "Got an incompatible server version '" << versionString << "'" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } if (! isDirectory) { int res = TRI_CreateDirectory(OutputDirectory.c_str()); if (res != TRI_ERROR_NO_ERROR) { cerr << "unable to create output directory '" << OutputDirectory << "': " << string(TRI_errno_string(res)) << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } } if (Progress) { cout << "Connected to ArangoDB '" << BaseClient.endpointString() << "', database: '" << BaseClient.databaseName() << "', username: '******'" << endl; cout << "Writing dump to output directory '" << OutputDirectory << "'" << endl; } memset(&Stats, 0, sizeof(Stats)); string errorMsg = ""; int res = StartBatch(errorMsg); if (res == TRI_ERROR_NO_ERROR) { res = RunDump(errorMsg); } if (BatchId > 0) { EndBatch(); } if (Progress) { if (DumpData) { cout << "Processed " << Stats._totalCollections << " collection(s), " << "wrote " << Stats._totalWritten << " byte(s) into datafiles, " << "sent " << Stats._totalBatches << " batch(es)" << endl; } else { cout << "Processed " << Stats._totalCollections << " collection(s)" << endl; } } if (res != TRI_ERROR_NO_ERROR) { cerr << errorMsg << endl; ret = EXIT_FAILURE; } TRIAGENS_REST_SHUTDOWN; arangodumpExitFunction(ret, NULL); return ret; }
int main (int argc, char* argv[]) { int ret = EXIT_SUCCESS; LocalEntryFunction(); TRIAGENS_C_INITIALIZE(argc, argv); TRIAGENS_REST_INITIALIZE(argc, argv); TRI_InitializeLogging(false); // ............................................................................. // set defaults // ............................................................................. BaseClient.setEndpointString(Endpoint::getDefaultEndpoint()); // ............................................................................. // parse the program options // ............................................................................. ParseProgramOptions(argc, argv); // use a minimum value for batches if (ChunkSize < 1024 * 128) { ChunkSize = 1024 * 128; } if (! InputDirectory.empty() && InputDirectory.back() == TRI_DIR_SEPARATOR_CHAR) { // trim trailing slash from path because it may cause problems on ... Windows TRI_ASSERT(InputDirectory.size() > 0); InputDirectory.pop_back(); } // ............................................................................. // check input directory // ............................................................................. if (InputDirectory == "" || ! TRI_IsDirectory(InputDirectory.c_str())) { cerr << "Error: input directory '" << InputDirectory << "' does not exist" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, nullptr); } if (! ImportStructure && ! ImportData) { cerr << "Error: must specify either --create-collection or --import-data" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, nullptr); } // ............................................................................. // set-up client connection // ............................................................................. BaseClient.createEndpoint(); if (BaseClient.endpointServer() == nullptr) { cerr << "Error: invalid value for --server.endpoint ('" << BaseClient.endpointString() << "')" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, nullptr); } Connection = GeneralClientConnection::factory(BaseClient.endpointServer(), BaseClient.requestTimeout(), BaseClient.connectTimeout(), ArangoClient::DEFAULT_RETRIES, BaseClient.sslProtocol()); Client = new SimpleHttpClient(Connection, BaseClient.requestTimeout(), false); Client->setLocationRewriter(nullptr, &rewriteLocation); Client->setUserNamePassword("/", BaseClient.username(), BaseClient.password()); string versionString = GetArangoVersion(); if (CreateDatabase && LastErrorCode == TRI_ERROR_ARANGO_DATABASE_NOT_FOUND) { // database not found, but database creation requested std::string old = BaseClient.databaseName(); cout << "Creating database '" << old << "'" << endl; BaseClient.setDatabaseName("_system"); int res = TryCreateDatabase(old); if (res != TRI_ERROR_NO_ERROR) { cerr << "Could not create database '" << old << "'" << endl; cerr << "Error message: '" << Client->getErrorMessage() << "'" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, nullptr); } // restore old database name BaseClient.setDatabaseName(old); // re-fetch version versionString = GetArangoVersion(); } if (! Connection->isConnected()) { cerr << "Could not connect to endpoint " << BaseClient.endpointServer()->getSpecification() << endl; cerr << "Error message: '" << Client->getErrorMessage() << "'" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, nullptr); } // successfully connected cout << "Server version: " << versionString << endl; // validate server version int major = 0; int minor = 0; if (sscanf(versionString.c_str(), "%d.%d", &major, &minor) != 2) { cerr << "Error: invalid server version '" << versionString << "'" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, nullptr); } if (major < 1 || major > 2 || (major == 1 && minor < 4)) { // we can connect to 1.4, 2.0 and higher only cerr << "Error: got incompatible server version '" << versionString << "'" << endl; if (! Force) { TRI_EXIT_FUNCTION(EXIT_FAILURE, nullptr); } } if (major >= 2) { // Version 1.4 did not yet have a cluster mode ClusterMode = GetArangoIsCluster(); } if (Progress) { cout << "Connected to ArangoDB '" << BaseClient.endpointServer()->getSpecification() << endl; } memset(&Stats, 0, sizeof(Stats)); string errorMsg = ""; int res; try { res = ProcessInputDirectory(errorMsg); } catch (std::exception const& ex) { cerr << "Error: caught exception " << ex.what() << endl; res = TRI_ERROR_INTERNAL; } catch (...) { cerr << "Error: caught unknown exception" << endl; res = TRI_ERROR_INTERNAL; } if (Progress) { if (ImportData) { cout << "Processed " << Stats._totalCollections << " collection(s), " << "read " << Stats._totalRead << " byte(s) from datafiles, " << "sent " << Stats._totalBatches << " batch(es)" << endl; } else if (ImportStructure) { cout << "Processed " << Stats._totalCollections << " collection(s)" << endl; } } if (res != TRI_ERROR_NO_ERROR) { if (! errorMsg.empty()) { cerr << "Error: " << errorMsg << endl; } ret = EXIT_FAILURE; } if (Client != nullptr) { delete Client; } TRIAGENS_REST_SHUTDOWN; LocalExitFunction(ret, nullptr); return ret; }
int main (int argc, char* argv[]) { int ret = EXIT_SUCCESS; arangorestoreEntryFunction(); TRIAGENS_C_INITIALISE(argc, argv); TRIAGENS_REST_INITIALISE(argc, argv); TRI_InitialiseLogging(false); // ............................................................................. // set defaults // ............................................................................. BaseClient.setEndpointString(Endpoint::getDefaultEndpoint()); // ............................................................................. // parse the program options // ............................................................................. ParseProgramOptions(argc, argv); // use a minimum value for batches if (ChunkSize < 1024 * 128) { ChunkSize = 1024 * 128; } // ............................................................................. // check input directory // ............................................................................. if (InputDirectory == "" || ! TRI_IsDirectory(InputDirectory.c_str())) { cerr << "input directory '" << InputDirectory << "' does not exist" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } if (! ImportStructure && ! ImportData) { cerr << "must specify either --create-collection or --import-data" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } // ............................................................................. // set-up client connection // ............................................................................. BaseClient.createEndpoint(); if (BaseClient.endpointServer() == 0) { cerr << "invalid value for --server.endpoint ('" << BaseClient.endpointString() << "')" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } Connection = GeneralClientConnection::factory(BaseClient.endpointServer(), BaseClient.requestTimeout(), BaseClient.connectTimeout(), ArangoClient::DEFAULT_RETRIES, BaseClient.sslProtocol()); if (Connection == 0) { cerr << "out of memory" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } Client = new SimpleHttpClient(Connection, BaseClient.requestTimeout(), false); if (Client == 0) { cerr << "out of memory" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } Client->setLocationRewriter(0, &rewriteLocation); Client->setUserNamePassword("/", BaseClient.username(), BaseClient.password()); const string versionString = GetArangoVersion(); if (! Connection->isConnected()) { cerr << "Could not connect to endpoint " << BaseClient.endpointServer()->getSpecification() << endl; cerr << "Error message: '" << Client->getErrorMessage() << "'" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } // successfully connected cout << "Server version: " << versionString << endl; // validate server version int major = 0; int minor = 0; if (sscanf(versionString.c_str(), "%d.%d", &major, &minor) != 2) { cerr << "invalid server version '" << versionString << "'" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } if (major < 1 || major > 2 || (major == 1 && minor < 4)) { // we can connect to 1.4, 2.0 and higher only cerr << "got incompatible server version '" << versionString << "'" << endl; if (! Force) { TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } } if (major >= 2) { // Version 1.4 did not yet have a cluster mode clusterMode = GetArangoIsCluster(); } if (Progress) { cout << "Connected to ArangoDB '" << BaseClient.endpointServer()->getSpecification() << endl; } memset(&Stats, 0, sizeof(Stats)); string errorMsg = ""; int res = ProcessInputDirectory(errorMsg); if (Progress) { if (ImportData) { cout << "Processed " << Stats._totalCollections << " collection(s), " << "read " << Stats._totalRead << " byte(s) from datafiles, " << "sent " << Stats._totalBatches << " batch(es)" << endl; } else if (ImportStructure) { cout << "Processed " << Stats._totalCollections << " collection(s)" << endl; } } if (res != TRI_ERROR_NO_ERROR) { cerr << errorMsg << endl; ret = EXIT_FAILURE; } if (Client != 0) { delete Client; } TRIAGENS_REST_SHUTDOWN; arangorestoreExitFunction(ret, NULL); return ret; }
int main (int argc, char* argv[]) { int ret = EXIT_SUCCESS; arangobEntryFunction(); TRIAGENS_C_INITIALIZE(argc, argv); TRIAGENS_REST_INITIALIZE(argc, argv); TRI_InitializeLogging(false); BaseClient.setEndpointString(Endpoint::getDefaultEndpoint()); // ............................................................................. // parse the program options // ............................................................................. ParseProgramOptions(argc, argv); // ............................................................................. // set-up client connection // ............................................................................. BaseClient.createEndpoint(); if (BaseClient.endpointServer() == nullptr) { LOG_FATAL_AND_EXIT("invalid value for --server.endpoint ('%s')", BaseClient.endpointString().c_str()); } BenchmarkOperation* testCase = GetTestCase(TestCase); if (testCase == nullptr) { LOG_FATAL_AND_EXIT("invalid test case name '%s'", TestCase.c_str()); return EXIT_FAILURE; // will not be reached } Status("starting threads..."); BenchmarkCounter<unsigned long> operationsCounter(0, (unsigned long) Operations); ConditionVariable startCondition; vector<Endpoint*> endpoints; vector<BenchmarkThread*> threads; const double stepSize = (double) Operations / (double) ThreadConcurrency; int64_t realStep = (int64_t) stepSize; if (stepSize - (double) ((int64_t) stepSize) > 0.0) { realStep++; } if (realStep % 1000 != 0) { realStep += 1000 - (realStep % 1000); } // add some more offset so we don't get into trouble with threads of different speed realStep += 10000; // start client threads for (int i = 0; i < ThreadConcurrency; ++i) { Endpoint* endpoint = Endpoint::clientFactory(BaseClient.endpointString()); endpoints.push_back(endpoint); BenchmarkThread* thread = new BenchmarkThread(testCase, &startCondition, &UpdateStartCounter, i, (unsigned long) BatchSize, &operationsCounter, endpoint, BaseClient.databaseName(), BaseClient.username(), BaseClient.password(), BaseClient.requestTimeout(), BaseClient.connectTimeout(), BaseClient.sslProtocol(), KeepAlive, Async, verbose); threads.push_back(thread); thread->setOffset((size_t) (i * realStep)); thread->start(); } // give all threads a chance to start so they will not miss the broadcast while (GetStartCounter() < ThreadConcurrency) { usleep(5000); } if (Delay) { Status("sleeping (startup delay)..."); sleep(10); } Status("executing tests..."); double start = TRI_microtime(); // broadcast the start signal to all threads { CONDITION_LOCKER(guard, startCondition); guard.broadcast(); } const size_t stepValue = (Operations / 20); size_t nextReportValue = stepValue; if (nextReportValue < 100) { nextReportValue = 100; } while (1) { const size_t numOperations = operationsCounter.getDone(); if (numOperations >= (size_t) Operations) { break; } if (Progress && numOperations >= nextReportValue) { LOG_INFO("number of operations: %d", (int) nextReportValue); nextReportValue += stepValue; } usleep(20000); } double time = TRI_microtime() - start; double requestTime = 0.0; for (int i = 0; i < ThreadConcurrency; ++i) { requestTime += threads[i]->getTime(); } size_t failures = operationsCounter.failures(); size_t incomplete = operationsCounter.incompleteFailures(); cout << endl; cout << "Total number of operations: " << Operations << ", keep alive: " << (KeepAlive ? "yes" : "no") << ", async: " << (Async ? "yes" : "no") << ", batch size: " << BatchSize << ", concurrency level (threads): " << ThreadConcurrency << endl; cout << "Test case: " << TestCase << ", complexity: " << Complexity << ", database: '" << BaseClient.databaseName() << "', collection: '" << Collection << "'" << endl; cout << "Total request/response duration (sum of all threads): " << fixed << requestTime << " s" << endl; cout << "Request/response duration (per thread): " << fixed << (requestTime / (double) ThreadConcurrency) << " s" << endl; cout << "Time needed per operation: " << fixed << (time / Operations) << " s" << endl; cout << "Time needed per operation per thread: " << fixed << (time / (double) Operations * (double) ThreadConcurrency) << " s" << endl; cout << "Operations per second rate: " << fixed << ((double) Operations / time) << endl; cout << "Elapsed time since start: " << fixed << time << " s" << endl << endl; if (failures > 0) { cerr << "WARNING: " << failures << " arangob request(s) failed!!" << endl; } if (incomplete > 0) { cerr << "WARNING: " << incomplete << " arangob requests with incomplete results!!" << endl; } testCase->tearDown(); for (int i = 0; i < ThreadConcurrency; ++i) { threads[i]->join(); delete threads[i]; delete endpoints[i]; } delete testCase; TRIAGENS_REST_SHUTDOWN; if (failures > 0) { ret = EXIT_FAILURE; } arangobExitFunction(ret, nullptr); return ret; }
static void Status (const string& value) { if (! BaseClient.quiet()) { cout << value << endl; } }
int main (int argc, char* argv[]) { TRIAGENS_C_INITIALISE(argc, argv); TRIAGENS_REST_INITIALISE(argc, argv); TRI_InitialiseLogging(false); int ret = EXIT_SUCCESS; BaseClient.setEndpointString(Endpoint::getDefaultEndpoint()); // ............................................................................. // parse the program options // ............................................................................. ParseProgramOptions(argc, argv); // ............................................................................. // set-up MRuby objects // ............................................................................. // create a new ruby shell mrb_state* mrb = MR_OpenShell(); TRI_InitMRUtils(mrb); // ............................................................................. // set-up client connection // ............................................................................. // check if we want to connect to a server bool useServer = (BaseClient.endpointString() != "none"); if (useServer) { BaseClient.createEndpoint(); if (BaseClient.endpointServer() == 0) { LOGGER_FATAL_AND_EXIT("invalid value for --server.endpoint ('" << BaseClient.endpointString() << "')"); } ClientConnection = createConnection(mrb); InitMRClientConnection(mrb, ClientConnection); } // ............................................................................. // banner // ............................................................................. // http://www.network-science.de/ascii/ Font: ogre if (! BaseClient.quiet()) { char const* g = TRI_SHELL_COLOR_GREEN; char const* r = TRI_SHELL_COLOR_RED; char const* z = TRI_SHELL_COLOR_RESET; if (! BaseClient.colors()) { g = ""; r = ""; z = ""; } printf("%s %s _ _ %s\n", g, r, z); printf("%s __ _ _ __ __ _ _ __ __ _ ___ %s(_)_ __| |__ %s\n", g, r, z); printf("%s / _` | '__/ _` | '_ \\ / _` |/ _ \\%s| | '__| '_ \\ %s\n", g, r, z); printf("%s| (_| | | | (_| | | | | (_| | (_) %s| | | | |_) |%s\n", g, r, z); printf("%s \\__,_|_| \\__,_|_| |_|\\__, |\\___/%s|_|_| |_.__/ %s\n", g, r, z); printf("%s |___/ %s %s\n", g, r, z); cout << endl << "Welcome to arangosh " << TRI_VERSION_FULL << ". Copyright (c) 2012 triAGENS GmbH" << endl; #ifdef TRI_MRUBY_VERSION cout << "Using MRUBY " << TRI_MRUBY_VERSION << " engine. Copyright (c) 2012 mruby developers." << endl; #endif #ifdef TRI_READLINE_VERSION cout << "Using READLINE " << TRI_READLINE_VERSION << endl; #endif cout << endl; BaseClient.printWelcomeInfo(); if (useServer) { if (ClientConnection->isConnected()) { if (! BaseClient.quiet()) { cout << "Connected to ArangoDB '" << BaseClient.endpointServer()->getSpecification() << "' Version " << ClientConnection->getVersion() << endl; } } else { cerr << "Could not connect to endpoint '" << BaseClient.endpointString() << "'" << endl; cerr << "Error message '" << ClientConnection->getErrorMessage() << "'" << endl; } } } // ............................................................................. // read files // ............................................................................. // load java script from js/bootstrap/*.h files if (StartupPath.empty()) { StartupLoader.defineScript("common/bootstrap/error.rb", MR_common_bootstrap_error); } else { LOGGER_DEBUG("using Ruby startup files at '" << StartupPath << "'"); StartupLoader.setDirectory(StartupPath); } // load all init files char const* files[] = { "common/bootstrap/error.rb" }; for (size_t i = 0; i < sizeof(files) / sizeof(files[0]); ++i) { bool ok = StartupLoader.loadScript(mrb, files[i]); if (ok) { LOGGER_TRACE("loaded ruby file '" << files[i] << "'"); } else { LOGGER_FATAL_AND_EXIT("cannot load ruby file '" << files[i] << "'"); } } // ............................................................................. // run normal shell // ............................................................................. RunShell(mrb); TRIAGENS_REST_SHUTDOWN; return ret; }
int main (int argc, char* argv[]) { int ret = EXIT_SUCCESS; arangoimpEntryFunction(); TRIAGENS_C_INITIALISE(argc, argv); TRIAGENS_REST_INITIALISE(argc, argv); TRI_InitialiseLogging(false); BaseClient.setEndpointString(Endpoint::getDefaultEndpoint()); // ............................................................................. // parse the program options // ............................................................................. ParseProgramOptions(argc, argv); // ............................................................................. // set-up client connection // ............................................................................. BaseClient.createEndpoint(); if (BaseClient.endpointServer() == 0) { cerr << "invalid value for --server.endpoint ('" << BaseClient.endpointString() << "')" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } ClientConnection = new V8ClientConnection(BaseClient.endpointServer(), BaseClient.databaseName(), BaseClient.username(), BaseClient.password(), BaseClient.requestTimeout(), BaseClient.connectTimeout(), ArangoClient::DEFAULT_RETRIES, BaseClient.sslProtocol(), false); if (! ClientConnection->isConnected() || ClientConnection->getLastHttpReturnCode() != HttpResponse::OK) { cerr << "Could not connect to endpoint '" << BaseClient.endpointServer()->getSpecification() << "', database: '" << BaseClient.databaseName() << "'" << endl; cerr << "Error message: '" << ClientConnection->getErrorMessage() << "'" << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } // successfully connected cout << "Connected to ArangoDB '" << BaseClient.endpointServer()->getSpecification() << "', version " << ClientConnection->getVersion() << ", database: '" << BaseClient.databaseName() << "', username: '******'" << endl; cout << "----------------------------------------" << endl; cout << "database: " << BaseClient.databaseName() << endl; cout << "collection: " << CollectionName << endl; cout << "create: " << (CreateCollection ? "yes" : "no") << endl; cout << "file: " << FileName << endl; cout << "type: " << TypeImport << endl; if (TypeImport == "csv") { cout << "quote: " << Quote << endl; cout << "separator: " << Separator << endl; } cout << "connect timeout: " << BaseClient.connectTimeout() << endl; cout << "request timeout: " << BaseClient.requestTimeout() << endl; cout << "----------------------------------------" << endl; ImportHelper ih(ClientConnection->getHttpClient(), ChunkSize); // create colletion if (CreateCollection) { ih.setCreateCollection(true); } // quote if (Quote.length() <= 1) { ih.setQuote(Quote); } else { cerr << "Wrong length of quote character." << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } // separator if (Separator.length() == 1) { ih.setSeparator(Separator); } else { cerr << "Separator must be exactly one character." << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } // collection name if (CollectionName == "") { cerr << "Collection name is missing." << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } // filename if (FileName == "") { cerr << "File name is missing." << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } if (FileName != "-" && ! FileUtils::isRegularFile(FileName)) { if (! FileUtils::exists(FileName)) { cerr << "Cannot open file '" << FileName << "'. File not found." << endl; } else if (FileUtils::isDirectory(FileName)) { cerr << "Specified file '" << FileName << "' is a directory. Please use a regular file." << endl; } else { cerr << "Cannot open '" << FileName << "'. Invalid file type." << endl; } TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } // progress if (Progress) { ih.setProgress(true); } // import type bool ok = false; if (TypeImport == "csv") { cout << "Starting CSV import..." << endl; ok = ih.importDelimited(CollectionName, FileName, ImportHelper::CSV); } else if (TypeImport == "tsv") { cout << "Starting TSV import..." << endl; ih.setQuote(""); ih.setSeparator("\\t"); ok = ih.importDelimited(CollectionName, FileName, ImportHelper::TSV); } else if (TypeImport == "json") { cout << "Starting JSON import..." << endl; ok = ih.importJson(CollectionName, FileName); } else { cerr << "Wrong type '" << TypeImport << "'." << endl; TRI_EXIT_FUNCTION(EXIT_FAILURE, NULL); } cout << endl; // give information about import if (ok) { cout << "created: " << ih.getImportedLines() << endl; cout << "errors: " << ih.getErrorLines() << endl; cout << "total: " << ih.getReadLines() << endl; } else { cerr << "error message: " << ih.getErrorMessage() << endl; } TRIAGENS_REST_SHUTDOWN; arangoimpExitFunction(ret, NULL); return ret; }