def init_workspace(): args = parse_arguments() if not args.track: args.track = settings.get_default_track() if args.list_rosinstalls: list_rosinstalls(args.track) sys.exit(0) if os.path.isabs(args.dir): workspace_dir = args.dir else: workspace_dir = os.path.join(os.getcwd(), args.dir) if not os.path.isdir(workspace_dir): os.mkdir(workspace_dir) if os.path.isdir(os.path.join(workspace_dir, 'src')): raise RuntimeError("This workspace is already initialised") uri_list = [] lookup_name_list = [] for uri in args.uri: if os.path.isabs(uri): uri_list.append(uri) elif os.path.isfile(os.path.join(os.getcwd(), uri)): uri_list.append(os.path.join(os.getcwd(), uri)) elif urlparse.urlparse(uri).scheme == "": # not a http element, let's look up our database lookup_name_list.append(uri) else: # it's a http element' uri_list.append(uri) rosinstall_database, lookup_track, lookup_database = get_rosinstall_database(args.track) (database_name_list, database_uri_list) = parse_database(lookup_name_list, rosinstall_database) lookup_name_list.extend(database_name_list) uri_list.extend(database_uri_list) populate_worskpace(os.path.join(workspace_dir, 'src'), uri_list, args.jobs) print_details(workspace_dir, uri_list, lookup_name_list, lookup_track, lookup_database)
def init_build(): args = parse_arguments() ########################## # Default underlays ########################## if args.no_default_underlay: args.default_underlay = None elif not args.default_underlay: args.default_underlay = settings.get_default_track() ########################## # Toolchains and Platform ########################## if args.list_toolchains: list_toolchains() return if args.list_platforms: list_platforms() return if args.clean: clean(args.dir, args.sources) return init_configured_build(args.default_underlay, args.dir, args.sources, args.underlays, args.install, args.doc, args.release, args.toolchain, args.platform)
def init_build(): args = parse_arguments() ########################## # Tracks ########################## if not args.track: args.track = settings.get_default_track() ########################## # Toolchains and Platform ########################## if args.list_toolchains: list_toolchains() return if args.list_platforms: list_platforms() return init_configured_build(args.dir, args.sources, args.underlays, args.install, args.release, args.toolchain, args.platform)
def init_workspace(): ''' Process the init workspace command and return success or failure to the calling script. ''' args = parse_arguments() if not args.track: args.track = settings.get_default_track() if args.list_rosinstalls: list_rosinstalls(args.track) return 0 if args.merge is not None: merge(args.merge, args.track, args.jobs) return 0 if os.path.isabs(args.dir): workspace_dir = args.dir else: workspace_dir = os.path.join(os.getcwd(), args.dir) if not os.path.isdir(workspace_dir): os.mkdir(workspace_dir) if os.path.isdir(os.path.join(workspace_dir, 'src')): raise RuntimeError("This workspace is already initialised") uri_list = [] lookup_name_list = [] for uri in args.uri: if os.path.isabs(uri): uri_list.append(uri) elif os.path.isfile(os.path.join(os.getcwd(), uri)): uri_list.append(os.path.join(os.getcwd(), uri)) elif urlparse.urlparse( uri ).scheme == "": # not a http element, let's look up our database lookup_name_list.append(uri) else: # it's a http element' uri_list.append(uri) rosinstall_database, lookup_track, lookup_database = get_rosinstall_database( args.track) (database_name_list, database_uri_list) = parse_database(lookup_name_list, rosinstall_database) lookup_name_list.extend(database_name_list) uri_list.extend(database_uri_list) populate_workspace(os.path.join(workspace_dir, 'src'), uri_list, args.jobs) print_details(workspace_dir, uri_list, lookup_name_list, lookup_track, lookup_database) return 0
def init_workspace(): args = parse_arguments() if not args.track: args.track = settings.get_default_track() if args.list_rosinstalls: list_rosinstalls(args.track) sys.exit(0) # if not which("/opt/ros/" + args.track + "/bin/catkin_init_workspace"): # sys.exit("\nCatkin is not installed: 'sudo apt-get install ros-%s-catkin'\n" % args.track) if os.path.isabs(args.dir): workspace_dir = args.dir else: workspace_dir = os.path.join(os.getcwd(), args.dir) if not os.path.isdir(workspace_dir): os.mkdir(workspace_dir) if os.path.isdir(os.path.join(workspace_dir, 'src')): sys.exit("This workspace is already initialised") if args.uri: uri = args.uri # assume its an absolute path or http uri if not os.path.isabs(args.uri): if os.path.isfile(os.path.join(os.getcwd(), args.uri)): uri = os.path.join(os.getcwd(), args.uri) else: if urlparse.urlparse(args.uri).scheme == "": # not a http element, let's look up our databas console.pretty_print("Retrieving", console.cyan) console.pretty_print(" %s " % args.uri, console.yellow) console.pretty_print("on track", console.cyan) console.pretty_print(" %s " % args.track, console.yellow) console.pretty_print("from", console.cyan) console.pretty_println(" %s " % settings.get_rosinstall_database_uri(), console.yellow) response = urllib2.urlopen('%s/%s.yaml' % (settings.get_rosinstall_database_uri(), args.track)) rosinstalls = yaml.load(response.read()) if args.uri in rosinstalls: uri = rosinstalls[args.uri] else: console.logerror("Uri not an absolute path, local file, http or in our rosinstall database.") sys.exit(1) else: uri = "" populate_worskpace(os.path.join(workspace_dir, 'src'), uri) print_details(workspace_dir, uri)
def init_configured_build(build_dir_="./", source_dir_="./src", underlays_="/opt/ros/groovy", install_prefix_="./install", release_=False, toolchain_="", platform_=""): ''' This one is used with pre-configured parameters. Note that init_build generates parameters parsed from the command line and then calls this function. ''' # Help us build the name for the eclipse workspace...usually we call in the workspace itself. workspace_dir = os.getcwd() ########################## # Build directory ########################## if os.path.isabs(build_dir_): build_dir = build_dir_ else: if build_dir_ == "." or build_dir_ == "./": build_dir = os.getcwd() else: build_dir = os.path.join(os.getcwd(), build_dir_) if not os.path.isfile(os.path.join(build_dir, "Makefile")): if not os.path.isdir(build_dir): # remember ./ is a valid build dir, even if it's not populated yet os.mkdir(build_dir) else: raise RuntimeError("This build directory is already initialised") ########################## # Source directory ########################## source_dir = os.path.abspath(source_dir_) build_source_dir = os.path.join(build_dir, 'src') if not os.path.isdir(source_dir): raise RuntimeError("Specified source space does not exist [" + source_dir + "]") if not os.path.isfile(os.path.join(source_dir, ".rosinstall")): raise RuntimeError("Could not find a valid source folder (must contain a .rosinstall file therein)'") if os.path.exists(build_source_dir): if not source_dir == build_source_dir: raise RuntimeError("The build directory already has a ./src directory which doesn't match the desired source directory [%s]" % source_dir) else: os.mkdir(build_source_dir) source_subdirectories = os.walk(source_dir).next()[1] for d in source_subdirectories: common.create_symlink(os.path.join(source_dir, d), os.path.join(build_source_dir, d)) ########################## # Underlays ########################## try: env_underlays = os.environ['CMAKE_PREFIX_PATH'] except KeyError: env_underlays = "" underlays_list = [underlay for underlay in underlays_.split(';') if underlay] env_underlays_list = [underlay for underlay in env_underlays.split(':') if underlay] for underlay in env_underlays_list: if underlay not in underlays_list: underlays_list.append(underlay) ########################## # Locate Catkin ########################## catkin_toplevel = None if os.path.isfile(os.path.join(source_dir, 'catkin', 'cmake', 'toplevel.cmake')): catkin_toplevel = os.path.join(source_dir, 'catkin', 'cmake', 'toplevel.cmake') else: catkin_toplevel, unused_catkin_python_path, unused_catkin_cmake_path = common.find_catkin(underlays_list) ########################## # Add toplevel if exists ########################## if not catkin_toplevel: # Add the default track underlay default_track = settings.get_default_track() if os.path.isfile(os.path.join("/opt/ros/%s" % default_track, 'share', 'catkin', 'cmake', 'toplevel.cmake')): catkin_toplevel = os.path.join("/opt/ros/%s" % default_track, 'share', 'catkin', 'cmake', 'toplevel.cmake') unused_catkin_python_path = os.path.join("/opt/ros/%s" % default_track, 'lib', 'python2.7', 'dist-packages') console.pretty_println("No catkin found, adding the default track underlay (use yujin_tools_settings to change) [/opt/ros/%s]" % default_track, console.cyan) underlays_list.append("/opt/ros/%s" % default_track) else: raise RuntimeError("Could not find an underlying catkin installation.") common.create_symlink(catkin_toplevel, os.path.join(build_source_dir, "CMakeLists.txt")) underlays = ';'.join(underlays_list) ########################## # Other Args ########################## if install_prefix_ == "/not_set_directory": install_prefix = os.path.join(build_dir, "install") else: install_prefix = install_prefix_ if release_: build_type = "Release" else: build_type = "DebugWithRelSymbols" name = os.path.basename(workspace_dir) + "_" + os.path.basename(build_dir) print_build_details(build_dir, source_dir, install_prefix, build_type, underlays, name, toolchain_, platform_) os.chdir(build_dir) ########################## # Toolchain ########################## if not toolchain_ == "": toolchains_dir = os.path.join(os.path.dirname(__file__), 'toolchains') custom_toolchains_dir = os.path.join(settings.yujin_tools_home(), 'toolchains') tmp_list = toolchain_.split('/') if len(tmp_list) != 2: raise RuntimeError("Toolchain specification invalid, must be <family>/<tuple> [%s]" % toolchain_) family = tmp_list[0] toolchain_tuple = tmp_list[1] toolchains = get_toolchains_or_platforms(toolchains_dir) custom_toolchains = get_toolchains_or_platforms(custom_toolchains_dir) if not family in toolchains and not family in custom_toolchains: raise RuntimeError("No toolchains available for family %s" % family) if family in toolchains and toolchain_tuple in toolchains[family]: toolchain_file = os.path.join(toolchains_dir, family, toolchain_tuple + ".cmake") elif family in custom_toolchains and toolchain_tuple in custom_toolchains[family]: toolchain_file = os.path.join(custom_toolchains_dir, family, toolchain_tuple + ".cmake") else: raise RuntimeError("Platform %s for family %s not available." % (family, toolchain_tuple)) if os.path.isfile(toolchain_file): shutil.copy(toolchain_file, os.path.join(build_dir, "toolchain.cmake")) else: raise RuntimeError("Toolchain module not available [%s]" % toolchain_file) ########################## # Platform ########################## platform_content = "" platforms_dir = os.path.join(os.path.dirname(__file__), 'platforms') custom_platforms_dir = os.path.join(settings.yujin_tools_home(), 'platforms') if not platform_ == "default": tmp_list = platform_.split('/') if len(tmp_list) != 2: raise RuntimeError("Platform specification invalid, must be <family>/<platform type> [%s]" % platform_) family = tmp_list[0] platform = tmp_list[1] platforms = get_toolchains_or_platforms(platforms_dir) custom_platforms = get_toolchains_or_platforms(custom_platforms_dir) if not family in platforms and not family in custom_platforms: raise RuntimeError("No platforms available for family %s" % family) if family in platforms and platform in platforms[family]: platform_file = os.path.join(platforms_dir, family, platform + ".cmake") elif family in custom_platforms and platform in custom_platforms[family]: platform_file = os.path.join(custom_platforms_dir, family, platform + ".cmake") else: raise RuntimeError("Platform %s for family %s not available." % (family, platform)) else: platform_file = os.path.join(platforms_dir, 'default.cmake') if os.path.isfile(platform_file): f = open(platform_file, 'r') try: platform_content = f.read() finally: f.close() else: raise RuntimeError("Platform configuration not available [%s]" % platform_) ########################## # Cache ########################## instantiate_config_cmake(platform_content, build_dir, build_type, install_prefix, underlays) ########################## # Templates ########################## instantiate_template('.bashrc', name, build_dir) instantiate_template('konsole', name, build_dir) instantiate_template('gnome-terminal', name, build_dir) instantiate_template('eclipse', name, build_dir)
def make_main(): args = _parse_args() cmake_args = args.cmake_args if args.no_color: terminal_color.disable_ANSI_colors() (base_path, build_path, devel_path, source_path) = common.get_default_paths() doc_path = config_cache.get_doc_prefix_from_config_cmake(base_path) validate_build_space(base_path) # raises a RuntimeError if there is a problem # Install rosdeps if requested if args.install_rosdeps: install_rosdeps(base_path, source_path, settings.get_default_track(), args.no_color) return if args.install_rosdeps_track is not None: install_rosdeps(source_path, args.install_rosdeps_track, args.no_color) return # Clear out previous temporaries if requested if args.pre_clean: console.pretty_print("Pre-cleaning before building.", console.cyan) shutil.rmtree(devel_path, ignore_errors=True) shutil.rmtree(build_path, ignore_errors=True) shutil.rmtree(doc_path, ignore_errors=True) # check for new build if not os.path.exists(build_path): os.mkdir(build_path) #if not os.path.exists(devel_path): # os.mkdir(devel_path) # ensure toplevel cmake file exists toplevel_cmake = os.path.join(source_path, 'CMakeLists.txt') if not os.path.exists(toplevel_cmake): return fmt('@{rf}No toplevel cmake file@') # did source paths get added to the original location? check_and_update_source_repo_paths(source_path) packages = find_packages(source_path, exclude_subspaces=True) # verify that specified package exists in workspace if args.pkg: packages_by_name = {p.name: path for path, p in packages.iteritems()} if args.pkg not in packages_by_name: raise RuntimeError('Package %s not found in the workspace' % args.pkg) # check if cmake must be run (either for a changed list of package paths or changed cmake arguments) force_cmake, _ = builder.cmake_input_changed(packages, build_path, cmake_args=cmake_args) # check if toolchain.cmake, config.cmake exist toolchain_cmd = "-DCMAKE_TOOLCHAIN_FILE=%s" % os.path.join(base_path, 'toolchain.cmake') if os.path.isfile(os.path.join(base_path, 'toolchain.cmake')) else None config_cmd = "-C%s" % os.path.join(base_path, 'config.cmake') if os.path.isfile(os.path.join(base_path, 'config.cmake')) else None # Help find catkin cmake and python unused_catkin_toplevel, catkin_python_path, unused_catkin_cmake_path = common.find_catkin(base_path) pkg_config_paths = common.generate_pkg_config_path(base_path) env = os.environ.copy() # PYTHONPATH # Don't add to the environment variable - this mucks up catkin's catkin_generated/setup_cached.py # environment later (how? I can't remember - something to do with the default underlay). # Maybe we can do away with this now catkin can look up install spaces? #try: # env['PYTHONPATH'] = env['PYTHONPATH'] + os.pathsep + catkin_python_path #except KeyError: # env['PYTHONPATH'] = catkin_python_path sys.path.append(catkin_python_path) # PKG_CONFIG_PATH for path in pkg_config_paths: try: env['PKG_CONFIG_PATH'] = env['PKG_CONFIG_PATH'] + os.pathsep + path except KeyError: env['PKG_CONFIG_PATH'] = path if args.doc_only: console.pretty_println('Generates documents only', console.bold_white) make_doc(source_path, doc_path, packages) return # consider calling cmake makefile = os.path.join(build_path, 'Makefile') if not os.path.exists(makefile) or args.force_cmake or force_cmake: cmd = ['cmake', source_path] if toolchain_cmd: cmd.append(toolchain_cmd) if config_cmd: cmd.append(config_cmd) cmd += cmake_args #new_env = common.generate_underlays_environment(base_path) try: builder.print_command_banner(cmd, build_path, color=not args.no_color) if args.no_color: builder.run_command(cmd, build_path, env=env) else: builder.run_command_colorized(cmd, build_path, env=env) except subprocess.CalledProcessError: return fmt('@{rf}Invoking @{boldon}"cmake"@{boldoff} failed') else: cmd = ['make', 'cmake_check_build_system'] #new_env = common.generate_environment(base_path) # underlays + current workspace try: builder.print_command_banner(cmd, build_path, color=not args.no_color) if args.no_color: builder.run_command(cmd, build_path, env=env) else: builder.run_command_colorized(cmd, build_path, env=env) except subprocess.CalledProcessError: return fmt('@{rf}Invoking @{boldon}"make cmake_check_build_system"@{boldoff} failed') insert_yujin_make_signature(base_path, devel_path) # invoke make if not args.cmake_only: if args.target: cmd = ['make', args.target] elif args.install: cmd = ['make', 'install'] elif args.tests: cmd = ['make', 'tests'] elif args.run_tests: cmd = ['make', 'test'] else: cmd = ['make'] jobs = args.jobs if args.jobs == '': cmd.append('-j') else: jobs = args.jobs if not jobs: if 'ROS_PARALLEL_JOBS' in os.environ: ros_parallel_jobs = os.environ['ROS_PARALLEL_JOBS'] cmd += [arg for arg in ros_parallel_jobs.split(' ') if arg] else: jobs = multiprocessing.cpu_count() if jobs: cmd.append('-j%d' % jobs) cmd.append('-l%d' % jobs) cmd += args.make_args try: make_path = build_path if args.pkg: make_path = os.path.join(make_path, packages_by_name[args.pkg]) builder.print_command_banner(cmd, make_path, color=not args.no_color) builder.run_command(cmd, make_path, env=env) except subprocess.CalledProcessError: return fmt('@{rf}Invoking @{boldon}"make"@{boldoff} failed') if args.doc: make_doc(source_path, doc_path, packages)