dispatcher.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013-2022 Regents of the University of California.
 *
 * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
 *
 * ndn-cxx library is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later version.
 *
 * ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
 *
 * You should have received copies of the GNU General Public License and GNU Lesser
 * General Public License along with ndn-cxx, e.g., in COPYING.md file.  If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
 */
 
#ifndef NDN_CXX_MGMT_DISPATCHER_HPP
#define NDN_CXX_MGMT_DISPATCHER_HPP
 
#include "ndn-cxx/face.hpp"
#include "ndn-cxx/encoding/block.hpp"
#include "ndn-cxx/ims/in-memory-storage-fifo.hpp"
#include "ndn-cxx/mgmt/control-response.hpp"
#include "ndn-cxx/mgmt/control-parameters.hpp"
#include "ndn-cxx/mgmt/status-dataset-context.hpp"
#include "ndn-cxx/security/key-chain.hpp"
 
#include <unordered_map>
 
namespace ndn {
namespace mgmt {
 
// ---- AUTHORIZATION ----
 
typedef std::function<void(const std::string& requester)> AcceptContinuation;
 
enum class RejectReply {
  SILENT,
  STATUS403
};
 
typedef std::function<void(RejectReply reply)> RejectContinuation;
 
typedef std::function<void(const Name& prefix, const Interest& interest,
                           const ControlParameters* params,
                           const AcceptContinuation& accept,
                           const RejectContinuation& reject)> Authorization;
 
Authorization
makeAcceptAllAuthorization();
 
// ---- CONTROL COMMAND ----
 
typedef std::function<bool(const ControlParameters& params)> ValidateParameters;
 
typedef std::function<void(const ControlResponse& resp)> CommandContinuation;
 
typedef std::function<void(const Name& prefix, const Interest& interest,
                           const ControlParameters& params,
                           const CommandContinuation& done)> ControlCommandHandler;
 
// ---- STATUS DATASET ----
 
typedef std::function<void(const Name& prefix, const Interest& interest,
                           StatusDatasetContext& context)> StatusDatasetHandler;
 
//---- NOTIFICATION STREAM ----
 
typedef std::function<void(const Block& notification)> PostNotification;
 
// ---- DISPATCHER ----
 
class Dispatcher : noncopyable
{
public:
  Dispatcher(Face& face, KeyChain& keyChain,
             const security::SigningInfo& signingInfo = security::SigningInfo(),
             size_t imsCapacity = 256);
 
  virtual
  ~Dispatcher();
 
  void
  addTopPrefix(const Name& prefix, bool wantRegister = true,
               const security::SigningInfo& signingInfo = security::SigningInfo());
 
  void
  removeTopPrefix(const Name& prefix);
 
public: // ControlCommand
  template<typename CP>
  void
  addControlCommand(const PartialName& relPrefix,
                    Authorization authorize,
                    ValidateParameters validate,
                    ControlCommandHandler handle);
 
public: // StatusDataset
  void
  addStatusDataset(const PartialName& relPrefix,
                   Authorization authorize,
                   StatusDatasetHandler handle);
 
public: // NotificationStream
  PostNotification
  addNotificationStream(const PartialName& relPrefix);
 
private:
  using InterestHandler = std::function<void(const Name& prefix, const Interest&)>;
 
  using AuthorizationAcceptedCallback = std::function<void(const std::string& requester,
                                                           const Name& prefix,
                                                           const Interest&,
                                                           const shared_ptr<ControlParameters>&)>;
 
  using AuthorizationRejectedCallback = std::function<void(RejectReply, const Interest&)>;
 
  using ControlParametersParser = std::function<shared_ptr<ControlParameters>(const name::Component&)>;
 
  bool
  isOverlappedWithOthers(const PartialName& relPrefix) const;
 
  void
  afterAuthorizationRejected(RejectReply act, const Interest& interest);
 
  void
  queryStorage(const Name& prefix, const Interest& interest, const InterestHandler& missContinuation);
 
  enum class SendDestination {
    NONE = 0,
    FACE = 1,
    IMS  = 2,
    FACE_AND_IMS = 3
  };
 
  void
  sendData(const Name& dataName, const Block& content, const MetaInfo& metaInfo,
           SendDestination destination);
 
  void
  sendOnFace(const Data& data);
 
  void
  processControlCommandInterest(const Name& prefix,
                                const Name& relPrefix,
                                const Interest& interest,
                                const ControlParametersParser& parser,
                                const Authorization& authorization,
                                const AuthorizationAcceptedCallback& accepted,
                                const AuthorizationRejectedCallback& rejected);
 
  void
  processAuthorizedControlCommandInterest(const std::string& requester,
                                          const Name& prefix,
                                          const Interest& interest,
                                          const shared_ptr<ControlParameters>& parameters,
                                          const ValidateParameters& validate,
                                          const ControlCommandHandler& handler);
 
  void
  sendControlResponse(const ControlResponse& resp, const Interest& interest, bool isNack = false);
 
  void
  processStatusDatasetInterest(const Name& prefix,
                               const Interest& interest,
                               const Authorization& authorization,
                               const AuthorizationAcceptedCallback& accepted,
                               const AuthorizationRejectedCallback& rejected);
 
  void
  processAuthorizedStatusDatasetInterest(const Name& prefix,
                                         const Interest& interest,
                                         const StatusDatasetHandler& handler);
 
  void
  sendStatusDatasetSegment(const Name& dataName, const Block& content, bool isFinalBlock);
 
  void
  postNotification(const Block& notification, const PartialName& relPrefix);
 
private:
  struct TopPrefixEntry
  {
    ScopedRegisteredPrefixHandle registeredPrefix;
    std::vector<ScopedInterestFilterHandle> interestFilters;
  };
  std::unordered_map<Name, TopPrefixEntry> m_topLevelPrefixes;
 
  Face& m_face;
  KeyChain& m_keyChain;
  security::SigningInfo m_signingInfo;
 
  std::unordered_map<PartialName, InterestHandler> m_handlers;
 
  // NotificationStream name => next sequence number
  std::unordered_map<Name, uint64_t> m_streams;
 
NDN_CXX_PUBLIC_WITH_TESTS_ELSE_PRIVATE:
  InMemoryStorageFifo m_storage;
};
 
template<typename CP>
void
Dispatcher::addControlCommand(const PartialName& relPrefix,
                              Authorization authorize,
                              ValidateParameters validate,
                              ControlCommandHandler handle)
{
  if (!m_topLevelPrefixes.empty()) {
    NDN_THROW(std::domain_error("one or more top-level prefix has been added"));
  }
 
  if (isOverlappedWithOthers(relPrefix)) {
    NDN_THROW(std::out_of_range("relPrefix overlaps with another relPrefix"));
  }
 
  ControlParametersParser parser = [] (const name::Component& comp) -> shared_ptr<ControlParameters> {
    return make_shared<CP>(comp.blockFromValue());
  };
  AuthorizationAcceptedCallback accepted = [this, validate = std::move(validate),
                                            handle = std::move(handle)] (auto&&... args) {
    processAuthorizedControlCommandInterest(std::forward<decltype(args)>(args)..., validate, handle);
  };
  AuthorizationRejectedCallback rejected = [this] (auto&&... args) {
    afterAuthorizationRejected(std::forward<decltype(args)>(args)...);
  };
 
  m_handlers[relPrefix] = [this, relPrefix,
                           parser = std::move(parser),
                           authorize = std::move(authorize),
                           accepted = std::move(accepted),
                           rejected = std::move(rejected)] (const auto& prefix, const auto& interest) {
    processControlCommandInterest(prefix, relPrefix, interest, parser, authorize, accepted, rejected);
  };
}
 
} // namespace mgmt
} // namespace ndn
 
#endif // NDN_CXX_MGMT_DISPATCHER_HPP