def main(): parser = make_parser() args = parser.parse_args() pathf.check_technical_area(args.area, args.module_name) module = args.module_name source = pathf.dev_module_path(module, args.area) logging.debug(source) if vcs_git.is_server_repo(source): repo = vcs_git.temp_clone(source) releases = vcs_git.list_module_releases(repo) if releases: last_release_num = releases[-1] else: print("No release has been done for " + module) # return so last_release_num can't be referenced before assignment return 1 else: raise Exception(source + " does not exist on the repository.") # Get a single log between last release and HEAD # If there is one, then changes have been made logs = list(repo.iter_commits(last_release_num + "..HEAD", max_count=1)) if logs: print("Changes have been made to " + module + " since release " + last_release_num) else: print("No changes have been made to " + module + " since most recent release " + last_release_num) shutil.rmtree(repo.working_tree_dir)
def main(): parser = make_parser() args = parser.parse_args() env.check_epics_version(args.epics_version) pathf.check_technical_area(args.area, args.module_name) # Force check of repo, not file system, for tools, etc and epics (previous releases are only stored on repo) if args.area in ["etc", "tools", "epics"]: args.git = True # Check for the existence of releases of this module/IOC releases = [] if args.git: # List branches of repository target = "the repository" source = pathf.dev_module_path(args.module_name, args.area) repo = vcs_git.temp_clone(source) releases = vcs_git.list_module_releases(repo) shutil.rmtree(repo.working_tree_dir) else: # List branches from prod target = "prod" source = env.prodArea(args.area) if args.area == 'python' and args.rhel_version >= 6: source = os.path.join(source, "RHEL{0}-{1}".format(args.rhel_version, platform.machine())) logging.debug(source) release_dir = os.path.join(source, args.module_name) if os.path.isdir(release_dir): for p in os.listdir(release_dir): if os.path.isdir(os.path.join(release_dir, p)): releases.append(p) # Check some releases have been made if len(releases) == 0: if args.git: print(args.module_name + ": No releases made in git") else: print(args.module_name + ": No releases made for " + args.epics_version) return 1 releases = env.sortReleases(releases) if args.latest: print("The latest release for " + args.module_name + " in " + target + " is: " + releases[-1]) else: print("Previous releases for " + args.module_name + " in " + target + ":") for release in releases: print(release)
def _check_if_remote_repo_has_app(self, remote_repo_path): """Checks if the remote repository contains an app_nameApp folder. This checks whether or not there is already a folder with the name "app_nameApp" on the remote repository with the given gitolite repository path. Sets the `_remote_repo_valid` boolean value to True if there are no conflicts. Returns: bool: True if app exists, False otherwise. Raises: :class:`~dls_ade.exceptions.RemoteRepoError`: If given repo path \ does not exist on gitolite. This should never be raised. There is a bug if it is! :class:`~dls_ade.exceptions.VCSGitError`: Issue with the vcs_git \ function calls. """ if not vcs_git.is_server_repo(remote_repo_path): # This should never get raised! err_message = ("Remote repo {repo:s} does not exist. Cannot " "clone to determine if there is an app_name " "conflict with {app_name:s}") err_message = err_message.format(repo=remote_repo_path, app_name=self._app_name) raise RemoteRepoError(err_message) temp_dir = "" exists = False try: repo = vcs_git.temp_clone(remote_repo_path) temp_dir = repo.working_tree_dir if os.path.exists(os.path.join(temp_dir, self._app_name + "App")): exists = True finally: try: if temp_dir: shutil.rmtree(temp_dir) except OSError: pass return exists
def clone_server_repo(self): """Clone the server_repo_path to a temp dir and return the path. If a branch name is set, then the remote branch will be checked out. Raises: VCSGitError: From vcs_git.temp_clone() """ logging.debug("Cloning the server repository to temporary directory.") repo = vcs_git.temp_clone(self._server_repo_path) if self._branch_name: vcs_git.checkout_remote_branch(self._branch_name, repo) self._server_repo_clone_path = repo.working_tree_dir logging.debug("The cloned directory is: " + self._server_repo_clone_path)
def main(): parser = make_parser() args = parser.parse_args() pathf.check_technical_area(args.area, args.module_name) source = pathf.dev_module_path(args.module_name, args.area) print("Branches of " + args.module_name + ":\n") repo = vcs_git.temp_clone(source) branches = vcs_git.list_remote_branches(repo) for branch in branches: print(branch) print("") shutil.rmtree(repo.working_tree_dir)
def test_checkout_entire_area(self): tempdir = tempfile.mkdtemp() cwd = os.getcwd() os.chdir(tempdir) modules = ["controlstest/targetOS/mock_repo/ioc/BTEST/BTEST-EB-IOC-03", "controlstest/targetOS/mock_repo/ioc/BTEST/TS", "controlstest/targetOS/mock_repo/ioc/BTEST2/TS"] should_not_clone = ["controlstest/targetOS/mock_repo/python/dls_testpythonmod", "controlstest/targetOS/mock_repo/support/testsupportmod"] process = subprocess.Popen("dls-checkout-module.py -i".split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) std_out, std_err = process.communicate('Y') logging.debug("Standard out:\n" + std_out) logging.debug("Standard error:\n" + std_err) # Check correct folders have been created for path in modules: assert_true(os.path.isdir(path.split('/', 2)[-1])) for path in should_not_clone: assert_false(os.path.isdir(path.split('/', 2)[-1])) # Check modules have been cloned correctly for path in modules: repo = path.split('/', 2)[-1] clone = vcs_git.temp_clone(path) comp_repo = clone.working_tree_dir assert_true(st.check_if_repos_equal(repo, comp_repo)) os.chdir(cwd) shutil.rmtree(tempdir)
def set_server_repo_to_default(self): """Sets the given server repository to a default state. Note: If used on an existing server repository, all commit history will be overwritten. Raises: :class:`.SettingsError`: If default given but no server repo. :class:`dls_ade.exceptions.VCSGitError`: From \ :mod:`~dls_ade.vcs_git` functions. """ if not self._default_server_repo_path: return if not self._server_repo_path: raise SettingsError("If 'default_server_repo_path is set, then " "'server_repo_path' must also be set.") logging.debug("Setting server repo to default.") logging.debug("'Default' server repo path: " + self._default_server_repo_path) temp_repo = vcs_git.temp_clone(self._default_server_repo_path) vcs_git.delete_remote(temp_repo.working_tree_dir, "origin") if vcs_git.is_server_repo(self._server_repo_path): temp_repo.create_remote( "origin", os.path.join(vcs_git.GIT_SSH_ROOT, self._server_repo_path) ) temp_repo.git.push("origin", temp_repo.active_branch, "-f") else: vcs_git.add_new_remote_and_push(self._server_repo_path, temp_repo.working_tree_dir)
def get_local_temp_clone(server_repo_path): """Obtain the root directory for a temporary clone of the given repository. Args: server_repo_path: The repository path for the server. Returns: str: The root directory of the cloned server repository. This will always be located in a temporary folder. Raises: :class:`~dls_ade.exceptions.VCSGitError`: From \ :func:`dls_ade,vcs_git.temp_clone`. """ logging.debug("Cloning server repo path: " + server_repo_path) repo = vcs_git.temp_clone(server_repo_path) tempdir = repo.working_tree_dir logging.debug("Server repo path cloned to: " + tempdir) return tempdir
def main(): parser = make_parser() args = parser.parse_args() check_parsed_args_compatible(args.imp, args.modules, args.contact, args.cc, parser) # Create the list of modules from args, or the gitolite server if none provided modules = [] if args.modules: for module in args.modules: modules.append(module) else: for module in get_area_module_list(args.area): modules.append(module) # If no contacts or csv file provided to edit, default script operation: print contacts if not (args.contact or args.cc or args.imp): print_out = [] for module in modules: source = pathf.dev_module_path(module, args.area) repo = vcs_git.temp_clone(source) # Retrieve contact info contact = repo.git.check_attr("module-contact", ".").split(' ')[-1] cc_contact = repo.git.check_attr("module-cc", ".").split(' ')[-1] if args.csv: print_out.append(output_csv_format(contact, cc_contact, module)) else: print_out.append("Contact: " + contact + " (CC: " + cc_contact + ")") shutil.rmtree(repo.working_tree_dir) if args.csv: print("Module,Contact,Contact Name,CC,CC Name") for entry in print_out: print(entry) return 0 # If we get to this point, we are assigning contacts if args.imp: contacts = import_from_csv(modules, args.area, args.imp) else: # If no csv file provided, retrieve contacts from args contacts = [] for module in modules: contacts.append((module, args.contact, args.cc)) # Checkout modules and change contacts for module, contact, cc in contacts: print("Cloning " + module + " from " + args.area + " area...") source = pathf.dev_module_path(module, args.area) repo = vcs_git.temp_clone(source) edit_summary = edit_contact_info(repo, contact, cc,) if edit_summary != 0: index = repo.index index.add(['.gitattributes']) index.commit(edit_summary) origin = repo.remotes.origin origin.push(repo.active_branch) shutil.rmtree(repo.working_tree_dir)
def main(): parser = make_parser() args = parser.parse_args() raw = set_raw_argument(args.raw) pathf.check_technical_area(args.area, args.module_name) check_parsed_args_compatible(args.releases, args.earlier_release, args.later_release, parser) check_releases_valid(args.releases, parser) source = pathf.dev_module_path(args.module_name, args.area) if vcs_git.is_server_repo(source): repo = vcs_git.temp_clone(source) releases = vcs_git.list_module_releases(repo) logging.debug(releases) else: raise Exception("Module " + args.module_name + " doesn't exist in " + source) # Set start and end releases and check they exist, set to defaults if not given start, end = set_log_range(args.module_name, args.releases, args.earlier_release, args.later_release, releases) # Create log info from log messages # log_info is a dictionary in the form {logs(list), commit_objects(dict), max_author_length(int)} log_info = get_log_messages(repo) if len(releases) > 0: if start == "": tag_start = releases[0] else: tag_start = start # Append tag info to log info from tag messages tags = get_tags_list(repo, tag_start, end, releases[-1]) log_info = get_tag_messages(tags, log_info) # Check if there are any logs, exit if not if not log_info['logs']: print("No logs for " + args.module_name + " between releases " + args.earlier_release + " and " + args.later_release) return 0 # Sort tags and commits chronologically by the UNIX time stamp in index 0 log_info['logs'] = sorted(log_info['logs'], key=itemgetter(0)) # Make list of printable log entries formatted_logs = format_log_messages(log_info, raw, args.verbose) if end == 'HEAD': print_bool = True else: print_bool = False release_marker = "(RELEASE: {})" for log in formatted_logs: if log.endswith(release_marker.format(end)): print_bool = True if print_bool: print(log) if log.endswith(release_marker.format(start)): break shutil.rmtree(repo.working_tree_dir)