void
StrategyChoiceManager::unsetStrategy(ControlParameters& parameters,
ControlResponse& response)
{
ndn::nfd::StrategyChoiceUnsetCommand command;
if (!validateParameters(command, parameters))
{
static const Name ROOT_PREFIX;
if (parameters.hasName() && parameters.getName() == ROOT_PREFIX)
{
NFD_LOG_DEBUG("strategy-choice result: FAIL reason: unset-root");
setResponse(response, 403, "Cannot unset root prefix strategy");
}
else
{
NFD_LOG_DEBUG("strategy-choice result: FAIL reason: malformed");
setResponse(response, 400, "Malformed command");
}
return;
}
m_strategyChoice.erase(parameters.getName());
NFD_LOG_DEBUG("strategy-choice result: SUCCESS");
setResponse(response, 200, "Success", parameters.wireEncode());
}
void
RemoteRegistrator::onRegSuccess(const ControlParameters& parameters,
const CommandOptions& options)
{
NFD_LOG_INFO("success to register " << parameters.getName());
RegisteredEntryIt iRegEntry = m_regEntries.find(parameters.getName());
if (m_regEntries.end() != iRegEntry)
{
NFD_LOG_DEBUG("Existing Entry: (" << iRegEntry->first
<< ", " << iRegEntry->second
<< ")");
scheduler::cancel(iRegEntry->second);
iRegEntry->second = scheduler::schedule(
m_refreshInterval,
bind(&RemoteRegistrator::startRegistration,
this, parameters, options, m_nRetries));
}
else
{
NFD_LOG_DEBUG("New Entry");
m_regEntries.insert(RegisteredEntry(
parameters.getName(),
scheduler::schedule(
m_refreshInterval,
bind(&RemoteRegistrator::startRegistration,
this, parameters, options, m_nRetries))));
}
}
void
FibManager::removeNextHop(const Name& topPrefix, const Interest& interest,
ControlParameters parameters,
const ndn::mgmt::CommandContinuation& done)
{
setFaceForSelfRegistration(interest, parameters);
NFD_LOG_TRACE("remove-nexthop prefix: " << parameters.getName()
<< " faceid: " << parameters.getFaceId());
auto face = m_getFace(parameters.getFaceId());
if (static_cast<bool>(face)) {
auto entry = m_fib.findExactMatch(parameters.getName());
if (static_cast<bool>(entry)) {
entry->removeNextHop(face);
NFD_LOG_DEBUG("remove-nexthop result: OK prefix: " << parameters.getName()
<< " faceid: " << parameters.getFaceId());
if (!entry->hasNextHops()) {
m_fib.erase(*entry);
}
}
else {
NFD_LOG_DEBUG("remove-nexthop result: OK");
}
}
else {
NFD_LOG_DEBUG("remove-nexthop result: OK");
}
done(ControlResponse(200, "Success").setBody(parameters.wireEncode()));
}
void
RibManager::unregisterEntry(const shared_ptr<const Interest>& request,
ControlParameters& params)
{
ndn::nfd::RibUnregisterCommand command;
// Passing all parameters gives error in validation,
// so passing only the required arguments.
ControlParameters parameters;
parameters.setName(params.getName());
if (params.hasFaceId()) {
parameters.setFaceId(params.getFaceId());
}
if (params.hasOrigin()) {
parameters.setOrigin(params.getOrigin());
}
if (!validateParameters(command, parameters)) {
NFD_LOG_DEBUG("unregister result: FAIL reason: malformed");
if (static_cast<bool>(request)) {
sendResponse(request->getName(), 400, "Malformed command");
}
return;
}
bool isSelfRegistration = (!parameters.hasFaceId() || parameters.getFaceId() == 0);
if (isSelfRegistration) {
shared_ptr<lp::IncomingFaceIdTag> incomingFaceIdTag = request->getTag<lp::IncomingFaceIdTag>();
if (incomingFaceIdTag == nullptr) {
sendResponse(request->getName(), 503,
"requested self-registration, but IncomingFaceId is unavailable");
return;
}
parameters.setFaceId(*incomingFaceIdTag);
}
// Respond since command is valid and authorized
sendSuccessResponse(request, parameters);
Route route;
route.faceId = parameters.getFaceId();
route.origin = parameters.getOrigin();
NFD_LOG_INFO("Removing route " << parameters.getName() << " nexthop=" << route.faceId
<< " origin=" << route.origin);
RibUpdate update;
update.setAction(RibUpdate::UNREGISTER)
.setName(parameters.getName())
.setRoute(route);
m_managedRib.beginApplyUpdate(update,
bind(&RibManager::onRibUpdateSuccess, this, update),
bind(&RibManager::onRibUpdateFailure, this, update, _1, _2));
}
void
StrategyChoiceManager::setStrategy(ControlParameters& parameters,
ControlResponse& response)
{
ndn::nfd::StrategyChoiceSetCommand command;
if (!validateParameters(command, parameters))
{
NFD_LOG_DEBUG("strategy-choice result: FAIL reason: malformed");
setResponse(response, 400, "Malformed command");
return;
}
const Name& prefix = parameters.getName();
const Name& selectedStrategy = parameters.getStrategy();
if (!m_strategyChoice.hasStrategy(selectedStrategy))
{
NFD_LOG_DEBUG("strategy-choice result: FAIL reason: unknown-strategy: "
<< parameters.getStrategy());
setResponse(response, 504, "Unsupported strategy");
return;
}
if (m_strategyChoice.insert(prefix, selectedStrategy))
{
NFD_LOG_DEBUG("strategy-choice result: SUCCESS");
setResponse(response, 200, "Success", parameters.wireEncode());
}
else
{
NFD_LOG_DEBUG("strategy-choice result: FAIL reason: not-installed");
setResponse(response, 405, "Strategy not installed");
}
}
void
FibManager::addNextHop(const Name& topPrefix, const Interest& interest,
ControlParameters parameters,
const ndn::mgmt::CommandContinuation& done)
{
setFaceForSelfRegistration(interest, parameters);
const Name& prefix = parameters.getName();
FaceId faceId = parameters.getFaceId();
uint64_t cost = parameters.getCost();
NFD_LOG_TRACE("add-nexthop prefix: " << prefix
<< " faceid: " << faceId
<< " cost: " << cost);
auto face = m_getFace(faceId);
if (static_cast<bool>(face)) {
auto entry = m_fib.insert(prefix).first;
entry->addNextHop(face, cost);
NFD_LOG_DEBUG("add-nexthop result: OK"
<< " prefix:" << prefix
<< " faceid: " << faceId
<< " cost: " << cost);
return done(ControlResponse(200, "Success").setBody(parameters.wireEncode()));
}
else {
NFD_LOG_INFO("add-nexthop result: FAIL reason: unknown-faceid: " << faceId);
return done(ControlResponse(410, "Face not found"));
}
}
void
AutoPrefixPropagator::onRefreshTimer(const ControlParameters& parameters,
const CommandOptions& options)
{
auto entryIt = m_propagatedEntries.find(parameters.getName());
BOOST_ASSERT(entryIt != m_propagatedEntries.end() && entryIt->second.isPropagated());
redoPropagation(entryIt, parameters, options, m_baseRetryWait);
}
void
AutoPrefixPropagator::afterRevokeFail(uint32_t code, const std::string& reason,
const ControlParameters& parameters,
const CommandOptions& options)
{
NFD_LOG_INFO("fail to revoke the propagation of " << parameters.getName()
<< "\n\t reason:" << reason);
}
virtual void
validateRequest(const ControlParameters& parameters) const
{
this->ControlCommand::validateRequest(parameters);
if (parameters.getName().size() == 0) {
throw ArgumentError("Name must not be ndn:/");
}
}
void
StrategyChoiceUnsetCommand::validateRequest(const ControlParameters& parameters) const
{
this->ControlCommand::validateRequest(parameters);
if (parameters.getName().size() == 0) {
BOOST_THROW_EXCEPTION(ArgumentError("Name must not be ndn:/"));
}
}
void
AutoPrefixPropagator::onRetryTimer(const ControlParameters& parameters,
const CommandOptions& options,
time::seconds retryWaitTime)
{
auto entryIt = m_propagatedEntries.find(parameters.getName());
BOOST_ASSERT(entryIt != m_propagatedEntries.end() && entryIt->second.isPropagateFail());
redoPropagation(entryIt, parameters, options, retryWaitTime);
}
void
FibManager::removeNextHop(ControlParameters& parameters,
ControlResponse& response)
{
ndn::nfd::FibRemoveNextHopCommand command;
if (!validateParameters(command, parameters))
{
NFD_LOG_DEBUG("remove-nexthop result: FAIL reason: malformed");
setResponse(response, 400, "Malformed command");
return;
}
NFD_LOG_TRACE("remove-nexthop prefix: " << parameters.getName()
<< " faceid: " << parameters.getFaceId());
shared_ptr<Face> faceToRemove = m_getFace(parameters.getFaceId());
if (static_cast<bool>(faceToRemove))
{
shared_ptr<fib::Entry> entry = m_managedFib.findExactMatch(parameters.getName());
if (static_cast<bool>(entry))
{
entry->removeNextHop(faceToRemove);
NFD_LOG_DEBUG("remove-nexthop result: OK prefix: " << parameters.getName()
<< " faceid: " << parameters.getFaceId());
if (!entry->hasNextHops())
{
m_managedFib.erase(*entry);
}
}
else
{
NFD_LOG_DEBUG("remove-nexthop result: OK, but entry for face id "
<< parameters.getFaceId() << " not found");
}
}
else
{
NFD_LOG_DEBUG("remove-nexthop result: OK, but face id "
<< parameters.getFaceId() << " not found");
}
setResponse(response, 200, "Success", parameters.wireEncode());
}
void
AutoPrefixPropagator::afterPropagateSucceed(const ControlParameters& parameters,
const CommandOptions& options,
const ndn::Scheduler::Event& refreshEvent)
{
NFD_LOG_TRACE("success to propagate " << parameters.getName());
auto entryIt = m_propagatedEntries.find(parameters.getName());
if (entryIt == m_propagatedEntries.end()) {
// propagation should be revoked if this entry has been erased (i.e., be in RELEASED state)
NFD_LOG_DEBUG("Already erased!");
ControlParameters newParameters = parameters;
return startRevocation(newParameters.unsetCost(), options, m_baseRetryWait);
}
// PROPAGATING --> PROPAGATED
BOOST_ASSERT(entryIt->second.isPropagating());
entryIt->second.succeed(scheduler::schedule(m_refreshInterval, refreshEvent));
}
void
AutoPrefixPropagator::afterRibInsert(const ControlParameters& parameters,
const CommandOptions& options)
{
BOOST_ASSERT(m_propagatedEntries.find(parameters.getName()) == m_propagatedEntries.end());
// keep valid entries although there is no connectivity to hub
auto& entry = m_propagatedEntries[parameters.getName()]
.setSigningIdentity(options.getSigningInfo().getSignerName());
if (!m_hasConnectedHub) {
NFD_LOG_INFO("no hub connected to propagate " << parameters.getName());
return;
}
// NEW --> PROPAGATING
entry.startPropagation();
startPropagation(parameters, options, m_baseRetryWait);
}
void AuvController::loadParams(const std::vector<std::string> &filenames)
{
for(unsigned int i=0; i<filenames.size(); i++)
{
ControlParameters *param = new ControlParameters();
param->load(filenames[i]);
_control_parameters.push_back(param);
_control_parameters_index[param->getName()] = i;
param->write(std::cerr);
}
}
void
AutoPrefixPropagator::afterRevokeSucceed(const ControlParameters& parameters,
const CommandOptions& options,
time::seconds retryWaitTime)
{
NFD_LOG_TRACE("success to revoke propagation of " << parameters.getName());
auto entryIt = m_propagatedEntries.find(parameters.getName());
if (m_propagatedEntries.end() != entryIt && !entryIt->second.isPropagateFail()) {
// if is not RELEASED or PROPAGATE_FAIL
NFD_LOG_DEBUG("propagated entry still exists");
// PROPAGATING / PROPAGATED --> PROPAGATING
BOOST_ASSERT(!entryIt->second.isNew());
entryIt->second.startPropagation();
ControlParameters newParameters = parameters;
startPropagation(newParameters.setCost(m_controlParameters.getCost()), options, retryWaitTime);
}
}
void
AutoPrefixPropagator::afterPropagateFail(uint32_t code, const std::string& reason,
const ControlParameters& parameters,
const CommandOptions& options,
time::seconds retryWaitTime,
const ndn::Scheduler::Event& retryEvent)
{
NFD_LOG_TRACE("fail to propagate " << parameters.getName()
<< "\n\t reason:" << reason
<< "\n\t retry wait time: " << retryWaitTime);
auto entryIt = m_propagatedEntries.find(parameters.getName());
if (entryIt == m_propagatedEntries.end()) {
// current state is RELEASED
return;
}
// PROPAGATING --> PROPAGATE_FAIL
BOOST_ASSERT(entryIt->second.isPropagating());
entryIt->second.fail(scheduler::schedule(retryWaitTime, retryEvent));
}
void
AutoPrefixPropagator::redoPropagation(PropagatedEntryIt entryIt,
const ControlParameters& parameters,
const CommandOptions& options,
time::seconds retryWaitTime)
{
if (doesCurrentPropagatedPrefixWork(parameters.getName())) {
// PROPAGATED / PROPAGATE_FAIL --> PROPAGATING
entryIt->second.startPropagation();
return startPropagation(parameters, options, retryWaitTime);
}
NFD_LOG_INFO("current propagated prefix does not work any more");
m_propagatedEntries.erase(entryIt);
// re-handle all locally RIB entries that can be covered by this propagated prefix
for (auto&& ribTableEntry : m_rib) {
if (parameters.getName().isPrefixOf(ribTableEntry.first)) {
afterInsertRibEntry(ribTableEntry.first);
}
}
}
void
AutoPrefixPropagator::startRevocation(const ControlParameters& parameters,
const CommandOptions& options,
time::seconds retryWaitTime)
{
NFD_LOG_INFO("start revoke propagation of " << parameters.getName());
m_nfdController.start<ndn::nfd::RibUnregisterCommand>(
parameters,
bind(&AutoPrefixPropagator::afterRevokeSucceed, this, parameters, options, retryWaitTime),
bind(&AutoPrefixPropagator::afterRevokeFail, this, _1, _2, parameters, options),
options);
}
void
RemoteRegistrator::onUnregFailure(uint32_t code, const std::string& reason,
const ControlParameters& parameters,
const CommandOptions& options,
int nRetries)
{
NFD_LOG_INFO("fail to unregister " << parameters.getName()
<< "\n\t reason:" << reason
<< "\n\t remain retries:" << nRetries);
if (nRetries > 0)
{
startUnregistration(parameters, options, nRetries - 1);
}
}
void
RemoteRegistrator::startUnregistration(const ControlParameters& parameters,
const CommandOptions& options,
int nRetries)
{
NFD_LOG_INFO("start unregister " << parameters.getName());
m_nfdController.start<ndn::nfd::RibUnregisterCommand>(
parameters,
bind(&RemoteRegistrator::onUnregSuccess,
this, parameters, options),
bind(&RemoteRegistrator::onUnregFailure,
this, _1, _2, parameters, options, nRetries),
options);
}
void
AutoPrefixPropagator::afterRibErase(const ControlParameters& parameters,
const CommandOptions& options)
{
auto entryIt = m_propagatedEntries.find(parameters.getName());
BOOST_ASSERT(entryIt != m_propagatedEntries.end());
bool hasPropagationSucceeded = entryIt->second.isPropagated();
// --> "RELEASED"
m_propagatedEntries.erase(entryIt);
if (!m_hasConnectedHub) {
NFD_LOG_INFO("no hub connected to revoke propagation of " << parameters.getName());
return;
}
if (!hasPropagationSucceeded) {
NFD_LOG_INFO("propagation has not succeeded: " << parameters.getName());
return;
}
startRevocation(parameters, options, m_baseRetryWait);
}
void
AutoPrefixPropagator::startPropagation(const ControlParameters& parameters,
const CommandOptions& options,
time::seconds retryWaitTime)
{
NFD_LOG_TRACE("start propagate " << parameters.getName());
ndn::Scheduler::Event refreshEvent =
bind(&AutoPrefixPropagator::onRefreshTimer, this, parameters, options);
ndn::Scheduler::Event retryEvent =
bind(&AutoPrefixPropagator::onRetryTimer, this, parameters, options,
std::min(m_maxRetryWait, retryWaitTime * 2));
m_nfdController.start<ndn::nfd::RibRegisterCommand>(
parameters,
bind(&AutoPrefixPropagator::afterPropagateSucceed, this, parameters, options, refreshEvent),
bind(&AutoPrefixPropagator::afterPropagateFail,
this, _1, _2, parameters, options, retryWaitTime, retryEvent),
options);
}
void
FibManager::addNextHop(ControlParameters& parameters,
ControlResponse& response)
{
ndn::nfd::FibAddNextHopCommand command;
if (!validateParameters(command, parameters))
{
NFD_LOG_DEBUG("add-nexthop result: FAIL reason: malformed");
setResponse(response, 400, "Malformed command");
return;
}
const Name& prefix = parameters.getName();
FaceId faceId = parameters.getFaceId();
uint64_t cost = parameters.getCost();
NFD_LOG_TRACE("add-nexthop prefix: " << prefix
<< " faceid: " << faceId
<< " cost: " << cost);
shared_ptr<Face> nextHopFace = m_getFace(faceId);
if (static_cast<bool>(nextHopFace))
{
shared_ptr<fib::Entry> entry = m_managedFib.insert(prefix).first;
entry->addNextHop(nextHopFace, cost);
NFD_LOG_DEBUG("add-nexthop result: OK"
<< " prefix:" << prefix
<< " faceid: " << faceId
<< " cost: " << cost);
setResponse(response, 200, "Success", parameters.wireEncode());
}
else
{
NFD_LOG_DEBUG("add-nexthop result: FAIL reason: unknown-faceid: " << faceId);
setResponse(response, 410, "Face not found");
}
}
void
RemoteRegistrator::onUnregSuccess(const ControlParameters& parameters,
const CommandOptions& options)
{
NFD_LOG_INFO("success to unregister " << parameters.getName());
}
void
RibManager::registerEntry(const shared_ptr<const Interest>& request,
ControlParameters& parameters)
{
ndn::nfd::RibRegisterCommand command;
if (!validateParameters(command, parameters)) {
NFD_LOG_DEBUG("register result: FAIL reason: malformed");
if (static_cast<bool>(request)) {
sendResponse(request->getName(), 400, "Malformed command");
}
return;
}
bool isSelfRegistration = (!parameters.hasFaceId() || parameters.getFaceId() == 0);
if (isSelfRegistration) {
shared_ptr<lp::IncomingFaceIdTag> incomingFaceIdTag = request->getTag<lp::IncomingFaceIdTag>();
if (incomingFaceIdTag == nullptr) {
sendResponse(request->getName(), 503,
"requested self-registration, but IncomingFaceId is unavailable");
return;
}
parameters.setFaceId(*incomingFaceIdTag);
}
// Respond since command is valid and authorized
sendSuccessResponse(request, parameters);
Route route;
route.faceId = parameters.getFaceId();
route.origin = parameters.getOrigin();
route.cost = parameters.getCost();
route.flags = parameters.getFlags();
if (parameters.hasExpirationPeriod() &&
parameters.getExpirationPeriod() != time::milliseconds::max())
{
route.expires = time::steady_clock::now() + parameters.getExpirationPeriod();
// Schedule a new event, the old one will be cancelled during rib insertion.
scheduler::EventId eventId = scheduler::schedule(parameters.getExpirationPeriod(),
bind(&Rib::onRouteExpiration, &m_managedRib, parameters.getName(), route));
NFD_LOG_TRACE("Scheduled unregistration at: " << route.expires <<
" with EventId: " << eventId);
// Set the NewEventId of this entry
route.setExpirationEvent(eventId);
}
else {
route.expires = time::steady_clock::TimePoint::max();
}
NFD_LOG_INFO("Adding route " << parameters.getName() << " nexthop=" << route.faceId
<< " origin=" << route.origin
<< " cost=" << route.cost);
RibUpdate update;
update.setAction(RibUpdate::REGISTER)
.setName(parameters.getName())
.setRoute(route);
m_managedRib.beginApplyUpdate(update,
bind(&RibManager::onRibUpdateSuccess, this, update),
bind(&RibManager::onRibUpdateFailure, this, update, _1, _2));
m_registeredFaces.insert(route.faceId);
}
