import os, sys, inspect
-VERSION="2.0.22"
+VERSION="2.0.23"
REVISION="x"
GIT="x"
INSTALL="x"
from waflib import Scripting
Scripting.waf_entry_point(cwd, VERSION, wafdir[0])
-
os.environ['PYTHONUNBUFFERED'] = '1'
-if Context.HEXVERSION not in (0x2001600,):
+if Context.HEXVERSION not in (0x2001700,):
Logs.error('''
Please use the version of waf that comes with Samba, not
a system installed version. See http://wiki.samba.org/index.php/Waf
import imp
# the following 3 constants are updated on each new release (do not touch)
-HEXVERSION=0x2001600
+HEXVERSION=0x2001700
"""Constant updated on new releases"""
-WAFVERSION="2.0.22"
+WAFVERSION="2.0.23"
"""Constant updated on new releases"""
-WAFREVISION="816d5bc48ba2abc4ac22f2b44d94d322bf992b9c"
+WAFREVISION="cc6b34cf555d354c34f554c41206134072588de7"
"""Git revision when the waf version is updated"""
WAFNAME="waf"
"""Task to execute"""
self.spawner = spawner
"""Coordinator object"""
- self.setDaemon(1)
+ self.daemon = True
self.start()
def run(self):
"""
""":py:class:`waflib.Runner.Parallel` producer instance"""
self.sem = Utils.threading.Semaphore(master.numjobs)
"""Bounded semaphore that prevents spawning more than *n* concurrent consumers"""
- self.setDaemon(1)
+ self.daemon = True
self.start()
def run(self):
"""
cls.scan = self.scan
elif has_deps:
def scan(self):
- nodes = []
- for x in self.generator.to_list(getattr(self.generator, 'deps', None)):
- node = self.generator.path.find_resource(x)
- if not node:
- self.generator.bld.fatal('Could not find %r (was it declared?)' % x)
- nodes.append(node)
+ deps = getattr(self.generator, 'deps', None)
+ nodes = self.generator.to_nodes(deps)
return [nodes, []]
cls.scan = scan
'__sh__' : 'sh',
'__xtensa__' : 'xtensa',
'__e2k__' : 'e2k',
+'__riscv' : 'riscv',
}
@conf
from waflib.Logs import debug
c_compiler = {
-'win32': ['msvc', 'gcc', 'clang'],
-'cygwin': ['gcc', 'clang'],
-'darwin': ['clang', 'gcc'],
-'aix': ['xlc', 'gcc', 'clang'],
-'linux': ['gcc', 'clang', 'icc'],
-'sunos': ['suncc', 'gcc'],
-'irix': ['gcc', 'irixcc'],
-'hpux': ['gcc'],
-'osf1V': ['gcc'],
-'gnu': ['gcc', 'clang'],
-'java': ['gcc', 'msvc', 'clang', 'icc'],
-'default':['clang', 'gcc'],
+'win32': ['msvc', 'gcc', 'clang'],
+'cygwin': ['gcc', 'clang'],
+'darwin': ['clang', 'gcc'],
+'aix': ['xlc', 'gcc', 'clang'],
+'linux': ['gcc', 'clang', 'icc'],
+'sunos': ['suncc', 'gcc'],
+'irix': ['gcc', 'irixcc'],
+'hpux': ['gcc'],
+'osf1V': ['gcc'],
+'gnu': ['gcc', 'clang'],
+'java': ['gcc', 'msvc', 'clang', 'icc'],
+'gnukfreebsd': ['gcc', 'clang'],
+'default': ['clang', 'gcc'],
}
"""
Dict mapping platform names to Waf tools finding specific C compilers::
from waflib.Logs import debug
cxx_compiler = {
-'win32': ['msvc', 'g++', 'clang++'],
-'cygwin': ['g++', 'clang++'],
-'darwin': ['clang++', 'g++'],
-'aix': ['xlc++', 'g++', 'clang++'],
-'linux': ['g++', 'clang++', 'icpc'],
-'sunos': ['sunc++', 'g++'],
-'irix': ['g++'],
-'hpux': ['g++'],
-'osf1V': ['g++'],
-'gnu': ['g++', 'clang++'],
-'java': ['g++', 'msvc', 'clang++', 'icpc'],
-'default': ['clang++', 'g++']
+'win32': ['msvc', 'g++', 'clang++'],
+'cygwin': ['g++', 'clang++'],
+'darwin': ['clang++', 'g++'],
+'aix': ['xlc++', 'g++', 'clang++'],
+'linux': ['g++', 'clang++', 'icpc'],
+'sunos': ['sunc++', 'g++'],
+'irix': ['g++'],
+'hpux': ['g++'],
+'osf1V': ['g++'],
+'gnu': ['g++', 'clang++'],
+'java': ['g++', 'msvc', 'clang++', 'icpc'],
+'gnukfreebsd': ['g++', 'clang++'],
+'default': ['clang++', 'g++']
}
"""
Dict mapping the platform names to Waf tools finding specific C++ compilers::
if not result:
path = [os.path.join(dct['prefix'], "libs")]
- conf.to_log("\n\n# try again with -L$prefix/libs, and pythonXY name rather than pythonX.Y (win32)\n")
+ conf.to_log("\n\n# try again with -L$prefix/libs, and pythonXY rather than pythonX.Y (win32)\n")
result = conf.check(lib=name, uselib='PYEMBED', libpath=path, mandatory=False, msg='Checking for library %s in $prefix/libs' % name)
+ if not result:
+ path = [os.path.normpath(os.path.join(dct['INCLUDEPY'], '..', 'libs'))]
+ conf.to_log("\n\n# try again with -L$INCLUDEPY/../libs, and pythonXY rather than pythonX.Y (win32)\n")
+ result = conf.check(lib=name, uselib='PYEMBED', libpath=path, mandatory=False, msg='Checking for library %s in $INCLUDEPY/../libs' % name)
+
if result:
break # do not forget to set LIBPATH_PYEMBED
pat = self.env.cxxstlib_PATTERN
if Utils.unversioned_sys_platform() == 'darwin':
pat = r"%s\.framework"
- re_qt = re.compile(pat % 'Qt5?(?P<name>\\D+)' + '$')
- for x in dirlst:
+ re_qt = re.compile(pat % 'Qt5?(?P<name>\\w+)' + '$')
+ for x in sorted(dirlst):
m = re_qt.match(x)
if m:
self.qt5_vars.append("Qt5%s" % m.group('name'))
"Process *.rc* files for C/C++: X{.rc -> [.res|.rc.o]}"
+import os
import re
from waflib import Task
from waflib.TaskGen import extension
from waflib.Tools import c_preproc
+from waflib import Utils
@extension('.rc')
def rc_file(self, node):
tmp.start(self.inputs[0], self.env)
return (tmp.nodes, tmp.names)
+ def exec_command(self, cmd, **kw):
+ if self.env.WINRC_TGT_F == '/fo':
+ # Since winres include paths may contain spaces, they do not fit in
+ # response files and are best passed as environment variables
+ replace_cmd = []
+ incpaths = []
+ while cmd:
+ # filter include path flags
+ flag = cmd.pop(0)
+ if flag.upper().startswith('/I'):
+ if len(flag) == 2:
+ incpaths.append(cmd.pop(0))
+ else:
+ incpaths.append(flag[2:])
+ else:
+ replace_cmd.append(flag)
+ cmd = replace_cmd
+ if incpaths:
+ # append to existing environment variables in INCLUDE
+ env = kw['env'] = dict(kw.get('env') or self.env.env or os.environ)
+ pre_includes = env.get('INCLUDE', '')
+ env['INCLUDE'] = pre_includes + os.pathsep + os.pathsep.join(incpaths)
+
+ return super(winrc, self).exec_command(cmd, **kw)
+
+ def quote_flag(self, flag):
+ if self.env.WINRC_TGT_F == '/fo':
+ # winres does not support quotes around flags in response files
+ return flag
+
+ return super(winrc, self).quote_flag(flag)
+
+
def configure(conf):
"""
Detects the programs RC or windres, depending on the C/C++ compiler in use
Invoke clangdb command before build
"""
if self.cmd.startswith('build'):
- Scripting.run_command('clangdb')
+ Scripting.run_command(self.cmd.replace('build','clangdb'))
old_execute_build(self)
--- /dev/null
+#!/usr/bin/env python
+# encoding: utf-8
+# Thomas Nagy, 2021 (ita)
+
+from waflib import Utils, Runner
+
+"""
+Re-enable the classic threading system from waf 1.x
+
+def configure(conf):
+ conf.load('classic_runner')
+"""
+
+class TaskConsumer(Utils.threading.Thread):
+ """
+ Task consumers belong to a pool of workers
+
+ They wait for tasks in the queue and then use ``task.process(...)``
+ """
+ def __init__(self, spawner):
+ Utils.threading.Thread.__init__(self)
+ """
+ Obtain :py:class:`waflib.Task.TaskBase` instances from this queue.
+ """
+ self.spawner = spawner
+ self.daemon = True
+ self.start()
+
+ def run(self):
+ """
+ Loop over the tasks to execute
+ """
+ try:
+ self.loop()
+ except Exception:
+ pass
+
+ def loop(self):
+ """
+ Obtain tasks from :py:attr:`waflib.Runner.TaskConsumer.ready` and call
+ :py:meth:`waflib.Task.TaskBase.process`. If the object is a function, execute it.
+ """
+ master = self.spawner.master
+ while 1:
+ if not master.stop:
+ try:
+ tsk = master.ready.get()
+ if tsk:
+ tsk.log_display(tsk.generator.bld)
+ master.process_task(tsk)
+ else:
+ break
+ finally:
+ master.out.put(tsk)
+
+class Spawner(object):
+ """
+ Daemon thread that consumes tasks from :py:class:`waflib.Runner.Parallel` producer and
+ spawns a consuming thread :py:class:`waflib.Runner.Consumer` for each
+ :py:class:`waflib.Task.Task` instance.
+ """
+ def __init__(self, master):
+ self.master = master
+ """:py:class:`waflib.Runner.Parallel` producer instance"""
+
+ self.pool = [TaskConsumer(self) for i in range(master.numjobs)]
+
+Runner.Spawner = Spawner
func = frame.f_code.co_name
if func == 'exec_command':
cmd = frame.f_locals.get('cmd')
- if isinstance(cmd, list) and ('gcc' in cmd[0] or 'g++' in cmd[0]):
+ if isinstance(cmd, list) and (len(cmd) > 0) and ('gcc' in cmd[0] or 'g++' in cmd[0]):
lines = []
for line in rec.msg.splitlines():
if 'warning: ' in line:
def options(opt):
opt.load('eclipse')
+To add additional targets beside standard ones (configure, dist, install, check)
+the environment ECLIPSE_EXTRA_TARGETS can be set (ie. to ['test', 'lint', 'docs'])
+
$ waf configure eclipse
"""
cdt_bld = oe_cdt + '.build.core'
extbuilder_dir = '.externalToolBuilders'
extbuilder_name = 'Waf_Builder.launch'
+settings_dir = '.settings'
+settings_name = 'language.settings.xml'
class eclipse(Build.BuildContext):
cmd = 'eclipse'
path = p.path_from(self.srcnode)
if (path.startswith("/")):
- cpppath.append(path)
+ if path not in cpppath:
+ cpppath.append(path)
else:
- workspace_includes.append(path)
+ if path not in workspace_includes:
+ workspace_includes.append(path)
if is_cc and path not in source_dirs:
source_dirs.append(path)
project = self.impl_create_javaproject(javasrcpath, javalibpath)
self.write_conf_to_xml('.classpath', project)
+ # Create editor language settings to have correct standards applied in IDE, as per project configuration
+ try:
+ os.mkdir(settings_dir)
+ except OSError:
+ pass # Ignore if dir already exists
+
+ lang_settings = Document()
+ project = lang_settings.createElement('project')
+
+ # Language configurations for C and C++ via cdt
+ if hasc:
+ configuration = self.add(lang_settings, project, 'configuration',
+ {'id' : 'org.eclipse.cdt.core.default.config.1', 'name': 'Default'})
+
+ extension = self.add(lang_settings, configuration, 'extension', {'point': 'org.eclipse.cdt.core.LanguageSettingsProvider'})
+
+ provider = self.add(lang_settings, extension, 'provider',
+ { 'copy-of': 'extension',
+ 'id': 'org.eclipse.cdt.ui.UserLanguageSettingsProvider'})
+
+ provider = self.add(lang_settings, extension, 'provider-reference',
+ { 'id': 'org.eclipse.cdt.core.ReferencedProjectsLanguageSettingsProvider',
+ 'ref': 'shared-provider'})
+
+ provider = self.add(lang_settings, extension, 'provider-reference',
+ { 'id': 'org.eclipse.cdt.managedbuilder.core.MBSLanguageSettingsProvider',
+ 'ref': 'shared-provider'})
+
+ # C and C++ are kept as separated providers so appropriate flags are used also in mixed projects
+ if self.env.CC:
+ provider = self.add(lang_settings, extension, 'provider',
+ { 'class': 'org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector',
+ 'console': 'false',
+ 'id': 'org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector.1',
+ 'keep-relative-paths' : 'false',
+ 'name': 'CDT GCC Built-in Compiler Settings',
+ 'parameter': '%s %s ${FLAGS} -E -P -v -dD "${INPUTS}"'%(self.env.CC[0],' '.join(self.env['CFLAGS'])),
+ 'prefer-non-shared': 'true' })
+
+ self.add(lang_settings, provider, 'language-scope', { 'id': 'org.eclipse.cdt.core.gcc'})
+
+ if self.env.CXX:
+ provider = self.add(lang_settings, extension, 'provider',
+ { 'class': 'org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector',
+ 'console': 'false',
+ 'id': 'org.eclipse.cdt.managedbuilder.language.settings.providers.GCCBuiltinSpecsDetector.2',
+ 'keep-relative-paths' : 'false',
+ 'name': 'CDT GCC Built-in Compiler Settings',
+ 'parameter': '%s %s ${FLAGS} -E -P -v -dD "${INPUTS}"'%(self.env.CXX[0],' '.join(self.env['CXXFLAGS'])),
+ 'prefer-non-shared': 'true' })
+ self.add(lang_settings, provider, 'language-scope', { 'id': 'org.eclipse.cdt.core.g++'})
+
+ lang_settings.appendChild(project)
+ self.write_conf_to_xml('%s%s%s'%(settings_dir, os.path.sep, settings_name), lang_settings)
+
def impl_create_project(self, executable, appname, hasc, hasjava, haspython, waf_executable):
doc = Document()
projectDescription = doc.createElement('projectDescription')
addTargetWrap('dist', False)
addTargetWrap('install', False)
addTargetWrap('check', False)
+ for addTgt in self.env.ECLIPSE_EXTRA_TARGETS or []:
+ addTargetWrap(addTgt, False)
storageModule = self.add(doc, cproject, 'storageModule',
{'moduleId': 'cdtBuildSystem',
self.add(doc, storageModule, 'project', {'id': '%s.null.1'%appname, 'name': appname})
+ storageModule = self.add(doc, cproject, 'storageModule',
+ {'moduleId': 'org.eclipse.cdt.core.LanguageSettingsProviders'})
+
+ storageModule = self.add(doc, cproject, 'storageModule',
+ {'moduleId': 'scannerConfiguration'})
+
doc.appendChild(cproject)
return doc
# Third-party tools are allowed to add extra names in here with append()
supported_compilers = ['gas', 'gcc', 'icc', 'clang']
-def scan(self):
- if not self.__class__.__name__ in self.env.ENABLE_GCCDEPS:
- return super(self.derived_gccdeps, self).scan()
- nodes = self.generator.bld.node_deps.get(self.uid(), [])
- names = []
- return (nodes, names)
-
re_o = re.compile(r"\.o$")
re_splitter = re.compile(r'(?<!\\)\s+') # split by space, except when spaces are escaped
else:
# Not hashable, assume it is a list and join into a string
node_lookup_key = (base_node, os.path.sep.join(path))
+
try:
- lock.acquire()
node = cached_nodes[node_lookup_key]
except KeyError:
- node = base_node.find_resource(path)
- cached_nodes[node_lookup_key] = node
- finally:
- lock.release()
+ # retry with lock on cache miss
+ with lock:
+ try:
+ node = cached_nodes[node_lookup_key]
+ except KeyError:
+ node = cached_nodes[node_lookup_key] = base_node.find_resource(path)
+
return node
def post_run(self):
if not self.__class__.__name__ in self.env.ENABLE_GCCDEPS:
return super(self.derived_gccdeps, self).post_run()
- name = self.outputs[0].abspath()
- name = re_o.sub('.d', name)
+ deps_filename = self.outputs[0].abspath()
+ deps_filename = re_o.sub('.d', deps_filename)
try:
- txt = Utils.readf(name)
+ deps_txt = Utils.readf(deps_filename)
except EnvironmentError:
Logs.error('Could not find a .d dependency file, are cflags/cxxflags overwritten?')
raise
- #os.remove(name)
# Compilers have the choice to either output the file's dependencies
# as one large Makefile rule:
# So the first step is to sanitize the input by stripping out the left-
# hand side of all these lines. After that, whatever remains are the
# implicit dependencies of task.outputs[0]
- txt = '\n'.join([remove_makefile_rule_lhs(line) for line in txt.splitlines()])
+ deps_txt = '\n'.join([remove_makefile_rule_lhs(line) for line in deps_txt.splitlines()])
# Now join all the lines together
- txt = txt.replace('\\\n', '')
+ deps_txt = deps_txt.replace('\\\n', '')
- val = txt.strip()
- val = [x.replace('\\ ', ' ') for x in re_splitter.split(val) if x]
+ dep_paths = deps_txt.strip()
+ dep_paths = [x.replace('\\ ', ' ') for x in re_splitter.split(dep_paths) if x]
- nodes = []
+ resolved_nodes = []
+ unresolved_names = []
bld = self.generator.bld
# Dynamically bind to the cache
except AttributeError:
cached_nodes = bld.cached_nodes = {}
- for x in val:
+ for path in dep_paths:
node = None
- if os.path.isabs(x):
- node = path_to_node(bld.root, x, cached_nodes)
+ if os.path.isabs(path):
+ node = path_to_node(bld.root, path, cached_nodes)
else:
# TODO waf 1.9 - single cwd value
- path = getattr(bld, 'cwdx', bld.bldnode)
+ base_node = getattr(bld, 'cwdx', bld.bldnode)
# when calling find_resource, make sure the path does not contain '..'
- x = [k for k in Utils.split_path(x) if k and k != '.']
- while '..' in x:
- idx = x.index('..')
+ path = [k for k in Utils.split_path(path) if k and k != '.']
+ while '..' in path:
+ idx = path.index('..')
if idx == 0:
- x = x[1:]
- path = path.parent
+ path = path[1:]
+ base_node = base_node.parent
else:
- del x[idx]
- del x[idx-1]
+ del path[idx]
+ del path[idx-1]
- node = path_to_node(path, x, cached_nodes)
+ node = path_to_node(base_node, path, cached_nodes)
if not node:
- raise ValueError('could not find %r for %r' % (x, self))
+ raise ValueError('could not find %r for %r' % (path, self))
+
if id(node) == id(self.inputs[0]):
# ignore the source file, it is already in the dependencies
# this way, successful config tests may be retrieved from the cache
continue
- nodes.append(node)
- Logs.debug('deps: gccdeps for %s returned %s', self, nodes)
+ resolved_nodes.append(node)
- bld.node_deps[self.uid()] = nodes
- bld.raw_deps[self.uid()] = []
+ Logs.debug('deps: gccdeps for %s returned %s', self, resolved_nodes)
+
+ bld.node_deps[self.uid()] = resolved_nodes
+ bld.raw_deps[self.uid()] = unresolved_names
try:
del self.cache_sig
Task.Task.post_run(self)
+def scan(self):
+ if not self.__class__.__name__ in self.env.ENABLE_GCCDEPS:
+ return super(self.derived_gccdeps, self).scan()
+
+ resolved_nodes = self.generator.bld.node_deps.get(self.uid(), [])
+ unresolved_names = []
+ return (resolved_nodes, unresolved_names)
+
def sig_implicit_deps(self):
if not self.__class__.__name__ in self.env.ENABLE_GCCDEPS:
return super(self.derived_gccdeps, self).sig_implicit_deps()
from waflib.TaskGen import feature, before_method
lock = threading.Lock()
-nodes = {} # Cache the path -> Node lookup
PREPROCESSOR_FLAG = '/showIncludes'
INCLUDE_PATTERN = 'Note: including file:'
if taskgen.env.get_flat(flag).find(PREPROCESSOR_FLAG) < 0:
taskgen.env.append_value(flag, PREPROCESSOR_FLAG)
+
+def get_correct_path_case(base_path, path):
+ '''
+ Return a case-corrected version of ``path`` by searching the filesystem for
+ ``path``, relative to ``base_path``, using the case returned by the filesystem.
+ '''
+ components = Utils.split_path(path)
+
+ corrected_path = ''
+ if os.path.isabs(path):
+ corrected_path = components.pop(0).upper() + os.sep
+
+ for part in components:
+ part = part.lower()
+ search_path = os.path.join(base_path, corrected_path)
+ if part == '..':
+ corrected_path = os.path.join(corrected_path, part)
+ search_path = os.path.normpath(search_path)
+ continue
+
+ for item in sorted(os.listdir(search_path)):
+ if item.lower() == part:
+ corrected_path = os.path.join(corrected_path, item)
+ break
+ else:
+ raise ValueError("Can't find %r in %r" % (part, search_path))
+
+ return corrected_path
+
+
def path_to_node(base_node, path, cached_nodes):
'''
Take the base node and the path and return a node
Results are cached because searching the node tree is expensive
The following code is executed by threads, it is not safe, so a lock is needed...
'''
- # normalize the path because ant_glob() does not understand
- # parent path components (..)
+ # normalize the path to remove parent path components (..)
path = os.path.normpath(path)
# normalize the path case to increase likelihood of a cache hit
- path = os.path.normcase(path)
-
- # ant_glob interprets [] and () characters, so those must be replaced
- path = path.replace('[', '?').replace(']', '?').replace('(', '[(]').replace(')', '[)]')
-
- node_lookup_key = (base_node, path)
+ node_lookup_key = (base_node, os.path.normcase(path))
try:
node = cached_nodes[node_lookup_key]
try:
node = cached_nodes[node_lookup_key]
except KeyError:
- node_list = base_node.ant_glob([path], ignorecase=True, remove=False, quiet=True, regex=False)
- node = cached_nodes[node_lookup_key] = node_list[0] if node_list else None
+ path = get_correct_path_case(base_node.abspath(), path)
+ node = cached_nodes[node_lookup_key] = base_node.find_node(path)
return node
if getattr(self, 'cached', None):
return Task.Task.post_run(self)
- bld = self.generator.bld
- unresolved_names = []
resolved_nodes = []
+ unresolved_names = []
+ bld = self.generator.bld
# Dynamically bind to the cache
try:
continue
if id(node) == id(self.inputs[0]):
- # Self-dependency
+ # ignore the source file, it is already in the dependencies
+ # this way, successful config tests may be retrieved from the cache
continue
resolved_nodes.append(node)
+ Logs.debug('deps: msvcdeps for %s returned %s', self, resolved_nodes)
+
bld.node_deps[self.uid()] = resolved_nodes
bld.raw_deps[self.uid()] = unresolved_names
self.collect_dirs()
default_project = getattr(self, 'default_project', None)
def sortfun(x):
- if x.name == default_project:
+ # folders should sort to the top
+ if getattr(x, 'VS_GUID_SOLUTIONFOLDER', None):
return ''
+ # followed by the default project
+ elif x.name == default_project:
+ return ' '
return getattr(x, 'path', None) and x.path.win32path() or x.name
self.all_projects.sort(key=sortfun)
SWIG_EXTS = ['.swig', '.i']
-re_module = re.compile(r'%module(?:\s*\(.*\))?\s+(.+)', re.M)
+re_module = re.compile(r'%module(?:\s*\(.*\))?\s+([^\r\n]+)', re.M)
re_1 = re.compile(r'^%module.*?\s+([\w]+)\s*?$', re.M)
re_2 = re.compile(r'[#%](?:include|import(?:\(module=".*"\))+|python(?:begin|code)) [<"](.*)[">]', re.M)
"""
Called during the build process to enable file caching
"""
+ if WAFCACHE_STATS:
+ # Init counter for statistics and hook to print results at the end
+ bld.cache_reqs = bld.cache_hits = bld.cache_puts = 0
+
+ def printstats(bld):
+ hit_ratio = 0
+ if bld.cache_reqs > 0:
+ hit_ratio = (bld.cache_hits / bld.cache_reqs) * 100
+ Logs.pprint('CYAN', ' wafcache stats: requests: %s, hits, %s, ratio: %.2f%%, writes %s' %
+ (bld.cache_reqs, bld.cache_hits, hit_ratio, bld.cache_puts) )
+
+ bld.add_post_fun(printstats)
+
if process_pool:
# already called once
return
for x in reversed(list(Task.classes.values())):
make_cached(x)
- if WAFCACHE_STATS:
- # Init counter for statistics and hook to print results at the end
- bld.cache_reqs = bld.cache_hits = bld.cache_puts = 0
-
- def printstats(bld):
- hit_ratio = 0
- if bld.cache_reqs > 0:
- hit_ratio = (bld.cache_hits / bld.cache_reqs) * 100
- Logs.pprint('CYAN', ' wafcache stats: requests: %s, hits, %s, ratio: %.2f%%, writes %s' %
- (bld.cache_reqs, bld.cache_hits, hit_ratio, bld.cache_puts) )
-
- bld.add_post_fun(printstats)
-
def cache_command(sig, files_from, files_to):
"""
Create a command for cache worker processes, returns a pickled
@subst('Runner.py')
def r4(code):
"generator syntax"
- return code.replace('next(self.biter)', 'self.biter.next()')
+ return code.replace('next(self.biter)', 'self.biter.next()').replace('self.daemon = True', 'self.setDaemon(1)')
@subst('Context.py')
def r5(code):
git.samba.org / samba.git / commitdiff