def fetch_and_reset(self, reset=True):
""" Fetch repo and reset it """
if git.Remote('', 'origin') in self._gitrepo.remotes:
origin = self._gitrepo.remotes.origin
print("Fetching {}".format(self._githubrepo.name))
origin.fetch('master')
if (parse_version('.'.join(map(
str, self._gitrepo.git.version_info))) >=
parse_version('2.17.0')):
origin.fetch(tags=True, prune=True, prune_tags=True)
else:
tags = self._gitrepo.git.tag(list=True)
if tags:
self._gitrepo.git.tag('--delete', tags.splitlines())
origin.fetch(tags=True, prune=True)
if reset:
print("Resetting {}".format(self._githubrepo.name))
self._gitrepo.git.reset('--hard', 'origin/master')
else:
print("Rebasing {}".format(self._githubrepo.name))
self._gitrepo.git.rebase('origin/master')
else:
print("Skipping fetching {}".format(self._githubrepo.name))
print("Cleaning local changes {}".format(self._githubrepo.name))
self._gitrepo.git.reset()
self._gitrepo.git.clean('-xffd')
def diff(self):
""" Diff commits in repo """
if self._gitrepo.head.is_valid():
if git.Remote('', 'origin') in self._gitrepo.remotes:
return self._gitrepo.git.diff('origin/master',
self._gitrepo.head.commit)
return self._gitrepo.git.diff(EMPTY_SHA, self._gitrepo.head.commit)
return ''
def pull(self, branch="master", progress: git.RemoteProgress = None):
assert git.Remote(self.repo, "origin") in self.repo.remotes
origin = self.repo.remotes["origin"]
if progress:
origin.pull(branch)
else:
origin.pull(branch, progress=progress)
def sync_remote(self, dst: Path, remote_url: str):
"""Synchronize a folder in dst with a git repo specified in remote url"""
r: git.Repo = git.Repo(dst)
remote = git.Remote(repo=r, name="origin").set_url(remote_url)
# Remove untracked files
for f in r.untracked_files:
target = Path(dst / f)
os.remove(target)
log.info(f"remove untracked file: {target}")
# Reset current tree and update to remote head
r.heads[0].checkout(force=True)
remote.pull()
def diff(self):
""" Diff commits in repo """
if self._gitrepo.head.is_valid():
if git.Remote('', 'origin') in self._gitrepo.remotes:
try:
return self._gitrepo.git.diff('origin/master',
self._gitrepo.head.commit)
except git.exc.GitCommandError:
return self._gitrepo.git.diff('origin/main',
self._gitrepo.head.commit)
return self._gitrepo.git.diff(EMPTY_SHA, self._gitrepo.head.commit)
return ''
def commit(self, message, directory=None, force=False, squash=False):
""" Create commit in repo """
if directory:
self._gitrepo.git.add(directory, force=force)
else:
self._gitrepo.git.add(all=True, force=force)
if squash:
if git.Remote('', 'origin') in self._gitrepo.remotes:
self._gitrepo.git.reset('origin/master', soft=True)
else:
self._gitrepo.git.update_ref('-d', 'HEAD')
if self._gitrepo.is_dirty():
self._gitrepo.index.commit(message)
def repo(self):
if not self._repo:
if os.path.exists(self.path):
self._repo = git.Repo(self.path)
if git.Remote(self._repo, "origin"
) not in self._repo.remotes and self.remote_url:
self._repo.create_remote("origin", self.remote_url)
elif self.remote_url:
parent_dir = os.path.dirname(self.path)
if not os.path.exists(parent_dir):
os.makedirs(parent_dir, exist_ok=True)
self._repo = git.Repo.init(self.path)
self._repo.create_remote("origin", self.remote_url)
else:
raise Exception(
"Couldn't find location repo and no remote was given.")
return self._repo
def update_local_repo(self):
"""
Обновление локального репозитория сценариев
"""
latest = False
scenarios_repo = git.Repo(self.SCENARIOS_ROOT)
scenarios_repo_remote = git.Remote(
scenarios_repo,
'master')
info = scenarios_repo_remote.fetch()[0]
remote_commit = info.commit
if scenarios_repo.commit().hexsha == remote_commit.hexsha:
latest = True
while remote_commit.hexsha != scenarios_repo.commit().hexsha:
remote_commit = remote_commit.parents[0]
return latest
def push(self, github, remote='origin'):
LOG.debug("Pushing local branch %s to %s (%s/%s)" %
(self._current_branch, remote, github.org, github.reponame))
repo = self.get_repo(github.org, github.reponame)
remote = git.Remote(repo, remote)
if github.ssh_key:
ssh_command = 'ssh -i %s' % os.path.expanduser(github.ssh_key)
env = {
'GIT_SSH_COMMAND': ssh_command,
'SSH_AGENT_PID': '',
'SSH_AUTH_SOCK': ''
}
else:
env = {}
with remote.repo.git.custom_environment(**env):
res = remote.push(self._current_branch)[0]
if res.flags & git.remote.PushInfo.ERROR:
raise Exception("git push failed to remote @ %s/%s with msg: %s" %
(github.org, github.reponame, res.summary))
def _sync(src, dest, restricted=False, reftypes=()):
repo = git.Repo(src)
remote = git.Remote(repo, dest)
refs = []
if (restricted):
ret = remote.push(("--mirror", "--dry-run"))
for info in ret:
# check if the local ref is either a head or a tag
if type(info.local_ref) in reftypes:
refs.append("".join(
("+", info.local_ref.name, ":", info.remote_ref_string)))
ret = None
if (refs):
ret = remote.push(refs)
else:
ret = remote.push("--mirror")
for info in ret:
if (info.flags & git.PushInfo.ERROR):
return False
return True
def commit_and_push_to_github(repo):
SYNC_MESSAGE = "Sync from mirror: https://gitlab.com/" + FLAGS.gitlab_username + "/" + FLAGS.repo
GITHUB_URL = "[email protected]:" + FLAGS.github_username + "/" + FLAGS.repo + ".git"
GITLAB_URL = "[email protected]:" + FLAGS.gitlab_username + "/" + FLAGS.repo + ".git"
repo.git.checkout('sync_from_gitlab')
# try:
# repo.git.rebase('master')
# except:
# pass
# git rebase -X theirs branch-b
# repo.git.rebase('-X theirs master')
# repo.git.merge('-X ours master')
repo.git.merge("master")
modify_readme(
os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])),
FLAGS.repo))
repo.git.add('README.md')
repo.git.commit(m=str(SYNC_MESSAGE))
remote = git.Remote(repo, "origin")
remote.set_url(GITHUB_URL)
remote.push('sync_from_gitlab')
repo.git.checkout('master')
remote.set_url(GITLAB_URL)
GIT_PULL_MSG = {
128: "ERROR",
64: "FAST_FORWARD",
32: "FORCED_UPDATE",
4: "HEAD_UPTODATE",
2: "NEW_HEAD",
1: "NEW_TAG",
16: "REJECTED",
8: "TAG_UPDATE"
}
if config['repo']['git']['enable_sync']:
repo = git.Repo(config['repo']['local_path'])
# repo.git.custom_environment(GIT_SSH_COMMAND='ssh -i ' + config['repo']['git']['ssh_key_file_path'])
remote_obj = git.Remote(repo, 'origin')
remote_obj.set_url(config['repo']['git']['remote_url'])
def pull():
def _pull():
pullinfo = remote_obj.pull()
flag = pullinfo[0].flags
# return flag
return GIT_PULL_MSG.get(flag, 'Unknown: ' + str(flag))
if not config['repo']['git']['enable_sync']:
return
# sync
ret = _pull()
def scmSpecificUpdateProject( self ):
if( self.config_local_user_name.hasChanged()
or self.config_local_user_email.hasChanged()
or self.config_local_pull_rebase.hasChanged() ):
# update local config
config = self.scm_project.configWriter( 'repository' )
if self.config_local_pull_rebase.hasChanged():
value = 'true' if self.config_local_pull_rebase.isChecked() else 'false'
config.set_value( 'pull', 'rebase', value )
if self.config_local_user_name.hasChanged():
if self.config_local_user_name.isChecked():
value = self.config_local_user_name.value()
config.set_value( 'user', 'name', value )
else:
config.remove_option( 'user', 'name' )
if self.config_local_user_email.hasChanged():
if self.config_local_user_email.isChecked():
value = self.config_local_user_email.value()
config.set_value( 'user', 'email', value )
else:
config.remove_option( 'user', 'email' )
config.release()
if self.url_origin.hasChanged():
# update remote origin
self.scm_project.cmdUpdateRemote( 'origin', self.url_origin.value() )
if( self.config_global_user_name.hasChanged()
or self.config_global_user_email.hasChanged() ):
# update global config
config = self.scm_project.configWriter( 'global' )
if self.config_global_user_name.hasChanged():
value = self.config_global_user_name.value()
if value == '':
config.remove_option( 'user', 'name' )
else:
config.set_value( 'user', 'name', value )
if self.config_global_user_email.hasChanged():
value = self.config_global_user_email.value()
if value == '':
config.remove_option( 'user', 'email' )
else:
config.set_value( 'user', 'email', value )
config.release()
if self.master_branch_check.hasChanged() or self.master_branch_name.hasChanged():
if self.master_branch_check.isChecked():
self.scm_project.setMasterBranchName( self.master_branch_name.value() )
else:
self.scm_project.setMasterBranchName( 'master' )
if self.setup_upstream.hasChanged():
if self.setup_upstream.isChecked():
# add remote upstream
self.scm_project.cmdAddRemote( 'upstream', self.url_upstream.value() )
import git
remote = git.Remote( self.scm_project.repo(), 'upstream' )
remote.add_url( self.url_upstream.value() )
else:
# delete remote upstream
self.scm_project.cmdDeleteRemote( 'upstream' )
elif( self.setup_upstream.isChecked()
and self.url_upstream.hasChanged() ):
# update remote upstream
self.scm_project.cmdUpdateRemote( 'upstream', self.url_upstream.value() )