def _get_test_target_md5sum(self, target):
"""Get test target md5sum. """
# pylint: disable=too-many-locals
related_file_list = []
related_file_data_list = []
test_file_name = os.path.abspath(self._executable(target))
if os.path.exists(test_file_name):
related_file_list.append(test_file_name)
if target.data.get('dynamic_link'):
for dep in self.targets[target.key].expanded_deps:
dep_target = self.targets[dep]
if 'cc_library' in dep_target.type:
lib_name = 'lib%s.so' % dep_target.name
lib_path = os.path.join(self.build_dir,
dep_target.path,
lib_name)
abs_lib_path = os.path.abspath(lib_path)
if os.path.exists(abs_lib_path):
related_file_list.append(abs_lib_path)
for i in target.data['testdata']:
if isinstance(i, tuple):
data_target = i[0]
else:
data_target = i
if '..' in data_target:
continue
if data_target.startswith('//'):
data_target = data_target[2:]
data_target_path = os.path.abspath(data_target)
else:
data_target_path = os.path.abspath('%s/%s' % (
target.path, data_target))
if os.path.exists(data_target_path):
related_file_data_list.append(data_target_path)
related_file_list.sort()
related_file_data_list.sort()
test_target_str = ''
test_target_data_str = ''
for f in related_file_list:
mtime = os.path.getmtime(f)
ctime = os.path.getctime(f)
test_target_str += str(mtime) + str(ctime)
for f in related_file_data_list:
mtime = os.path.getmtime(f)
ctime = os.path.getctime(f)
test_target_data_str += str(mtime) + str(ctime)
return md5sum(test_target_str), md5sum(test_target_data_str)
def rule_hash(self):
"""Calculate a hash string to be used to judge whether regenerate per-target ninja file"""
if self.__rule_hash is None:
# All build related factors should be added to avoid outdated ninja file beeing used.
entropy = {
'blade_revision': self.blade.revision(),
'config': config.digest(),
'type': self.type,
'name': self.name,
'srcs': self.srcs,
}
deps = []
for dkey in self.deps:
dep = self.target_database[dkey]
deps.append(dep.rule_hash())
entropy['deps'] = deps
# Add more entropy
entropy.update(self._rule_hash_entropy())
# Sort to make the result stable
entropy_str = str(sorted(entropy.items()))
# Entropy dict can't cantains normal object, because it's default repr contains address,
# which is changed in different build, so it should not be used as stable hash entropy.
# If this assert failed, remove the culprit element from entropy if it is unrelated or
# override it's `__repe__` if it is related.
assert ' object at 0x' not in entropy_str
self.__rule_hash = md5sum(entropy_str)
return self.__rule_hash
def _update_test_history(self):
old_env = self.test_history.get('env', {})
env_keys = _filter_envs(os.environ.keys())
new_env = dict((key, os.environ[key]) for key in env_keys)
if old_env and new_env != old_env:
console.notice('Some tests will be run due to test environments changed:')
new, old = _diff_env(new_env, old_env)
if new:
console.notice('New environments: %s' % new)
if old:
console.notice('Old environments: %s' % old)
self.test_history['env'] = new_env
self.env_md5 = md5sum(str(sorted(iteritems(new_env))))
def _update_test_history(self):
old_env = self.test_history.get('env', {})
env_keys = os.environ.keys()
env_keys = set(env_keys).difference(_TEST_IGNORED_ENV_VARS)
new_env = dict((key, os.environ[key]) for key in env_keys)
if old_env and new_env != old_env:
console.notice('Some tests will be run due to test environments changed:')
new, old = _diff_env(new_env, old_env)
if new:
console.notice('new environments: %s' % new)
if old:
console.notice('old environments: %s' % old)
self.test_history['env'] = new_env
self.env_md5 = md5sum(str(sorted(new_env.iteritems())))
def rule_hash(self):
"""Calculate a hash string to be used to judge whether regenerate per-target ninja file"""
if self.__rule_hash is None:
entropy = {
'type': self.type,
'name': self.name,
'srcs': self.srcs,
}
deps = []
for dkey in self.deps:
dep = self.target_database[dkey]
deps.append(dep.rule_hash())
entropy['deps'] = deps
entropy.update(self._rule_hash_entropy())
entropy_str = str(sorted(entropy.items()))
assert ' object at 0x' not in entropy_str
self.__rule_hash = md5sum(entropy_str)
return self.__rule_hash
