## -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-
import os, os.path
import sys
import shutil
import types
import warnings
import TaskGen
import Task
import Options
import Build
import Utils
import Constants
import ccroot
ccroot.USE_TOP_LEVEL = True
import wutils
try:
set
except NameError:
from sets import Set as set # Python 2.3 fallback
all_modules = [
'core',
'network',
'config-store',
'internet',
'propagation',
'point-to-point',
'csma',
'emu',
'bridge',
'tap-bridge',
'virtual-net-device',
'applications',
'nix-vector-routing',
'olsr',
'aodv',
'dsdv',
'click',
'openflow',
'mobility',
'wifi',
'netanim',
'stats',
'uan',
'spectrum',
'mesh',
'test',
'test/ns3tcp',
'test/ns3wifi',
'flow-monitor',
'wimax',
'lte',
'mpi',
'topology-read',
'energy',
'tools',
'visualizer',
'point-to-point-layout',
'csma-layout',
'template',
'buildings',
]
def set_options(opt):
opt.sub_options('core')
opt.sub_options('click')
opt.sub_options('openflow')
opt.add_option('--enable-rpath',
help=("Link programs with rpath"
" (normally not needed, see "
" --run and --shell; moreover, only works in some"
" specific platforms, such as Linux and Solaris)"),
action="store_true", dest='enable_rpath', default=False)
opt.add_option('--enable-modules',
help=("Build only these modules (and dependencies)"),
dest='enable_modules')
def configure(conf):
conf.sub_config('core')
conf.sub_config('emu')
conf.sub_config('tap-bridge')
conf.sub_config('config-store')
conf.sub_config('internet')
conf.sub_config('netanim')
conf.sub_config('test')
conf.sub_config('click')
conf.sub_config('openflow')
conf.sub_config('stats')
conf.sub_config('visualizer')
blddir = os.path.abspath(os.path.join(conf.blddir, conf.env.variant()))
conf.env.append_value('NS3_MODULE_PATH', blddir)
if Options.options.enable_rpath:
conf.env.append_value('RPATH', '-Wl,-rpath=%s' % (os.path.join(blddir),))
## Used to link the 'test-runner' program with all of ns-3 code
conf.env['NS3_MODULES'] = ['ns3-' + module.split('/')[-1] for module in all_modules]
class ns3module_taskgen(TaskGen.task_gen):
def __init__(self, *args, **kwargs):
super(ns3module_taskgen, self).__init__(*args, **kwargs)
self.libs = []
def apply(self):
static_enabled = False
shared_enabled = True
bld = self.bld
if bld.env['ENABLE_STATIC_NS3']:
static_enabled = True
shared_enabled = False
if bld.env['ENABLE_SHARED_AND_STATIC_NS3']:
static_enabled = True
shared_enabled = True
assert self.name.startswith("ns3-")
name = self.name.split("ns3-")[1]
if static_enabled:
static = self._create_ns3_module(self.bld, name, self.dependencies, True)
self.libs.append(static)
else:
static = None
if shared_enabled:
shared = self._create_ns3_module(self.bld, name, self.dependencies, False)
self.libs.append(shared)
else:
shared = None
if static is not None and shared is None:
static.name = self.name + "--lib"
static.uselib_local = ['ns3-%s--lib' % (dep,) for dep in self.dependencies]
elif shared is not None and static is None:
shared.name = self.name + "--lib"
shared.uselib_local = ['ns3-%s--lib' % (dep,) for dep in self.dependencies]
else:
shared.name = self.name + "--lib"
shared.uselib_local = ['ns3-%s--lib' % (dep,) for dep in self.dependencies]
static.name = self.name + "--static"
static.uselib_local = ['ns3-%s--static' % (dep,) for dep in self.dependencies]
if not self.test:
pcfile = bld.new_task_gen('ns3pcfile')
pcfile.module = self
def _create_ns3_module(self, bld, name, dependencies, static):
# FIXME: env modifications are overwritten by parent caller
# Create a separate library for this module.
if static:
module = bld.new_task_gen('cxx', 'cstaticlib')
else:
module = bld.new_task_gen('cxx', 'cshlib')
module.source = self.source
module.env = self.env.copy()
features = list(self.features)
features.remove("ns3module")
module.features.extend(features)
module.path = self.path
module.uselib = self.uselib
if hasattr(self, 'includes'):
module.includes = self.includes
if hasattr(self, "is_ns3_module"):
module.is_ns3_module = self.is_ns3_module
module.is_static = static
module.vnum = wutils.VNUM
# Add the proper path to the module's name.
module.target = '%s/ns3-%s' % (bld.srcnode.relpath_gen(self.path), name)
# Set the libraries this module depends on.
module.module_deps = list(dependencies)
if not static:
module.env.append_value('CXXFLAGS', module.env['shlib_CXXFLAGS'])
module.env.append_value('CCFLAGS', module.env['shlib_CXXFLAGS'])
# Turn on the link flags for shared libraries if we have the
# proper compiler and platform.
if module.env['CXX_NAME'] in ['gcc', 'icc'] and module.env['WL_SONAME_SUPPORTED']:
# Get the module library name without any relative paths
# at its beginning because all of the libraries will end
# up in the same directory.
module_library_name = os.path.basename(ccroot.get_target_name(module))
module.env.append_value('LINKFLAGS', '-Wl,--soname=%s' % module_library_name)
elif module.env['CXX_NAME'] in ['gcc', 'icc'] and \
os.uname()[4] == 'x86_64' and \
module.env['ENABLE_PYTHON_BINDINGS']:
# enable that flag for static builds only on x86-64 platforms
# when gcc is present and only when we want python bindings
# (it's more efficient to not use this option if we can avoid it)
module.env.append_value('CXXFLAGS', '-mcmodel=large')
module.env.append_value('CCFLAGS', '-mcmodel=large')
module.env.append_value('CXXDEFINES', "NS3_MODULE_COMPILATION")
module.env.append_value('CCDEFINES', "NS3_MODULE_COMPILATION")
module.install_path = "${LIBDIR}"
return module
def create_ns3_module(bld, name, dependencies=(), test=False):
module = bld.new_task_gen('ns3module')
module.bld = bld
module.name = "ns3-" + name
module.dependencies = dependencies
# Initially create an empty value for this because the pcfile
# writing task assumes every module has a uselib attribute.
module.uselib = ''
module.uselib_local = ['ns3-' + dep for dep in dependencies]
module.module_deps = list(dependencies)
module.test = test
module.is_ns3_module = True
return module
def create_ns3_module_test_library(bld, name):
# Create an ns3 module for the test library that depends only on
# the module being tested.
library_name = name + "-test"
library = bld.create_ns3_module(library_name, [name], test = True)
# Modify attributes for the test library that are different from a
# normal module.
del library.is_ns3_module
library.is_ns3_module_test_library = True
library.module_name = 'ns3-' + name
# Add this module and test library to the list.
bld.env.append_value('NS3_MODULES_WITH_TEST_LIBRARIES', (library.module_name, library.name))
# Set the include path from the build directory to modules.
relative_path_from_build_to_here = bld.path.relpath_gen(bld.bldnode)
include_flag = '-I' + relative_path_from_build_to_here
library.env.append_value('CXXFLAGS', include_flag)
library.env.append_value('CCFLAGS', include_flag)
return library
def create_obj(bld, *args):
warnings.warn("(in %s) Use bld.new_task_gen(...) now, instead of bld.create_obj(...)" % str(bld.path),
DeprecationWarning, stacklevel=2)
return bld.new_task_gen(*args)
def ns3_python_bindings(bld):
# this method is called from a module wscript, so remember bld.path is not bindings/python!
module_abs_src_path = bld.path.abspath()
module = os.path.basename(module_abs_src_path)
env = bld.env
env.append_value("MODULAR_BINDINGS_MODULES", "ns3-"+module)
if not env['ENABLE_PYTHON_BINDINGS']:
return
if env['BINDINGS_TYPE'] not in ('modular', 'both'):
return
bindings_dir = bld.path.find_dir("bindings")
if bindings_dir is None or not os.path.exists(bindings_dir.abspath()):
warnings.warn("(in %s) Requested to build modular python bindings, but apidefs dir not found "
"=> skipped the bindings." % str(bld.path),
Warning, stacklevel=2)
return
if ("ns3-%s" % (module,)) not in env.NS3_ENABLED_MODULES:
#print "bindings for module %s which is not enabled, skip" % module
return
env.append_value('PYTHON_MODULES_BUILT', module)
apidefs = env['PYTHON_BINDINGS_APIDEFS'].replace("-", "_")
#debug = ('PYBINDGEN_DEBUG' in os.environ)
debug = True # XXX
source = [bld.srcnode.find_resource('bindings/python/ns3modulegen-modular.py').relpath_gen(bld.path),
"bindings/modulegen__%s.py" % apidefs]
if bindings_dir.find_resource("modulegen_customizations.py") is not None:
source.append("bindings/modulegen_customizations.py")
# the local customization file may or not exist
if bld.path.find_resource("bindings/modulegen_local.py"):
source.append("bindings/modulegen_local.py")
module_py_name = module.replace('-', '_')
module_target_dir = bld.srcnode.find_dir("bindings/python/ns").relpath_gen(bld.path)
# if bindings/<module>.py exists, it becomes the module frontend, and the C extension befomes _<module>
if bld.path.find_resource("bindings/%s.py" % (module_py_name,)) is not None:
bld.new_task_gen(
features='copy',
source=("bindings/%s.py" % (module_py_name,)),
target=('%s/%s.py' % (module_target_dir, module_py_name)))
extension_name = '_%s' % (module_py_name,)
else:
extension_name = module_py_name
target = ['bindings/ns3module.cc', 'bindings/ns3module.h', 'bindings/ns3modulegen.log']
#if not debug:
# target.append('ns3modulegen.log')
argv = ['NS3_ENABLED_FEATURES=${FEATURES}', '${PYTHON}']
#if debug:
# argv.extend(["-m", "pdb"])
argv.extend(['${SRC[0]}', module_abs_src_path, apidefs, extension_name, '${TGT[0]}'])
argv.extend(['2>', '${TGT[2]}']) # 2> ns3modulegen.log
features = []
for (name, caption, was_enabled, reason_not_enabled) in env['NS3_OPTIONAL_FEATURES']:
if was_enabled:
features.append(name)
bindgen = bld.new_task_gen('command', source=source, target=target, command=argv)
bindgen.env['FEATURES'] = ','.join(features)
bindgen.dep_vars = ['FEATURES']
bindgen.before = 'cxx'
bindgen.after = 'gen_ns3_module_header_task'
bindgen.name = "pybindgen(ns3 module %s)" % module
# generate the extension module
pymod = bld.new_task_gen(features='cxx cshlib pyext')
pymod.source = ['bindings/ns3module.cc']
pymod.target = '%s/%s' % (module_target_dir, extension_name)
pymod.name = 'ns3module_%s' % module
pymod.uselib_local = ["%s--lib" % mod for mod in pymod.env['NS3_ENABLED_MODULES']] # Should be '"ns3-"+module', but see bug 1117
if pymod.env['ENABLE_STATIC_NS3']:
if sys.platform == 'darwin':
pymod.env.append_value('LINKFLAGS', '-Wl,-all_load')
for mod in pymod.uselib_local:
mod = mod.split("--lib")[0]
pymod.env.append_value('LINKFLAGS', '-l' + mod)
else:
pymod.env.append_value('LINKFLAGS', '-Wl,--whole-archive,-Bstatic')
for mod in pymod.uselib_local:
mod = mod.split("--lib")[0]
pymod.env.append_value('LINKFLAGS', '-l' + mod)
pymod.env.append_value('LINKFLAGS', '-Wl,-Bdynamic,--no-whole-archive')
defines = list(pymod.env['CXXDEFINES'])
defines.extend(['NS_DEPRECATED=', 'NS3_DEPRECATED_H'])
if Options.platform == 'win32':
try:
defines.remove('_DEBUG') # causes undefined symbols on win32
except ValueError:
pass
pymod.env['CXXDEFINES'] = defines
pymod.includes = 'bindings'
return pymod
def build(bld):
bld.create_ns3_module = types.MethodType(create_ns3_module, bld)
bld.create_ns3_module_test_library = types.MethodType(create_ns3_module_test_library, bld)
bld.create_obj = types.MethodType(create_obj, bld)
bld.ns3_python_bindings = types.MethodType(ns3_python_bindings, bld)
# Remove these modules from the list of all modules.
for not_built in bld.env['MODULES_NOT_BUILT']:
# XXX Becaue these modules are located in subdirectories of
# test, their names in the all_modules list include the extra
# relative path "test/". If these modules are moved into the
# src directory, then this if block should be removed.
if not_built == 'ns3tcp' or not_built == 'ns3wifi':
not_built = 'test/' + not_built
if not_built in all_modules:
all_modules.remove(not_built)
bld.add_subdirs(list(all_modules))
for module in all_modules:
modheader = bld.new_task_gen('ns3moduleheader')
modheader.module = module.split('/')[-1]
class ns3pcfile_task(Task.Task):
after = 'cc cxx'
def __str__(self):
"string to display to the user"
tgt_str = ' '.join([a.nice_path(self.env) for a in self.outputs])
return 'pcfile: %s\n' % (tgt_str)
def runnable_status(self):
return super(ns3pcfile_task, self).runnable_status()
def _self_libs(self, env, name, libdir):
if env['ENABLE_STATIC_NS3']:
path_st = 'STATICLIBPATH_ST'
lib_st = 'STATICLIB_ST'
lib_marker = 'STATICLIB_MARKER'
else:
path_st = 'LIBPATH_ST'
lib_st = 'LIB_ST'
lib_marker = 'SHLIB_MARKER'
retval = [env[path_st] % libdir,
env[lib_marker],
env[lib_st] % name]
return retval
def _lib(self, env, dep):
libpath = env['LIBPATH_%s' % dep]
linkflags = env['LINKFLAGS_%s' % dep]
libs = env['LIB_%s' % dep]
retval = []
for path in libpath:
retval.append(env['LIBPATH_ST'] % path)
retval = retval + linkflags
for lib in libs:
retval.append(env['LIB_ST'] % lib)
return retval
def _listify(self, v):
if isinstance(v, list):
return v
else:
return [v]
def _cflags(self, dep):
flags = self.env['CFLAGS_%s' % dep]
return self._listify(flags)
def _cxxflags(self, dep):
return self._listify(self.env['CXXFLAGS_%s' % dep])
def _defines(self, dep):
defines = self.env['CCDEFINES_%s' % dep] + self.env['CXXDEFINES_%s' % dep]
return [self.env['CCDEFINES_ST'] % define for define in self.env['CCDEFINES_%s' % dep]] + \
[self.env['CXXDEFINES_ST'] % define for define in self.env['CXXDEFINES_%s' % dep]]
def _includes(self, dep):
includes = self.env['CPPPATH_%s' % dep]
return [self.env['CPPPATH_ST'] % include for include in includes]
def _generate_pcfile(self, name, use, uselib_local, prefix, outfilename):
outfile = open(outfilename, 'w')
includedir = os.path.join(prefix, 'include')
libdir = os.path.join(prefix, 'lib')
libs = self._self_libs(self.env, name, '${libdir}')
for dep in use:
libs = libs + self._lib(self.env, dep)
for dep in uselib_local:
libs = libs + [self.env['LIB_ST'] % dep]
cflags = [self.env['CPPPATH_ST'] % '${includedir}']
for dep in use:
cflags = cflags + self._cflags(dep) + self._cxxflags(dep) + \
self._defines(dep) + self._includes(dep)
print >> outfile, """
prefix=%s
libdir=%s
includedir=%s
Name: lib%s
Description: ns-3 module %s
Version: devel
Libs: %s
Cflags: %s
""" % (prefix, libdir, includedir,
name, name, ' '.join(libs), ' '.join(cflags))
outfile.close()
def run(self):
output_filename = self.outputs[0].bldpath(self.env)
self._generate_pcfile(self.module.name, self.module.uselib,
self.module.uselib_local,
self.env['PREFIX'], output_filename)
class ns3pcfile_taskgen(TaskGen.task_gen):
def __init__(self, *args, **kwargs):
super(ns3pcfile_taskgen, self).__init__(*args, **kwargs)
def apply(self):
output_filename = 'lib%s.pc' % self.module.name
output_node = self.path.find_or_declare(output_filename)
assert output_node is not None, str(self)
task = self.create_task('ns3pcfile', env=self.env)
self.bld.install_files(os.path.join('${PREFIX}', 'lib', 'pkgconfig'),
output_node)
task.set_outputs([output_node])
task.module = self.module
class ns3header_taskgen(TaskGen.task_gen):
"""A set of NS-3 header files"""
COLOR = 'BLUE'
def __init__(self, *args, **kwargs):
super(ns3header_taskgen, self).__init__(*args, **kwargs)
self.install_path = None
self.sub_dir = None # if not None, header files will be published as ns3/sub_dir/file.h
self.module = None # module name
self.mode = 'install'
def apply(self):
for filename in set(self.to_list(self.source)):
src_node = self.path.find_resource(filename)
if self.module is None:
raise Utils.WafError("'module' missing on ns3headers object %s" % self)
ns3_dir_node = self.bld.path.find_dir("ns3")
if self.sub_dir is not None:
ns3_dir_node = ns3_dir_node.find_dir(self.sub_dir)
for filename in set(self.to_list(self.source)):
src_node = self.path.find_resource(filename)
if src_node is None:
raise Utils.WafError("source ns3 header file %s not found" % (filename,))
dst_node = ns3_dir_node.find_or_declare(os.path.basename(filename))
assert dst_node is not None
task = self.create_task('ns3header', env=self.env)
task.mode = self.mode
if self.mode == 'install':
self.bld.install_files('${PREFIX}/include/ns3', [src_node])
task.set_inputs([src_node])
task.set_outputs([dst_node])
else:
task.header_to_remove = dst_node
class ns3header_task(Task.Task):
before = 'cc cxx gen_ns3_module_header_task'
color = 'BLUE'
def __str__(self):
"string to display to the user"
env = self.env
src_str = ' '.join([a.nice_path(env) for a in self.inputs])
tgt_str = ' '.join([a.nice_path(env) for a in self.outputs])
if self.outputs: sep = ' -> '
else: sep = ''
if self.mode == 'remove':
return 'rm-ns3-header %s\n' % (self.header_to_remove.bldpath(self.env),)
return 'install-ns3-header: %s%s%s\n' % (src_str, sep, tgt_str)
def runnable_status(self):
if self.mode == 'remove':
if os.path.exists(self.header_to_remove.bldpath(self.env)):
return Constants.RUN_ME
else:
return Constants.SKIP_ME
else:
return super(ns3header_task, self).runnable_status()
def run(self):
if self.mode == 'install':
assert len(self.inputs) == len(self.outputs)
inputs = [node.srcpath(self.env) for node in self.inputs]
outputs = [node.bldpath(self.env) for node in self.outputs]
for src, dst in zip(inputs, outputs):
try:
os.chmod(dst, 0600)
except OSError:
pass
shutil.copy2(src, dst)
## make the headers in builddir read-only, to prevent
## accidental modification
os.chmod(dst, 0400)
return 0
else:
assert len(self.inputs) == 0
assert len(self.outputs) == 0
out_file_name = self.header_to_remove.bldpath(self.env)
try:
os.unlink(out_file_name)
except OSError, ex:
if ex.errno != 2:
raise
return 0
class gen_ns3_module_header_task(Task.Task):
before = 'cc cxx'
after = 'ns3header_task'
color = 'BLUE'
def runnable_status(self):
if self.mode == 'remove':
if os.path.exists(self.header_to_remove.bldpath(self.env)):
return Constants.RUN_ME
else:
return Constants.SKIP_ME
else:
return super(gen_ns3_module_header_task, self).runnable_status()
def __str__(self):
"string to display to the user"
env = self.env
src_str = ' '.join([a.nice_path(env) for a in self.inputs])
tgt_str = ' '.join([a.nice_path(env) for a in self.outputs])
if self.outputs: sep = ' -> '
else: sep = ''
if self.mode == 'remove':
return 'rm-module-header %s\n' % (self.header_to_remove.bldpath(self.env),)
return 'gen-module-header: %s%s%s\n' % (src_str, sep, tgt_str)
def run(self):
if self.mode == 'remove':
assert len(self.inputs) == 0
assert len(self.outputs) == 0
out_file_name = self.header_to_remove.bldpath(self.env)
try:
os.unlink(out_file_name)
except OSError, ex:
if ex.errno != 2:
raise
return 0
assert len(self.outputs) == 1
out_file_name = self.outputs[0].bldpath(self.env)
header_files = [os.path.basename(node.abspath(self.env)) for node in self.inputs]
outfile = file(out_file_name, "w")
header_files.sort()
print >> outfile, """
#ifdef NS3_MODULE_COMPILATION
# error "Do not include ns3 module aggregator headers from other modules; these are meant only for end user scripts."
#endif
#ifndef NS3_MODULE_%s
""" % (self.module.upper().replace('-', '_'),)
# if self.module_deps:
# print >> outfile, "// Module dependencies:"
# for dep in self.module_deps:
# print >> outfile, "#include \"%s-module.h\"" % dep
print >> outfile
print >> outfile, "// Module headers:"
for header in header_files:
print >> outfile, "#include \"%s\"" % (header,)
print >> outfile, "#endif"
outfile.close()
return 0
def sig_explicit_deps(self):
self.m.update('\n'.join([node.abspath(self.env) for node in self.inputs]))
return self.m.digest()
def unique_id(self):
try:
return self.uid
except AttributeError:
"this is not a real hot zone, but we want to avoid surprizes here"
m = Utils.md5()
m.update("ns-3-module-header-%s" % self.module)
self.uid = m.digest()
return self.uid
class ns3moduleheader_taskgen(TaskGen.task_gen):
"""
Generates a 'ns3/foo-module.h' header file that includes all
public ns3 headers of a certain module.
"""
COLOR = 'BLUE'
def __init__(self, *args, **kwargs):
super(ns3moduleheader_taskgen, self).__init__(*args, **kwargs)
self.mode = 'install'
def apply(self):
## get all of the ns3 headers
ns3_dir_node = self.bld.path.find_dir("ns3")
all_headers_inputs = []
found_the_module = False
for ns3headers in self.bld.all_task_gen:
if isinstance(ns3headers, ns3header_taskgen):
if ns3headers.module != self.module:
continue
found_the_module = True
for source in set(ns3headers.to_list(ns3headers.source)):
source = os.path.basename(source)
node = ns3_dir_node.find_or_declare(os.path.basename(source))
if node is None:
fatal("missing header file %s" % (source,))
all_headers_inputs.append(node)
if not found_the_module:
raise Utils.WscriptError("error finding headers for module %s" % self.module)
if not all_headers_inputs:
return
all_headers_outputs = [ns3_dir_node.find_or_declare("%s-module.h" % self.module)]
task = self.create_task('gen_ns3_module_header', env=self.env)
task.module = self.module
task.mode = self.mode
if self.mode == 'install':
self.bld.install_files('${PREFIX}/include/ns3',
ns3_dir_node.find_or_declare("%s-module.h" % self.module))
task.set_inputs(all_headers_inputs)
task.set_outputs(all_headers_outputs)
module_obj = self.bld.name_to_obj("ns3-" + self.module, self.env)
assert module_obj is not None, self.module
task.module_deps = module_obj.module_deps
else:
task.header_to_remove = all_headers_outputs[0]
def install(self):
pass