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_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