void TextCodecICU::createICUConverter() const { ASSERT(!m_converterICU); #if defined(USING_SYSTEM_ICU) const char* name = m_encoding.name(); m_needsGBKFallbacks = name[0] == 'G' && name[1] == 'B' && name[2] == 'K' && !name[3]; #endif UErrorCode err; UConverter*& cachedConverter = cachedConverterICU(); if (cachedConverter) { err = U_ZERO_ERROR; const char* cachedName = ucnv_getName(cachedConverter, &err); if (U_SUCCESS(err) && m_encoding == cachedName) { m_converterICU = cachedConverter; cachedConverter = 0; return; } } err = U_ZERO_ERROR; m_converterICU = ucnv_open(m_encoding.name(), &err); DLOG_IF(ERROR, err == U_AMBIGUOUS_ALIAS_WARNING) << "ICU ambiguous alias warning for encoding: " << m_encoding.name(); if (m_converterICU) ucnv_setFallback(m_converterICU, TRUE); }
int main(int argc, char** argv) { int err; std::string usage("Usage: " + std::string(argv[0]) + " [options] <hostport>\n"); usage += " Runs a master node with launcher that is running on host:port."; google::SetUsageMessage(usage); google::InitGoogleLogging(argv[0]); google::InstallFailureSignalHandler(); google::ParseCommandLineFlags(&argc, &argv, true); if (argc != 2) { fprintf(stderr, "Invalid number of aruments provided\n%s\n", google::ProgramUsage()); exit(EXIT_FAILURE); } accept_fd = listen_to(FLAGS_address.c_str()); CHECK_GE(accept_fd, 0) << "Could not listen on " << FLAGS_address; DLOG_IF(INFO, FLAGS_log_network) << "Listening on " << FLAGS_address; launcher_fd = connect_to(argv[1]); CHECK_GE(launcher_fd, 0) << "Could not connect to launcher " << argv[1]; DLOG_IF(INFO, FLAGS_log_network) << "Connected to launcher at " << argv[1]; // Tell the launcher what address we are listening on. err = send_string(launcher_fd, FLAGS_address); CHECK_GE(err, 0) << "Error sending master info"; // student code int tick_seconds; master_node_init(FLAGS_max_workers, tick_seconds); struct timeval tick_period; tick_period.tv_sec = tick_seconds; tick_period.tv_usec = 0; harness_begin_main_loop(&tick_period); return 0; }
std::shared_ptr<ScheduledFuture> ScheduledMessageService::schedule(std::shared_ptr<ActorMessage> msg, unsigned long delay) { DLOG_IF(FATAL, (msg->getDestMemberId() == idgs::pb::UNKNOWN_MEMBER || msg->getSourceMemberId() == idgs::pb::UNKNOWN_MEMBER)) << "Unknown member: " << msg->toString(); std::shared_ptr<ScheduledFuture> result(new ScheduledFuture(msg, sys::getCurrentTime() + delay)); PendingFuturesType& pFuture = tasks[delay]; if (!pFuture.get()) { pFuture.reset(new PendingFutures()); } pFuture->queue.push(result); return result; }
int main(int argc, char* argv[]) { paracel::main_env comm_main_env(argc, argv); paracel::Comm comm(MPI_COMM_WORLD); google::InitGoogleLogging(argv[0]); int num_cookies = 7; LOG(INFO) << "Found " << num_cookies << " cookies"; LOG_IF(INFO, comm.get_rank() == 0) << "Got lots of cookies"; DLOG(INFO) << "Found cookies"; DLOG_IF(INFO, comm.get_rank() == 0) << "Got lots of cookies"; VLOG_IF(1, comm.get_rank() == 0) << "I'm printed when size is more than 1024 and when you run the " "program with --v=1 or more"; return 0; }
int main(int argc, char* argv[]) { el::Configurations defaultConf; defaultConf.setToDefault(); defaultConf.setGlobally(el::ConfigurationType::ToFile, std::string("false")); defaultConf.setGlobally(el::ConfigurationType::ToStandardOutput, std::string("true")); el::Loggers::reconfigureLogger("default", defaultConf); if (::isatty(::fileno(stdout))) el::Loggers::addFlag(el::LoggingFlag::ColoredTerminalOutput); ::consul::Agent agent; ::consul::KVPair::ValueT value; TCLAP::ValueArg<::consul::KVPair::IndexT> casArg("C", "cas", "Check-and-Set index. When performing a PUT or DELETE, only operate if the ModifyIndex matches the passed in CAS value", false, std::numeric_limits<::consul::KVPair::IndexT>::max(), "modify-index"); TCLAP::ValueArg<::consul::KVPair::SessionT> sessionArg("S", "session", "Acquire a lock using the specified Session", false, "", "session"); TCLAP::ValueArg<::consul::KVPair::FlagsT> flagsArg("F", "flags", "Opaque numeric value attached to a key (0 through (2^64)-1)", false, std::numeric_limits<::consul::KVPair::FlagsT>::max() - 1, "flag"); enum class MethodType : char { GET, PUT, DELETE }; MethodType methodType; bool debugFlag = false; bool recursiveFlag = false; std::vector<::consul::KVPair::KeyT> keys; try { TCLAP::CmdLine cmd(COMMAND_HELP_MSG, '=', "0.1"); // Args are displayed LIFO std::vector<TCLAP::Arg*> cmdMajorModes; TCLAP::MultiArg<::consul::KVPair::KeyT> keyArg("k", "key", "Key(s) operate on with the consul agent", true, "string"); cmdMajorModes.push_back(&keyArg); TCLAP::ValueArg<std::string> decodeArg("D", "decode", "Decode a base64 encoded string", false, "dGVzdA==", "base64-encoded-string"); cmdMajorModes.push_back(&decodeArg); TCLAP::ValueArg<std::string> encodeArg("E", "encode", "Encode a stream of bytes using base64", false, "test", "stream of bytes"); cmdMajorModes.push_back(&encodeArg); cmd.xorAdd(cmdMajorModes); TCLAP::SwitchArg debugArg("d", "debug", "Print additional information with debugging", false); cmd.add(debugArg); TCLAP::ValueArg<consul::Agent::PortT> portArg("p", "port", "Port number of consul agent", false, agent.port(), "port"); cmd.add(portArg); TCLAP::ValueArg<consul::Agent::HostT> hostArg("H", "host", "Hostname of consul agent", false, agent.host().c_str(), "hostname"); cmd.add(hostArg); std::vector<std::string> methods{{"GET","PUT","DELETE"}}; TCLAP::ValuesConstraint<std::string> methodConstraint(methods); TCLAP::ValueArg<std::string> methodArg("m", "method", "HTTP method used to act on the key", false, "get", &methodConstraint); cmd.add(methodArg); TCLAP::ValueArg<std::string> valueArg("v", "value", "Value to be used when PUT'ing a key (will be base64 encoded automatically).", false, "", "value"); cmd.add(valueArg); TCLAP::SwitchArg recursiveArg("r", "recursive", "Pass the '?recurse' query parameter to recursively find all keys"); cmd.add(recursiveArg); // NOTE: the following *Args were defined above try{} block cmd.add(casArg); cmd.add(flagsArg); cmd.add(sessionArg); TCLAP::ValueArg<std::string> clusterArg("c", "cluster", "consul Cluster (i.e. '?dc=<cluster>')", false, "", "dc1"); cmd.add(clusterArg); cmd.parse(argc, argv); if (debugArg.isSet()) { debugFlag = debugArg.getValue(); } if (hostArg.isSet()) { agent.setHost(hostArg.getValue()); } if (portArg.isSet()) { agent.setPort(portArg.getValue()); } if (decodeArg.isSet()) { base64::decoder D; const std::string testInput{decodeArg.getValue()}; std::istringstream iss{testInput}; std::ostringstream oss; D.decode(iss, oss); std::cout << "Result: \"" << oss.str() << "\"" << std::endl; return EX_OK; } if (encodeArg.isSet()) { base64::encoder E; const std::string testInput{encodeArg.getValue()}; std::istringstream iss{testInput}; std::ostringstream oss; E.encode(iss, oss); std::cout << "-----BEGIN BASE64 ENCODED STREAM-----" << std::endl << oss.str() << "-----END BASE64 ENCODED STREAM-----" << std::endl ; return EX_OK; } keys = keyArg.getValue(); if (clusterArg.isSet()) { agent.setCluster(clusterArg.getValue()); } if (recursiveArg.isSet()) { recursiveFlag = recursiveArg.getValue(); } if (methodArg.isSet()) { const auto& v = methodArg.getValue(); if (v == "GET") { methodType = MethodType::GET; } else if (v == "PUT") { if (!valueArg.isSet()) { LOG(ERROR) << "Unable to use PUT method without specifying a value argument (--value=)"; return EX_USAGE; } if (keys.size() > 1) { LOG(ERROR) << "Unable to pass multiple key arguments when PUT'ing a value"; return EX_USAGE; } methodType = MethodType::PUT; } else if (v == "DELETE") { methodType = MethodType::DELETE; } else { LOG(FATAL) << "Unknown type: " << v; return EX_SOFTWARE; } } if (valueArg.isSet()) { value = valueArg.getValue(); } } catch (TCLAP::ArgException &e) { LOG(FATAL) << e.error() << " for arg " << e.argId(); return EX_USAGE; } try { for (auto& key : keys) { auto kvUrl = agent.kvUrl(key); LOG_IF(debugFlag, INFO) << "Key URL: " << kvUrl; auto params = cpr::Parameters(); if (!agent.cluster().empty()) { LOG_IF(debugFlag, INFO) << "Passing ?dc=" << agent.cluster() << " flag"; params.AddParameter({"dc", agent.cluster()}); } else { LOG_IF(debugFlag, INFO) << "No consul ?dc= specified"; } if (recursiveFlag && (methodType == MethodType::GET || methodType == MethodType::DELETE)) { LOG_IF(debugFlag, INFO) << "Passing ?recurse flag"; params.AddParameter({"recurse", ""}); } else { LOG_IF(debugFlag, INFO) << "Not passing the ?recurse flag"; } if (casArg.isSet() && (methodType == MethodType::PUT || methodType == MethodType::DELETE)) { auto casStr = ::boost::lexical_cast<std::string>(casArg.getValue()); LOG_IF(debugFlag, INFO) << "Passing ?cas=" << casStr << " parameter"; params.AddParameter({"cas", casStr}); } if (sessionArg.isSet() && methodType == MethodType::PUT) { LOG_IF(debugFlag, INFO) << "Passing ?acquire=" << sessionArg.getValue() << " parameter"; params.AddParameter({"acquire", sessionArg.getValue()}); } if (flagsArg.isSet() && methodType == MethodType::PUT) { auto flagsStr = ::boost::lexical_cast<std::string>(flagsArg.getValue()); LOG_IF(debugFlag, INFO) << "Passing ?flags=" << flagsStr << " parameter"; params.AddParameter({"flags", flagsStr}); } if (methodType == MethodType::GET) { auto r = cpr::Get(cpr::Url{kvUrl}, cpr::Header{{"Connection", "close"}}, cpr::Timeout{agent.timeoutMs()}, params); if (r.status_code != 200) { LOG(ERROR) << "consul agent returned error " << r.status_code; return EX_TEMPFAIL; } DLOG_IF(debugFlag, INFO) << "URL: " << r.url; consul::KVPairs kvps; std::string err; if (!::consul::KVPairs::InitFromJson(kvps, r.text, err)) { LOG(ERROR) << "Failed to load KVPair(s) from JSON: " << err; return EX_PROTOCOL; } if (recursiveFlag) { LOG_IF(debugFlag, INFO) << "Found " << kvps.size() << " objects when searching for " << kvUrl; } else { if (kvps.size() > 1) { LOG(ERROR) << "Non-recursive GET for " << r.url << " returned " << kvps.size() << " objects"; return EX_PROTOCOL; } } std::size_t i = 0; for (auto& kvp : kvps.objs()) { if (recursiveFlag) { std::cout << "========== BEGIN KEY " << ++i << "/" << kvps.size() << " ==========" << std::endl; } std::cout << "Key: " << kvp.key() << std::endl; std::cout << "Value: " << kvp.value() << std::endl; if (!kvp.session().empty()) { std::cout << "Session: " << kvp.session() << std::endl; } DLOG_IF(debugFlag, INFO) << "Value (base64-encoded): " << kvp.valueEncoded(); LOG_IF(debugFlag, INFO) << "CreateIndex: " << kvp.createIndex(); LOG_IF(debugFlag, INFO) << "ModifyIndex: " << kvp.modifyIndex(); LOG_IF(debugFlag, INFO) << "LockIndex: " << kvp.lockIndex(); LOG_IF(debugFlag, INFO) << "Flags: " << kvp.flags(); LOG_IF(debugFlag, INFO) << "Session: " << (!kvp.session().empty() ? kvp.session() : "[none]"); LOG_IF(debugFlag, INFO) << "JSON: " << kvp.json(); } } else if (methodType == MethodType::DELETE) { auto r = cpr::Delete(cpr::Url{kvUrl}, cpr::Header{{"Connection", "close"}}, cpr::Timeout{agent.timeoutMs()}, cpr::Payload{value}, params); if (r.status_code != 200) { LOG(ERROR) << "consul agent returned error " << r.status_code; return EX_TEMPFAIL; } DLOG_IF(debugFlag, INFO) << "URL: " << r.url; } else if (methodType == MethodType::PUT) { auto r = cpr::Put(cpr::Url{kvUrl}, cpr::Header{{"Connection", "close"}}, cpr::Timeout{agent.timeoutMs()}, cpr::Payload{value}, params); if (r.status_code != 200) { LOG(ERROR) << "consul agent returned error " << r.status_code; return EX_TEMPFAIL; } DLOG_IF(debugFlag, INFO) << "URL: " << r.url; if (r.text == "true") { LOG(INFO) << "Succeeded in posting key \"" << keys.at(0) << "\""; } else if (r.text == "false") { LOG(WARNING) << "Unable to PUT key \"" << keys.at(0) << "\""; return EX_CANTCREAT; } } else { DLOG(FATAL) << "Unsupported methodType"; } } return EX_OK; } catch (std::exception & e) { LOG(FATAL) << "cpr threw an exception: " << e.what(); return EX_SOFTWARE; } return EX_OK; }
boost::any CsvRecordParser::next() { if(!configured_) { throw std::runtime_error("not configured"); } //if we already have a line, consume that if((uint64_t)rowIndex_ < row_.size()) { if (schema_.find(rowIndex_) == schema_.end() ) { dumpDebugInfo(); std::ostringstream os; os << "Invalid schema. Unable to find type for column " << rowIndex_ << "."; throw std::runtime_error(os.str()); } boost::any myany; bool isNull = false; if (row_[rowIndex_] == "") { isNull = true; myany = CsvRecord(isNull); } else if (schema_[rowIndex_].second == "logical") { bool boolCell; std::string stringCell = row_[rowIndex_]; std::transform(stringCell.begin(), stringCell.end(), stringCell.begin(), ::tolower); if (stringCell == "true") { boolCell = true; } else if (stringCell == "false") { boolCell = false; } else { boolCell = static_cast<bool>(atoll(row_[rowIndex_].c_str())); } myany = CsvRecord(isNull, boolCell); } else if (schema_[rowIndex_].second == "integer") { myany = CsvRecord(isNull, (int32_t)atoi(row_[rowIndex_].c_str())); } else if (schema_[rowIndex_].second == "int64") { myany = CsvRecord(isNull, (double)atof(row_[rowIndex_].c_str())); } else if (schema_[rowIndex_].second == "numeric") { myany = CsvRecord(isNull, (double)atof(row_[rowIndex_].c_str())); } else if (schema_[rowIndex_].second == "character") { myany = CsvRecord(isNull, row_[rowIndex_]); } else { std::ostringstream os; os << "Unsupported type "; os << schema_[rowIndex_].second; os << ". Supported types are int64, double and string"; throw std::runtime_error(os.str()); } DLOG_IF(INFO, recordsProduced_ < 10) << "returning record: " << row_[rowIndex_]; ++recordsProduced_; rowIndex_++; return myany; } else if((uint64_t)rowIndex_ == row_.size()) { if(rowIndex_ != 0) { //notify we're done with line if(!observer_) { throw std::runtime_error("observer not set"); } observer_->update(0); } if(splitProducer_->hasNext()) { //load new line and reset rowIndex_ boost::shared_ptr<splitproducer::Split> s; std::string line; bool isCommentLineFlag = false; bool isEmptyLineFlag = false; do { try { s = splitProducer_->next(); line = std::string(const_cast<const char*>(reinterpret_cast<char *>(s->buffer)), s->used); } catch(const splitproducer::EmptySplitException& e) { DLOG(INFO) << "Split producer returned an empty split"; throw; } /** * Discard comment lines */ isCommentLineFlag = isCommentLine(line, commentCharacter_); if (isCommentLineFlag) { ++commentLinesDiscarded_; } /** * Discard blank lines */ isEmptyLineFlag = line == ""; if (isEmptyLineFlag) { ++blankLinesDiscarded_; } } while (isCommentLineFlag || isEmptyLineFlag); std::istringstream ss(line); text::csv::csv_istream is(ss, delimiter_); is >> row_; rowIndex_ = 0; return next(); } else { throw std::runtime_error("no more records");
static jboolean nativeP2pDeviceDoSend(JNIEnv*, jobject, jbyteArray) { DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", __func__); return JNI_TRUE; }
static jbyteArray nativeP2pDeviceDoReceive(JNIEnv*, jobject) { DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", __func__); return NULL; }
static jboolean nativeP2pDeviceDoDisconnect(JNIEnv*, jobject) { DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf("%s", __func__); return JNI_TRUE; }