every parts are wroking, implemented ndnsd-tool completly and also th…

README.md

@@ -0,0 +1,2 @@
+# NDNSD
+NDN Service Discovery

examples/consumer.cpp

@@ -17,10 +17,26 @@
  * NDNSD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  **/
 
-#include<iostream>
 #include "ndnsd/discovery/service-discovery.hpp"
+#include <ndn-cxx/util/logger.hpp>
+
+#include<iostream>
 #include <list>
 
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/variables_map.hpp>
+#include <boost/program_options/parsers.hpp>
+
+NDN_LOG_INIT(ndnsd.examples.ConsumerApp);
+
+static void
+usage(const boost::program_options::options_description& options)
+{
+  std::cout << "Usage: ndnsd-consumer [options] e.g. printer \n"
+            << options;
+   exit(2);
+}
+
 class Consumer
 {
 public:
@@ -32,17 +48,18 @@ class Consumer
   void
   execute ()
   {
+    // process and handle request
     m_serviceDiscovery.consumerHandler();
   }
 
 private:
   void
   processCallback(const ndnsd::discovery::Reply& callback)
   {
+    NDN_LOG_INFO("Service info received");
     auto status = (callback.status == ndnsd::discovery::ACTIVE)? "ACTIVE": "EXPIRED";
-
     std::cout << "Status: " << status << std::endl;
-    for (auto& item : callback.serviceDetails)
+    for (const auto& item : callback.serviceDetails)
     {
       std::cout << item.first << ": " << item.second << std::endl;
     }
@@ -56,15 +73,63 @@ class Consumer
 int
 main(int argc, char* argv[])
 {
-  if (argc != 2) {
-    std::cout << "usage: " << argv[0] << " <service-name> "
-              << std::endl;
-    return 1;
-  }
+  std::string serviceName;
+  int contFlag = -1;
+
+  namespace po = boost::program_options;
+  po::options_description visibleOptDesc("Options");
+
+  visibleOptDesc.add_options()
+    ("help,h",      "print this message and exit")
+    ("serviceName,s", po::value<std::string>(&serviceName)->required(), "Service name to fetch service info")
+    ("continuous,c", po::value<int>(&contFlag), "continuous discovery, 1 for true 0 for false")
+  ;
+
+  try
+  {
+    po::variables_map optVm;
+    po::store(po::parse_command_line(argc, argv, visibleOptDesc), optVm);
+    po::notify(optVm);
+
+    if (optVm.count("continuous")) {
+        if (contFlag != ndnsd::discovery::OPTIONAL and contFlag != ndnsd::discovery::REQUIRED) 
+        {
+          std::cout << "'c' must be either '0' or '1', default i.e. '0' will be used" << std::endl;
+        }
+      }
+    else
+      contFlag = 0;
+
+    if (optVm.count("serviceName")) {
+      if (serviceName.empty())
+      {
+        std::cerr << "ERROR: serviceName cannot be empty" << std::endl;
+        usage(visibleOptDesc);
+      }
+    }
 
+  }
+  catch (const po::error& e) {
+    std::cerr << "ERROR: " << e.what() << std::endl;
+    usage(visibleOptDesc);
+  }
+  // TODO: protocol shouldn't be hard-coded.
   std::map<char, uint8_t> flags;
-  flags.insert(std::pair<char, uint8_t>('p', ndnsd::SYNC_PROTOCOL_CHRONOSYNC)); //protocol choice
-  flags.insert(std::pair<char, uint8_t>('t', ndnsd::discovery::CONSUMER)); //c: consumer - 0, p:producer - 1
+  flags.insert(std::pair<char, uint8_t>('p', ndnsd::SYNC_PROTOCOL_PSYNC)); //protocol choice
+  flags.insert(std::pair<char, uint8_t>('t', ndnsd::discovery::CONSUMER)); //type producer: 1
+  flags.insert(std::pair<char, uint8_t>('c', contFlag));
+
+  try
+  {
+    std::cout << "Fetching service info for: " << serviceName << std::endl;
+    NDN_LOG_INFO("Fetching service info for: " << serviceName);
+    Consumer consumer(serviceName, flags);
+    consumer.execute();
+  }
+  catch (const std::exception& e) {
+    std::cerr << "ERROR: " << e.what() << std::endl;
+    NDN_LOG_ERROR("Cannot execute consumer, try again later: " << e.what());
+  }
 
   try {
     Consumer consumer(argv[1], flags);

examples/producer.cpp

@@ -17,10 +17,13 @@
  * NDNSD, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  **/
 
-#include<iostream>
 #include "ndnsd/discovery/service-discovery.hpp"
+#include <ndn-cxx/util/logger.hpp>
+
+#include<iostream>
 #include <list>
-#include <boost/filesystem.hpp>
+
+NDN_LOG_INIT(ndnsd.examples.ProducerApp);
 
 inline bool
 isFile(const std::string& fileName)
@@ -46,8 +49,8 @@ class Producer
   void
   processCallback(const ndnsd::discovery::Reply& callback)
   {
+    NDN_LOG_INFO("Service publish callback received");
     auto status = (callback.status == ndnsd::discovery::ACTIVE)? "ACTIVE": "EXPIRED";
-
     std::cout << "\n Status: " << status << std::endl;
     for (auto& item : callback.serviceDetails)
     {
@@ -63,14 +66,16 @@ int
 main(int argc, char* argv[])
 {
   std::map<char, uint8_t> flags;
-  flags.insert(std::pair<char, uint8_t>('p', ndnsd::SYNC_PROTOCOL_CHRONOSYNC)); //protocol choice
+  flags.insert(std::pair<char, uint8_t>('p', ndnsd::SYNC_PROTOCOL_PSYNC)); //protocol choice
   flags.insert(std::pair<char, uint8_t>('t', ndnsd::discovery::PRODUCER)); //type producer: 1
 
   try {
+    NDN_LOG_INFO("Starting producer application");
     Producer producer(argv[1], flags);
     producer.execute();
   }
   catch (const std::exception& e) {
     std::cout << "Exception: " << e.what() << std::endl;
+    NDN_LOG_ERROR("Cannot execute producer, try again later: " << e.what());
   }
 }

ndnsd/communication/sync-adapter.cpp

@@ -2,8 +2,8 @@
 /*
  * Copyright (c) 2014-2020,  The University of Memphis
  *
- * This file is part of NDNSD.
- * See NLSR's AUTHORS.md for complete list of NDNSD authors and contributors.
+ * This file is originally from NLSR and is modified here per the use.
+ * See NLSR's AUTHORS.md for complete list of NLSR authors and contributors.
  *
  * NDNSD 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,
@@ -21,13 +21,16 @@
  **/
 
 #include "sync-adapter.hpp"
+
+#include <ndn-cxx/util/logger.hpp>
+
 #include <iostream>
 
-INIT_LOGGER(SyncProtocolAdapter);
+NDN_LOG_INIT(ndnsd.SyncProtocolAdapter);
 
 namespace ndnsd {
 
-const auto FIXED_SESSION = ndn::name::Component::fromNumber(0);
+const auto CHRONOSYNC_FIXED_SESSION = ndn::name::Component::fromNumber(0);
 
 SyncProtocolAdapter::SyncProtocolAdapter(ndn::Face& face,
                                          uint8_t syncProtocol,
@@ -39,7 +42,7 @@ SyncProtocolAdapter::SyncProtocolAdapter(ndn::Face& face,
   , m_syncUpdateCallback(syncUpdateCallback)
 {
   if (m_syncProtocol == SYNC_PROTOCOL_CHRONOSYNC) {
-    NDNSD_LOG_DEBUG("Using ChronoSync");
+    NDN_LOG_DEBUG("Using ChronoSync");
     m_chronoSyncLogic = std::make_shared<chronosync::Logic>(face,
                           syncPrefix,
                           userPrefix,
@@ -52,10 +55,10 @@ SyncProtocolAdapter::SyncProtocolAdapter(ndn::Face& face,
                           syncInterestLifetime,
                           chronosync::Logic::DEFAULT_SYNC_REPLY_FRESHNESS,
                           chronosync::Logic::DEFAULT_RECOVERY_INTEREST_LIFETIME,
-                          FIXED_SESSION);
+                          CHRONOSYNC_FIXED_SESSION);
   }
   else {
-    NDNSD_LOG_DEBUG("Using PSync");
+    NDN_LOG_DEBUG("Using PSync");
     m_psyncLogic = std::make_shared<psync::FullProducer>(80,
                      face,
                      syncPrefix,
@@ -69,7 +72,7 @@ void
 SyncProtocolAdapter::addUserNode(const ndn::Name& userPrefix)
 {
   if (m_syncProtocol == SYNC_PROTOCOL_CHRONOSYNC) {
-    m_chronoSyncLogic->addUserNode(userPrefix, chronosync::Logic::DEFAULT_NAME, FIXED_SESSION);
+    m_chronoSyncLogic->addUserNode(userPrefix, chronosync::Logic::DEFAULT_NAME, CHRONOSYNC_FIXED_SESSION);
   }
   else {
     m_psyncLogic->addUserNode(userPrefix);
@@ -79,10 +82,10 @@ SyncProtocolAdapter::addUserNode(const ndn::Name& userPrefix)
 void
 SyncProtocolAdapter::publishUpdate(const ndn::Name& userPrefix)
 {
-  NDNSD_LOG_INFO("Publishing update for Sync Prefix " << userPrefix);
+  NDN_LOG_INFO("Publishing update for Sync Prefix " << userPrefix);
   if (m_syncProtocol == SYNC_PROTOCOL_CHRONOSYNC) {
     auto seq = m_chronoSyncLogic->getSeqNo(userPrefix) + 1;
-    NDNSD_LOG_INFO("SeqNumber :" << seq);
+    NDN_LOG_INFO("SeqNumber :" << seq);
     m_chronoSyncLogic->updateSeqNo(seq, userPrefix);
   }
   else {
@@ -93,11 +96,11 @@ SyncProtocolAdapter::publishUpdate(const ndn::Name& userPrefix)
 void
 SyncProtocolAdapter::onChronoSyncUpdate(const std::vector<chronosync::MissingDataInfo>& updates)
 {
-  NDNSD_LOG_INFO("Received ChronoSync update event");
+  NDN_LOG_INFO("Received ChronoSync update event");
   std::vector<ndnsd::SyncDataInfo> dinfo;
 
   for (const auto& update : updates) {
-    // Remove FIXED_SESSION
+    // Remove CHRONOSYNC_FIXED_SESSION
     SyncDataInfo di;
     di.prefix = update.session.getPrefix(-1);
     di.highSeq = update.high;
@@ -109,11 +112,10 @@ SyncProtocolAdapter::onChronoSyncUpdate(const std::vector<chronosync::MissingDat
 void
 SyncProtocolAdapter::onPSyncUpdate(const std::vector<psync::MissingDataInfo>& updates)
 {
-  NDNSD_LOG_INFO("Received PSync update event");
+  NDN_LOG_INFO("Received PSync update event");
   std::vector<ndnsd::SyncDataInfo> dinfo;
 
   for (const auto& update : updates) {
-    // Remove FIXED_SESSION
     SyncDataInfo di;
     di.prefix = update.prefix;
     di.highSeq = update.highSeq;

ndnsd/communication/sync-adapter.hpp

@@ -2,8 +2,8 @@
 /*
  * Copyright (c) 2014-2020,  The University of Memphis
  *
- * This file is part of NDNSD.
- * See NLSR's AUTHORS.md for complete list of NDNSD authors and contributors.
+ * This file is originally from NLSR and is modified here per the use.
+ * See NLSR's AUTHORS.md for complete list of NLSR authors and contributors.
  *
  * NDNSD 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,
@@ -23,7 +23,6 @@
 #ifndef NDNSD_SYNC_ADAPTER_HPP
 #define NDNSD_SYNC_ADAPTER_HPP
 
-#include "logger.hpp"
 #include <ndn-cxx/face.hpp>
 #include <ChronoSync/logic.hpp>
 #include <PSync/full-producer.hpp>

ndnsd/discovery/file-processor.cpp

@@ -19,6 +19,12 @@
 
 #include "file-processor.hpp"
 
+#include<iostream>
+
+#include <ndn-cxx/util/logger.hpp>
+
+NDN_LOG_INIT(ndnsd.FileProcessor);
+
 namespace ndnsd {
 namespace discovery {
 
@@ -28,12 +34,14 @@ ServiceInfoFileProcessor::ServiceInfoFileProcessor(const std::string filename)
   processFile();
 }
 
+// need to implement sanity check, 1. correct file is edited, required section is not modified
+// and so on
 void
 ServiceInfoFileProcessor::processFile()
 {
   try
   {
-    NDNSD_LOG_INFO("FP: Reading file: "<< m_filename);
+    NDN_LOG_INFO("Reading file: "<< m_filename);
     boost::property_tree::ptree pt;
     read_info(m_filename, pt);
     for (auto& block: pt)
@@ -68,17 +76,17 @@ ServiceInfoFileProcessor::processFile()
           const auto& key = details.first; //get_value<std::string >();
           const auto& val = details.second.get_value<std::string >();
 
-          NDNSD_LOG_INFO("FP: Reading file: "<< val);
-
+          NDN_LOG_INFO("Reading file: "<< val);
           m_serviceMetaInfo.insert(std::pair<std::string, std::string>(key, val));
         }
       }
     }
-    NDNSD_LOG_INFO("FP: Successfully updated the file content: ");
+    NDN_LOG_INFO("Successfully updated the file content: ");
   }
   catch (std::exception const& e)
   {
     std::cerr << e.what() << std::endl;
+    NDN_LOG_INFO("Error reading file: " << m_filename);
     throw e;
   }
 }

ndnsd/discovery/file-processor.hpp

@@ -20,18 +20,13 @@
 #ifndef NDNSD_FILE_PROCESSOR_HPP
 #define NDNSD_FILE_PROCESSOR_HPP
 
-#include "logger.hpp"
 #include <ndn-cxx/face.hpp>
 #include <ndn-cxx/util/time.hpp>
 
 #include <boost/filesystem.hpp>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/info_parser.hpp>
 
-#include <iostream>
-
-INIT_LOGGER(ServiceDiscovery);
-
 namespace ndnsd {
 namespace discovery {
 
@@ -54,7 +49,7 @@ class ServiceInfoFileProcessor
     return m_applicationPrefix;
   }
 
-  ndn::time::milliseconds
+  ndn::time::seconds
   getServiceLifetime()
   {
     return m_serviceLifeTime;
@@ -74,7 +69,7 @@ class ServiceInfoFileProcessor
   ndn::Name m_serviceName;
   ndn::Name m_applicationPrefix;
   std::map<std::string, std::string> m_serviceMetaInfo;
-  ndn::time::milliseconds m_serviceLifeTime;
+  ndn::time::seconds m_serviceLifeTime;
 };
 
 } // namespace discovery