Difference between revisions of "App Store Technical Requirements"

From Nsnam
Jump to: navigation, search
(New module layout)
(update page)
Line 14: Line 14:
 
framework called [http://live.gnome.org/Jhbuild jhbuild] exists for  
 
framework called [http://live.gnome.org/Jhbuild jhbuild] exists for  
 
building and managing the dependencies between these disparate projects.
 
building and managing the dependencies between these disparate projects.
 +
 +
The modular build and integration with bake is described in a separate [[BakeIntegration | wiki page]] and is intended to be enabled for ns-3.27.
  
 
Once we have a modular build, and an ability to separately download and  
 
Once we have a modular build, and an ability to separately download and  
Line 44: Line 46:
 
* list of ns-3 package dependencies (other ns-3 packages which this package depends upon)
 
* list of ns-3 package dependencies (other ns-3 packages which this package depends upon)
  
= Requirements =
+
This page used to have a list of requirements for a home-grown app store, but lately, we are thinking of adapting the implementation at [http://apps.cytoscape.org/ Cytoscape] and tailoring it to ns-3's needs. This is a project idea for the [https://www.nsnam.org/wiki/GSOC2017Projects#App_Store 2017 Google Summer of Code].
 
+
== Build and configuration ==
+
 
+
* Enable optimized, debug, and static builds
+
* Separate tests from models
+
* Doxygen support
+
* Test.py framework supports the modularization
+
* Python bindings support the modularization
+
* integrate lcov code coverage tests
+
* integrate with buildbots
+
 
+
== API and work flow ==
+
 
+
Assume that our download script is called download.py and our
+
build script is called build.py.
+
 
+
  wget http://www.nsnam.org/releases/ns-allinone-3.x.tar.bz2
+
  bunzip2 ns-allinone-3.x.tar.bz2 && tar xvf ns-allinone-3.x.tar.bz2
+
  cd ns-allinone-3.x
+
 
+
In this directory, users will find the following directory layout:
+
 
+
  build.py download.py constants.py? VERSION LICENSE README
+
 
+
Download essential modules:
+
 
+
  ./download.py
+
 
+
This will leave a layout such as follows:
+
 
+
  download.py build.py pygccxml pybindgen ns-3.10 gcc-xml
+
 
+
 
+
For typical users, the next step is as follows:
+
 
+
  ./build.py
+
 
+
The above will take the following steps:
+
* build all typical prerequisites such as pybindgen
+
* cd ns3-10
+
* ./waf configure && ./waf && ./waf install
+
 
+
The above will install headers into build/debug/ns3/ and libraries for each of the enabled modules into build/debug/lib.  Each enabled module will be placed in a separate library that has a name of the form libns3-simulator.so for the simulator module.
+
 
+
'''Open issue:''' How to express and honor platform limitations, such as
+
only trying to download/build NSC on platforms supporting it.
+
 
+
Once the build process is done, there will be a bunch of libraries in a
+
common build directory, and all applicable headers.  Specifically,
+
we envision for module simulator, there may be a libns3-simulator.so, libns3-simulator-test.so,
+
a python .so, and possibly others. 
+
 
+
=== Python ===
+
 
+
We have a few choices for supporting Python.  First, note that this type
+
of system provides an opportunity for the python build tools to be added
+
as packages to the overall build system, so that users can more easily
+
build their bindings.  We can try to build lots of small python modules,
+
or run a scan at the very end of the ns-3 build process to build a customized
+
python ns3 module, such as:
+
 
+
* python-scan.py
+
* ...
+
* pybindgen
+
 
+
which operates on the headers in the build/debug/ns3 directory and creates
+
a python module .so library that matches the ns-3 configured components.
+
 
+
'''Open issue:''' What is the eventual python API?  Should each module be
+
imported separately such as import node as ns.node, or should we try to
+
go for a single ns3 python module?  Or, we could continue to maintain bindings.  Another consideration is that constantly generating bindings will slow down the builds.
+
 
+
=== Tests ===
+
 
+
Tests are run by running ./test.py, which knows how to find the available
+
test libraries and run the tests.
+
 
+
Presently, test.py hardcodes the examples or samples; it needs to become
+
smarter to learn what examples are around and need testing.
+
 
+
=== Doxygen ===
+
 
+
Doxygen can be run such as "build.py doxygen" on the build/debug/ns3
+
directory.  I would guess that we don't try to modularize this but instead
+
to run on the build/debug/ns3/ directory once all headers have been copied in.
+
 
+
=== Build flags ===
+
 
+
To configure different options such as  -g, -fprofile-arcs, e.g., use the
+
CFLAGS environment variable.
+
 
+
=== Running programs ===
+
 
+
To run programs:
+
 
+
  ./build.py shell
+
  build/debug/examples/csma/csma-bridge
+
or
+
  python build/debug/examples/csma/csma-bridge.py
+
 
+
=== Other examples ===
+
 
+
Build all known ns-3 modules:
+
 
+
  ./build.py all
+
 
+
In the above case, suppose that the program could not download and fetch
+
a module.  Here, it can interactively prompt the user "Module foo not
+
found; do you wish to continue [Y/n]?".
+
 
+
Build the core of ns-3, plus device models WiFi and CSMA:
+
 
+
  ./build ns3-core wifi csma
+
 
+
ns3-core is a meta-module containing simulator common node mobility etc. 
+
'''Open issue:''' what is the right granularity for this module?
+
 
+
=== Example third-party ns-3 module ===
+
 
+
Suppose a research group at Example Univ. publishes a new WiMin device
+
module.  It gets a new unique module name from ns-3 project, such as
+
wimin.  It also contributes metadata to the master ns-3 build script.
+
 
+
==== Downloading ====
+
 
+
The "download.py" system should have enough metadata to fetch it, whether
+
it is a tarball release or some other kind of release. 
+
 
+
'''Open issue:''' How does user toggle the download behavior of a module?
+
Is there a sticky "./download.py --disable-module=wimin" option?  Or does
+
user manually edit the module metadata file?
+
 
+
'''Open issue:''' Where does this module download to?  Options include:
+
# ns-3-allinone/wimin
+
# ns-3-allinone/ns-3-dev/wimin
+
# ns-3-allinone/ns-3-dev/modules/wimin
+
 
+
In the first case above, this will result in an ns-3-allinone directory that
+
is flat and possibly including non-ns3 modules mixed with ns-3 modules
+
(e.g. pygccxml, nam-1, aodv, olsr, simulator, click, ... will all be at
+
the same directory level). 
+
 
+
In the second case, it has advantage of keeping all ns-3-specific modules
+
within an ns-3 subdirectory.  This may support better the developer who
+
has multiple ns-3 branches that are supported by "common" libraries such
+
as nsc, pybindgen, etc. that do not have to change.
+
 
+
The third case is somewhat analogous to the present situation where we
+
have ns-3-allinone/ns-3-dev/src/wimin.
+
 
+
==== Building ====
+
 
+
  ./build.py
+
 
+
at the top level should recurse and cause the wimin module to be built
+
based on the provided (jhbuild) metadata.
+
 
+
At this top level, there need to be some global CFLAGS in effect that
+
cause debug/optimized/static to be consistently performed.
+
 
+
Let's assume that the downloaded module looked like this:
+
 
+
  ns-3-allinone/ns-3-dev/wimin/model
+
                              /examples
+
                              /doc
+
                              /test
+
                              /helper
+
                              /bindings
+
 
+
After the build step, it looks like this:
+
 
+
  ns-3-allinone/ns-3-dev/wimin/model
+
                              /examples
+
                              /doc
+
                              /test
+
                              /helper
+
                              /lib/libns3-wimin.so
+
                              /lib/libns3-wimin-test.so
+
                              /bindings/ns3wimin.so
+
                              /include
+
                              /bin
+
 
+
==== Installing ====
+
 
+
The install step will next put it into these places:
+
 
+
  installprefix/bin
+
  installprefix/include/wimin
+
  installprefix/bindings/python
+
  installprefix/lib
+
 
+
where installprefix defaults to either "ns-3-allinone/install/debug"
+
or "ns-3-allinone/ns-3-dev/install/debug" but can be overridden if
+
a different prefix is configured.
+
 
+
= Plan and Status =
+
 
+
== Plan ==
+
 
+
We are aiming to first make the existing ns-3 modular, and then work
+
on the second issue of supporting easy integration of modules
+
maintained by third parties.
+
 
+
This plan will be carried out in two stages:
+
* Stage 1: (for ns-3.11) make existing ns-3 modular
+
** users can explicitly disable unneeded modules from their build
+
** tests are decoupled from the main libraries; changes to test programs do not cause all examples to be relinked
+
** modular Python bindings are generated
+
* Stage 2: (post ns-3.11) enable the "app store" concept
+
** allow jhbuild or similar scripts to orchestrate a larger build, including managing third-party dependencies (e.g. click or openflow)
+
** each module gets an independent version number, and metadata coordinates version dependencies between modules
+
** allow users to use their own build system if they want
+
 
+
== Stage 1 Status ==
+
 
+
Stage 1 will be included in the ns-3.11 release. 
+
 
+
The primary goal is to be able to enable/disable modules and allow users to tailor the build to include the components that they need.  Making the existing ns-3 into a modular system is mainly a job of reorganizing the source tree and modifying waf and the python bindings generation code.
+
 
+
Most of the changes related to the Stage 1 reorganization has been committed to http://code.nsnam.org/watrous/ns-3-dev.
+
 
+
The items that have been completed to date are:
+
# Resolve the circular dependencies in the ns3 modules.
+
# Reorganize the following modules:  simulator, core, common, node, internet-stack into a new set of modules:  core, network, internet, propagation, spectrum, along the lines of what was discussed on the list
+
# A new file .ns3rc that allows users to specify which items are in the build or out of the build.
+
# Separate libraries for each module:  each module builds one "model" library and possibly one "test" library.  Only the test-runner links the test code.
+
# The example programs that test.py runs (if examples are enabled in the build) are specified in each examples directory in a new file "examples-to-run.py", rather than in the main test.py program. 
+
# Modular Python bindings are created for each module and put in the module's bindings directory.  See http://www.nsnam.org/wiki/index.php/NS-3_Python_Bindings#Modular_Python_Bindings for more information on the modular Python bindings.
+
# src/helper went away; helpers are maintained on a per-module basis.
+
# All test code has been properly redistributed in the new directory layout.  The plan is that "build verification tests" (BVTs) will live with the model code, and other tests (e.g. UNIT) will live in a test/ directory.
+
# some examples or samples migrated from the top level examples/ or samples/ directory to the module examples/ directory.
+
 
+
The items that are unfinished but are proposed to be finished for this release are:
+
# ./waf --doxygen needs to be re-enabled; print-introspected-doxygen utility is not presently built as part of all modules.
+
# Fix project documentation (tutorial, wiki, manual, etc.) to align with the new layout
+
 
+
=== New module layout ===
+
 
+
A prototypical module looks like this:
+
 
+
  src/modulename/
+
                bindings/
+
                doc/
+
                examples/
+
                helper/
+
                model/
+
                test/
+
                          examples-to-run.py
+
                utils/
+
                wscript
+
 
+
Not all directories will be present in each module.
+
 
+
=== Module dependencies ===
+
 
+
[[File:Module-relationships.png]]
+
 
+
[[File:plot_module_dependencies]]
+
 
+
=== Modular libraries ===
+
 
+
Enabling a module will cause at least one library to be built:  libns3-modulename.so.  If the module has a test library, then libns3-modulename-test.so will be built, too.  Other modules that the module depends on will also be built. 
+
 
+
For example, try these commands:
+
 
+
  ./waf  configure --disable-python --enable-modules=core
+
  ./waf
+
  cd build/debug/
+
  ls
+
 
+
and the following libraries should be present:
+
 
+
  bindings  libns3-core.so      ns3      scratch  utils
+
  examples  libns3-core-test.so  samples  src
+
 
+
Running test.py will cause only those tests that depend on module core to be run:
+
+
  20 of 24 tests passed (20 passed, 4 skipped, 0 failed, 0 crashed, 0 valgrind errors)
+
 
+
Repeat for the "network" module instead of the "core" module, and the following will be built, since network depends on core:
+
 
+
  bindings  libns3-core.so      libns3-network.so      ns3      scratch  utils
+
  examples  libns3-core-test.so  libns3-network-test.so  samples  src
+
 
+
=== the .ns3rc file ===
+
 
+
Using a command-line option (--enable-modules=modulename) to ./waf at configure stage can be used to control which modules are built.  There is an alternate way, which is to write an .ns3rc file:
+
 
+
  #! /usr/bin/env python
+
 
+
  # A list of the modules that will be enabled when ns-3 is run.
+
  # Modules that depend on the listed modules will be enabled also.
+
  #
+
  # All modules can be enabled by choosing 'all_modules'.
+
  modules_enabled = ['core', 'network', 'internet', 'mpi', 'mobility', 'bridge', 'propagation', 'spectrum']
+
 
+
 
+
The precedence rules are as follows:
+
 
+
# the --enable-modules configure string overrides any .ns3rc file
+
# the .ns3rc file in the top level ns-3 directory is next consulted, if present
+
# the system searches for ~/.ns3rc if the above two are unspecified
+
 
+
If none of the above limits the modules to be built, all modules that waf knows about will be built.
+
 
+
The maintained version of the .ns3rc file in the ns-3-dev repository resides in the ns-3-dev/utils directory.  The reason for this is if it were in the top-level directory, it would be prone to accidental checkins from maintainers that enable the modules they want to use.  Therefore, users need to manually copy the .ns3rc from the utils directory to their preferred place (top level directory, their home directory) to enable persistent modular build configuration.
+
 
+
=== examples-to-run.py ===
+
 
+
In ns-3.10, test.py hardcodes a number of examples to run in the test suite.  In ns-3.11, we will add a new file "examples-to-run.py" in each module test/ directory, to tell the test framework which of the models should be run and under which test conditions.  The syntax is the same as in current test.py; e.g. the src/spectrum/test/examples-to-run.py is given below:
+
 
+
  #! /usr/bin/env python
+
  ## -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-
+
  # A list of C++ examples to run in order to ensure that they remain
+
  # buildable and runnable over time.  Each tuple in the list contains
+
  #
+
  #    (example_name, do_run, do_valgrind_run).
+
  #
+
  # See test.py for more information.
+
  cpp_examples = [
+
    ("adhoc-aloha-ideal-phy", "True", "True"),
+
    ("adhoc-aloha-ideal-phy-with-microwave-oven", "True", "True"),
+
  ]
+
  # A list of Python examples to run in order to ensure that they remain
+
  # runnable over time.  Each tuple in the list contains
+
  #
+
  #    (example_name, do_run).
+
  #
+
  # See test.py for more information.
+
  python_examples = []
+
 
+
=== Open issue review ===
+
 
+
'''Open issue:''' Should tests be built by default, or should they be disabled?
+
In other programs, you typically do a "make test" explicitly.  Here, we
+
could add a "./waf test" explicit command, or we could make it built by
+
default but disabled if users "./waf configure --disable-tests".
+
 
+
* The present situation is that test libraries will be built by default.
+
 
+
'''Open issue:''' Bug 848:  Linux FHS requires version number appended to the
+
library.  Should we start doing this?
+
 
+
* Currently, we are not proposing to fix this for ns-3.11.
+
 
+
'''Open issue:''' Do we want to keep including version number in the ns-3 directory name?
+
 
+
* No change proposed for ns-3.11
+
 
+
'''Open issue:''' Install/uninstall to typical file system locations, e.g.
+
/usr/lib/libns3-simulator.so.3.10
+
/usr/lib/libns3-simulator.so.3 -> /usr/lib/libns3-simulator.so.3.10
+
 
+
* No change proposed for ns-3.11.
+
 
+
'''Open issue:''' Documentation organization.  Proposing that each module
+
contain
+
its .rst file(s) in the module/<modulename>/doc/ directory.  Modules that
+
want to chain up to the main documentation tree can do so by adding
+
themselves
+
to the index.rst.  In the future, when users develop modules in the app
+
store
+
framework, users can choose to chain up to the main manual, or they can
+
provide
+
their own makefiles and even choose their own markup (e.g. latex) if
+
they want, and separate html/pdf can be generated.
+
 
+
* No change proposed for ns-3.11
+
 
+
== Stage 2 Status ==
+
 
+
For the second stage, we have been looking at GNOME jhbuild to build packages at
+
the top-level ns-3-allinone directory.  jhbuild may need to be
+
wrapped by a specialized ns-3 build.py or download.py wrapper.  However, we
+
encountered these limitations so far:
+
# jhbuild has no support for scons
+
# waf support is limited; for instance, controlling configuration options is limited
+
# jhbuild has no support for hierarchical builds: although you can have metamodules, and moduleset includes, there is (AFAIK) no option to say "build only this metamodule".  The options to "start at module X", or "skip module Y" are not sufficient.
+

Revision as of 15:13, 28 March 2017

Main Page - Current Development - Developer FAQ - Tools - Related Projects - Project Ideas - Summer Projects

Installation - Troubleshooting - User FAQ - HOWTOs - Samples - Models - Education - Contributed Code - Papers

Goals

The long-term goal is to move ns-3 to separate modules, for build and maintenance reasons. For build reasons, since ns-3 is becoming large, we would like to allow users to enable/disable subsets of the available model library. For maintenance reasons, it is important that we move to a development model where modules can evolve on different timescales and be maintained by different organizations.

An analogy is the GNOME desktop, which is composed of a number of individual libraries that evolve on their own timescales. A build framework called jhbuild exists for building and managing the dependencies between these disparate projects.

The modular build and integration with bake is described in a separate wiki page and is intended to be enabled for ns-3.27.

Once we have a modular build, and an ability to separately download and install third-party modules, we will need to distinguish the maintenance status or certification of modules. The ns-3 project will maintain a set of core ns-3 modules including those essential for all ns-3 simulations, and will maintain a master build file containing metadata to contributed modules; this will allow users to fetch and build what they need. Eventually, modules will have a maintenance state associated with them describing aspects such as who is the maintainer, whether it is actively maintained, whether it contains documentation or tests, whether it passed an ns-3 project code review, whether it is currently passing the tests, etc. The current status of all known ns-3 modules will be maintained in a database and be browsable on the project web site.

Maintenance-status-example.PNG

Figure caption: Mock-up of future model status page (models and colors selected are just for example purposes)

The basic idea of the ns-3 app store would be to store on a server a set of user-submitted metadata which describes various source code packages. Typical metadata would include:

  • unique name
  • version number
  • last known good ns-3 version (tested against)
  • description
  • download url
  • untar/unzip command
  • configure command
  • build command
  • system prerequisites (if user needs to apt-get install other libraries)
  • list of ns-3 package dependencies (other ns-3 packages which this package depends upon)

This page used to have a list of requirements for a home-grown app store, but lately, we are thinking of adapting the implementation at Cytoscape and tailoring it to ns-3's needs. This is a project idea for the 2017 Google Summer of Code.