node.hpp

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil -*- */
#ifndef NDN_NODE_HPP
#define NDN_NODE_HPP

#include <map>
#include <deque>
#include <ndnboost/atomic.hpp>
#include <ndn-cpp/common.hpp>
#include <ndn-cpp/interest.hpp>
#include <ndn-cpp/data.hpp>
#include <ndn-cpp/forwarding-flags.hpp>
#include <ndn-cpp/interest-filter.hpp>
#include <ndn-cpp/face.hpp>
#include "util/command-interest-generator.hpp"
#include "encoding/element-listener.hpp"

struct ndn_Interest;

namespace ndn {

class KeyChain;

class Node : public ElementListener {
public:
  Node(const ptr_lib::shared_ptr<Transport>& transport, const ptr_lib::shared_ptr<const Transport::ConnectionInfo>& connectionInfo);

  void
  expressInterest
    (uint64_t pendingInterestId,
     const ptr_lib::shared_ptr<const Interest>& interestCopy,
     const OnData& onData, const OnTimeout& onTimeout, WireFormat& wireFormat,
     Face* face);

  void
  removePendingInterest(uint64_t pendingInterestId);

  void
  makeCommandInterest
    (Interest& interest, KeyChain& keyChain, const Name& certificateName,
     WireFormat& wireFormat)
  {
    commandInterestGenerator_.generate
      (interest, keyChain, certificateName, wireFormat);
  }

  void
  registerPrefix
    (uint64_t registeredPrefixId,
     const ptr_lib::shared_ptr<const Name>& prefixCopy,
     const OnInterestCallback& onInterest,
     const OnRegisterFailed& onRegisterFailed,
     const OnRegisterSuccess& onRegisterSuccess, const ForwardingFlags& flags,
     WireFormat& wireFormat, KeyChain& commandKeyChain,
     const Name& commandCertificateName, Face* face);

  void
  registerPrefix
    (uint64_t registeredPrefixId,
     const ptr_lib::shared_ptr<const Name>& prefixCopy,
     const OnInterestCallback& onInterest,
     const OnRegisterFailed& onRegisterFailed,
     const OnRegisterSuccess& onRegisterSuccess, const ForwardingFlags& flags,
     WireFormat& wireFormat, Face* face)
  {
    registerPrefix
      (registeredPrefixId, prefixCopy, onInterest, onRegisterFailed,
       onRegisterSuccess, flags, wireFormat, *face->getCommandKeyChain(),
       face->getCommandCertificateName(), face);
  }

  void
  removeRegisteredPrefix(uint64_t registeredPrefixId);

  void
  setInterestFilter
    (uint64_t interestFilterId,
     const ptr_lib::shared_ptr<const InterestFilter>& filterCopy,
     const OnInterestCallback& onInterest, Face* face);

  void
  unsetInterestFilter(uint64_t interestFilterId);

  void
  send(const uint8_t *encoding, size_t encodingLength);

  void
  processEvents();

  const ptr_lib::shared_ptr<Transport>&
  getTransport() { return transport_; }

  const ptr_lib::shared_ptr<const Transport::ConnectionInfo>&
  getConnectionInfo() { return connectionInfo_; }

  void
  onReceivedElement(const uint8_t *element, size_t elementLength);

  bool
  isLocal() { return transport_->isLocal(*connectionInfo_); }

  void
  shutdown();

  static size_t
  getMaxNdnPacketSize() { return MAX_NDN_PACKET_SIZE; }

  void
  callLater(Milliseconds delayMilliseconds, const Face::Callback& callback);

  uint64_t
  getNextEntryId();

private:
  enum ConnectStatus {
    ConnectStatus_UNCONNECTED = 1,
    ConnectStatus_CONNECT_REQUESTED = 2,
    ConnectStatus_CONNECT_COMPLETE = 3
  };

  class DelayedCall {
  public:
    DelayedCall(Milliseconds delayMilliseconds, const Face::Callback& callback);

    MillisecondsSince1970
    getCallTime() const { return callTime_; }

    void
    callCallback() const { callback_(); }

    class Compare {
    public:
      bool
      operator()
        (const ptr_lib::shared_ptr<const DelayedCall>& x,
         const ptr_lib::shared_ptr<const DelayedCall>& y) const
      {
        return x->callTime_ < y->callTime_;
      }
    };

  private:
    const Face::Callback callback_;
    MillisecondsSince1970 callTime_;
  };

  class PendingInterest {
  public:
    PendingInterest
      (uint64_t pendingInterestId, const ptr_lib::shared_ptr<const Interest>& interest, const OnData& onData,
       const OnTimeout& onTimeout);

    uint64_t
    getPendingInterestId() { return pendingInterestId_; }

    const ptr_lib::shared_ptr<const Interest>&
    getInterest() { return interest_; }

    const OnData&
    getOnData() { return onData_; }

    void
    setIsRemoved() { isRemoved_ = true; }

    bool
    getIsRemoved() { return isRemoved_; }

    void
    callTimeout();

  private:
    ptr_lib::shared_ptr<const Interest> interest_;
    uint64_t pendingInterestId_;            
    const OnData onData_;
    const OnTimeout onTimeout_;
    bool isRemoved_;
  };

  class RegisteredPrefix {
  public:
    RegisteredPrefix
      (uint64_t registeredPrefixId, const ptr_lib::shared_ptr<const Name>& prefix,
       uint64_t relatedInterestFilterId)
    : registeredPrefixId_(registeredPrefixId), prefix_(prefix),
      relatedInterestFilterId_(relatedInterestFilterId)
    {
    }

    uint64_t
    getRegisteredPrefixId() { return registeredPrefixId_; }

    const ptr_lib::shared_ptr<const Name>&
    getPrefix() { return prefix_; }

    uint64_t
    getRelatedInterestFilterId() { return relatedInterestFilterId_; }

  private:
    uint64_t registeredPrefixId_;            
    ptr_lib::shared_ptr<const Name> prefix_;
    uint64_t relatedInterestFilterId_;
  };

  class InterestFilterEntry {
  public:
    InterestFilterEntry
      (uint64_t interestFilterId,
       const ptr_lib::shared_ptr<const InterestFilter>& filter,
       const OnInterestCallback& onInterest, Face* face)
    : interestFilterId_(interestFilterId), filter_(filter),
      prefix_(new Name(filter->getPrefix())), onInterest_(onInterest), face_(face)
    {
    }

    uint64_t
    getInterestFilterId() { return interestFilterId_; }

    const ptr_lib::shared_ptr<const InterestFilter>&
    getFilter() { return filter_; }

    const ptr_lib::shared_ptr<const Name>&
    getPrefix() { return prefix_; }

    const OnInterestCallback&
    getOnInterest() { return onInterest_; }

    Face&
    getFace() { return *face_; }

  private:
    uint64_t interestFilterId_;  
    ptr_lib::shared_ptr<const InterestFilter> filter_;
    ptr_lib::shared_ptr<const Name> prefix_;
    const OnInterestCallback onInterest_;
    Face* face_;
  };

  class RegisterResponse {
  public:
    class Info;
    RegisterResponse(ptr_lib::shared_ptr<RegisterResponse::Info> info)
    : info_(info)
    {
    }

    void
    operator()(const ptr_lib::shared_ptr<const Interest>& interest,
               const ptr_lib::shared_ptr<Data>& responseData);

    void
    operator()(const ptr_lib::shared_ptr<const Interest>& timedOutInterest);

    class Info {
    public:
      Info(const ptr_lib::shared_ptr<const Name>& prefix,
           const OnRegisterFailed& onRegisterFailed,
           const OnRegisterSuccess& onRegisterSuccess,
           uint64_t registeredPrefixId)
      : prefix_(prefix), onRegisterFailed_(onRegisterFailed),
        onRegisterSuccess_(onRegisterSuccess),
        registeredPrefixId_(registeredPrefixId)
      {
      }

      ptr_lib::shared_ptr<const Name> prefix_;
      const OnRegisterFailed onRegisterFailed_;
      const OnRegisterSuccess onRegisterSuccess_;
      uint64_t registeredPrefixId_;
    };

  private:
    ptr_lib::shared_ptr<Info> info_;
  };

  void
  expressInterestHelper
    (uint64_t pendingInterestId,
     const ptr_lib::shared_ptr<const Interest>& interestCopy,
     const OnData& onData, const OnTimeout& onTimeout, WireFormat* wireFormat,
     Face* face);

  void
  processInterestTimeout(ptr_lib::shared_ptr<PendingInterest> pendingInterest);

  void
  extractEntriesForExpressedInterest
    (const Name& name,
     std::vector<ptr_lib::shared_ptr<PendingInterest> > &entries);

  void
  nfdRegisterPrefix
    (uint64_t registeredPrefixId, const ptr_lib::shared_ptr<const Name>& prefix,
     const OnInterestCallback& onInterest,
     const OnRegisterFailed& onRegisterFailed,
     const OnRegisterSuccess& onRegisterSuccess, const ForwardingFlags& flags,
     KeyChain& commandKeyChain, const Name& commandCertificateName,
     WireFormat& wireFormat, Face* face);

  void
  onConnected();

  ptr_lib::shared_ptr<Transport> transport_;
  ptr_lib::shared_ptr<const Transport::ConnectionInfo> connectionInfo_;
  std::vector<ptr_lib::shared_ptr<PendingInterest> > pendingInterestTable_;
  std::vector<ptr_lib::shared_ptr<RegisteredPrefix> > registeredPrefixTable_;
  std::vector<ptr_lib::shared_ptr<InterestFilterEntry> > interestFilterTable_;
  // Use a deque so we can efficiently remove from the front.
  std::deque<ptr_lib::shared_ptr<DelayedCall> > delayedCallTable_;
  DelayedCall::Compare delayedCallCompare_;
  std::vector<Face::Callback> onConnectedCallbacks_;
  CommandInterestGenerator commandInterestGenerator_;
  Name timeoutPrefix_;
  // lastEntryId_ is used to get the next unique ID. Use atomic_uint64_t to be
  // thread safe. This is not exposed in the public API or shared with the
  // application, so use ndnboost. */
  ndnboost::atomic_uint64_t lastEntryId_;
  ConnectStatus connectStatus_;
};

}

#endif