def javac_flags(self):
global_config = config.get_section('global_config')
java_config = config.get_section('java_config')
debug_info_level = global_config['debug_info_level']
debug_info_options = java_config['debug_info_levels'][debug_info_level]
warnings = self.data.get('warnings')
if not warnings:
warnings = java_config['warnings']
return debug_info_options + warnings
def javac_flags(self):
global_config = config.get_section('global_config')
java_config = config.get_section('java_config')
debug_info_level = global_config['debug_info_level']
debug_info_options = java_config['debug_info_levels'][debug_info_level]
warnings = self.data.get('warnings')
if not warnings:
warnings = java_config['warnings']
return debug_info_options + warnings
def get_flags_except_warning(self):
"""Get the flags that are not warning flags. """
global_config = config.get_section('global_config')
cc_config = config.get_section('cc_config')
if not self.options.m:
flags_except_warning = []
linkflags = []
else:
flags_except_warning = ['-m%s' % self.options.m]
linkflags = ['-m%s' % self.options.m]
flags_except_warning.append('-pipe')
# Debugging information setting
debug_info_level = global_config['debug_info_level']
debug_info_options = cc_config['debug_info_levels'][debug_info_level]
flags_except_warning += debug_info_options
# Option debugging flags
if self.options.profile == 'debug':
flags_except_warning.append('-fstack-protector')
elif self.options.profile == 'release':
flags_except_warning.append('-DNDEBUG')
flags_except_warning += [
'-D_FILE_OFFSET_BITS=64',
'-D__STDC_CONSTANT_MACROS',
'-D__STDC_FORMAT_MACROS',
'-D__STDC_LIMIT_MACROS',
]
if getattr(self.options, 'gprof', False):
flags_except_warning.append('-pg')
linkflags.append('-pg')
platform = self.build_platform
if getattr(self.options, 'coverage', False):
if ((platform.gcc_in_use() and platform.get_cc_version() > '4.1')
or self.build_platform.clang_in_use()):
flags_except_warning.append('--coverage')
linkflags.append('--coverage')
else:
flags_except_warning.append('-fprofile-arcs')
flags_except_warning.append('-ftest-coverage')
linkflags += [
'-Wl,--whole-archive', '-lgcov', '-Wl,--no-whole-archive'
]
flags_except_warning = self._filter_out_invalid_flags(
flags_except_warning)
return flags_except_warning, linkflags
def _generate_proto_builders(self):
self._add_rule('time_value = Value("%s")' % time.asctime())
proto_config = config.get_section('proto_library_config')
protoc_bin = proto_config['protoc']
protoc_java_bin = protoc_bin
if proto_config['protoc_java']:
protoc_java_bin = proto_config['protoc_java']
protobuf_path = proto_config['protobuf_path']
protobuf_incs_str = protoc_import_path_option(
proto_config['protobuf_incs'])
protobuf_java_incs = protobuf_incs_str
if proto_config['protobuf_java_incs']:
protobuf_java_incs = protoc_import_path_option(
proto_config['protobuf_java_incs'])
protobuf_php_path = proto_config['protobuf_php_path']
protoc_php_plugin = proto_config['protoc_php_plugin']
protoc_go_plugin = proto_config['protoc_go_plugin']
self._add_rule(
'scons_helper.setup_proto_builders(top_env, "%s", protoc_bin="%s", '
'protoc_java_bin="%s", protobuf_path="%s", '
'protobuf_incs_str="%s", protobuf_java_incs="%s", '
'protobuf_php_path="%s", protoc_php_plugin="%s", '
'protoc_go_plugin="%s")' %
(self.build_dir, protoc_bin, protoc_java_bin, protobuf_path,
protobuf_incs_str, protobuf_java_incs, protobuf_php_path,
protoc_php_plugin, protoc_go_plugin))
def __init__(self, name, srcs, deps, optimize, deprecated, blade, kwargs):
"""Init method.
Init the thrift target.
"""
srcs = var_to_list(srcs)
self._check_thrift_srcs_name(srcs)
CcTarget.__init__(self, name, 'fbthrift_library', srcs, deps, None, '',
[], [], [], optimize, [], [], blade, kwargs)
fbthrift_config = config.get_section('fbthrift_config')
fbthrift_libs = var_to_list(fbthrift_config['fbthrift_libs'])
fbthrift1_bin = fbthrift_config['fbthrift1']
fbthrift2_bin = fbthrift_config['fbthrift2']
# Hardcode deps rule to thrift libraries.
self._add_hardcode_library(fbthrift_libs)
# Link all the symbols by default
self.data['link_all_symbols'] = True
# For each thrift file initialize a FBThriftHelper, which will be used
# to get the source files generated from thrift file.
self.fbthrift_helpers = {}
for src in srcs:
self.fbthrift_helpers[src] = FBThriftHelper(
os.path.join(self.path, src))
def _generate_java_coverage_report(self):
java_test_config = config.get_section('java_test_config')
jacoco_home = java_test_config['jacoco_home']
coverage_reporter = java_test_config['coverage_reporter']
if not jacoco_home or not coverage_reporter:
console.warning('Missing jacoco home or coverage report generator '
'in global configuration. '
'Abort java coverage report generation.')
return
jacoco_libs = os.path.join(jacoco_home, 'lib', 'jacocoant.jar')
report_dir = os.path.join(self.build_dir, 'java', 'coverage_report')
if not os.path.exists(report_dir):
os.makedirs(report_dir)
coverage_data = self._get_java_coverage_data()
if coverage_data:
cmd = ['java -classpath %s:%s com.tencent.gdt.blade.ReportGenerator' % (
coverage_reporter, jacoco_libs)]
cmd.append(report_dir)
for data in coverage_data:
cmd.append(','.join(data))
cmd_str = ' '.join(cmd)
console.info('Generating java coverage report')
console.info(cmd_str)
if subprocess.call(cmd_str, shell=True):
console.warning('Failed to generate java coverage report')
def __init__(self, name, srcs, deps, visibility, warning, defs, incs,
extra_cppflags, extra_linkflags, testdata, always_run,
exclusive, kwargs):
# pylint: disable=too-many-locals
super(CuTest, self).__init__(name=name,
srcs=srcs,
deps=deps,
visibility=visibility,
warning=warning,
defs=defs,
incs=incs,
extra_cppflags=extra_cppflags,
extra_linkflags=extra_linkflags,
kwargs=kwargs)
self.type = 'cu_test'
self.data['testdata'] = var_to_list(testdata)
self.data['always_run'] = always_run
self.data['exclusive'] = exclusive
cc_test_config = config.get_section('cc_test_config')
gtest_lib = var_to_list(cc_test_config['gtest_libs'])
gtest_main_lib = var_to_list(cc_test_config['gtest_main_libs'])
# Hardcode deps rule to thirdparty gtest main lib.
self._add_hardcode_library(gtest_lib)
self._add_hardcode_library(gtest_main_lib)
def generate_proto_rules(self):
proto_config = config.get_section('proto_library_config')
protoc = proto_config['protoc']
protoc_java = protoc
if proto_config['protoc_java']:
protoc_java = proto_config['protoc_java']
protobuf_incs = protoc_import_path_option(
proto_config['protobuf_incs'])
protobuf_java_incs = protobuf_incs
if proto_config['protobuf_java_incs']:
protobuf_java_incs = protoc_import_path_option(
proto_config['protobuf_java_incs'])
self._add_rule('''
protocflags =
protoccpppluginflags =
protocjavapluginflags =
protocpythonpluginflags =
''')
self.generate_rule(
name='proto',
command='%s --proto_path=. %s -I=`dirname ${in}` '
'--cpp_out=%s ${protocflags} ${protoccpppluginflags} ${in}' %
(protoc, protobuf_incs, self.build_dir),
description='PROTOC ${in}')
self.generate_rule(
name='protojava',
command='%s --proto_path=. %s --java_out=%s/`dirname ${in}` '
'${protocjavapluginflags} ${in}' %
(protoc_java, protobuf_java_incs, self.build_dir),
description='PROTOCJAVA ${in}')
self.generate_rule(name='protopython',
command='%s --proto_path=. %s -I=`dirname ${in}` '
'--python_out=%s ${protocpythonpluginflags} ${in}' %
(protoc, protobuf_incs, self.build_dir),
description='PROTOCPYTHON ${in}')
self.generate_rule(
name='protodescriptors',
command='%s --proto_path=. %s -I=`dirname ${first}` '
'--descriptor_set_out=${out} --include_imports '
'--include_source_info ${in}' % (protoc, protobuf_incs),
description='PROTODESCRIPTORS ${in}')
protoc_go_plugin = proto_config['protoc_go_plugin']
if protoc_go_plugin:
go_home = config.get_item('go_config', 'go_home')
if not go_home:
console.error_exit(
'go_home is not configured in either BLADE_ROOT or BLADE_ROOT.local.'
)
outdir = os.path.join(go_home, 'src')
subplugins = proto_config['protoc_go_subplugins']
if subplugins:
go_out = 'plugins=%s:%s' % ('+'.join(subplugins), outdir)
else:
go_out = outdir
self.generate_rule(
name='protogo',
command='%s --proto_path=. %s -I=`dirname ${in}` '
'--plugin=protoc-gen-go=%s --go_out=%s ${in}' %
(protoc, protobuf_incs, protoc_go_plugin, go_out),
description='PROTOCGOLANG ${in}')
def __init__(self, name, srcs, deps, optimize, visibility, deprecated,
kwargs):
srcs = var_to_list(srcs)
self._check_thrift_srcs_name(srcs)
super(FBThriftLibrary, self).__init__(name=name,
type='fbthrift_library',
srcs=srcs,
deps=deps,
visibility=visibility,
warning='',
defs=[],
incs=[],
export_incs=[],
optimize=optimize,
extra_cppflags=[],
extra_linkflags=[],
kwargs=kwargs)
fbthrift_config = config.get_section('fbthrift_config')
fbthrift_libs = var_to_list(fbthrift_config['fbthrift_libs'])
# Hardcode deps rule to thrift libraries.
self._add_hardcode_library(fbthrift_libs)
# Link all the symbols by default
self.data['link_all_symbols'] = True
# For each thrift file initialize a FBThriftHelper, which will be used
# to get the source files generated from thrift file.
self.fbthrift_helpers = {}
for src in srcs:
self.fbthrift_helpers[src] = FBThriftHelper(
os.path.join(self.path, src))
def __init__(self, log_dir):
"""Init method. """
if not os.path.exists(log_dir):
os.makedirs(log_dir)
self.__log_dir = log_dir
# key: (id, classifier)
# id: jar id in the format group:artifact:version
# value: an instance of MavenArtifact
self.__jar_database = {}
java_config = config.get_section('java_config')
self.__maven = java_config.get('maven')
self.__central_repository = java_config.get('maven_central')
self._check_config()
self.__snapshot_update_policy = java_config.get(
'maven_snapshot_update_policy')
if self.__snapshot_update_policy == 'interval':
interval = java_config.get('maven_snapshot_update_interval')
if not interval:
console.fatal(
'java_config: "maven_snapshot_update_interval" is required when '
'"maven_snapshot_update_policy" is "interval"')
self.__snapshot_update_interval = interval * 60 # minutes
else:
self.__snapshot_update_interval = 86400
# Local repository is set to the maven default directory
# and could not be configured currently
local_repository = '~/.m2/repository'
self.__local_repository = os.path.expanduser(local_repository)
# Download the snapshot artifact daily
self.__build_time = time.time()
def _generate_java_coverage_report(self):
java_test_config = config.get_section('java_test_config')
jacoco_home = java_test_config['jacoco_home']
coverage_reporter = java_test_config['coverage_reporter']
if not jacoco_home or not coverage_reporter:
console.warning('Missing jacoco home or coverage report generator '
'in global configuration. '
'Abort java coverage report generation.')
return
jacoco_libs = os.path.join(jacoco_home, 'lib', 'jacocoant.jar')
report_dir = os.path.join(self.build_dir, 'java', 'coverage_report')
if not os.path.exists(report_dir):
os.makedirs(report_dir)
coverage_data = self._get_java_coverage_data()
if coverage_data:
java = 'java'
java_home = config.get_item('java_config', 'java_home')
if java_home:
java = os.path.join(java_home, 'bin', 'java')
cmd = [
'%s -classpath %s:%s com.tencent.gdt.blade.ReportGenerator' %
(java, coverage_reporter, jacoco_libs)
]
cmd.append(report_dir)
for data in coverage_data:
cmd.append(','.join(data))
cmd_str = ' '.join(cmd)
console.info('Generating java coverage report')
console.debug(cmd_str)
if subprocess.call(cmd_str, shell=True) != 0:
console.warning('Failed to generate java coverage report')
def protoc_plugin_flags(self):
protoc_plugin_config = config.get_section('protoc_plugin_config')
flags = {}
for plugin in self.data['protoc_plugins']:
p = protoc_plugin_config[plugin]
for language in p.code_generation:
flags[language] = p.protoc_plugin_flag(self.build_path)
return flags
def _generate_fbthrift_builders(self):
fbthrift_config = config.get_section('fbthrift_config')
fbthrift1_bin = fbthrift_config['fbthrift1']
fbthrift2_bin = fbthrift_config['fbthrift2']
fbthrift_incs_str = _incs_list_to_string(fbthrift_config['fbthrift_incs'])
self._add_rule('scons_helper.setup_fbthrift_builders(top_env, "%s", '
'fbthrift1_bin="%s", fbthrift2_bin="%s", fbthrift_incs_str="%s")' % (
self.build_dir, fbthrift1_bin, fbthrift2_bin, fbthrift_incs_str))
def _get_globals_for_extension():
"""Get global variables for loadable extensions."""
result = build_rules.get_all_for_extension()
global_config = config.get_section('global_config')
if global_config.get('restricted_dsl'):
result['__builtins__'] = restricted.safe_builtins
result['blade'] = dsl_api.get_blade_module()
return result
def _get_globals_for_build_file(source_dir):
"""Get global variables for BUILD files."""
result = build_rules.get_all()
global_config = config.get_section('global_config')
if global_config.get('restricted_dsl') and source_dir not in global_config.get('unrestricted_dsl_dirs'):
result['__builtins__'] = restricted.safe_builtins
result['blade'] = dsl_api.get_blade_module()
return result
def protoc_plugin_flags(self):
protoc_plugin_config = config.get_section('protoc_plugin_config')
flags = {}
for plugin in self.data['protoc_plugins']:
p = protoc_plugin_config[plugin]
for language in p.code_generation:
flags[language] = p.protoc_plugin_flag(self.build_path)
return flags
def _protoc_plugin_rules(self):
"""Generate scons rules for each protoc plugin. """
env_name = self._env_name()
protoc_plugin_config = config.get_section('protoc_plugin_config')
for plugin in self.data['protoc_plugins']:
p = protoc_plugin_config[plugin]
for language in p.code_generation:
self._write_rule('%s.Append(PROTOC%sPLUGINFLAGS = "%s ")' % (
env_name, language.upper(),
p.protoc_plugin_flag(self.build_path)))
def _protoc_plugin_rules(self):
"""Generate scons rules for each protoc plugin. """
env_name = self._env_name()
protoc_plugin_config = config.get_section('protoc_plugin_config')
for plugin in self.data['protoc_plugins']:
p = protoc_plugin_config[plugin]
for language in p.code_generation:
self._write_rule('%s.Append(PROTOC%sPLUGINFLAGS = "%s ")' % (
env_name, language.upper(),
p.protoc_plugin_flag(self.build_path)))
def __init__(self, name, srcs, deps, optimize, deprecated,
generate_descriptors, target_languages, plugins,
source_encoding, blade, kwargs):
"""Init method.
Init the proto target.
"""
# pylint: disable=too-many-locals
srcs = var_to_list(srcs)
CcTarget.__init__(self, name, 'proto_library', srcs, deps, None, '',
[], [], [], optimize, [], [], blade, kwargs)
self._check_proto_srcs_name(srcs)
if srcs:
self.data['public_protos'] = [
self._source_file_path(s) for s in srcs
]
proto_config = config.get_section('proto_library_config')
protobuf_libs = var_to_list(proto_config['protobuf_libs'])
protobuf_java_libs = var_to_list(proto_config['protobuf_java_libs'])
protobuf_python_libs = var_to_list(
proto_config['protobuf_python_libs'])
# Hardcode deps rule to thirdparty protobuf lib.
self._add_hardcode_library(protobuf_libs)
self._add_hardcode_java_library(protobuf_java_libs)
self._add_hardcode_library(protobuf_python_libs)
# Normally a proto target depends on another proto target when
# it references a message defined in that target. Then in the
# generated code there is public API with return type/arguments
# defined outside and in java it needs to export that dependency,
# which is also the case for java protobuf library.
self.data['exported_deps'] = self._unify_deps(var_to_list(deps))
self.data['exported_deps'] += self._unify_deps(protobuf_java_libs)
self._handle_protoc_plugins(var_to_list(plugins))
# Link all the symbols by default
self.data['link_all_symbols'] = True
self.data['deprecated'] = deprecated
self.data['source_encoding'] = source_encoding
self.data['java_sources_explict_dependency'] = []
self.data['python_vars'] = []
self.data['python_sources'] = []
self.data['generate_descriptors'] = generate_descriptors
# TODO(chen3feng): Change the values to a `set` rather than separated attributes
target_languages = set(var_to_list(target_languages))
self.data['generate_java'] = 'java' in target_languages
self.data['generate_python'] = 'python' in target_languages
self.data['generate_go'] = 'go' in target_languages
def _get_cc_flags(self):
"""Get the common c/c++ flags."""
global_config = config.get_section('global_config')
cc_config = config.get_section('cc_config')
cppflags = []
linkflags = []
if self.options.m:
cppflags = ['-m%s' % self.options.m]
linkflags = ['-m%s' % self.options.m]
# Add -fno-omit-frame-pointer to optimize mode for easy debugging.
cppflags += ['-pipe', '-fno-omit-frame-pointer']
# Debugging information setting
debug_info_level = global_config['debug_info_level']
debug_info_options = cc_config['debug_info_levels'][debug_info_level]
cppflags += debug_info_options
# Option debugging flags
if self.options.profile == 'debug':
cppflags.append('-fstack-protector')
elif self.options.profile == 'release':
cppflags.append('-DNDEBUG')
cppflags += [
'-D_FILE_OFFSET_BITS=64',
'-D__STDC_CONSTANT_MACROS',
'-D__STDC_FORMAT_MACROS',
'-D__STDC_LIMIT_MACROS',
]
if getattr(self.options, 'gprof', False):
cppflags.append('-pg')
linkflags.append('-pg')
if getattr(self.options, 'coverage', False):
cppflags.append('--coverage')
linkflags.append('--coverage')
cppflags = self.build_toolchain.filter_cc_flags(cppflags)
return cppflags, linkflags
def get_warning_flags(self):
"""Get the warning flags. """
cc_config = config.get_section('cc_config')
cppflags = cc_config['warnings']
cxxflags = cc_config['cxx_warnings']
cflags = cc_config['c_warnings']
filtered_cppflags = self._filter_out_invalid_flags(cppflags)
filtered_cxxflags = self._filter_out_invalid_flags(cxxflags, 'c++')
filtered_cflags = self._filter_out_invalid_flags(cflags, 'c')
return filtered_cppflags, filtered_cxxflags, filtered_cflags
def _generate_thrift_builders(self):
# Generate thrift library builders.
thrift_config = config.get_section('thrift_config')
thrift_incs_str = _incs_list_to_string(thrift_config['thrift_incs'])
thrift_bin = thrift_config['thrift']
if thrift_bin.startswith('//'):
thrift_bin = thrift_bin.replace('//', self.build_dir + '/')
thrift_bin = thrift_bin.replace(':', '/')
thrift_gen_params = thrift_config['thrift_gen_params']
self._add_rule(
'scons_helper.setup_thrift_builders(top_env, build_dir="%s", thrift_bin="%s", thrift_incs_str="%s", thrift_gen_params="%s")' % (
self.build_dir, thrift_bin, thrift_incs_str, thrift_gen_params))
def _get_warning_flags(self):
"""Get the warning flags. """
cc_config = config.get_section('cc_config')
cppflags = cc_config['warnings']
cxxflags = cc_config['cxx_warnings']
cflags = cc_config['c_warnings']
filtered_cppflags = self.build_toolchain.filter_cc_flags(cppflags)
filtered_cxxflags = self.build_toolchain.filter_cc_flags(cxxflags, 'c++')
filtered_cflags = self.build_toolchain.filter_cc_flags(cflags, 'c')
return filtered_cppflags, filtered_cxxflags, filtered_cflags
def generate_java_scala_rules(self):
java_config = config.get_section('java_config')
self.generate_javac_rules(java_config)
self.generate_java_resource_rules()
jar = self.get_java_command(java_config, 'jar')
args = '%s ${out} ${in}' % jar
self.generate_java_jar_rules(java_config)
self.generate_java_test_rules()
self.generate_fatjar_rules(java_config)
self.generate_java_binary_rules()
self.generate_scalac_rule(java_config)
self.generate_scalatest_rule(java_config)
def scalac_flags(self):
flags = []
scala_config = config.get_section('scala_config')
target_platform = scala_config['target_platform']
if target_platform:
flags.append('-target:%s' % target_platform)
warnings = self.data.get('warnings')
if warnings:
flags.append(warnings)
global_warnings = scala_config['warnings']
if global_warnings:
flags.append(global_warnings)
return flags
def scalac_flags(self):
flags = []
scala_config = config.get_section('scala_config')
target_platform = scala_config['target_platform']
if target_platform:
flags.append('-target:%s' % target_platform)
warnings = self.attr.get('warnings')
if warnings:
flags.append(warnings)
global_warnings = scala_config['warnings']
if global_warnings:
flags.append(global_warnings)
return flags
def generate_thrift_rules(self):
thrift_config = config.get_section('thrift_config')
incs = _incs_list_to_string(thrift_config['thrift_incs'])
gen_params = thrift_config['thrift_gen_params']
thrift = thrift_config['thrift']
if thrift.startswith('//'):
thrift = thrift.replace('//', self.build_dir + '/')
thrift = thrift.replace(':', '/')
self.generate_rule(name='thrift',
command='%s --gen %s '
'-I . %s -I `dirname ${in}` '
'-out %s/`dirname ${in}` ${in}' %
(thrift, gen_params, incs, self.build_dir),
description='THRIFT ${in}')
def _check_proto_deps(self):
"""Only proto_library or gen_rule target is allowed as deps. """
proto_config = config.get_section('proto_library_config')
protobuf_libs = var_to_list(proto_config['protobuf_libs'])
protobuf_java_libs = var_to_list(proto_config['protobuf_java_libs'])
protobuf_libs = [self._unify_dep(d) for d in protobuf_libs + protobuf_java_libs]
proto_deps = protobuf_libs + self.data['protoc_plugin_deps']
for dkey in self.deps:
if dkey in proto_deps:
continue
dep = self.target_database[dkey]
if dep.type != 'proto_library' and dep.type != 'gen_rule':
self.error_exit('Invalid dep %s. Proto_library can only depend on proto_library '
'or gen_rule.' % dep.fullname)
def generate_java_scala_rules(self):
java_config = config.get_section('java_config')
self.generate_javac_rules(java_config)
self.generate_java_resource_rules()
jar = self.get_java_command(java_config, 'jar')
args = '%s ${out} ${in}' % jar
self.generate_rule(name='javajar',
command=self.generate_toolchain_command('java_jar', suffix=args),
description='JAVA JAR ${out}')
self.generate_java_test_rules()
self.generate_rule(name='fatjar',
command=self.generate_toolchain_command('java_fatjar'),
description='FAT JAR ${out}')
self.generate_java_binary_rules()
self.generate_scala_rules(java_config)
def _check_proto_deps(self):
"""Only proto_library or gen_rule target is allowed as deps. """
proto_config = config.get_section('proto_library_config')
protobuf_libs = var_to_list(proto_config['protobuf_libs'])
protobuf_java_libs = var_to_list(proto_config['protobuf_java_libs'])
protobuf_libs = [self._unify_dep(d) for d in protobuf_libs + protobuf_java_libs]
proto_deps = protobuf_libs + self.data['protoc_plugin_deps']
for dkey in self.deps:
if dkey in proto_deps:
continue
dep = self.target_database[dkey]
if dep.type != 'proto_library' and dep.type != 'gen_rule':
console.error_exit('%s: Invalid dep %s. Proto_library can '
'only depend on proto_library or gen_rule.' %
(self.fullname, dep.fullname))
def _generate_java_versions(self):
java_config = config.get_section('java_config')
version = java_config['version']
source_version = java_config.get('source_version', version)
target_version = java_config.get('target_version', version)
# JAVAVERSION must be set because scons need it to deduce class names
# from java source, and the default value '1.5' is too low.
blade_java_version = version or '1.6'
self._write_rule('%s.Replace(JAVAVERSION="%s")' %
(self._env_name(), blade_java_version))
if source_version:
self._write_rule('%s.Append(JAVACFLAGS="-source %s")' %
(self._env_name(), source_version))
if target_version:
self._write_rule('%s.Append(JAVACFLAGS="-target %s")' %
(self._env_name(), target_version))
def _generate_java_versions(self):
java_config = config.get_section('java_config')
version = java_config['version']
source_version = java_config.get('source_version', version)
target_version = java_config.get('target_version', version)
# JAVAVERSION must be set because scons need it to deduce class names
# from java source, and the default value '1.5' is too low.
blade_java_version = version or '1.6'
self._write_rule('%s.Replace(JAVAVERSION="%s")' % (
self._env_name(), blade_java_version))
if source_version:
self._write_rule('%s.Append(JAVACFLAGS="-source %s")' % (
self._env_name(), source_version))
if target_version:
self._write_rule('%s.Append(JAVACFLAGS="-target %s")' % (
self._env_name(), target_version))
def _generate_cc_compile_rules(self, cc, cxx, cppflags):
self._generate_cc_vars()
cc_config = config.get_section('cc_config')
cflags, cxxflags = cc_config['cflags'], cc_config['cxxflags']
cppflags = cc_config['cppflags'] + cppflags
includes = cc_config['extra_incs']
includes = includes + ['.', self.build_dir]
includes = ' '.join(['-I%s' % inc for inc in includes])
template = self._cc_compile_command_wrapper_template()
cc_command = (
'%s -o ${out} -MMD -MF ${out}.d -c -fPIC %s %s ${optimize} '
'${c_warnings} ${cppflags} %s ${includes} ${in}') % (
cc, ' '.join(cflags), ' '.join(cppflags), includes)
self.generate_rule(name='cc',
command=template % cc_command,
description='CC ${in}',
depfile='${out}.d',
deps='gcc')
cxx_command = (
'%s -o ${out} -MMD -MF ${out}.d -c -fPIC %s %s ${optimize} '
'${cxx_warnings} ${cppflags} %s ${includes} ${in}') % (
cxx, ' '.join(cxxflags), ' '.join(cppflags), includes)
self.generate_rule(name='cxx',
command=template % cxx_command,
description='CXX ${in}',
depfile='${out}.d',
deps='gcc')
securecc = '%s %s' % (cc_config['securecc'], cxx)
self.generate_rule(
name='securecccompile',
command='%s -o ${out} -c -fPIC '
'%s %s ${optimize} ${cxx_warnings} ${cppflags} %s ${includes} ${in}'
% (securecc, ' '.join(cxxflags), ' '.join(cppflags), includes),
description='SECURECC ${in}')
self.generate_rule(name='securecc',
command=self._builtin_command('securecc_object'),
description='SECURECC ${in}',
restat=True)
self._generate_cc_hdrs_rule(cc, cxx, cppflags, cflags, cxxflags,
includes)
def _handle_protoc_plugins(self, plugins):
"""Handle protoc plugins and corresponding dependencies."""
protoc_plugin_config = config.get_section('protoc_plugin_config')
protoc_plugins = []
protoc_plugin_deps, protoc_plugin_java_deps = set(), set()
for plugin in plugins:
if plugin not in protoc_plugin_config:
self.error('Unknown plugin %s' % plugin)
continue
p = protoc_plugin_config[plugin]
protoc_plugins.append(p)
for language, v in iteritems(p.code_generation):
for key in v['deps']:
if key not in self.deps:
self.deps.append(key)
protoc_plugin_deps.add(key)
if language == 'java':
protoc_plugin_java_deps.add(key)
self.attr['protoc_plugin_deps'] = list(protoc_plugin_deps)
self.attr['exported_deps'] += list(protoc_plugin_java_deps)
self.attr['protoc_plugins'] = protoc_plugins
def _setup_env_java(self):
env_java = 'env_java'
self._add_rule('%s = top_env.Clone()' % env_java)
java_config = config.get_section('java_config')
version = java_config['version']
source_version = java_config.get('source_version', version)
target_version = java_config.get('target_version', version)
# JAVAVERSION must be set because scons need it to deduce class names
# from java source, and the default value '1.5' is too low.
java_version = version or '1.6'
self._add_rule('%s.Replace(JAVAVERSION="%s")' % (env_java, java_version))
if source_version:
self._add_rule('%s.Append(JAVACFLAGS="-source %s")' % (
env_java, source_version))
if target_version:
self._add_rule('%s.Append(JAVACFLAGS="-target %s")' % (
env_java, target_version))
jacoco_home = config.get_item('java_test_config', 'jacoco_home')
if jacoco_home:
jacoco_agent = os.path.join(jacoco_home, 'lib', 'jacocoagent.jar')
self._add_rule('%s.Replace(JACOCOAGENT="%s")' % (env_java, jacoco_agent))
def _init_visibility(self, visibility):
"""Initialize the `visibility` attribute.
Parameters
-----------
visibility: the visibility list in BUILD file
Description
-----------
Visibility determines whether another target is able to depend
on this target.
Visibility specify a list of target patterns in the same form as deps,
i.e. //path:target, '//path/:...'. There is a special value is "PUBLIC",
which means this target is visible globally within the code base.
Note that targets inside the same BUILD file are always visible to each
other.
"""
if visibility is None:
global_config = config.get_section('global_config')
if self.key in global_config.get('legacy_public_targets'):
visibility = {'PUBLIC'}
else:
visibility = global_config.get('default_visibility')
self._visibility.update(visibility)
return
self._visibility_is_default = False
visibility = var_to_list(visibility)
if 'PUBLIC' in visibility:
self._visibility.add('PUBLIC')
return
self._visibility.clear()
for v in visibility:
if not target_pattern.is_valid_in_build(v):
#self.error('Invalid build target pattern "%s" for visibility' % v)
continue
key = target_pattern.normalize(v, self.path)
self._visibility.add(key)
def __init__(self, log_dir):
"""Init method. """
if not os.path.exists(log_dir):
os.makedirs(log_dir)
self.__log_dir = log_dir
# key: (id, classifier)
# id: jar id in the format group:artifact:version
# value: an instance of MavenArtifact
self.__jar_database = {}
java_config = config.get_section('java_config')
self.__maven = java_config.get('maven')
self.__central_repository = java_config.get('maven_central')
# Local repository is set to the maven default directory
# and could not be configured currently
local_repository = '~/.m2/repository'
self.__local_repository = os.path.expanduser(local_repository)
self.__need_check_config = True
# Download the snapshot artifact daily
self.__build_time = time.time()
self.__one_day_interval = 86400
def __init__(self,
name,
srcs,
deps,
optimize,
deprecated,
blade,
kwargs):
srcs = var_to_list(srcs)
self._check_thrift_srcs_name(srcs)
CcTarget.__init__(self,
name,
'fbthrift_library',
srcs,
deps,
None,
'',
[], [], [], optimize, [], [],
blade,
kwargs)
fbthrift_config = config.get_section('fbthrift_config')
fbthrift_libs = var_to_list(fbthrift_config['fbthrift_libs'])
# Hardcode deps rule to thrift libraries.
self._add_hardcode_library(fbthrift_libs)
# Link all the symbols by default
self.data['link_all_symbols'] = True
# For each thrift file initialize a FBThriftHelper, which will be used
# to get the source files generated from thrift file.
self.fbthrift_helpers = {}
for src in srcs:
self.fbthrift_helpers[src] = FBThriftHelper(
os.path.join(self.path, src))
def __init__(self,
name,
srcs,
deps,
optimize,
deprecated,
generate_descriptors,
plugins,
source_encoding,
blade,
kwargs):
"""Init method.
Init the proto target.
"""
# pylint: disable=too-many-locals
srcs = var_to_list(srcs)
self._check_proto_srcs_name(srcs)
CcTarget.__init__(self,
name,
'proto_library',
srcs,
deps,
None,
'',
[], [], [], optimize, [], [],
blade,
kwargs)
if srcs:
self.data['public_protos'] = [self._source_file_path(s) for s in srcs]
proto_config = config.get_section('proto_library_config')
protobuf_libs = var_to_list(proto_config['protobuf_libs'])
protobuf_java_libs = var_to_list(proto_config['protobuf_java_libs'])
protobuf_python_libs = var_to_list(proto_config['protobuf_python_libs'])
# Hardcode deps rule to thirdparty protobuf lib.
self._add_hardcode_library(protobuf_libs)
self._add_hardcode_java_library(protobuf_java_libs)
self._add_hardcode_library(protobuf_python_libs)
plugins = var_to_list(plugins)
self.data['protoc_plugins'] = plugins
# Handle protoc plugin deps according to the language
protoc_plugin_config = config.get_section('protoc_plugin_config')
protoc_plugin_deps = set()
protoc_plugin_java_deps = set()
for plugin in plugins:
if plugin not in protoc_plugin_config:
console.error_exit('%s: Unknown plugin %s' % (self.fullname, plugin))
p = protoc_plugin_config[plugin]
for language, v in p.code_generation.iteritems():
for key in v['deps']:
if key not in self.deps:
self.deps.append(key)
if key not in self.expanded_deps:
self.expanded_deps.append(key)
protoc_plugin_deps.add(key)
if language == 'java':
protoc_plugin_java_deps.add(key)
self.data['protoc_plugin_deps'] = list(protoc_plugin_deps)
# Normally a proto target depends on another proto target when
# it references a message defined in that target. Then in the
# generated code there is public API with return type/arguments
# defined outside and in java it needs to export that dependency,
# which is also the case for java protobuf library.
self.data['exported_deps'] = self._unify_deps(var_to_list(deps))
self.data['exported_deps'] += self._unify_deps(protobuf_java_libs)
self.data['exported_deps'] += list(protoc_plugin_java_deps)
# Link all the symbols by default
self.data['link_all_symbols'] = True
self.data['deprecated'] = deprecated
self.data['source_encoding'] = source_encoding
self.data['java_sources_explict_dependency'] = []
self.data['python_vars'] = []
self.data['python_sources'] = []
self.data['generate_descriptors'] = generate_descriptors
