virtual hexabus::Packet::Ptr handle_query() const { if ( !is_readable() ) return Packet::Ptr(new ErrorPacket(HXB_ERR_UNKNOWNEID)); boost::optional<TValue> value = _read(); if ( !value ) { std::stringstream oss; oss << "Error reading endpoint " << name() << " (" << eid() << ")"; throw hexabus::GenericException(oss.str()); } return Packet::Ptr(new InfoPacket<TValue>(eid(), *value)); }
void View::create(const RootEntity& gent) { std::string eid(gent->getId()); if (m_contents.count(eid)) { // already known locally, just emit the signal EntityCreated.emit( m_contents[eid] ); return; } bool alreadyAppeared = false; PendingSightMap::iterator pending = m_pending.find(eid); if (pending != m_pending.end()) { // already being retrieved, but we have the data now alreadyAppeared = (pending->second == SACTION_QUEUED) || (pending->second == SACTION_APPEAR); pending->second = SACTION_DISCARD; // when the SIGHT turns up } Entity* ent = createEntity(gent); m_contents[eid] = ent; ent->init(gent, true); if (gent->isDefaultLoc()) setTopLevelEntity(ent); InitialSightEntity.emit(ent); // depends on relative order that sight(create) and appear are received in if (alreadyAppeared) { ent->setVisible(true); EntityCreated.emit(ent); } }
void Network::setStringEdgeAttribute(vertex_id vid1, vertex_id vid2, const std::string& attribute_name, const std::string& val) { if (!containsVertex(vid1)) throw ElementNotFoundException("Vertex " + std::to_string(vid1)); if (!containsVertex(vid2)) throw ElementNotFoundException("Vertex " + std::to_string(vid2)); if (!containsEdge(vid1, vid2)) throw ElementNotFoundException("Edge (" + std::to_string(vid2) + ", " + std::to_string(vid2) + ")"); if (edge_string_attribute.count(attribute_name)==0) throw ElementNotFoundException("Attribute " + attribute_name); edge_id eid(vid1, vid2, isDirected()); edge_string_attribute.at(attribute_name)[eid] = val; }
std::string Network::getStringEdgeAttribute(vertex_id vid1, vertex_id vid2, const std::string& attribute_name) const { if (!containsVertex(vid1)) throw ElementNotFoundException("Vertex " + std::to_string(vid1)); if (!containsVertex(vid2)) throw ElementNotFoundException("Vertex " + std::to_string(vid2)); if (!containsEdge(vid1, vid2)) throw ElementNotFoundException("Edge (" + std::to_string(vid1) + ", " + std::to_string(vid2) + ")"); if (edge_string_attribute.count(attribute_name)==0) throw ElementNotFoundException("Attribute " + attribute_name); edge_id eid(vid1, vid2, isDirected()); if (edge_string_attribute.at(attribute_name).count(eid)==0) throw ElementNotFoundException("No attribute value for attribute " + attribute_name + " on edge (" + std::to_string(vid1) + "," + std::to_string(vid2) + ")"); return edge_string_attribute.at(attribute_name).at(eid); }
std::istream& DeliveryPredictabilityMap::deserialize(std::istream& stream) { data::Number elements_read(0); data::Number map_size; stream >> map_size; while(elements_read < map_size) { /* read the EID */ data::Number eid_len; stream >> eid_len; // create a buffer for the EID std::vector<char> eid_cstr(eid_len.get<size_t>()); // read the EID string stream.read(&eid_cstr[0], eid_cstr.size()); // convert the string into an EID object dtn::data::EID eid(std::string(eid_cstr.begin(), eid_cstr.end())); if(eid == data::EID()) throw dtn::InvalidDataException("EID could not be casted, while parsing a dp_map."); /* read the probability (float) */ float f; dtn::data::Number float_len; stream >> float_len; // create a buffer for the data string std::vector<char> f_cstr(float_len.get<size_t>()); // read the data string stream.read(&f_cstr[0], f_cstr.size()); // convert string data into a stringstream std::stringstream ss(std::string(f_cstr.begin(), f_cstr.end())); // convert string data into a float ss >> f; if(ss.fail()) throw dtn::InvalidDataException("Float could not be casted, while parsing a dp_map."); /* check if f is in a proper range */ if(f < 0 || f > 1) continue; /* insert the data into the map */ _predictmap[eid] = f; elements_read += 1; } IBRCOMMON_LOGGER_DEBUG_TAG("DeliveryPredictabilityMap", 20) << "Deserialized with " << _predictmap.size() << " items." << IBRCOMMON_LOGGER_ENDL; IBRCOMMON_LOGGER_DEBUG_TAG("DeliveryPredictabilityMap", 60) << *this << IBRCOMMON_LOGGER_ENDL; return stream; }
virtual void visit(ElementType type, long id) { ElementId eid(type, id); ElementPtr e = _map->getElement(eid); if (e->getTags().get("REF1") != _ref && e->getTags().get("REF2") != _ref) { RecursiveElementRemover(eid).apply(_map); } }
// See eq. 2.1.4 Matrix<std::complex<double> > U23(double delta, double angle) { std::complex<double> eid(cos(delta), sin(delta)); Matrix<std::complex<double> > ret(3, 3); ret(0, 0) = 1; ret(1, 1) = cos(angle); ret(1, 2) = sin(angle) * eid; ret(2, 1) = -sin(angle) * std::conj(eid); ret(2, 2) = cos(angle); return ret; }
void BundleStorageTest::testRaiseEvent(dtn::storage::BundleStorage &storage) { /* test signature (const Event *evt) */ dtn::data::EID eid("dtn://node-one/test"); dtn::data::Bundle b; b.lifetime = 60; b.source = dtn::data::EID("dtn://node-two/foo"); storage.store(b); storage.wait(); dtn::core::TimeEvent::raise(dtn::utils::Clock::getTime() + 3600, dtn::core::TIME_SECOND_TICK); }
/** Assumes unit viscosity. @todo Dont like the total_volume bare here */ UpscaledTensor analyze(const std::vector<FlowResults>& frv, double total_volume) { const size_t d = frv.size(); UpscaledTensor r(d); // averaging const auto& volumes = frv[0].volumes(); // assumption: element info for all exps identical const auto elements = volumes.size(); // assumption: element info for all exps identical // average xy(z) components for pressure gradients and velocities for each experiment (outer index) // and each component (inner index) vector<vector<double>> vel_avgs(d, vector<double>(d)), pgrad_avgs(d, vector<double>(d)); for (size_t I(0); I < d; ++I) // experiment, 0..d-1 for (size_t c(0); c < d; ++c) { // for each spatial component, 0..d-1 auto& pgrads = frv[I].components(FlowResults::Data::pressure_gradient, c); auto& vels = frv[I].components(FlowResults::Data::velocity, c); double pgrad_avg(0.), vel_avg(0.); for (size_t eid(0); eid < elements; ++eid) { pgrad_avg += pgrads[eid] * volumes[eid]; vel_avg += vels[eid] * volumes[eid]; } vel_avgs[I][c] = vel_avg / total_volume; pgrad_avgs[I][c] = pgrad_avg / total_volume; } // accumulating upscaled darcy problem // 1) velocity const size_t odiags = d == 3 ? 3 : 1; // number of off-diagonal terms vector<double64> u(d*d + odiags, 0.); // rhs, velocity component averages plus zeros for (size_t I(0); I < d; ++I) for (size_t c(0); c < d; ++c) u[I*d + c] = -vel_avgs[I][c]; // 2) pressure gradients, 3D only from here DenseMatrix<12> capacity(12, 9); capacity = 0.; for (size_t I(0); I < d; ++I) for (size_t t(0); t < d; ++t) for (size_t c(0); c < d; ++c) capacity(I*3+t, t*d+c) = pgrad_avgs[I][c]; // symmetry conditions capacity(9, 1) = capacity(10, 2) = capacity(11, 5) = 1.; capacity(9, 3) = capacity(10, 6) = capacity(11, 7) = -1; // solving overdetermined system and initializing tensor auto k = solve_overdet(capacity, u); for (size_t i(0); i < d; ++i) for (size_t j(0); j < d; ++j) r(i, j) = k[i*d + j]; return r; }
bool Network::deleteEdge(vertex_id vid1, vertex_id vid2) { if (!containsEdge(vid1,vid2)) return false; edge_id eid(vid1,vid2,isDirected()); out_edges[vid1].erase(vid2); in_edges[vid2].erase(vid1); if (!isDirected()) { out_edges[vid2].erase(vid1); in_edges[vid1].erase(vid2); } // remove attribute values (including WEIGHT, if present, which is treated as any other numeric attribute) for (std::map<std::string,std::map<edge_id,std::string> >::iterator it=edge_string_attribute.begin(); it!=edge_string_attribute.end(); it++) edge_string_attribute[it->first].erase(eid); for (std::map<std::string,std::map<edge_id,double> >::iterator it=edge_numeric_attribute.begin(); it!=edge_numeric_attribute.end(); it++) edge_numeric_attribute[it->first].erase(eid); num_edges--; return true; }
TEST_F(ExtentIdTest, malformed) { const fd::ContainerId cid("container"); const uint32_t off(23); const fd::ExtentId eid(cid, off); const std::string eidstr(eid.str()); // suffix too short EXPECT_THROW(fd::ExtentId(eidstr.substr(0, eidstr.size() - 2)), fd::ExtentId::NotAnExtentId); // suffix too long EXPECT_THROW(fd::ExtentId(eidstr + "0"), fd::ExtentId::NotAnExtentId); // wrong separator TODO("AR: figure out what's wrong here"); // This is really curious: // // EXPECT_THROW(fd::ExtentId(str), // fd::ExtentId::NotAnExtentId); // // yields a compiler error: // // /home/arne/Projects/CloudFounders/3.6/volumedriver-core/src/filedriver/test/ExtentIdTest.cpp:56:34: error: no matching function for call to 'filedriver::ExtentId::ExtentId()' // EXPECT_THROW(fd::ExtentId(str), // ... // // . The nonsensical lambda is to work around that. auto fun([&] { std::string str(eidstr); const char sep = '*'; ASSERT_NE(sep, separator[0]); str[str.find_last_of(separator)] = sep; fd::ExtentId eid(str); }); EXPECT_THROW(fun(), fd::ExtentId::NotAnExtentId); }
void checkForMatch(const shared_ptr<const Node>& n) { // find other nearby candidates set<long> neighbors = _findNeighbors(n); ElementId from(n->getElementId()); _elementsEvaluated++; int neighborCount = 0; vector<double> classes; for (set<long>::const_iterator it = neighbors.begin(); it != neighbors.end(); ++it) { ElementId eid(ElementType::Node, *it); const shared_ptr<const Node>& neighbor = _map->getNode(*it); // make sure we only create one match per pair. Use the node with the larger circular error // to make sure we do the larger of the two queries. If the CE is equal then use the eid // with the lower id. Arbitrary, but it will prevent duplicates. if ((neighbor->getCircularError() < n->getCircularError()) || (neighbor->getCircularError() == n->getCircularError() && from.getId() < eid.getId())) { if (OsmSchema::getInstance().isPoi(*n)) { // score each candidate and push it on the result vector PlacesPoiMatch* m = new PlacesPoiMatch(_map, from, eid, _threshold); // if we're confident this is a miss if (m->getClassification().getMissP() >= _rejectScore) { delete m; } else { _result.push_back(m); neighborCount++; } } } } _neighborCountSum += neighborCount; _neighborCountMax = std::max(_neighborCountMax, neighborCount); }
int main(int argc, char *argv[]) { int index; int c; std::string ptp_dev("tun0"); std::string app_name("tunnel"); std::string endpoint("dtn:none"); unsigned int lifetime = 60; bool daemonize = false; bool stop_daemon = false; std::string pidfile; bool throughput = false; #ifdef HAVE_LIBDAEMON while ((c = getopt (argc, argv, "td:s:l:hDkp:")) != -1) #else while ((c = getopt (argc, argv, "td:s:l:h")) != -1) #endif switch (c) { #ifdef HAVE_LIBDAEMON case 'D': daemonize = true; break; case 'k': daemonize = true; stop_daemon = true; break; case 'p': pidfile = optarg; break; #endif case 'd': ptp_dev = optarg; break; case 't': throughput = true; break; case 's': app_name = optarg; break; case 'l': lifetime = atoi(optarg); break; default: print_help(argv[0]); return 1; } int optindex = 0; for (index = optind; index < argc; ++index) { switch (optindex) { case 0: endpoint = std::string(argv[index]); break; } optindex++; } // print help if not enough parameters are set if (!stop_daemon && (optindex < 1)) { print_help(argv[0]); exit(0); } // catch process signals ibrcommon::SignalHandler sighandler(term); sighandler.handle(SIGINT); sighandler.handle(SIGTERM); sighandler.handle(SIGQUIT); //initialize sighandler after possible exit call sighandler.initialize(); // logging options //const unsigned char logopts = ibrcommon::Logger::LOG_DATETIME | ibrcommon::Logger::LOG_LEVEL; const unsigned char logopts = 0; // error filter const unsigned char logerr = ibrcommon::Logger::LOGGER_ERR | ibrcommon::Logger::LOGGER_CRIT; // logging filter, everything but debug, err and crit const unsigned char logstd = ibrcommon::Logger::LOGGER_ALL ^ (ibrcommon::Logger::LOGGER_DEBUG | logerr); // syslog filter, everything but DEBUG and NOTICE const unsigned char logsys = ibrcommon::Logger::LOGGER_ALL ^ (ibrcommon::Logger::LOGGER_DEBUG | ibrcommon::Logger::LOGGER_NOTICE); #ifdef HAVE_LIBDAEMON if (daemonize) { // enable syslog logging ibrcommon::Logger::enableSyslog(argv[0], LOG_PID, LOG_DAEMON, logsys); } else #endif { // add logging to the cout ibrcommon::Logger::addStream(std::cout, logstd, logopts); // add logging to the cerr ibrcommon::Logger::addStream(std::cerr, logerr, logopts); } #ifdef HAVE_LIBDAEMON if (daemonize) { #ifdef HAVE_DAEMON_RESET_SIGS /* Reset signal handlers */ if (daemon_reset_sigs(-1) < 0) { IBRCOMMON_LOGGER_TAG("Core", error) << "Failed to reset all signal handlers: " << strerror(errno) << IBRCOMMON_LOGGER_ENDL; return 1; } /* Unblock signals */ if (daemon_unblock_sigs(-1) < 0) { IBRCOMMON_LOGGER_TAG("Core", error) << "Failed to unblock all signals: " << strerror(errno) << IBRCOMMON_LOGGER_ENDL; return 1; } #endif pid_t pid; /* Set identification string for the daemon for both syslog and PID file */ daemon_pid_file_ident = daemon_log_ident = daemon_ident_from_argv0(argv[0]); /* set the pid file path */ if (pidfile.length() > 0) { __daemon_pidfile__ = new char[pidfile.length() + 1]; ::strcpy(__daemon_pidfile__, pidfile.c_str()); daemon_pid_file_proc = __daemon_pid_file_proc__; } /* Check if we are called with -k parameter */ if (stop_daemon) { int ret; /* Kill daemon with SIGTERM */ /* Check if the new function daemon_pid_file_kill_wait() is available, if it is, use it. */ if ((ret = daemon_pid_file_kill_wait(SIGTERM, 5)) < 0) IBRCOMMON_LOGGER_TAG("Core", warning) << "Failed to kill daemon: " << strerror(errno) << IBRCOMMON_LOGGER_ENDL; return ret < 0 ? 1 : 0; } /* Check that the daemon is not rung twice a the same time */ if ((pid = daemon_pid_file_is_running()) >= 0) { IBRCOMMON_LOGGER_TAG("Core", error) << "Daemon already running on PID file " << pid << IBRCOMMON_LOGGER_ENDL; return 1; } /* Prepare for return value passing from the initialization procedure of the daemon process */ if (daemon_retval_init() < 0) { IBRCOMMON_LOGGER_TAG("Core", error) << "Failed to create pipe." << IBRCOMMON_LOGGER_ENDL; return 1; } /* Do the fork */ if ((pid = daemon_fork()) < 0) { /* Exit on error */ daemon_retval_done(); return 1; } else if (pid) { /* The parent */ int ret; /* Wait for 20 seconds for the return value passed from the daemon process */ if ((ret = daemon_retval_wait(20)) < 0) { IBRCOMMON_LOGGER_TAG("Core", error) << "Could not recieve return value from daemon process: " << strerror(errno) << IBRCOMMON_LOGGER_ENDL; return 255; } return ret; } else { /* The daemon */ /* Close FDs */ if (daemon_close_all(-1) < 0) { IBRCOMMON_LOGGER_TAG("Core", error) << "Failed to close all file descriptors: " << strerror(errno) << IBRCOMMON_LOGGER_ENDL; /* Send the error condition to the parent process */ daemon_retval_send(1); /* Do a cleanup */ daemon_retval_send(255); daemon_signal_done(); daemon_pid_file_remove(); return -1; } /* Create the PID file */ if (daemon_pid_file_create() < 0) { IBRCOMMON_LOGGER_TAG("Core", error) << "Could not create PID file ( " << strerror(errno) << ")." << IBRCOMMON_LOGGER_ENDL; daemon_retval_send(2); /* Do a cleanup */ daemon_retval_send(255); daemon_signal_done(); daemon_pid_file_remove(); return -1; } /* Send OK to parent process */ daemon_retval_send(0); } } #endif IBRCOMMON_LOGGER_TAG("Core", info) << "IBR-DTN IP <-> Bundle Tunnel" << IBRCOMMON_LOGGER_ENDL; // create a connection to the dtn daemon ibrcommon::vaddress addr("localhost", 4550); ibrcommon::socketstream conn(new ibrcommon::tcpsocket(addr)); try { // set-up tun2bundle gateway TUN2BundleGateway gateway(app_name, conn, ptp_dev); _gateway = &gateway; IBRCOMMON_LOGGER_TAG("Core", info) << "Local: " << app_name << IBRCOMMON_LOGGER_ENDL; IBRCOMMON_LOGGER_TAG("Core", info) << "Peer: " << endpoint << IBRCOMMON_LOGGER_ENDL; IBRCOMMON_LOGGER_TAG("Core", info) << "Device: " << gateway.getDeviceName() << IBRCOMMON_LOGGER_ENDL; IBRCOMMON_LOGGER_TAG("Core", notice) << IBRCOMMON_LOGGER_ENDL; IBRCOMMON_LOGGER_TAG("Core", notice) << "Now you need to set-up the ip tunnel. You can use commands like this:" << IBRCOMMON_LOGGER_ENDL; IBRCOMMON_LOGGER_TAG("Core", notice) << "# sudo ip link set " << gateway.getDeviceName() << " up mtu 65535" << IBRCOMMON_LOGGER_ENDL; IBRCOMMON_LOGGER_TAG("Core", notice) << "# sudo ip addr add 10.0.0.1/24 dev " << gateway.getDeviceName() << IBRCOMMON_LOGGER_ENDL; IBRCOMMON_LOGGER_TAG("Core", notice) << IBRCOMMON_LOGGER_ENDL; timer_t timerid; struct sigevent sev; if (!daemonize && throughput) { // enable throughput timer signal(SIGRTMIN, timer_display_throughput); sev.sigev_notify = SIGEV_SIGNAL; sev.sigev_signo = SIGRTMIN; sev.sigev_value.sival_ptr = &timerid; // create a timer timer_create(CLOCK_MONOTONIC, &sev, &timerid); // arm the timer struct itimerspec its; size_t freq_nanosecs = 200000000; its.it_value.tv_sec = freq_nanosecs / 1000000000;; its.it_value.tv_nsec = freq_nanosecs % 1000000000; its.it_interval.tv_sec = its.it_value.tv_sec; its.it_interval.tv_nsec = its.it_value.tv_nsec; if (timer_settime(timerid, 0, &its, NULL) == -1) { IBRCOMMON_LOGGER_TAG("Core", error) << "Timer set failed." << IBRCOMMON_LOGGER_ENDL; } } // destination dtn::data::EID eid(endpoint); while (m_running) { gateway.process(eid, lifetime); } gateway.shutdown(); } catch (const ibrcommon::Exception &ex) { if (m_running) { IBRCOMMON_LOGGER_TAG("Core", error) << ex.what() << IBRCOMMON_LOGGER_ENDL; return -1; } } #ifdef HAVE_LIBDAEMON if (daemonize) { /* Do a cleanup */ IBRCOMMON_LOGGER_TAG("Core", info) << "Stopped " << app_name << IBRCOMMON_LOGGER_ENDL; daemon_retval_send(255); daemon_signal_done(); daemon_pid_file_remove(); } else #endif { std::cout << std::endl; } return 0; }