A console script that allows you to easily update multiple git repositories at once
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.

284 lignes
10 KiB

  1. # -*- coding: utf-8 -*-
  2. #
  3. # Copyright (C) 2011-2014 Ben Kurtovic <ben.kurtovic@gmail.com>
  4. # See the LICENSE file for details.
  5. from __future__ import print_function
  6. import os
  7. from colorama import Fore, Style
  8. from git import RemoteReference as RemoteRef, Repo, exc
  9. from git.util import RemoteProgress
  10. __all__ = ["update_bookmarks", "update_directories"]
  11. BOLD = Style.BRIGHT
  12. BLUE = Fore.BLUE + BOLD
  13. GREEN = Fore.GREEN + BOLD
  14. RED = Fore.RED + BOLD
  15. YELLOW = Fore.YELLOW + BOLD
  16. RESET = Style.RESET_ALL
  17. INDENT1 = " " * 3
  18. INDENT2 = " " * 7
  19. ERROR = RED + "Error:" + RESET
  20. class _ProgressMonitor(RemoteProgress):
  21. """Displays relevant output during the fetching process."""
  22. def __init__(self):
  23. super(_ProgressMonitor, self).__init__()
  24. self._started = False
  25. def update(self, op_code, cur_count, max_count=None, message=''):
  26. """Called whenever progress changes. Overrides default behavior."""
  27. if op_code & (self.COMPRESSING | self.RECEIVING):
  28. if op_code & self.BEGIN:
  29. print("\b, " if self._started else " (", end="")
  30. if not self._started:
  31. self._started = True
  32. if op_code & self.END:
  33. end = ")"
  34. else:
  35. end = "\b" * (1 + len(cur_count) + len(max_count))
  36. print("{0}/{1}".format(cur_count, max_count), end=end)
  37. class _Stasher(object):
  38. """Manages the stash state of a given repository."""
  39. def __init__(self, repo):
  40. self._repo = repo
  41. self._clean = self._stashed = False
  42. def clean(self):
  43. """Ensure the working directory is clean, so we can do checkouts."""
  44. if not self._clean:
  45. res = self._repo.git.stash("--all")
  46. self._clean = True
  47. if res != "No local changes to save":
  48. self._stashed = True
  49. def restore(self):
  50. """Restore the pre-stash state."""
  51. if self._stashed:
  52. self._repo.git.stash("pop", "--index")
  53. def _read_config(repo, attr):
  54. """Read an attribute from git config."""
  55. try:
  56. return repo.git.config("--get", attr)
  57. except exc.GitCommandError:
  58. return None
  59. def _fetch_remotes(remotes):
  60. """Fetch a list of remotes, displaying progress info along the way."""
  61. def _get_name(ref):
  62. """Return the local name of a remote or tag reference."""
  63. return ref.remote_head if isinstance(ref, RemoteRef) else ref.name
  64. info = [("NEW_HEAD", "new branch", "new branches"),
  65. ("NEW_TAG", "new tag", "new tags"),
  66. ("FAST_FORWARD", "branch update", "branch updates")]
  67. up_to_date = BLUE + "up to date" + RESET
  68. for remote in remotes:
  69. print(INDENT2, "Fetching", BOLD + remote.name, end="")
  70. try:
  71. results = remote.fetch(progress=_ProgressMonitor())
  72. except exc.GitCommandError as err:
  73. msg = err.command[0].replace("Error when fetching: ", "")
  74. if not msg.endswith("."):
  75. msg += "."
  76. print(":", RED + "error:", msg)
  77. return
  78. except AssertionError: # Seems to be the result of a bug in GitPython
  79. # This happens when git initiates an auto-gc during fetch:
  80. print(":", RED + "error:", "something went wrong in GitPython,",
  81. "but the fetch might have been successful.")
  82. return
  83. rlist = []
  84. for attr, singular, plural in info:
  85. names = [_get_name(res.ref)
  86. for res in results if res.flags & getattr(res, attr)]
  87. if names:
  88. desc = singular if len(names) == 1 else plural
  89. colored = GREEN + desc + RESET
  90. rlist.append("{0} ({1})".format(colored, ", ".join(names)))
  91. print(":", (", ".join(rlist) if rlist else up_to_date) + ".")
  92. def _is_up_to_date(repo, branch, upstream):
  93. """Return whether *branch* is up-to-date with its *upstream*."""
  94. base = repo.git.merge_base(branch.commit, upstream.commit)
  95. return repo.commit(base) == upstream.commit
  96. def _rebase(repo, name):
  97. """Rebase the current HEAD of *repo* onto the branch *name*."""
  98. print(GREEN + "rebasing...", end="")
  99. try:
  100. res = repo.git.rebase(name, "--preserve-merges")
  101. except exc.GitCommandError as err:
  102. msg = err.stderr.replace("\n", " ").strip()
  103. if not msg.endswith("."):
  104. msg += "."
  105. if "unstaged changes" in msg:
  106. print(RED + " error:", "unstaged changes.")
  107. elif "uncommitted changes" in msg:
  108. print(RED + " error:", "uncommitted changes.")
  109. else:
  110. try:
  111. repo.git.rebase("--abort")
  112. except exc.GitCommandError:
  113. pass
  114. print(RED + " error:", msg if msg else "rebase conflict.",
  115. "Aborted.")
  116. else:
  117. print("\b" * 6 + " " * 6 + "\b" * 6 + GREEN + "ed", end=".\n")
  118. def _merge(repo, name):
  119. """Merge the branch *name* into the current HEAD of *repo*."""
  120. print(GREEN + "merging...", end="")
  121. try:
  122. repo.git.merge(name)
  123. except exc.GitCommandError as err:
  124. msg = err.stderr.replace("\n", " ").strip()
  125. if not msg.endswith("."):
  126. msg += "."
  127. if "local changes" in msg and "would be overwritten" in msg:
  128. print(RED + " error:", "uncommitted changes.")
  129. else:
  130. try:
  131. repo.git.merge("--abort")
  132. except exc.GitCommandError:
  133. pass
  134. print(RED + " error:", msg if msg else "merge conflict.",
  135. "Aborted.")
  136. else:
  137. print("\b" * 6 + " " * 6 + "\b" * 6 + GREEN + "ed", end=".\n")
  138. def _update_branch(repo, branch, merge, rebase, stasher=None):
  139. """Update a single branch."""
  140. print(INDENT2, "Updating", BOLD + branch.name, end=": ")
  141. upstream = branch.tracking_branch()
  142. if not upstream:
  143. print(YELLOW + "skipped:", "no upstream is tracked.")
  144. return
  145. try:
  146. branch.commit, upstream.commit
  147. except ValueError:
  148. print(YELLOW + "skipped:", "branch has no revisions.")
  149. return
  150. if _is_up_to_date(repo, branch, upstream):
  151. print(BLUE + "up to date", end=".\n")
  152. return
  153. if stasher:
  154. stasher.clean()
  155. branch.checkout()
  156. config_attr = "branch.{0}.rebase".format(branch.name)
  157. if not merge and (rebase or _read_config(repo, config_attr)):
  158. _rebase(repo, upstream.name)
  159. else:
  160. _merge(repo, upstream.name)
  161. def _update_branches(repo, active, merge, rebase):
  162. """Update a list of branches."""
  163. _update_branch(repo, active, merge, rebase)
  164. branches = set(repo.heads) - {active}
  165. if branches:
  166. stasher = _Stasher(repo)
  167. try:
  168. for branch in sorted(branches, key=lambda b: b.name):
  169. _update_branch(repo, branch, merge, rebase, stasher)
  170. finally:
  171. active.checkout()
  172. stasher.restore()
  173. def _update_repository(repo, current_only=False, rebase=False, merge=False):
  174. """Update a single git repository by fetching remotes and rebasing/merging.
  175. The specific actions depend on the arguments given. We will fetch all
  176. remotes if *current_only* is ``False``, or only the remote tracked by the
  177. current branch if ``True``. By default, we will merge unless
  178. ``pull.rebase`` or ``branch.<name>.rebase`` is set in config; *rebase* will
  179. cause us to always rebase with ``--preserve-merges``, and *merge* will
  180. cause us to always merge.
  181. """
  182. print(INDENT1, BOLD + os.path.split(repo.working_dir)[1] + ":")
  183. active = repo.active_branch
  184. if current_only:
  185. ref = active.tracking_branch()
  186. if not ref:
  187. print(INDENT2, ERROR, "no remote tracked by current branch.")
  188. return
  189. remotes = [repo.remotes[ref.remote_name]]
  190. else:
  191. remotes = repo.remotes
  192. if not remotes:
  193. print(INDENT2, ERROR, "no remotes configured to pull from.")
  194. return
  195. rebase = rebase or _read_config(repo, "pull.rebase")
  196. _fetch_remotes(remotes)
  197. _update_branches(repo, active, merge, rebase)
  198. def _update_subdirectories(path, long_name, update_args):
  199. """Update all subdirectories that are git repos in a given directory."""
  200. repos = []
  201. for item in os.listdir(path):
  202. try:
  203. repo = Repo(os.path.join(path, item))
  204. except (exc.InvalidGitRepositoryError, exc.NoSuchPathError):
  205. continue
  206. repos.append(repo)
  207. suffix = "ies" if len(repos) != 1 else "y"
  208. print(long_name[0].upper() + long_name[1:],
  209. "contains {0} git repositor{1}:".format(len(repos), suffix))
  210. for repo in sorted(repos, key=lambda r: os.path.split(r.working_dir)[1]):
  211. _update_repository(repo, *update_args)
  212. def _update_directory(path, update_args, is_bookmark=False):
  213. """Update a particular directory.
  214. Determine whether the directory is a git repo on its own, a directory of
  215. git repositories, or something invalid. If the first, update the single
  216. repository; if the second, update all repositories contained within; if the
  217. third, print an error.
  218. """
  219. dir_type = "bookmark" if is_bookmark else "directory"
  220. long_name = dir_type + ' "' + BOLD + path + RESET + '"'
  221. try:
  222. repo = Repo(path)
  223. except exc.NoSuchPathError:
  224. print(ERROR, long_name, "doesn't exist!")
  225. except exc.InvalidGitRepositoryError:
  226. if os.path.isdir(path):
  227. _update_subdirectories(path, long_name, update_args)
  228. else:
  229. print(ERROR, long_name, "isn't a repository!")
  230. else:
  231. long_name = (dir_type.capitalize() + ' "' + BOLD + repo.working_dir +
  232. RESET + '"')
  233. print(long_name, "is a git repository:")
  234. _update_repository(repo, *update_args)
  235. def update_bookmarks(bookmarks, update_args):
  236. """Loop through and update all bookmarks."""
  237. if bookmarks:
  238. for path, name in bookmarks:
  239. _update_directory(path, update_args, is_bookmark=True)
  240. else:
  241. print("You don't have any bookmarks configured! Get help with 'gitup -h'.")
  242. def update_directories(paths, update_args):
  243. """Update a list of directories supplied by command arguments."""
  244. for path in paths:
  245. full_path = os.path.abspath(path)
  246. _update_directory(full_path, update_args, is_bookmark=False)