## -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*- import os, os.path 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 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', ) 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') 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] def create_ns3_module(bld, name, dependencies=(), test=False): # Create a separate library for this module. if bld.env['ENABLE_STATIC_NS3']: module = bld.new_task_gen('cxx', 'cstaticlib') else: module = bld.new_task_gen('cxx', 'cshlib') if not test: pcfile = bld.new_task_gen('ns3pcfile') pcfile.module = module module.is_ns3_module = True module.name = 'ns3-' + name # Add the proper path to the module's name. module.target = '%s/ns3-%s' % (bld.srcnode.relpath_gen(bld.path), name) # Set the libraries this module depends on. module.uselib_local = ['ns3-' + dep for dep in dependencies] module.module_deps = list(dependencies) if not module.env['ENABLE_STATIC_NS3']: 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") 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/.py exists, it becomes the module frontend, and the C extension befomes _ 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 = "ns3-"+module if pymod.env['ENABLE_STATIC_NS3']: if sys.platform == 'darwin': pymod.env.append_value('LINKFLAGS', '-Wl,-all_load') for mod in pymod.uselib_local: pymod.env.append_value('LINKFLAGS', '-l' + mod) else: pymod.env.append_value('LINKFLAGS', '-Wl,--whole-archive,-Bstatic') for mod in pymod.uselib_local: 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) 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' return [env[path_st] % libdir, env[lib_marker], env[lib_st] % name] 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 = os.path.join('pkgconfig', 'lib%s.pc' % self.module.name) output_node = self.bld.path.find_or_declare(output_filename) task = self.create_task('ns3pcfile', env=self.env) self.bld.install_files(os.path.join('${PREFIX}', 'lib', 'pkgconfig'), output_filename) 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) self.bld.install_files('${PREFIX}/include/ns3', [src_node]) 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': 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 self.bld.install_files('${PREFIX}/include/ns3', ns3_dir_node.find_or_declare("%s-module.h" % self.module)) 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': 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