BOOST_FIXTURE_TEST_CASE(ValidatedFaceRequestDestroyFace,
AuthorizedCommandFixture<ValidatedFaceRequestFixture>)
{
ControlParameters parameters;
parameters.setUri("tcp://127.0.0.1");
Block encodedParameters(parameters.wireEncode());
Name commandName("/localhost/nfd/faces");
commandName.append("destroy");
commandName.append(encodedParameters);
shared_ptr<Interest> command(make_shared<Interest>(commandName));
generateCommand(*command);
onValidatedFaceRequest(command);
BOOST_CHECK(didDestroyFaceFire());
}
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
RibRegisterCommand::validateResponse(const ControlParameters& parameters) const
{
this->ControlCommand::validateResponse(parameters);
if (parameters.getFaceId() == INVALID_FACE_ID) {
BOOST_THROW_EXCEPTION(ArgumentError("FaceId must be valid"));
}
}
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:/"));
}
}
virtual void
validateRequest(const ControlParameters& parameters) const
{
this->ControlCommand::validateRequest(parameters);
if (parameters.getName().size() == 0) {
throw ArgumentError("Name must not be ndn:/");
}
}
void
RibUnregisterCommand::validateResponse(const ControlParameters& parameters) const
{
this->ControlCommand::validateResponse(parameters);
if (parameters.getFaceId() == 0) {
BOOST_THROW_EXCEPTION(ArgumentError("FaceId must not be zero"));
}
}
void
FibHelper::AddRoute(Ptr<Node> node, const Name& prefix, shared_ptr<Face> face, int32_t metric)
{
NS_LOG_LOGIC("[" << node->GetId() << "]$ route add " << prefix << " via " << face->getLocalUri()
<< " metric " << metric);
// Get L3Protocol object
Ptr<L3Protocol> L3protocol = node->GetObject<L3Protocol>();
// Get the forwarder instance
shared_ptr<nfd::Forwarder> m_forwarder = L3protocol->getForwarder();
ControlParameters parameters;
parameters.setName(prefix);
parameters.setFaceId(face->getId());
parameters.setCost(metric);
AddNextHop(parameters, node);
}
virtual void
validateResponse(const ControlParameters& parameters) const
{
this->ControlCommand::validateResponse(parameters);
if (parameters.getFaceId() == 0) {
throw ArgumentError("FaceId must not be zero");
}
}
void
FaceDestroyCommand::validateRequest(const ControlParameters& parameters) const
{
this->ControlCommand::validateRequest(parameters);
if (parameters.getFaceId() == 0) {
BOOST_THROW_EXCEPTION(ArgumentError("FaceId must not be zero"));
}
}
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);
}
static ControlParameters
makeUpdateFaceResponse(const Face& face)
{
ControlParameters params;
params.setFaceId(face.getId())
.setFacePersistency(face.getPersistency());
auto linkService = dynamic_cast<face::GenericLinkService*>(face.getLinkService());
if (linkService != nullptr) {
const auto& options = linkService->getOptions();
params.setBaseCongestionMarkingInterval(options.baseCongestionMarkingInterval)
.setDefaultCongestionThreshold(options.defaultCongestionThreshold)
.setFlagBit(ndn::nfd::BIT_LOCAL_FIELDS_ENABLED, options.allowLocalFields, false)
.setFlagBit(ndn::nfd::BIT_LP_RELIABILITY_ENABLED, options.reliabilityOptions.isEnabled, false)
.setFlagBit(ndn::nfd::BIT_CONGESTION_MARKING_ENABLED, options.allowCongestionMarking, false);
}
return params;
}
void
Nfdc::faceDestroy()
{
ControlParameters parameters;
const std::string& faceName = m_commandLineArguments[0];
FaceIdFetcher::start(m_face, m_controller, faceName, false,
[this] (const uint32_t faceId) {
ControlParameters faceParameters;
faceParameters.setFaceId(faceId);
m_controller.start<FaceDestroyCommand>(faceParameters,
bind(&Nfdc::onSuccess, this, _1,
"Face destroy succeeded"),
bind(&Nfdc::onError, this, _1, _2,
"Face destroy failed"));
},
bind(&Nfdc::onObtainFaceIdFailure, this, _1));
}
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
Nfdc::ribRegisterPrefix(const ControlParameters& faceCreateResult)
{
ControlParameters ribParameters;
ribParameters
.setName(m_name)
.setCost(m_cost)
.setFlags(m_flags)
.setOrigin(m_origin)
.setFaceId(faceCreateResult.getFaceId());
if (m_expires != DEFAULT_EXPIRATION_PERIOD)
ribParameters.setExpirationPeriod(m_expires);
m_controller.start<RibRegisterCommand>(ribParameters,
bind(&Nfdc::onSuccess, this, _1,
"Successful in name registration"),
bind(&Nfdc::onError, this, _1, _2,
"Failed in name registration"));
}
Name
ControlCommand::getRequestName(const Name& commandPrefix,
const ControlParameters& parameters) const
{
this->validateRequest(parameters);
Name name = commandPrefix;
name.append(m_module).append(m_verb);
name.append(parameters.wireEncode());
return name;
}
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");
}
}
BOOST_FIXTURE_TEST_CASE(CreateFaceMissingUri, AuthorizedCommandFixture<FaceFixture>)
{
ControlParameters parameters;
Block encodedParameters(parameters.wireEncode());
Name commandName("/localhost/nfd/faces");
commandName.append("create");
commandName.append(encodedParameters);
shared_ptr<Interest> command(make_shared<Interest>(commandName));
generateCommand(*command);
getFace()->onReceiveData +=
bind(&FaceFixture::validateControlResponse, this, _1,
command->getName(), 400, "Malformed command");
createFace(*command, parameters);
BOOST_REQUIRE(didCallbackFire());
}
BOOST_FIXTURE_TEST_CASE(UnsupportedCommand, AuthorizedCommandFixture<FaceManagerFixture>)
{
ControlParameters parameters;
Block encodedParameters(parameters.wireEncode());
Name commandName("/localhost/nfd/faces");
commandName.append("unsupported");
commandName.append(encodedParameters);
shared_ptr<Interest> command(make_shared<Interest>(commandName));
generateCommand(*command);
getFace()->onReceiveData +=
bind(&FaceManagerFixture::validateControlResponse, this, _1,
command->getName(), 501, "Unsupported command");
getManager().onFaceRequest(*command);
BOOST_REQUIRE(didCallbackFire());
}
/** \brief make a Command Interest from parameters
*/
Interest
makeCommandInterest(const ControlParameters& parameters,
const Sign& sign) const
{
this->validateRequest(parameters);
Name name = m_prefix;
name.append(parameters.wireEncode());
Interest commandInterest(name);
sign(commandInterest);
return commandInterest;
}
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
Controller::processValidatedCommandResponse(const Data& data,
const shared_ptr<ControlCommand>& command,
const CommandSucceedCallback& onSuccess,
const CommandFailCallback& onFailure)
{
ControlResponse response;
try {
response.wireDecode(data.getContent().blockFromValue());
}
catch (const tlv::Error& e) {
onFailure(ControlResponse(ERROR_SERVER, e.what()));
return;
}
uint32_t code = response.getCode();
if (code >= ERROR_LBOUND) {
onFailure(response);
return;
}
ControlParameters parameters;
try {
parameters.wireDecode(response.getBody());
}
catch (const tlv::Error& e) {
onFailure(ControlResponse(ERROR_SERVER, e.what()));
return;
}
try {
command->validateResponse(parameters);
}
catch (const ControlCommand::ArgumentError& e) {
onFailure(ControlResponse(ERROR_SERVER, e.what()));
return;
}
onSuccess(parameters);
}
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
FaceLocalControlCommand::validateRequest(const ControlParameters& parameters) const
{
this->ControlCommand::validateRequest(parameters);
switch (parameters.getLocalControlFeature()) {
case LOCAL_CONTROL_FEATURE_INCOMING_FACE_ID:
case LOCAL_CONTROL_FEATURE_NEXT_HOP_FACE_ID:
break;
default:
BOOST_THROW_EXCEPTION(ArgumentError("LocalControlFeature is invalid"));
}
}
void
FaceManager::destroyFace(const Interest& request,
ControlParameters& parameters)
{
const Name& requestName = request.getName();
ndn::nfd::FaceDestroyCommand command;
if (!validateParameters(command, parameters))
{
sendResponse(requestName, 400, "Malformed command");
return;
}
shared_ptr<Face> target = m_faceTable.get(parameters.getFaceId());
if (static_cast<bool>(target))
{
target->close();
}
sendResponse(requestName, 200, "Success", parameters.wireEncode());
}
BOOST_FIXTURE_TEST_CASE(UnsignedCommand, AllStrategiesFixture)
{
ControlParameters parameters;
parameters.setName("/test");
parameters.setStrategy("/localhost/nfd/strategy/best-route");
Block encodedParameters(parameters.wireEncode());
Name commandName("/localhost/nfd/strategy-choice");
commandName.append("set");
commandName.append(encodedParameters);
shared_ptr<Interest> command(make_shared<Interest>(commandName));
getFace()->onReceiveData +=
bind(&StrategyChoiceManagerFixture::validateControlResponse, this, _1,
command->getName(), 401, "Signature required");
getManager().onStrategyChoiceRequest(*command);
BOOST_REQUIRE(didCallbackFire());
}
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);
}
}
}
virtual void
validateRequest(const ControlParameters& parameters) const
{
this->ControlCommand::validateRequest(parameters);
switch (parameters.getLocalControlFeature()) {
case LOCAL_CONTROL_FEATURE_INCOMING_FACE_ID:
case LOCAL_CONTROL_FEATURE_NEXT_HOP_FACE_ID:
break;
default:
throw ArgumentError("LocalControlFeature is invalid");
}
}
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);
}
BOOST_FIXTURE_TEST_CASE(CreateFaceBadUri, AuthorizedCommandFixture<FaceFixture>)
{
ControlParameters parameters;
parameters.setUri("tcp:/127.0.0.1");
Block encodedParameters(parameters.wireEncode());
Name commandName("/localhost/nfd/faces");
commandName.append("create");
commandName.append(encodedParameters);
shared_ptr<Interest> command(make_shared<Interest>(commandName));
generateCommand(*command);
getFace()->onReceiveData += [this, command] (const Data& response) {
this->validateControlResponse(response, command->getName(), 400, "Malformed command");
};
createFace(*command, parameters);
BOOST_REQUIRE(didCallbackFire());
}