int main(void) { Arc::Logger logger(Arc::Logger::rootLogger, "Test"); Arc::LogStream logcerr(std::cerr); Arc::Logger::rootLogger.addDestination(logcerr); logger.msg(Arc::INFO, "Creating client side chain"); std::string id; std::string url("https://localhost/arex"); Arc::NS ns("a-rex", "http://www.nordugrid.org/schemas/a-rex"); Arc::MCCConfig cfg; Arc::UserConfig uc; uc.ApplyToConfig(cfg); Arc::ClientSOAP client(cfg, url, 60); std::string faultstring; Arc::PayloadSOAP request(ns); Arc::XMLNode req = request.NewChild("a-rex:CacheCheck").NewChild("a-rex:TheseFilesNeedToCheck"); req.NewChild("a-rex:FileURL") = "http://example.org/test.txt"; Arc::PayloadSOAP* response; Arc::MCC_Status status = client.process(&request, &response); if (!status) { std::cerr << "Request failed" << std::endl; } std::string str; response->GetDoc(str, true); std::cout << str << std::endl; return 0; }
int main(int argc, char** argv) { signal(SIGTTOU,SIG_IGN); signal(SIGTTIN,SIG_IGN); signal(SIGINT, do_shutdown); // Log to stderr Arc::LogStream logcerr(std::cerr); Arc::Logger::getRootLogger().addDestination(logcerr); Arc::Logger::getRootLogger().setThreshold(Arc::INFO); Generator generator; int num = 10; if (argc == 1 || argc == 2) { // run mock a number of times if (argc == 2 && (std::string(argv[1]) == "-h" || !Arc::stringto(argv[1], num))) { usage(); return 1; } generator.start(); for (int i = 0; i < num; ++i) { std::string source = "mock://mocksrc/mock." + Arc::tostring(i); std::string destination = "mock://mockdest/mock." + Arc::tostring(i); generator.run(source, destination); } } else if (argc == 3) { // run with given source and destination generator.start(); generator.run(argv[1], argv[2]); } else { usage(); return 1; } while (generator.counter.get() > 0 && run) { sleep(1); } return 0; }
int main(void) { signal(SIGTTOU,SIG_IGN); signal(SIGTTIN,SIG_IGN); Arc::Logger logger(Arc::Logger::rootLogger, "Test"); Arc::LogStream logcerr(std::cerr); Arc::Logger::rootLogger.addDestination(logcerr); /******** Test to gridsite delegation service **********/ std::string gs_deleg_url_str("https://cream.grid.upjs.sk:8443/ce-cream/services/gridsite-delegation"); Arc::URL gs_deleg_url(gs_deleg_url_str); Arc::MCCConfig gs_deleg_mcc_cfg; //Use voms-proxy-init or arcproxy to generate a gsi legacy proxy, and //put put it into mcc configuraton by using "AddProxy" gs_deleg_mcc_cfg.AddProxy("proxy.pem"); //gs_deleg_mcc_cfg.AddPrivateKey("../echo/userkey-nopass.pem"); //gs_deleg_mcc_cfg.AddCertificate("../echo/usercert.pem"); gs_deleg_mcc_cfg.AddCADir("../echo/certificates"); //Create a delegation SOAP client logger.msg(Arc::INFO, "Creating a delegation soap client"); Arc::ClientX509Delegation *gs_deleg_client = NULL; gs_deleg_client = new Arc::ClientX509Delegation(gs_deleg_mcc_cfg, gs_deleg_url); std::string gs_delegation_id; gs_delegation_id = Arc::UUID(); if(gs_deleg_client) { if(!(gs_deleg_client->createDelegation(Arc::DELEG_GRIDSITE, gs_delegation_id))) { logger.msg(Arc::ERROR, "Delegation to gridsite delegation service failed"); throw std::runtime_error("Delegation to gridsite delegation service failed"); } } logger.msg(Arc::INFO, "Delegation ID: %s", gs_delegation_id.c_str()); if(gs_deleg_client) delete gs_deleg_client; return 0; }
int RUNMAIN(arccat)(int argc, char **argv) { setlocale(LC_ALL, ""); Arc::Logger logger(Arc::Logger::getRootLogger(), "arccat"); Arc::LogStream logcerr(std::cerr); logcerr.setFormat(Arc::ShortFormat); Arc::Logger::getRootLogger().addDestination(logcerr); Arc::Logger::getRootLogger().setThreshold(Arc::WARNING); Arc::ArcLocation::Init(argv[0]); ClientOptions opt(ClientOptions::CO_CAT, istring("[job ...]"), istring("The arccat command performs the cat " "command on the stdout, stderr or grid\n" "manager's error log of the job.")); std::list<std::string> jobidentifiers = opt.Parse(argc, argv); if (opt.showversion) { std::cout << Arc::IString("%s version %s", "arccat", VERSION) << std::endl; return 0; } // If debug is specified as argument, it should be set before loading the configuration. if (!opt.debug.empty()) Arc::Logger::getRootLogger().setThreshold(Arc::string_to_level(opt.debug)); if (opt.show_plugins) { std::list<std::string> types; types.push_back("HED:JobControllerPlugin"); showplugins("arccat", types, logger); return 0; } Arc::UserConfig usercfg(opt.conffile, opt.joblist); if (!usercfg) { logger.msg(Arc::ERROR, "Failed configuration initialization"); return 1; } if (!checkproxy(usercfg)) { return 1; } if (opt.debug.empty() && !usercfg.Verbosity().empty()) Arc::Logger::getRootLogger().setThreshold(Arc::string_to_level(usercfg.Verbosity())); for (std::list<std::string>::const_iterator it = opt.jobidinfiles.begin(); it != opt.jobidinfiles.end(); it++) { if (!Arc::Job::ReadJobIDsFromFile(*it, jobidentifiers)) { logger.msg(Arc::WARNING, "Cannot read specified jobid file: %s", *it); } } if (opt.timeout > 0) usercfg.Timeout(opt.timeout); if ((!opt.joblist.empty() || !opt.status.empty()) && jobidentifiers.empty() && opt.clusters.empty()) opt.all = true; if (jobidentifiers.empty() && opt.clusters.empty() && !opt.all) { logger.msg(Arc::ERROR, "No jobs given"); return 1; } std::list<std::string> selectedURLs; if (!opt.clusters.empty()) { selectedURLs = getSelectedURLsFromUserConfigAndCommandLine(usercfg, opt.clusters); } std::list<std::string> rejectManagementURLs = getRejectManagementURLsFromUserConfigAndCommandLine(usercfg, opt.rejectmanagement); std::list<Arc::Job> jobs; Arc::JobInformationStorageXML jobList(usercfg.JobListFile()); if (( opt.all && !jobList.ReadAll(jobs, rejectManagementURLs)) || (!opt.all && !jobList.Read(jobs, jobidentifiers, selectedURLs, rejectManagementURLs))) { logger.msg(Arc::ERROR, "Unable to read job information from file (%s)", usercfg.JobListFile()); return 1; } if (!opt.all) { for (std::list<std::string>::const_iterator itJIDAndName = jobidentifiers.begin(); itJIDAndName != jobidentifiers.end(); ++itJIDAndName) { std::cout << Arc::IString("Warning: Job not found in job list: %s", *itJIDAndName) << std::endl; } } Arc::JobSupervisor jobmaster(usercfg, jobs); jobmaster.Update(); jobmaster.SelectValid(); if (!opt.status.empty()) { jobmaster.SelectByStatus(opt.status); } jobs = jobmaster.GetSelectedJobs(); if (jobs.empty()) { std::cout << Arc::IString("No jobs") << std::endl; return 1; } std::string resourceName; Arc::Job::ResourceType resource; if (opt.show_joblog) { resource = Arc::Job::JOBLOG; resourceName = "joblog"; } else if (opt.show_stderr) { resource = Arc::Job::STDERR; resourceName = "stderr"; } else { resource = Arc::Job::STDOUT; resourceName = "stdout"; } // saving to a temp file is necessary because chunks from server // may arrive out of order std::string filename = Glib::build_filename(Glib::get_tmp_dir(), "arccat.XXXXXX"); int tmp_h = Glib::mkstemp(filename); if (tmp_h == -1) { logger.msg(Arc::INFO, "Could not create temporary file \"%s\"", filename); logger.msg(Arc::ERROR, "Cannot create output of %s for any jobs", resourceName); return 1; } Arc::URL dst("stdio:///"+Arc::tostring(tmp_h)); if (!dst) { logger.msg(Arc::ERROR, "Cannot create output of %s for any jobs", resourceName); logger.msg(Arc::INFO, "Invalid destination URL %s", dst.str()); close(tmp_h); unlink(filename.c_str()); return 1; } int retval = 0; for (std::list<Arc::Job>::const_iterator it = jobs.begin(); it != jobs.end(); it++) { if (!it->State || (!opt.status.empty() && std::find(opt.status.begin(), opt.status.end(), it->State()) == opt.status.end() && std::find(opt.status.begin(), opt.status.end(), it->State.GetGeneralState()) == opt.status.end())) { continue; } if (it->State == Arc::JobState::DELETED) { logger.msg(Arc::WARNING, "Job deleted: %s", it->JobID); retval = 1; continue; } // The job-log might be available before the job has started (middleware dependent). if (!opt.show_joblog && !it->State.IsFinished() && it->State != Arc::JobState::RUNNING && it->State != Arc::JobState::FINISHING) { logger.msg(Arc::WARNING, "Job has not started yet: %s", it->JobID); retval = 1; continue; } if ((opt.show_joblog && it->LogDir.empty()) || (!opt.show_joblog && opt.show_stderr && it->StdErr.empty()) || (!opt.show_joblog && !opt.show_stderr && it->StdOut.empty())) { logger.msg(Arc::ERROR, "Cannot determine the %s location: %s", resourceName, it->JobID); retval = 1; continue; } Arc::URL src; it->GetURLToResource(resource, src); if (!src) { logger.msg(Arc::ERROR, "Cannot create output of %s for job (%s): Invalid source %s", resourceName, it->JobID, src.str()); retval = 1; continue; } if (!it->CopyJobFile(usercfg, src, dst)) { retval = 1; continue; } logger.msg(Arc::VERBOSE, "Catting %s for job %s", resourceName, it->JobID); std::ifstream is(filename.c_str()); char c; while (is.get(c)) { std::cout.put(c); } is.close(); } close(tmp_h); unlink(filename.c_str()); return retval; }
int main(void){ signal(SIGTTOU,SIG_IGN); signal(SIGTTIN,SIG_IGN); signal(SIGPIPE,SIG_IGN); Arc::Logger logger(Arc::Logger::rootLogger, "PDPTest"); Arc::LogStream logcerr(std::cerr); Arc::Logger::rootLogger.addDestination(logcerr); logger.msg(Arc::INFO, "Start test"); ArcSec::EvaluatorLoader eval_loader; //TEST: XACMLEvaluator, XACMLPolicy, XACMLRequest //Load the Evaluator ArcSec::Evaluator* eval = NULL; std::string evaluator = "xacml.evaluator"; eval = eval_loader.getEvaluator(evaluator); if(eval == NULL) { logger.msg(Arc::ERROR, "Can not dynamically produce Evaluator"); return 0; } ArcSec::Policy* policy = NULL; std::string policyclassname = "xacml.policy"; ArcSec::SourceFile policy_source("XACML_Policy.xml"); policy = eval_loader.getPolicy(policyclassname, policy_source); if(policy == NULL) logger.msg(Arc::ERROR, "Can not dynamically produce Policy"); ArcSec::Request* request = NULL; std::string requestclassname = "xacml.request"; ArcSec::SourceFile request_source("XACML_Request.xml"); request = eval_loader.getRequest(requestclassname, request_source); if(request == NULL) logger.msg(Arc::ERROR, "Can not dynamically produce Request"); /**Two options to add policy into evaluator*/ //eval->addPolicy(policy_source); eval->addPolicy(policy); ArcSec::Response *resp = NULL; /**Feed evaluator with request to execute evaluation*/ resp = eval->evaluate(request_source); //resp = eval->evaluate(request_source, policy); //resp = eval->evaluate(request, policy_source); //resp = eval->evaluate(request_source, policy_source); //resp = eval->evaluate(request, policy); /**Get the response*/ ArcSec::ResponseList rlist = resp->getResponseItems(); std::cout<<rlist[0]->res<<std::endl; if(resp){ delete resp; resp = NULL; } delete eval; delete request; return 0; }
int RUNMAIN(arcinfo)(int argc, char **argv) { setlocale(LC_ALL, ""); Arc::Logger logger(Arc::Logger::getRootLogger(), "arcinfo"); Arc::LogStream logcerr(std::cerr); logcerr.setFormat(Arc::ShortFormat); Arc::Logger::getRootLogger().addDestination(logcerr); Arc::Logger::getRootLogger().setThreshold(Arc::WARNING); Arc::ArcLocation::Init(argv[0]); ClientOptions opt(ClientOptions::CO_INFO, istring("[resource ...]"), istring("The arcinfo command is used for " "obtaining the status of computing " "resources on the Grid.")); { std::list<std::string> clusterstmp = opt.Parse(argc, argv); opt.clusters.insert(opt.clusters.end(), clusterstmp.begin(), clusterstmp.end()); } if (opt.showversion) { std::cout << Arc::IString("%s version %s", "arcinfo", VERSION) << std::endl; return 0; } // If debug is specified as argument, it should be set before loading the configuration. if (!opt.debug.empty()) Arc::Logger::getRootLogger().setThreshold(Arc::string_to_level(opt.debug)); if (opt.show_plugins) { std::list<std::string> types; types.push_back("HED:ServiceEndpointRetrieverPlugin"); types.push_back("HED:TargetInformationRetrieverPlugin"); showplugins("arcinfo", types, logger); return 0; } Arc::UserConfig usercfg(opt.conffile); if (!usercfg) { logger.msg(Arc::ERROR, "Failed configuration initialization"); return 1; } if (opt.list_configured_services) { std::map<std::string, Arc::ConfigEndpoint> allServices = usercfg.GetAllConfiguredServices(); std::cout << "Configured registries:" << std::endl; for (std::map<std::string, Arc::ConfigEndpoint>::const_iterator it = allServices.begin(); it != allServices.end(); it++) { if (it->second.type == Arc::ConfigEndpoint::REGISTRY) { std::cout << " " << it->first << ": " << it->second.URLString; if (!it->second.InterfaceName.empty()) { std::cout << " (" << it->second.InterfaceName << ")"; } std::cout << std::endl; } } std::cout << "Configured computing elements:" << std::endl; for (std::map<std::string, Arc::ConfigEndpoint>::const_iterator it = allServices.begin(); it != allServices.end(); it++) { if (it->second.type == Arc::ConfigEndpoint::COMPUTINGINFO) { std::cout << " " << it->first << ": " << it->second.URLString; if (!it->second.InterfaceName.empty() || !it->second.RequestedSubmissionInterfaceName.empty()) { std::cout << " (" << it->second.InterfaceName; if (!it->second.InterfaceName.empty() && !it->second.RequestedSubmissionInterfaceName.empty()) { std::cout << " / "; } std::cout << it->second.RequestedSubmissionInterfaceName + ")"; } std::cout << std::endl; } } return 0; } if (opt.debug.empty() && !usercfg.Verbosity().empty()) Arc::Logger::getRootLogger().setThreshold(Arc::string_to_level(usercfg.Verbosity())); if (opt.timeout > 0) usercfg.Timeout(opt.timeout); std::list<Arc::Endpoint> endpoints = getServicesFromUserConfigAndCommandLine(usercfg, opt.indexurls, opt.clusters, opt.requestedSubmissionInterfaceName, opt.infointerface); std::set<std::string> preferredInterfaceNames; if (usercfg.InfoInterface().empty()) { preferredInterfaceNames.insert("org.nordugrid.ldapglue2"); } else { preferredInterfaceNames.insert(usercfg.InfoInterface()); } std::list<std::string> rejectDiscoveryURLs = getRejectDiscoveryURLsFromUserConfigAndCommandLine(usercfg, opt.rejectdiscovery); Arc::ComputingServiceUniq csu; Arc::ComputingServiceRetriever csr(usercfg, std::list<Arc::Endpoint>(), rejectDiscoveryURLs, preferredInterfaceNames); csr.addConsumer(csu); for (std::list<Arc::Endpoint>::const_iterator it = endpoints.begin(); it != endpoints.end(); ++it) { csr.addEndpoint(*it); } csr.wait(); std::list<Arc::ComputingServiceType> services = csu.getServices(); for (std::list<Arc::ComputingServiceType>::const_iterator it = services.begin(); it != services.end(); ++it) { if (opt.longlist) { if (it != services.begin()) std::cout << std::endl; std::cout << *it; std::cout << std::flush; } else { std::cout << "Computing service: " << (**it).Name; if (!(**it).QualityLevel.empty()) { std::cout << " (" << (**it).QualityLevel << ")"; } std::cout << std::endl; std::stringstream infostream, submissionstream; for (std::map<int, Arc::ComputingEndpointType>::const_iterator itCE = it->ComputingEndpoint.begin(); itCE != it->ComputingEndpoint.end(); ++itCE) { if (itCE->second->Capability.count(Arc::Endpoint::GetStringForCapability(Arc::Endpoint::COMPUTINGINFO))) { infostream << " " << Arc::IString("Information endpoint") << ": " << itCE->second->URLString << std::endl; } if (itCE->second->Capability.empty() || itCE->second->Capability.count(Arc::Endpoint::GetStringForCapability(Arc::Endpoint::JOBSUBMIT)) || itCE->second->Capability.count(Arc::Endpoint::GetStringForCapability(Arc::Endpoint::JOBCREATION))) { submissionstream << " "; submissionstream << Arc::IString("Submission endpoint") << ": "; submissionstream << itCE->second->URLString; submissionstream << " (" << Arc::IString("status") << ": "; submissionstream << itCE->second->HealthState << ", "; submissionstream << Arc::IString("interface") << ": "; submissionstream << itCE->second->InterfaceName << ")" << std::endl; } } std::cout << infostream.str() << submissionstream.str(); } } bool anEndpointFailed = false; // Check if querying endpoint succeeded. Arc::EndpointStatusMap statusMap = csr.getAllStatuses(); for (std::list<Arc::Endpoint>::const_iterator it = endpoints.begin(); it != endpoints.end(); ++it) { Arc::EndpointStatusMap::const_iterator itStatus = statusMap.find(*it); if (itStatus != statusMap.end() && itStatus->second != Arc::EndpointQueryingStatus::SUCCESSFUL && itStatus->second != Arc::EndpointQueryingStatus::SUSPENDED_NOTREQUIRED) { if (!anEndpointFailed) { anEndpointFailed = true; std::cerr << Arc::IString("ERROR: Failed to retrieve information from the following endpoints:") << std::endl; } std::cerr << " " << it->URLString; if (!itStatus->second.getDescription().empty()) { std::cerr << " (" << itStatus->second.getDescription() << ")"; } std::cerr << std::endl; } } if (anEndpointFailed) return 1; if (services.empty()) { std::cerr << Arc::IString("ERROR: Failed to retrieve information"); if (!endpoints.empty()) { std::cerr << " " << Arc::IString("from the following endpoints:") << std::endl; for (std::list<Arc::Endpoint>::const_iterator it = endpoints.begin(); it != endpoints.end(); ++it) { std::cerr << " " << it->URLString << std::endl; } } else { std::cerr << std::endl; } return 1; } return 0; }
int main(int argc, char* argv[]){ // Some variables... int numberOfThreads; int duration; int i; Glib::Thread** threads; const char* config_file = NULL; int debug_level = -1; Arc::LogStream logcerr(std::cerr); // Process options - quick hack, must use Glib options later while(argc >= 3) { if(strcmp(argv[1],"-c") == 0) { config_file = argv[2]; argv[2]=argv[0]; argv+=2; argc-=2; } else if(strcmp(argv[1],"-d") == 0) { debug_level=Arc::string_to_level(argv[2]); argv[2]=argv[0]; argv+=2; argc-=2; } else if(strcmp(argv[1],"-r") == 0) { alwaysReconnect=true; argv+=1; argc-=1; } else { break; }; } if(debug_level >= 0) { Arc::Logger::getRootLogger().setThreshold((Arc::LogLevel)debug_level); Arc::Logger::getRootLogger().addDestination(logcerr); } // Extract command line arguments. if (argc!=4){ std::cerr << "Wrong number of arguments!" << std::endl << std::endl << "Usage:" << std::endl << "perftest [-c config] [-d debug] [-r] url threads duration" << std::endl << std::endl << "Arguments:" << std::endl << "url The url of the service." << std::endl << "threads The number of concurrent requests." << std::endl << "duration The duration of the test in seconds." << std::endl << "-c config The file containing client chain XML configuration with " << std::endl << " 'soap' entry point and HOSTNAME, PORTNUMBER and PATH " << std::endl << " keyword for hostname, port and HTTP path of 'echo' service." << std::endl << "-d debug The textual representation of desired debug level. Available " << std::endl << " levels: DEBUG, VERBOSE, INFO, WARNING, ERROR, FATAL." << std::endl << "-r If specified close connection and reconnect after " << std::endl << " every request." << std::endl; exit(EXIT_FAILURE); } url_str = std::string(argv[1]); numberOfThreads = atoi(argv[2]); duration = atoi(argv[3]); // Start threads. run=true; finishedThreads=0; //Glib::thread_init(); mutex=new Glib::Mutex; threads = new Glib::Thread*[numberOfThreads]; for (i=0; i<numberOfThreads; i++) threads[i]=Glib::Thread::create(sigc::ptr_fun(sendRequests),true); // Sleep while the threads are working. Glib::usleep(duration*1000000); // Stop the threads run=false; while(finishedThreads<numberOfThreads) Glib::usleep(100000); // Print the result of the test. Glib::Mutex::Lock lock(*mutex); totalRequests = completedRequests+failedRequests; totalTime = completedTime+failedTime; std::cout << "========================================" << std::endl; std::cout << "URL: " << url_str << std::endl; std::cout << "Number of threads: " << numberOfThreads << std::endl; std::cout << "Duration: " << duration << " s" << std::endl; std::cout << "Number of requests: " << totalRequests << std::endl; std::cout << "Completed requests: " << completedRequests << " (" << Round(completedRequests*100.0/totalRequests) << "%)" << std::endl; std::cout << "Failed requests: " << failedRequests << " (" << Round(failedRequests*100.0/totalRequests) << "%)" << std::endl; std::cout << "Completed requests per second: " << Round(completedRequests/duration) << std::endl; std::cout << "Average response time for all requests: " << Round(1000*totalTime.as_double()/totalRequests) << " ms" << std::endl; if (completedRequests!=0) std::cout << "Average response time for completed requests: " << Round(1000*completedTime.as_double()/completedRequests) << " ms" << std::endl; if (failedRequests!=0) std::cout << "Average response time for failed requests: " << Round(1000*failedTime.as_double()/failedRequests) << " ms" << std::endl; std::cout << "========================================" << std::endl; return 0; }
int main(int argc, char **argv) { setlocale(LC_ALL, ""); Arc::LogStream logcerr(std::cerr); logcerr.setFormat(Arc::ShortFormat); Arc::Logger::getRootLogger().addDestination(logcerr); Arc::Logger::getRootLogger().setThreshold(Arc::WARNING); Arc::ArcLocation::Init(argv[0]); Arc::OptionParser options(istring("url"), istring("The arcls command is used for listing " "files in grid storage elements " "and file\nindex catalogues.")); bool longlist = false; options.AddOption('l', "long", istring("long format (more information)"), longlist); bool locations = false; options.AddOption('L', "locations", istring("show URLs of file locations"), locations); bool metadata = false; options.AddOption('m', "metadata", istring("display all available metadata"), metadata); bool infinite_recursion = false; options.AddOption('r', "recursive", istring("operate recursively"), infinite_recursion); int recursion = 0; options.AddOption('D', "depth", istring("operate recursively up to specified level"), istring("level"), recursion); bool nolist = false; options.AddOption('n', "nolist", istring("show only description of requested object, do not list content of directories"), nolist); bool forcelist = false; options.AddOption('f', "forcelist", istring("treat requested object as directory and always try to list content"), forcelist); bool checkaccess = false; options.AddOption('c', "checkaccess", istring("check readability of object, does not show any information about object"), checkaccess); bool show_plugins = false; options.AddOption('P', "listplugins", istring("list the available plugins (protocols supported)"), show_plugins); int timeout = 20; options.AddOption('t', "timeout", istring("timeout in seconds (default 20)"), istring("seconds"), timeout); std::string conffile; options.AddOption('z', "conffile", istring("configuration file (default ~/.arc/client.conf)"), istring("filename"), conffile); std::string debug; options.AddOption('d', "debug", istring("FATAL, ERROR, WARNING, INFO, VERBOSE or DEBUG"), istring("debuglevel"), debug); bool version = false; options.AddOption('v', "version", istring("print version information"), version); std::list<std::string> params = options.Parse(argc, argv); if (version) { std::cout << Arc::IString("%s version %s", "arcls", VERSION) << std::endl; return 0; } // If debug is specified as argument, it should be set before loading the configuration. if (!debug.empty()) Arc::Logger::getRootLogger().setThreshold(Arc::string_to_level(debug)); if (show_plugins) { std::list<Arc::ModuleDesc> modules; Arc::PluginsFactory pf(Arc::BaseConfig().MakeConfig(Arc::Config()).Parent()); pf.scan(Arc::FinderLoader::GetLibrariesList(), modules); Arc::PluginsFactory::FilterByKind("HED:DMC", modules); std::cout << Arc::IString("Protocol plugins available:") << std::endl; for (std::list<Arc::ModuleDesc>::iterator itMod = modules.begin(); itMod != modules.end(); itMod++) { for (std::list<Arc::PluginDesc>::iterator itPlug = itMod->plugins.begin(); itPlug != itMod->plugins.end(); itPlug++) { std::cout << " " << itPlug->name << " - " << itPlug->description << std::endl; } } return 0; } // credentials will be initialised later if necessary Arc::UserConfig usercfg(conffile, Arc::initializeCredentialsType::TryCredentials); if (!usercfg) { logger.msg(Arc::ERROR, "Failed configuration initialization"); return 1; } usercfg.UtilsDirPath(Arc::UserConfig::ARCUSERDIRECTORY); if (debug.empty() && !usercfg.Verbosity().empty()) Arc::Logger::getRootLogger().setThreshold(Arc::string_to_level(usercfg.Verbosity())); // Analyze options if (params.size() != 1) { logger.msg(Arc::ERROR, "Wrong number of parameters specified"); return 1; } if(forcelist && nolist) { logger.msg(Arc::ERROR, "Incompatible options --nolist and --forcelist requested"); return 1; } if(recursion && nolist) { logger.msg(Arc::ERROR, "Requesting recursion and --nolist has no sense"); return 1; } if(infinite_recursion) recursion = INT_MAX; std::list<std::string>::iterator it = params.begin(); if(!arcls(*it, usercfg, longlist, locations, metadata, nolist, forcelist, checkaccess, recursion, timeout)) return 1; return 0; }
int main(void) { signal(SIGTTOU,SIG_IGN); signal(SIGTTIN,SIG_IGN); Arc::Logger logger(Arc::Logger::rootLogger, "Test"); Arc::LogStream logcerr(std::cerr); Arc::Logger::rootLogger.addDestination(logcerr); logger.msg(Arc::INFO, "Creating client side chain"); // Create client chain Arc::XMLNode client_doc("\ <ArcConfig\ xmlns=\"http://www.nordugrid.org/schemas/ArcConfig/2007\"\ xmlns:tcp=\"http://www.nordugrid.org/schemas/ArcMCCTCP/2007\">\ <ModuleManager>\ <Path>.libs/</Path>\ <Path>../../hed/mcc/http/.libs/</Path>\ <Path>../../hed/mcc/soap/.libs/</Path>\ <Path>../../hed/mcc/tls/.libs/</Path>\ <Path>../../hed/mcc/tcp/.libs/</Path>\ <Path>../../hed/shc/.libs/</Path>\ </ModuleManager>\ <Plugins><Name>mcctcp</Name></Plugins>\ <Plugins><Name>mcctls</Name></Plugins>\ <Plugins><Name>mcchttp</Name></Plugins>\ <Plugins><Name>mccsoap</Name></Plugins>\ <Plugins><Name>arcshc</Name></Plugins>\ <Chain>\ <Component name='tcp.client' id='tcp'><tcp:Connect><tcp:Host>127.0.0.1</tcp:Host><tcp:Port>50000</tcp:Port></tcp:Connect></Component>\ <Component name='tls.client' id='tls'><next id='tcp'/>\ <!--For proxy certificate, KeyPath and CertificatePath are supposed to be the same-->\ <KeyPath>./testkey-nopass.pem</KeyPath>\ <CertificatePath>./testcert.pem</CertificatePath>\ <CACertificatePath>./testcacert.pem</CACertificatePath>\ </Component>\ <Component name='http.client' id='http'><next id='tcp'/>\ <Method>POST</Method>\ <Endpoint>/Echo</Endpoint>\ </Component>\ <Component name='soap.client' id='soap' entry='soap'>\ <next id='http'/>\ </Component>\ </Chain>\ </ArcConfig>"); Arc::Config client_config(client_doc); if(!client_config) { logger.msg(Arc::ERROR, "Failed to load client configuration"); return -1; }; Arc::MCCLoader client_loader(client_config); logger.msg(Arc::INFO, "Client side MCCs are loaded"); Arc::MCC* client_entry = client_loader["soap"]; if(!client_entry) { logger.msg(Arc::ERROR, "Client chain does not have entry point"); return -1; }; // for (int i = 0; i < 10; i++) { // Create and send echo request logger.msg(Arc::INFO, "Creating and sending request"); Arc::NS echo_ns; echo_ns["echo"]="http://www.nordugrid.org/schemas/echo"; Arc::PayloadSOAP req(echo_ns); req.NewChild("echo").NewChild("say")="HELLO"; Arc::Message reqmsg; Arc::Message repmsg; reqmsg.Payload(&req); // It is a responsibility of code initiating first Message to // provide Context and Attributes as well. Arc::MessageAttributes attributes_req; Arc::MessageAttributes attributes_rep; Arc::MessageContext context; reqmsg.Attributes(&attributes_req); reqmsg.Context(&context); repmsg.Attributes(&attributes_rep); repmsg.Context(&context); Arc::MCC_Status status = client_entry->process(reqmsg,repmsg); if(!status) { logger.msg(Arc::ERROR, "Request failed"); std::cerr << "Status: " << std::string(status) << std::endl; return -1; }; Arc::PayloadSOAP* resp = NULL; if(repmsg.Payload() == NULL) { logger.msg(Arc::ERROR, "There is no response"); return -1; }; try { resp = dynamic_cast<Arc::PayloadSOAP*>(repmsg.Payload()); } catch(std::exception&) { }; if(resp == NULL) { logger.msg(Arc::ERROR, "Response is not SOAP"); return -1; }; std::string xml; resp->GetXML(xml); std::cout << "XML: "<< xml << std::endl; std::cout << "Response: " << (std::string)((*resp)["echoResponse"]["hear"]) << std::endl; //} return 0; }
int main(int argc, char **argv) { Arc::LogStream logcerr(std::cerr); Arc::Logger::getRootLogger().addDestination(logcerr); Arc::Logger::getRootLogger().setThreshold(Arc::WARNING); Arc::OptionParser options("", "", ""); int nJobs = -1; options.AddOption('N', "NJobs", "njobs", "number of jobs to write/read to/from storage", nJobs); int bunchSize = 100000; options.AddOption('B', "bunchSize", "", "size of bunches of job objects to pass to JobInformationStorage object methods", bunchSize); std::string action = "write"; options.AddOption('a', "action", "write, append, appendreturnnew, read, readall, remove", "Action to perform", action); std::string filename = ""; options.AddOption('f', "filename", "", "", filename); std::string typeS = ""; options.AddOption('t', "type", "BDB or XML", "Type of storage back-end to use", typeS); std::string hostname = "test.nordugrid.org"; options.AddOption(0, "hostname", "", "", hostname); std::list<std::string> endpoints; options.AddOption(0, "endpoint", "", "", endpoints); std::list<std::string> rejectEndpoints; options.AddOption(0, "rejectEndpoint", "reject", "Reject jobs with JobManagementURL matching specified endpoints (matching algorithm: URL::StringMatches)", rejectEndpoints); std::string jobidinfile; options.AddOption('i', "jobids-from-file", "a file containing a list of job IDs", "filename", jobidinfile); std::string jobidoutfile; options.AddOption('o', "jobids-to-file", "the IDs of jobs will be appended to this file", "filename", jobidoutfile); std::string debug; options.AddOption('d', "debug", "FATAL, ERROR, WARNING, INFO, VERBOSE or DEBUG", "debuglevel", debug); options.Parse(argc, argv); if (!debug.empty()) Arc::Logger::getRootLogger().setThreshold(Arc::string_to_level(debug)); if (filename.empty()) { std::cerr << "ERROR: No filename specified." << std::endl; return 1; } Arc::JobInformationStorage** jisPointer = NULL; if (typeS == "XML") { Arc::JobInformationStorageXML *jisXML = new Arc::JobInformationStorageXML(filename); jisPointer = (Arc::JobInformationStorage**)&jisXML; } #ifdef DBJSTORE_ENABLED else if (typeS == "BDB") { Arc::JobInformationStorageBDB *jisDB4 = new Arc::JobInformationStorageBDB(filename); jisPointer = (Arc::JobInformationStorage**)&jisDB4; } #endif else { std::cerr << "ERROR: Unable to determine storage back-end to use." << std::endl; return 1; } Arc::JobInformationStorage& jis = **jisPointer; Arc::Period timing; if (action == "write" || action == "append") { if (nJobs <= 0) { std::cerr << "ERROR: Invalid number of jobs specified (nJobs = " << nJobs << ")" << std::endl; goto error; } if (bunchSize <= 0) { std::cerr << "ERROR: Invalid bunch size (bunchSize = " << bunchSize << ")" << std::endl; goto error; } if (action == "write") { remove(filename.c_str()); } else { Arc::FileCopy(filename, "append-" + filename); filename = "append-" + filename; } Arc::Job j; j.ServiceInformationInterfaceName = "org.nordugrid.test"; j.JobStatusInterfaceName = "org.nordugrid.test"; j.JobManagementInterfaceName = "org.nordugrid.test"; j.JobDescriptionDocument = "&( executable = \"/bin/echo\" )( arguments = \"Hello World\" )( stdout = \"std.out\" )( stderr = \"std.out\" )( cputime = \"PT1M\" )( outputfiles = ( \"std.out\" \"\" ) ( \"std.out\" \"\" ) )( queue = \"gridlong\" )( jobname = \"Hello World\" )( clientsoftware = \"libarccompute-trunk\" )( clientxrsl = \"&( executable = \"\"/bin/echo\"\" )( arguments = \"\"Hello World\"\" )( stdout = \"\"std.out\"\" )( join = \"\"yes\"\" )( cputime = \"\"1\"\" )( jobname = \"\"Hello World\"\" )\" )( hostname = \"x220-skou\" )( savestate = \"yes\" )"; srand(Arc::Time().GetTimeNanoseconds()); for (int m = 0; m <= nJobs/bunchSize; ++m) { std::list<Arc::Job> jobs; const int bunchEnd = (m != nJobs/bunchSize)*(m+1)*bunchSize + (m == nJobs/bunchSize)*(nJobs%bunchSize); for (int n = m*bunchSize; n < bunchEnd; ++n) { j.Name = "Job " + Arc::tostring(n); j.IDFromEndpoint = Arc::tostring(rand())+Arc::tostring(n)+Arc::tostring(rand()); j.JobID = "http://" + hostname + "/" + j.IDFromEndpoint; j.ServiceInformationURL = Arc::URL("http://" + hostname + "/serviceinfo"); j.JobStatusURL = Arc::URL("http://" + hostname + "/jobstatus"); j.JobManagementURL = Arc::URL("http://" + hostname + "/jobmanagement"); j.StageInDir = Arc::URL("http://" + hostname + "/stagein/" + j.IDFromEndpoint); j.StageOutDir = Arc::URL("http://" + hostname + "/stageout/" + j.IDFromEndpoint); j.SessionDir = Arc::URL("http://" + hostname + "/session/" + j.IDFromEndpoint); j.LocalSubmissionTime = Arc::Time(); jobs.push_back(j); } if (!jobidoutfile.empty()) { Arc::Job::WriteJobIDsToFile(jobs, jobidoutfile); } Arc::Time tBefore; jis.Write(jobs); timing += Arc::Time()-tBefore; } } else if (action == "appendreturnnew") { if (nJobs <= 0) { std::cerr << "ERROR: Invalid number of jobs specified (nJobs = " << nJobs << ")" << std::endl; goto error; } if (bunchSize <= 0) { std::cerr << "ERROR: Invalid bunch size (bunchSize = " << bunchSize << ")" << std::endl; goto error; } Arc::FileCopy(filename, "append-" + filename); filename = "append-" + filename; Arc::Job j; j.ServiceInformationInterfaceName = "org.nordugrid.test"; j.JobStatusInterfaceName = "org.nordugrid.test"; j.JobManagementInterfaceName = "org.nordugrid.test"; j.JobDescriptionDocument = "&( executable = \"/bin/echo\" )( arguments = \"Hello World\" )( stdout = \"std.out\" )( stderr = \"std.out\" )( cputime = \"PT1M\" )( outputfiles = ( \"std.out\" \"\" ) ( \"std.out\" \"\" ) )( queue = \"gridlong\" )( jobname = \"Hello World\" )( clientsoftware = \"libarccompute-trunk\" )( clientxrsl = \"&( executable = \"\"/bin/echo\"\" )( arguments = \"\"Hello World\"\" )( stdout = \"\"std.out\"\" )( join = \"\"yes\"\" )( cputime = \"\"1\"\" )( jobname = \"\"Hello World\"\" )\" )( hostname = \"x220-skou\" )( savestate = \"yes\" )"; std::list<std::string> identifiers; Arc::Job::ReadJobIDsFromFile(jobidinfile, identifiers); for (int m = 0; m <= nJobs/bunchSize; ++m) { std::list<Arc::Job> jobs; std::set<std::string> prunedServices; const int bunchEnd = (m != nJobs/bunchSize)*(m+1)*bunchSize + (m == nJobs/bunchSize)*(nJobs%bunchSize); for (int n = m*bunchSize; n < bunchEnd; ++n) { std::string jobHostName = hostname; if (!identifiers.empty()) { Arc::URL temp(identifiers.front()); identifiers.pop_front(); jobHostName = temp.Host(); j.IDFromEndpoint = temp.Path(); } else { j.IDFromEndpoint = Arc::tostring(rand())+Arc::tostring(rand()); } prunedServices.insert(jobHostName); j.Name = "Job " + Arc::tostring(n); j.JobID = "http://" + jobHostName + "/" + j.IDFromEndpoint; j.ServiceInformationURL = Arc::URL("http://" + jobHostName + "/serviceinfo"); j.JobStatusURL = Arc::URL("http://" + jobHostName + "/jobstatus"); j.JobManagementURL = Arc::URL("http://" + jobHostName + "/jobmanagement"); j.StageInDir = Arc::URL("http://" + jobHostName + "/stagein/" + j.IDFromEndpoint); j.StageOutDir = Arc::URL("http://" + jobHostName + "/stageout/" + j.IDFromEndpoint); j.SessionDir = Arc::URL("http://" + jobHostName + "/session/" + j.IDFromEndpoint); j.LocalSubmissionTime = Arc::Time(); jobs.push_back(j); } std::list<const Arc::Job*> newJobs; Arc::Time tBefore; jis.Write(jobs, prunedServices, newJobs); timing += Arc::Time()-tBefore; } } else if (action == "readall") { std::list<Arc::Job> jobs; Arc::Time tBefore; jis.ReadAll(jobs, rejectEndpoints); timing += Arc::Time()-tBefore; } else if (action == "read") { std::list<Arc::Job> jobs; std::list<std::string> identifiers; Arc::Job::ReadJobIDsFromFile(jobidinfile, identifiers); Arc::Time tBefore; jis.Read(jobs, identifiers, endpoints, rejectEndpoints); timing += Arc::Time()-tBefore; } else if (action == "remove") { std::list<std::string> identifiers; Arc::Job::ReadJobIDsFromFile(jobidinfile, identifiers); Arc::Time tBefore; jis.Remove(identifiers); timing += Arc::Time()-tBefore; } else { std::cerr << "ERROR: Invalid action specified (action = \"" << action << "\")" << std::endl; delete *jisPointer; return 1; } delete *jisPointer; { int nanosecs = timing.GetPeriodNanoseconds(); std::string zerosToPrefix = ""; for (int i = 100000000; i > 1; i /= 10) { if (nanosecs / i == 0) zerosToPrefix += "0"; else break; } std::cout << timing.GetPeriod() << "." << zerosToPrefix << nanosecs/1000 << std::endl; } return 0; error: delete *jisPointer; return 1; }