A console script that allows you to easily update multiple git repositories at once
25개 이상의 토픽을 선택하실 수 없습니다. Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

227 lines
8.3 KiB

  1. # -*- coding: utf-8 -*-
  2. #
  3. # Copyright (C) 2011-2015 Ben Kurtovic <ben.kurtovic@gmail.com>
  4. # Released under the terms of the MIT License. See LICENSE 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. cur_count = str(int(cur_count))
  29. if max_count:
  30. max_count = str(int(max_count))
  31. if op_code & self.BEGIN:
  32. print("\b, " if self._started else " (", end="")
  33. if not self._started:
  34. self._started = True
  35. if op_code & self.END:
  36. end = ")"
  37. elif max_count:
  38. end = "\b" * (1 + len(cur_count) + len(max_count))
  39. else:
  40. end = "\b" * len(cur_count)
  41. if max_count:
  42. print("{0}/{1}".format(cur_count, max_count), end=end)
  43. else:
  44. print(str(cur_count), end=end)
  45. def _fetch_remotes(remotes):
  46. """Fetch a list of remotes, displaying progress info along the way."""
  47. def _get_name(ref):
  48. """Return the local name of a remote or tag reference."""
  49. return ref.remote_head if isinstance(ref, RemoteRef) else ref.name
  50. info = [("NEW_HEAD", "new branch", "new branches"),
  51. ("NEW_TAG", "new tag", "new tags"),
  52. ("FAST_FORWARD", "branch update", "branch updates")]
  53. up_to_date = BLUE + "up to date" + RESET
  54. for remote in remotes:
  55. print(INDENT2, "Fetching", BOLD + remote.name, end="")
  56. if not remote.config_reader.has_option("fetch"):
  57. print(":", YELLOW + "skipped:", "no configured refspec.")
  58. continue
  59. try:
  60. results = remote.fetch(progress=_ProgressMonitor())
  61. except exc.GitCommandError as err:
  62. msg = err.command[0].replace("Error when fetching: ", "")
  63. if not msg.endswith("."):
  64. msg += "."
  65. print(":", RED + "error:", msg)
  66. return
  67. except AssertionError: # Seems to be the result of a bug in GitPython
  68. # This happens when git initiates an auto-gc during fetch:
  69. print(":", RED + "error:", "something went wrong in GitPython,",
  70. "but the fetch might have been successful.")
  71. return
  72. rlist = []
  73. for attr, singular, plural in info:
  74. names = [_get_name(res.ref)
  75. for res in results if res.flags & getattr(res, attr)]
  76. if names:
  77. desc = singular if len(names) == 1 else plural
  78. colored = GREEN + desc + RESET
  79. rlist.append("{0} ({1})".format(colored, ", ".join(names)))
  80. print(":", (", ".join(rlist) if rlist else up_to_date) + ".")
  81. def _update_branch(repo, branch, is_active=False):
  82. """Update a single branch."""
  83. print(INDENT2, "Updating", BOLD + branch.name, end=": ")
  84. upstream = branch.tracking_branch()
  85. if not upstream:
  86. print(YELLOW + "skipped:", "no upstream is tracked.")
  87. return
  88. try:
  89. branch.commit, upstream.commit
  90. except ValueError:
  91. print(YELLOW + "skipped:", "branch has no revisions.")
  92. return
  93. base = repo.git.merge_base(branch.commit, upstream.commit)
  94. if repo.commit(base) == upstream.commit:
  95. print(BLUE + "up to date", end=".\n")
  96. return
  97. if is_active:
  98. try:
  99. repo.git.merge(upstream.name, ff_only=True)
  100. print(GREEN + "done", end=".\n")
  101. except exc.GitCommandError as err:
  102. msg = err.stderr
  103. if "local changes" in msg and "would be overwritten" in msg:
  104. print(YELLOW + "skipped:", "uncommitted changes.")
  105. else:
  106. print(YELLOW + "skipped:", "not possible to fast-forward.")
  107. else:
  108. status = repo.git.merge_base(
  109. branch.commit, upstream.commit, is_ancestor=True,
  110. with_extended_output=True, with_exceptions=False)[0]
  111. if status != 0:
  112. print(YELLOW + "skipped:", "not possible to fast-forward.")
  113. else:
  114. repo.git.branch(branch.name, upstream.name, force=True)
  115. print(GREEN + "done", end=".\n")
  116. def _update_repository(repo, current_only=False, fetch_only=False):
  117. """Update a single git repository by fetching remotes and rebasing/merging.
  118. The specific actions depend on the arguments given. We will fetch all
  119. remotes if *current_only* is ``False``, or only the remote tracked by the
  120. current branch if ``True``. If *fetch_only* is ``False``, we will also
  121. update all fast-forwardable branches that are tracking valid upstreams.
  122. """
  123. print(INDENT1, BOLD + os.path.split(repo.working_dir)[1] + ":")
  124. try:
  125. active = repo.active_branch
  126. except TypeError: # Happens when HEAD is detached
  127. active = None
  128. if current_only:
  129. if not active:
  130. print(INDENT2, ERROR,
  131. "--current-only doesn't make sense with a detached HEAD.")
  132. return
  133. ref = active.tracking_branch()
  134. if not ref:
  135. print(INDENT2, ERROR, "no remote tracked by current branch.")
  136. return
  137. remotes = [repo.remotes[ref.remote_name]]
  138. else:
  139. remotes = repo.remotes
  140. if not remotes:
  141. print(INDENT2, ERROR, "no remotes configured to fetch.")
  142. return
  143. _fetch_remotes(remotes)
  144. if not fetch_only:
  145. for branch in sorted(repo.heads, key=lambda b: b.name):
  146. _update_branch(repo, branch, branch == active)
  147. def _update_subdirectories(path, long_name, update_args):
  148. """Update all subdirectories that are git repos in a given directory."""
  149. repos = []
  150. for item in os.listdir(path):
  151. try:
  152. repo = Repo(os.path.join(path, item))
  153. except (exc.InvalidGitRepositoryError, exc.NoSuchPathError):
  154. continue
  155. repos.append(repo)
  156. suffix = "ies" if len(repos) != 1 else "y"
  157. print(long_name[0].upper() + long_name[1:],
  158. "contains {0} git repositor{1}:".format(len(repos), suffix))
  159. for repo in sorted(repos, key=lambda r: os.path.split(r.working_dir)[1]):
  160. _update_repository(repo, *update_args)
  161. def _update_directory(path, update_args, is_bookmark=False):
  162. """Update a particular directory.
  163. Determine whether the directory is a git repo on its own, a directory of
  164. git repositories, or something invalid. If the first, update the single
  165. repository; if the second, update all repositories contained within; if the
  166. third, print an error.
  167. """
  168. dir_type = "bookmark" if is_bookmark else "directory"
  169. long_name = dir_type + ' "' + BOLD + path + RESET + '"'
  170. try:
  171. repo = Repo(path)
  172. except exc.NoSuchPathError:
  173. print(ERROR, long_name, "doesn't exist!")
  174. except exc.InvalidGitRepositoryError:
  175. if os.path.isdir(path):
  176. _update_subdirectories(path, long_name, update_args)
  177. else:
  178. print(ERROR, long_name, "isn't a repository!")
  179. else:
  180. long_name = (dir_type.capitalize() + ' "' + BOLD + repo.working_dir +
  181. RESET + '"')
  182. print(long_name, "is a git repository:")
  183. _update_repository(repo, *update_args)
  184. def update_bookmarks(bookmarks, update_args):
  185. """Loop through and update all bookmarks."""
  186. if bookmarks:
  187. for path, name in bookmarks:
  188. _update_directory(path, update_args, is_bookmark=True)
  189. else:
  190. print("You don't have any bookmarks configured! Get help with 'gitup -h'.")
  191. def update_directories(paths, update_args):
  192. """Update a list of directories supplied by command arguments."""
  193. for path in paths:
  194. full_path = os.path.abspath(path)
  195. _update_directory(full_path, update_args, is_bookmark=False)