def get_stack_of_remote_repository(name, type_, url, workspace=None, version=None, skip_update=False): if workspace is None: workspace = tempfile.mkdtemp() if not os.path.isdir(workspace): os.makedirs(workspace) # fetch repository workdir = os.path.join(workspace, name) client = vcstools.VcsClient(type_, workdir) is_good = False if client.path_exists(): if client.get_url() == url: if not skip_update: logging.disable(logging.WARNING) is_good = client.update(version if version is not None else '') logging.disable(logging.NOTSET) else: is_good = True if not is_good: shutil.rmtree(workdir) if not is_good: logging.disable(logging.WARNING) is_good = client.checkout(url, version=version if version is not None else '') logging.disable(logging.NOTSET) if not is_good: raise RuntimeError('Impossible to update/checkout repo.') # parse stack.xml stack_xml_path = os.path.join(workdir, 'stack.xml') if not os.path.isfile(stack_xml_path): raise IOError('No stack.xml found in repository.') return rospkg.stack.parse_stack_file(stack_xml_path)
def checkout_dev_to_tmp(name, distro_stack): """ Checkout an VCS-based 'dev' code tree to the tmp dir. @return: temporary directory that contains checkout of SVN tree in directory 'name'. temporary directory will be a subdirectory of OS-provided temporary space. @rtype: str """ for key in ['svn', 'git', 'hg', 'bzr']: if key in distro_stack._rules: break else: raise Exception("stack [%s] does not have any supported checkout rules"%(name)) try: if key == 'svn': uri = distro_stack.expand_rule(distro_stack._rules[key]['dev']) version = '' elif key in ['hg', 'git', 'bzr']: uri = distro_stack.expand_rule(distro_stack._rules[key]['uri']) version = distro_stack.expand_rule(distro_stack._rules[key]['dev-branch']) else: raise Exception ("key %s not implemented"%key) except KeyError: raise Exception("cannot checkout stack dev tree to tmp: %s rules have no 'dev' key"%(key)) tmp_dir = tempfile.mkdtemp() dest = os.path.join(tmp_dir, name) print 'Checking out a fresh copy of %s from %s to %s...'%(name, uri, dest) vcs_client = vcstools.VcsClient(key, dest) vcs_client.checkout(uri, version) return tmp_dir
def checkout_branch(distro_stack, branch_name, executor): """ Checkout an VCS-based 'dev' code tree to a temporary directory. WARNING: executor cannot be used for simulating this method. :param executor: only used for printing. Actual checkout will occur regardless of executor. :param distro_stack: `DistroStack` instance for stack :param branch_name: branch name to checkout. See `rospkg.distro.VcsConfig` for valid values. :returns: temporary directory that contains checkout of tree temporary directory. The checkout will be in a subdirectory matching the stack name. This returns the parent directory so that checkout and the temporary directory can be removed easily. ``str`` :raises: :exc:`ValueError` if branch is invalid """ stack_name = distro_stack.name vcs_config = distro_stack.vcs_config # get this before we do anything with sideeffects uri, branch_version = vcs_config.get_branch(branch_name, anonymous=False) branch_version = branch_version or '' # convert for vcstools tmp_dir = tempfile.mkdtemp() dest = os.path.join(tmp_dir, stack_name) executor.info('Checking out a fresh copy of %s from %s to %s...' % (stack_name, uri, dest)) vcs_client = vcstools.VcsClient(vcs_config.type, dest) vcs_client.checkout(uri, branch_version) return tmp_dir
def get_stack_of_remote_repository(name, type, url, workspace=None, version=None): if workspace is None: workspace = tempfile.mkdtemp() if not os.path.isdir(workspace): os.makedirs(workspace) #print('Working on repository "%s" at "%s"...' % (name, url)) # fetch repository workdir = os.path.join(workspace, name) client = vcstools.VcsClient(type, workdir) if client.path_exists(): if client.get_url() == url: client.update(version if version is not None else '') else: shutil.rmtree(workdir) client.checkout(url, version=version if version is not None else '', shallow=True) else: client.checkout(url, version=version if version is not None else '', shallow=True) # parse stack.xml stack_xml_path = os.path.join(workdir, 'stack.xml') if not os.path.isfile(stack_xml_path): raise IOError( 'No stack.xml found in repository "%s" at "%s"; skipping' % (name, url)) return rospkg.stack.parse_stack_file(stack_xml_path)
def process_repo(repo, ros_distro, repos_dir, build_binary=False, redo=False): # Create the repo directory if needed repo_dir = os.path.join(repos_dir, repo['name']) repo['working_dir'] = repo_dir print( "+++ Processing repository: [%(name)s] from `%(url)s` in directory [%(working_dir)s]" % repo) if not redo: if os.path.exists(os.path.join(repo_dir, 'GENERATED')): print( " [%(name)s] Distribution generation has already been done on this repo, and redo was not set, skipping..." % repo) return make_directory(repo_dir) # Setup the sources src_dir = os.path.join(repo_dir, 'sources') repo['src_dir'] = src_dir # Detect the scm type scm_type = detect_scm_type(repo['url']) vcs_client = vcstools.VcsClient(scm_type, src_dir) # If the source directory exists, try to update it source_ok = False if os.path.exists(src_dir): # If the source directory contains a repo of the correct type # and if the url's match, try to update if vcs_client.detect_presence() and vcs_client.get_url( ) == repo['url']: print(" [%(name)s] Sources exist, attempting to update..." % repo) vcs_client.update(vcs_client.get_version()) source_ok = True # Else remove the directory so it can get a fresh checkout else: # Why did it fail? if not vcs_client.detect_presence(): print( " [%(name)s] Sources exist, but scm type doesn't match, deleting..." % repo) elif vcs_client.get_url() != repo['url']: print( " [%(name)s] Sources exist, but url's don't match, deleting..." % repo) else: print( " [%(name)s] Sources exist, but could not update, deleting..." % repo) # Remove the tree from shutil import rmtree rmtree(src_dir) # Make a new directory to checkout to make_directory(src_dir) # If the update failed, check it out if not source_ok: print(" [%(name)s] Fetching sources to %(src_dir)s ..." % repo) vcs_client.checkout(repo['url']) # Generate a Homebrew formula using the 'generate-homebrew-formula' command script_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'generate-homebrew-formula.py') stack_path = os.path.abspath(os.path.join(src_dir, 'stack.yaml')) call(repo_dir, ['python', script_path, ros_distro, stack_path, repo['url']]) # If the call was successful, put a GENEREATED file in the directory open(os.path.join(repo_dir, 'GENERATED'), 'w').close()
def repo_clone(https_url, vcs_type): reponame = https_url.rsplit('/', 1)[1] client = vcstools.VcsClient(vcs_type, repos_local_path + reponame) client.checkout(https_url)