NS-3 simulation for communication between wifi nodes on different wireless LAN

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/* NS-3 simulation for communication between wifi nodes on different wireless LAN
 * Extension of the "third" example
 */

#include "ns3/core-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/network-module.h"
#include "ns3/applications-module.h"
#include "ns3/wifi-module.h"
#include "ns3/mobility-module.h"
#include "ns3/csma-module.h"
#include "ns3/internet-module.h"

// Default Network Topology
//
//   Wifi 10.1.3.0
//                    AP
//    *    *    *    *
//    |     |     |     |    10.1.1.0                                     10.1.4.0
//   n7  n8  n9  n0 --------------  n1  n4  n5  n6  n3 -------------- n2  n10  n11  n12
//                               p2p           |     |     |    |     |         p2p         |       |       |      |
//                                         ===========                            *      *       *     *
//                                             LAN 10.1.2.0                         AP
//                                                                                                  Wifi 10.1.5.0
using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("Wifi2Wifi");

int
main (int argc, char *argv[])
{
  bool verbose = true;
  uint32_t nCsma = 3;
  uint32_t nWifi1 = 3;
  uint32_t nWifi2 = 3;

  CommandLine cmd;
  cmd.AddValue ("nCsma", "Number of \"extra\" CSMA nodes/devices", nCsma);
  cmd.AddValue ("nWifi1", "Number of wifi 1 STA devices", nWifi1);
  cmd.AddValue ("nWifi2", "Number of wifi 2 STA devices", nWifi2);
  cmd.AddValue ("verbose", "Tell echo applications to log if true", verbose);

  cmd.Parse (argc,argv);

  if (nWifi1 > 18)
    {
      std::cout << "Number of wifi 1 nodes " << nWifi1 <<
                   " specified exceeds the mobility bounding box" << std::endl;
      exit (1);
    }
  if (nWifi2 > 18)
    {
      std::cout << "Number of wifi 2 nodes " << nWifi2 <<
                   " specified exceeds the mobility bounding box" << std::endl;
      exit (1);
    }

  if (verbose)
    {
      LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO);
      LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO);
    }

  /* First p2p*/
  NodeContainer p2pNodes;
  p2pNodes.Create (2);

  PointToPointHelper pointToPoint;
  pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
  pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));

  NetDeviceContainer p2pDevices;
  p2pDevices = pointToPoint.Install (p2pNodes);

  /* Second p2p*/
  NodeContainer p2pNodes2;
  p2pNodes2.Create (2);

  PointToPointHelper pointToPoint2;
  pointToPoint2.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));
  pointToPoint2.SetChannelAttribute ("Delay", StringValue ("2ms"));

  NetDeviceContainer p2pDevices2;
  p2pDevices2 = pointToPoint2.Install (p2pNodes2);

  NodeContainer csmaNodes;
  csmaNodes.Add (p2pNodes.Get (1));
  csmaNodes.Add (p2pNodes2.Get (1));
  csmaNodes.Create (nCsma);


  CsmaHelper csma;
  csma.SetChannelAttribute ("DataRate", StringValue ("100Mbps"));
  csma.SetChannelAttribute ("Delay", TimeValue (NanoSeconds (6560)));

  NetDeviceContainer csmaDevices;
  csmaDevices = csma.Install (csmaNodes);

  /*First Wifi*/
  NodeContainer wifiStaNodes;
  wifiStaNodes.Create (nWifi1);
  NodeContainer wifiApNode = p2pNodes.Get (0);

  YansWifiChannelHelper channel = YansWifiChannelHelper::Default ();
  YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();
  phy.SetChannel (channel.Create ());

  WifiHelper wifi = WifiHelper::Default ();
  wifi.SetRemoteStationManager ("ns3::AarfWifiManager");

  NqosWifiMacHelper mac = NqosWifiMacHelper::Default ();

  Ssid ssid = Ssid ("SUPERMAN");
  mac.SetType ("ns3::StaWifiMac",
               "Ssid", SsidValue (ssid),
               "ActiveProbing", BooleanValue (false));

  NetDeviceContainer staDevices;
  staDevices = wifi.Install (phy, mac, wifiStaNodes);

  mac.SetType ("ns3::ApWifiMac",
               "Ssid", SsidValue (ssid));

  NetDeviceContainer apDevices;
  apDevices = wifi.Install (phy, mac, wifiApNode);

  MobilityHelper mobility;

  mobility.SetPositionAllocator ("ns3::GridPositionAllocator",
                                 "MinX", DoubleValue (-30.0),
                                 "MinY", DoubleValue (-10.0),
                                 "DeltaX", DoubleValue (5.0),
                                 "DeltaY", DoubleValue (10.0),
                                 "GridWidth", UintegerValue (3),
                                 "LayoutType", StringValue ("RowFirst"));

  mobility.SetMobilityModel ("ns3::RandomWalk2dMobilityModel",
                             "Bounds", RectangleValue (Rectangle (-50, 50, -50, 50)));
  mobility.Install (wifiStaNodes);

  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
  mobility.Install (wifiApNode);

  /* Second Wifi */

  NodeContainer wifiStaNodes2;
  wifiStaNodes2.Create (nWifi2);
  NodeContainer wifiApNode2 = p2pNodes2.Get (0);

  YansWifiChannelHelper channel2 = YansWifiChannelHelper::Default ();
  YansWifiPhyHelper phy2 = YansWifiPhyHelper::Default ();
  phy2.SetChannel (channel2.Create ());

  WifiHelper wifi2 = WifiHelper::Default ();
  wifi2.SetRemoteStationManager ("ns3::AarfWifiManager");

  NqosWifiMacHelper mac2 = NqosWifiMacHelper::Default ();

  Ssid ssid2 = Ssid ("BATMAN");
  mac2.SetType ("ns3::StaWifiMac",
               "Ssid", SsidValue (ssid2),
               "ActiveProbing", BooleanValue (false));

  NetDeviceContainer staDevices2;
  staDevices2 = wifi.Install (phy2, mac2, wifiStaNodes2);

  mac2.SetType ("ns3::ApWifiMac",
               "Ssid", SsidValue (ssid2));

  NetDeviceContainer apDevices2;
  apDevices2 = wifi2.Install (phy2, mac2, wifiApNode2);

  MobilityHelper mobility2;

  mobility2.SetPositionAllocator ("ns3::GridPositionAllocator",
                                 "MinX", DoubleValue (20.0),
                                 "MinY", DoubleValue (-20.0),
                                 "DeltaX", DoubleValue (5.0),
                                 "DeltaY", DoubleValue (10.0),
                                 "GridWidth", UintegerValue (3),
                                 "LayoutType", StringValue ("RowFirst"));

  mobility2.SetMobilityModel ("ns3::RandomWalk2dMobilityModel",
                             "Bounds", RectangleValue (Rectangle (-50, 50, -50, 50)));
  mobility2.Install (wifiStaNodes2);

  mobility2.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
  mobility2.Install (wifiApNode2);


  InternetStackHelper stack;
  stack.Install (csmaNodes);
  stack.Install (wifiApNode);
  stack.Install (wifiApNode2);
  stack.Install (wifiStaNodes);
  stack.Install (wifiStaNodes2);

  Ipv4AddressHelper address;

  address.SetBase ("10.1.1.0", "255.255.255.0");
  Ipv4InterfaceContainer p2pInterfaces;
  p2pInterfaces = address.Assign (p2pDevices);

  address.SetBase ("10.1.2.0", "255.255.255.0");
  Ipv4InterfaceContainer csmaInterfaces;
  csmaInterfaces = address.Assign (csmaDevices);

  address.SetBase ("10.1.3.0", "255.255.255.0");
  Ipv4InterfaceContainer wifiInterfaces;
  wifiInterfaces = address.Assign (staDevices);
  //wifiInterfaces = address.Assign (apDevices);

  address.SetBase ("10.1.4.0", "255.255.255.0");
  Ipv4InterfaceContainer p2pInterfaces2;
  p2pInterfaces2 = address.Assign (p2pDevices2);

  address.SetBase ("10.1.5.0", "255.255.255.0");
  Ipv4InterfaceContainer wifiInterfaces2;
  wifiInterfaces2 = address.Assign (staDevices2);
  wifiInterfaces2 = address.Assign (apDevices2);


  
  /* Make a node from the second Wifi network as the server */
  UdpEchoServerHelper echoServer (9);
  ApplicationContainer serverApps = echoServer.Install (wifiStaNodes2.Get (1));
  serverApps.Start (Seconds (1.0));
  serverApps.Stop (Seconds (10.0));


  /* Make a node from the first Wifi network as the client */
  UdpEchoClientHelper echoClient (wifiInterfaces2.GetAddress (1), 9);  //connect to server
  echoClient.SetAttribute ("MaxPackets", UintegerValue (6));
  echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
  echoClient.SetAttribute ("PacketSize", UintegerValue (1024));
  ApplicationContainer clientApps = echoClient.Install (wifiStaNodes.Get (1));
  clientApps.Start (Seconds (2.0));
  clientApps.Stop (Seconds (10.0));

  Ipv4GlobalRoutingHelper::PopulateRoutingTables ();

  Simulator::Stop (Seconds (10.0));

  Simulator::Run ();
  Simulator::Destroy ();
  return 0;
}

REFERENCES:

https://www.nsnam.org/documentation/

Installing ndnSIM on Ubuntu 15.04

ndnSIM

The ndnSIM is NS-3 module that implements Named Data Networking (NDN) communication model, the clean slate Internet design. ndnSIM is specially optimized for simulation purposes and has a cleaner and more extensible internal structure comparing to the existing NDN implementation (NDNx).        - ndnSIM website

The steps for installation I followed from the ndnSIM website are as follows:

 

1. Boost library

Minimum version: 1.49
To check the version installed on your system do:
dpkg -s libboost-dev | grep 'Version'

If the version requirement is not satisfied, do the following:
sudo add-apt-repository ppa:boost-latest/ppa
sudo apt-get update
sudo apt-get install libboost-all-dev 

The version installed on mine is 1.55.0.2.

2. ndn-cxx library

Add the NDN ppa repository and install ndn-cxx-dev
sudo add-apt-repository ppa:named-data/ppa
sudo apt-get update
sudo apt-get install ndn-cxx-dev

The following installations are optional:
sudo apt-get install doxygen graphviz python-sphinx python-pip
sudo pip install sphinxcontrib-doxylink sphinxcontrib-googleanalytics

3. For the visualizer

sudo apt-get install python-dev python-pygraphviz python-kiwi
sudo apt-get install python-pygoocanvas python-gnome2
sudo apt-get install python-rsvg ipython

4. If not already installed, git

sudo apt-get install git

5. ndnSIM source download

mkdir ndnSIM
cd ndnSIM

git clone https://github.com/named-data-ndnSIM/ns-3-dev.git ns-3
git clone https://github.com/named-data-ndnSIM/pybindgen.git pybindgen

git clone --recursive https://github.com/named-data-ndnSIM/ndnSIM.git ns-3/src/ndnSIM

6. Prerequisites for build

sudo apt-get install build-essential
sudo apt-get install libsqlite3-dev libcrypto++-dev

7. Compile and install ndn-cxx library

cd ndnSIM/ndn-cxx
./waf configure --enable-shared --disable-static
./waf
sudo ./waf install 
sudo ldconfig

8. Compile ns3 with ndnSIM module

cd <ns-3-folder>
./waf configure --enable-examples
./waf

9. Run your first example

./waf --run=ndn-simple --vis

References:

http://ndnsim.net/1.0/getting-started.html 

http://named-data.net/doc/ndn-cxx/current/INSTALL.html 

Installing Fluentd

Step 1:

Install ruby

(Fluentd is written in ruby)

ruby 2.0.0 

Open a terminal and type in

     tar -zxvf Downloads/ruby-2.0.0-p247.tar.gz 

     cd ruby-2.0.0-p247

     ./configure

     sudo make install

Step 2:

Install rake

(Shortcut to install everything you need as this would also install rubygems)

    

    sudo apt-get install rake

Step 3:

Install fluentd 

         sudo gem install fluentd --no-ri --no-rdoc  

Step 4:

Running fluentd  

      #Move to directory where you wish to setup fluentd
        fluentd --setup ./fluent
        fluentd -c ./fluent/fluent.conf

Intro to Fluentd

Official Website: fluentd.org

A brief description-

                   Fluentd is an open source tool for log aggregation.
It can be used in myriad ways... You can customize it according to your needs...

Its default input plugins include options to...

           1. Tail file
           2. Listen on port
           3. Retreive records form HTTP post messages
           4. read syslogs directly
           5. execute external programs to receive or pull event logs

Its default output plugins include options to...

           1.Output to file
           2. Forward to other Fluentd nodes
           3. pass events to an external program as a tab-separated value (TSV) file
           4. Output to MongoDB

                    You can also buffer the data using the buffer plugins.

The basic configuration has three parts:

           1. Source directive    :     Specify sources for data

           2. Match directive     :     Filters the input data based on matching tags
                                                   and takes the action corresponding to the tag.
                                             
                                                   e.g. If the system requires access logs to be
                                                          forwarded to other Fluentd node then we
                                                          can make the configuration as:
                                                                   
                                                                    Tail apache access log file using in_tail
                                                          plugin. Give the tag as something like
                                                          apache.access. In the match directive
                                                          (match apache.access) write the output
                                                          configuration for out_forward plugin.

           3. Include directive    :    Directives in separate configuration files can be
                                                   imported using the include directive

You can even write your own regex in the pattern field of source directive

So... go ahead and enjoy logging.....