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)
