def test_creation_and_removal(self, bare_rw_repo):
new_name = "test_new_one"
arg_list = (new_name, "git@server:hello.git")
remote = Remote.create(bare_rw_repo, *arg_list)
self.assertEqual(remote.name, "test_new_one")
self.assertIn(remote, bare_rw_repo.remotes)
self.assertTrue(remote.exists())
# create same one again
self.failUnlessRaises(GitCommandError, Remote.create, bare_rw_repo,
*arg_list)
Remote.remove(bare_rw_repo, new_name)
self.assertTrue(remote.exists(
)) # We still have a cache that doesn't know we were deleted by name
remote._clear_cache()
assert not remote.exists(
) # Cache should be renewed now. This is an issue ...
for remote in bare_rw_repo.remotes:
if remote.name == new_name:
raise AssertionError("Remote removal failed")
# END if deleted remote matches existing remote's name
# END for each remote
# Issue #262 - the next call would fail if bug wasn't fixed
bare_rw_repo.create_remote('bogus', '/bogus/path', mirror='push')
def remote_repo_creator(self):
rw_daemon_repo_dir = tempfile.mktemp(prefix="daemon_repo-%s-" % func.__name__)
rw_repo_dir = tempfile.mktemp(prefix="daemon_cloned_repo-%s-" % func.__name__)
rw_daemon_repo = self.rorepo.clone(rw_daemon_repo_dir, shared=True, bare=True)
# recursive alternates info ?
rw_repo = rw_daemon_repo.clone(rw_repo_dir, shared=True, bare=False, n=True)
try:
rw_repo.head.commit = working_tree_ref
rw_repo.head.reference.checkout()
# prepare for git-daemon
rw_daemon_repo.daemon_export = True
# this thing is just annoying !
with rw_daemon_repo.config_writer() as crw:
section = "daemon"
try:
crw.add_section(section)
except Exception:
pass
crw.set(section, "receivepack", True)
# Initialize the remote - first do it as local remote and pull, then
# we change the url to point to the daemon.
d_remote = Remote.create(rw_repo, "daemon_origin", rw_daemon_repo_dir)
d_remote.fetch()
base_daemon_path, rel_repo_dir = osp.split(rw_daemon_repo_dir)
remote_repo_url = Git.polish_url("git://localhost:%s/%s" % (GIT_DAEMON_PORT, rel_repo_dir))
with d_remote.config_writer as cw:
cw.set('url', remote_repo_url)
with git_daemon_launched(Git.polish_url(base_daemon_path, is_cygwin=False), # No daemon in Cygwin.
'127.0.0.1',
GIT_DAEMON_PORT):
# Try listing remotes, to diagnose whether the daemon is up.
rw_repo.git.ls_remote(d_remote)
with cwd(rw_repo.working_dir):
try:
return func(self, rw_repo, rw_daemon_repo)
except:
log.info("Keeping repos after failure: \n rw_repo_dir: %s \n rw_daemon_repo_dir: %s",
rw_repo_dir, rw_daemon_repo_dir)
rw_repo_dir = rw_daemon_repo_dir = None
raise
finally:
rw_repo.git.clear_cache()
rw_daemon_repo.git.clear_cache()
del rw_repo
del rw_daemon_repo
import gc
gc.collect()
if rw_repo_dir:
rmtree(rw_repo_dir)
if rw_daemon_repo_dir:
rmtree(rw_daemon_repo_dir)
def remote_repo_creator(self):
remote_repo_dir = tempfile.mktemp("remote_repo_%s" % func.__name__)
repo_dir = tempfile.mktemp("remote_clone_non_bare_repo")
rw_remote_repo = self.rorepo.clone(remote_repo_dir,
shared=True,
bare=True)
rw_repo = rw_remote_repo.clone(
repo_dir, shared=True, bare=False,
n=True) # recursive alternates info ?
rw_repo.head.commit = working_tree_ref
rw_repo.head.reference.checkout()
# prepare for git-daemon
rw_remote_repo.daemon_export = True
# this thing is just annoying !
crw = rw_remote_repo.config_writer()
section = "daemon"
try:
crw.add_section(section)
except Exception:
pass
crw.set(section, "receivepack", True)
# release lock
del (crw)
# initialize the remote - first do it as local remote and pull, then
# we change the url to point to the daemon. The daemon should be started
# by the user, not by us
d_remote = Remote.create(rw_repo, "daemon_origin", remote_repo_dir)
d_remote.fetch()
remote_repo_url = "git://localhost%s" % remote_repo_dir
# some oddity: on windows, python 2.5, it for some reason does not realize
# that it has the config_writer property, but instead calls __getattr__
# which will not yield the expected results. 'pinging' the members
# with a dir call creates the config_writer property that we require
# ... bugs like these make me wonder wheter python really wants to be used
# for production. It doesn't happen on linux though.
dir(d_remote)
d_remote.config_writer.set('url', remote_repo_url)
# try to list remotes to diagnoes whether the server is up
try:
rw_repo.git.ls_remote(d_remote)
except GitCommandError, e:
print str(e)
if os.name == 'nt':
raise AssertionError(
'git-daemon needs to run this test, but windows does not have one. Otherwise, run: git-daemon "%s"'
% tempfile.gettempdir())
else:
raise AssertionError(
'Please start a git-daemon to run this test, execute: git-daemon "%s"'
% tempfile.gettempdir())
async def test_get_github_repo(tmp_path: Path, session: ClientSession) -> None:
repo = Repo.init(str(tmp_path))
config = Configuration(github_user="******", github_token="some-token")
pr = PullRequester(tmp_path, config, session)
remote = Remote.create(repo, "origin", "[email protected]:foo/bar.git")
assert pr._get_github_repo() == GitHubRepository(owner="foo", repo="bar")
remote.set_url("https://github.com/foo/bar.git")
assert pr._get_github_repo() == GitHubRepository(owner="foo", repo="bar")
remote.set_url("ssh://[email protected]/foo/bar")
assert pr._get_github_repo() == GitHubRepository(owner="foo", repo="bar")
def remote_repo_creator(self):
remote_repo_dir = _mktemp("remote_repo_%s" % func.__name__)
repo_dir = _mktemp("remote_clone_non_bare_repo")
rw_remote_repo = self.rorepo.clone(remote_repo_dir,
shared=True,
bare=True)
rw_repo = rw_remote_repo.clone(
repo_dir, shared=True, bare=False,
n=True) # recursive alternates info ?
rw_repo.head.commit = working_tree_ref
rw_repo.head.reference.checkout()
# prepare for git-daemon
rw_remote_repo.daemon_export = True
# this thing is just annoying !
crw = rw_remote_repo.config_writer()
section = "daemon"
try:
crw.add_section(section)
except Exception:
pass
crw.set(section, "receivepack", True)
# release lock
del (crw)
# initialize the remote - first do it as local remote and pull, then
# we change the url to point to the daemon. The daemon should be started
# by the user, not by us
d_remote = Remote.create(rw_repo, "daemon_origin", remote_repo_dir)
d_remote.fetch()
remote_repo_url = "git://localhost%s" % remote_repo_dir
d_remote.config_writer.set('url', remote_repo_url)
# try to list remotes to diagnoes whether the server is up
try:
rw_repo.git.ls_remote(d_remote)
except GitCommandError, e:
print str(e)
if os.name == 'nt':
raise AssertionError(
'git-daemon needs to run this test, but windows does not have one. Otherwise, run: git-daemon "%s"'
% os.path.dirname(_mktemp()))
else:
raise AssertionError(
'Please start a git-daemon to run this test, execute: git-daemon "%s"'
% os.path.dirname(_mktemp()))
def remote_repo_creator(self):
remote_repo_dir = tempfile.mktemp("remote_repo_%s" % func.__name__)
repo_dir = tempfile.mktemp("remote_clone_non_bare_repo")
rw_remote_repo = self.rorepo.clone(remote_repo_dir, shared=True, bare=True)
rw_repo = rw_remote_repo.clone(repo_dir, shared=True, bare=False, n=True) # recursive alternates info ?
rw_repo.head.commit = working_tree_ref
rw_repo.head.reference.checkout()
# prepare for git-daemon
rw_remote_repo.daemon_export = True
# this thing is just annoying !
crw = rw_remote_repo.config_writer()
section = "daemon"
try:
crw.add_section(section)
except Exception:
pass
crw.set(section, "receivepack", True)
# release lock
del(crw)
# initialize the remote - first do it as local remote and pull, then
# we change the url to point to the daemon. The daemon should be started
# by the user, not by us
d_remote = Remote.create(rw_repo, "daemon_origin", remote_repo_dir)
d_remote.fetch()
remote_repo_url = "git://localhost%s" % remote_repo_dir
# some oddity: on windows, python 2.5, it for some reason does not realize
# that it has the config_writer property, but instead calls __getattr__
# which will not yield the expected results. 'pinging' the members
# with a dir call creates the config_writer property that we require
# ... bugs like these make me wonder wheter python really wants to be used
# for production. It doesn't happen on linux though.
dir(d_remote)
d_remote.config_writer.set('url', remote_repo_url)
# try to list remotes to diagnoes whether the server is up
try:
rw_repo.git.ls_remote(d_remote)
except GitCommandError,e:
print str(e)
if os.name == 'nt':
raise AssertionError('git-daemon needs to run this test, but windows does not have one. Otherwise, run: git-daemon "%s"'%tempfile.gettempdir())
else:
raise AssertionError('Please start a git-daemon to run this test, execute: git-daemon "%s"'%tempfile.gettempdir())
def remote_repo_creator(self):
remote_repo_dir = _mktemp("remote_repo_%s" % func.__name__)
repo_dir = _mktemp("remote_clone_non_bare_repo")
rw_remote_repo = self.rorepo.clone(remote_repo_dir, shared=True, bare=True)
rw_repo = rw_remote_repo.clone(repo_dir, shared=True, bare=False, n=True) # recursive alternates info ?
rw_repo.head.commit = working_tree_ref
rw_repo.head.reference.checkout()
# prepare for git-daemon
rw_remote_repo.daemon_export = True
# this thing is just annoying !
crw = rw_remote_repo.config_writer()
section = "daemon"
try:
crw.add_section(section)
except Exception:
pass
crw.set(section, "receivepack", True)
# release lock
del (crw)
# initialize the remote - first do it as local remote and pull, then
# we change the url to point to the daemon. The daemon should be started
# by the user, not by us
d_remote = Remote.create(rw_repo, "daemon_origin", remote_repo_dir)
d_remote.fetch()
remote_repo_url = "git://localhost%s" % remote_repo_dir
d_remote.config_writer.set("url", remote_repo_url)
# try to list remotes to diagnoes whether the server is up
try:
rw_repo.git.ls_remote(d_remote)
except GitCommandError, e:
print str(e)
if os.name == "nt":
raise AssertionError(
'git-daemon needs to run this test, but windows does not have one. Otherwise, run: git-daemon "%s"'
% os.path.dirname(_mktemp())
)
else:
raise AssertionError(
'Please start a git-daemon to run this test, execute: git-daemon "%s"'
% os.path.dirname(_mktemp())
)
def test_creation_and_removal(self, bare_rw_repo):
new_name = "test_new_one"
arg_list = (new_name, "git@server:hello.git")
remote = Remote.create(bare_rw_repo, *arg_list)
assert remote.name == "test_new_one"
assert remote in bare_rw_repo.remotes
assert remote.exists()
# create same one again
self.failUnlessRaises(GitCommandError, Remote.create, bare_rw_repo, *arg_list)
Remote.remove(bare_rw_repo, new_name)
assert remote.exists() # We still have a cache that doesn't know we were deleted by name
remote._clear_cache()
assert not remote.exists() # Cache should be renewed now. This is an issue ...
for remote in bare_rw_repo.remotes:
if remote.name == new_name:
raise AssertionError("Remote removal failed")
def test_creation_and_removal(self, bare_rw_repo):
new_name = "test_new_one"
arg_list = (new_name, "git@server:hello.git")
remote = Remote.create(bare_rw_repo, *arg_list)
assert remote.name == "test_new_one"
assert remote in bare_rw_repo.remotes
assert remote.exists()
# create same one again
self.failUnlessRaises(GitCommandError, Remote.create, bare_rw_repo, *arg_list)
Remote.remove(bare_rw_repo, new_name)
assert remote.exists() # We still have a cache that doesn't know we were deleted by name
remote._clear_cache()
assert not remote.exists() # Cache should be renewed now. This is an issue ...
for remote in bare_rw_repo.remotes:
if remote.name == new_name:
raise AssertionError("Remote removal failed")
async def test_get_authenticated_remote(tmp_path: Path,
session: ClientSession) -> None:
repo = Repo.init(str(tmp_path))
config = Configuration(github_user="******", github_token="some-token")
pr = PullRequester(tmp_path, config, session)
remote = Remote.create(repo, "origin", "https://github.com/foo/bar")
url = pr._get_authenticated_remote()
assert url == "https://*****:*****@github.com/foo/bar"
remote.set_url("https://[email protected]:8080/foo/bar")
url = pr._get_authenticated_remote()
assert url == "https://*****:*****@github.com:8080/foo/bar"
remote.set_url("[email protected]:bar/foo")
url = pr._get_authenticated_remote()
assert url == "https://*****:*****@github.com/bar/foo"
remote.set_url("ssh://*****:*****@github.com/baz/stuff")
url = pr._get_authenticated_remote()
assert url == "https://*****:*****@github.com/baz/stuff"
def test_creation_and_removal(self, bare_rw_repo):
new_name = "test_new_one"
arg_list = (new_name, "git@server:hello.git")
remote = Remote.create(bare_rw_repo, *arg_list)
assert remote.name == "test_new_one"
assert remote in bare_rw_repo.remotes
assert remote.exists()
# create same one again
self.failUnlessRaises(GitCommandError, Remote.create, bare_rw_repo, *arg_list)
Remote.remove(bare_rw_repo, new_name)
assert remote.exists() # We still have a cache that doesn't know we were deleted by name
remote._clear_cache()
assert not remote.exists() # Cache should be renewed now. This is an issue ...
for remote in bare_rw_repo.remotes:
if remote.name == new_name:
raise AssertionError("Remote removal failed")
# END if deleted remote matches existing remote's name
# END for each remote
# Issue #262 - the next call would fail if bug wasn't fixed
bare_rw_repo.create_remote('bogus', '/bogus/path', mirror='push')
def remote_repo_creator(self):
remote_repo_dir = tempfile.mktemp("remote_repo_%s" % func.__name__)
repo_dir = tempfile.mktemp("remote_clone_non_bare_repo")
rw_remote_repo = self.rorepo.clone(remote_repo_dir,
shared=True,
bare=True)
# recursive alternates info ?
rw_repo = rw_remote_repo.clone(repo_dir,
shared=True,
bare=False,
n=True)
rw_repo.head.commit = working_tree_ref
rw_repo.head.reference.checkout()
# prepare for git-daemon
rw_remote_repo.daemon_export = True
# this thing is just annoying !
with rw_remote_repo.config_writer() as crw:
section = "daemon"
try:
crw.add_section(section)
except Exception:
pass
crw.set(section, "receivepack", True)
# Initialize the remote - first do it as local remote and pull, then
# we change the url to point to the daemon.
d_remote = Remote.create(rw_repo, "daemon_origin", remote_repo_dir)
d_remote.fetch()
base_path, rel_repo_dir = osp.split(remote_repo_dir)
remote_repo_url = Git.polish_url("git://localhost:%s/%s" %
(GIT_DAEMON_PORT, rel_repo_dir))
with d_remote.config_writer as cw:
cw.set('url', remote_repo_url)
try:
gd = launch_git_daemon(Git.polish_url(base_path), '127.0.0.1',
GIT_DAEMON_PORT)
except Exception as ex:
if is_win:
msg = textwrap.dedent("""
The `git-daemon.exe` must be in PATH.
For MINGW, look into .\Git\mingw64\libexec\git-core\), but problems with paths might appear.
CYGWIN has no daemon, but if one exists, it gets along fine (has also paths problems)
Anyhow, alternatively try starting `git-daemon` manually:"""
)
else:
msg = "Please try starting `git-daemon` manually:"
msg += textwrap.dedent("""
git daemon --enable=receive-pack --base-path=%s %s
You can also run the daemon on a different port by passing --port=<port>"
and setting the environment variable GIT_PYTHON_TEST_GIT_DAEMON_PORT to <port>
""" % (base_path, base_path))
raise AssertionError(ex, msg)
# END make assertion
else:
# Try listing remotes, to diagnose whether the daemon is up.
rw_repo.git.ls_remote(d_remote)
# adjust working dir
prev_cwd = os.getcwd()
os.chdir(rw_repo.working_dir)
try:
return func(self, rw_repo, rw_remote_repo)
except:
log.info(
"Keeping repos after failure: repo_dir = %s, remote_repo_dir = %s",
repo_dir, remote_repo_dir)
repo_dir = remote_repo_dir = None
raise
finally:
os.chdir(prev_cwd)
finally:
try:
log.debug("Killing git-daemon...")
gd.proc.kill()
except:
## Either it has died (and we're here), or it won't die, again here...
pass
rw_repo.git.clear_cache()
rw_remote_repo.git.clear_cache()
rw_repo = rw_remote_repo = None
import gc
gc.collect()
if repo_dir:
rmtree(repo_dir)
if remote_repo_dir:
rmtree(remote_repo_dir)
if gd is not None:
gd.proc.wait()
def remote_repo_creator(self):
remote_repo_dir = _mktemp("remote_repo_%s" % func.__name__)
repo_dir = _mktemp("remote_clone_non_bare_repo")
rw_remote_repo = self.rorepo.clone(remote_repo_dir, shared=True, bare=True)
# recursive alternates info ?
rw_repo = rw_remote_repo.clone(repo_dir, shared=True, bare=False, n=True)
rw_repo.head.commit = working_tree_ref
rw_repo.head.reference.checkout()
# prepare for git-daemon
rw_remote_repo.daemon_export = True
# this thing is just annoying !
crw = rw_remote_repo.config_writer()
section = "daemon"
try:
crw.add_section(section)
except Exception:
pass
crw.set(section, "receivepack", True)
# release lock
crw.release()
del(crw)
# initialize the remote - first do it as local remote and pull, then
# we change the url to point to the daemon. The daemon should be started
# by the user, not by us
d_remote = Remote.create(rw_repo, "daemon_origin", remote_repo_dir)
d_remote.fetch()
remote_repo_url = "git://localhost:%s%s" % (GIT_DAEMON_PORT, remote_repo_dir)
d_remote.config_writer.set('url', remote_repo_url)
temp_dir = osp(_mktemp())
# On windows, this will fail ... we deal with failures anyway and default to telling the user to do it
try:
gd = Git().daemon(temp_dir, enable='receive-pack', listen='127.0.0.1', port=GIT_DAEMON_PORT,
as_process=True)
# yes, I know ... fortunately, this is always going to work if sleep time is just large enough
time.sleep(0.5)
except Exception:
gd = None
# end
# try to list remotes to diagnoes whether the server is up
try:
rw_repo.git.ls_remote(d_remote)
except GitCommandError as e:
# We assume in good faith that we didn't start the daemon - but make sure we kill it anyway
# Of course we expect it to work here already, but maybe there are timing constraints
# on some platforms ?
if gd is not None:
os.kill(gd.proc.pid, 15)
print(str(e))
if os.name == 'nt':
msg = "git-daemon needs to run this test, but windows does not have one. "
msg += 'Otherwise, run: git-daemon "%s"' % temp_dir
raise AssertionError(msg)
else:
msg = 'Please start a git-daemon to run this test, execute: git daemon --enable=receive-pack "%s"'
msg += 'You can also run the daemon on a different port by passing --port=<port>'
msg += 'and setting the environment variable GIT_PYTHON_TEST_GIT_DAEMON_PORT to <port>'
msg %= temp_dir
raise AssertionError(msg)
# END make assertion
# END catch ls remote error
# adjust working dir
prev_cwd = os.getcwd()
os.chdir(rw_repo.working_dir)
try:
try:
return func(self, rw_repo, rw_remote_repo)
except:
print("Keeping repos after failure: repo_dir = %s, remote_repo_dir = %s"
% (repo_dir, remote_repo_dir), file=sys.stderr)
repo_dir = remote_repo_dir = None
raise
finally:
# gd.proc.kill() ... no idea why that doesn't work
if gd is not None:
os.kill(gd.proc.pid, 15)
os.chdir(prev_cwd)
rw_repo.git.clear_cache()
rw_remote_repo.git.clear_cache()
if repo_dir:
shutil.rmtree(repo_dir, onerror=_rmtree_onerror)
if remote_repo_dir:
shutil.rmtree(remote_repo_dir, onerror=_rmtree_onerror)
if gd is not None:
gd.proc.wait()
def test_analyze_pr(tmp_path: Path, mock_push: Mock) -> None:
runner = CliRunner()
repo = Repo.init(str(tmp_path))
Remote.create(repo, "origin", "https://github.com/foo/bar")
src = (Path(__file__).parent / "data" / "kubernetes" / "gafaelfawr" /
"Chart.yaml")
dst = tmp_path / "Chart.yaml"
shutil.copy(src, dst)
repo.index.add(str(dst))
actor = Actor("Someone", "*****@*****.**")
repo.index.commit("Initial commit", author=actor, committer=actor)
sqre = dict_to_yaml({"entries": {"gafaelfawr": [{"version": "1.4.0"}]}})
payload = {"name": "Someone", "email": "*****@*****.**"}
created_pr = False
def check_pr_post(url: str, **kwargs: Any) -> CallbackResult:
change = "Update gafaelfawr Helm chart from 1.3.1 to 1.4.0"
assert json.loads(kwargs["data"]) == {
"title": CommitMessage.title,
"body": f"- {change}\n",
"head": "u/neophile",
"base": "master",
"maintainer_can_modify": True,
"draft": False,
}
assert repo.head.ref.name == "u/neophile"
yaml = YAML()
data = yaml.load(dst)
assert data["dependencies"][0]["version"] == "1.4.0"
commit = repo.head.commit
assert commit.author.name == "Someone"
assert commit.author.email == "*****@*****.**"
assert commit.message == f"{CommitMessage.title}\n\n- {change}\n"
nonlocal created_pr
created_pr = True
return CallbackResult(status=201)
with aioresponses() as mock:
mock.get("https://lsst-sqre.github.io/charts/index.yaml", body=sqre)
mock.get("https://api.github.com/user", payload=payload)
mock.get(
"https://api.github.com/repos/foo/bar",
payload={"default_branch": "master"},
)
pattern = re.compile(r"https://api.github.com/repos/foo/bar/pulls\?.*")
mock.get(pattern, payload=[])
mock.post(
"https://api.github.com/repos/foo/bar/pulls",
callback=check_pr_post,
)
result = runner.invoke(
main,
["analyze", "--path", str(tmp_path), "--pr"],
env={"NEOPHILE_CACHE_ENABLED": "0"},
)
assert created_pr
assert result.exit_code == 0
assert mock_push.call_args_list == [
call("u/neophile:u/neophile", force=True)
]
assert repo.head.ref.name == "master"
def remote_repo_creator(self):
rw_daemon_repo_dir = tempfile.mktemp(prefix="daemon_repo-%s-" %
func.__name__)
rw_repo_dir = tempfile.mktemp(prefix="daemon_cloned_repo-%s-" %
func.__name__)
rw_daemon_repo = self.rorepo.clone(rw_daemon_repo_dir,
shared=True,
bare=True)
# recursive alternates info ?
rw_repo = rw_daemon_repo.clone(rw_repo_dir,
shared=True,
bare=False,
n=True)
try:
rw_repo.head.commit = working_tree_ref
rw_repo.head.reference.checkout()
# prepare for git-daemon
rw_daemon_repo.daemon_export = True
# this thing is just annoying !
with rw_daemon_repo.config_writer() as crw:
section = "daemon"
try:
crw.add_section(section)
except Exception:
pass
crw.set(section, "receivepack", True)
# Initialize the remote - first do it as local remote and pull, then
# we change the url to point to the daemon.
d_remote = Remote.create(rw_repo, "daemon_origin",
rw_daemon_repo_dir)
d_remote.fetch()
base_daemon_path, rel_repo_dir = osp.split(rw_daemon_repo_dir)
remote_repo_url = Git.polish_url(
"git://localhost:%s/%s" % (GIT_DAEMON_PORT, rel_repo_dir))
with d_remote.config_writer as cw:
cw.set('url', remote_repo_url)
with git_daemon_launched(
Git.polish_url(
base_daemon_path,
is_cygwin=False), # No daemon in Cygwin.
'127.0.0.1',
GIT_DAEMON_PORT):
# Try listing remotes, to diagnose whether the daemon is up.
rw_repo.git.ls_remote(d_remote)
with cwd(rw_repo.working_dir):
try:
return func(self, rw_repo, rw_daemon_repo)
except:
log.info(
"Keeping repos after failure: \n rw_repo_dir: %s \n rw_daemon_repo_dir: %s",
rw_repo_dir, rw_daemon_repo_dir)
rw_repo_dir = rw_daemon_repo_dir = None
raise
finally:
rw_repo.git.clear_cache()
rw_daemon_repo.git.clear_cache()
del rw_repo
del rw_daemon_repo
gc.collect()
gitdb.util.mman.collect()
gc.collect()
if rw_repo_dir:
rmtree(rw_repo_dir)
if rw_daemon_repo_dir:
rmtree(rw_daemon_repo_dir)
def remote_repo_creator(self):
remote_repo_dir = _mktemp("remote_repo_%s" % func.__name__)
repo_dir = _mktemp("remote_clone_non_bare_repo")
rw_remote_repo = self.rorepo.clone(remote_repo_dir,
shared=True,
bare=True)
# recursive alternates info ?
rw_repo = rw_remote_repo.clone(repo_dir,
shared=True,
bare=False,
n=True)
rw_repo.head.commit = working_tree_ref
rw_repo.head.reference.checkout()
# prepare for git-daemon
rw_remote_repo.daemon_export = True
# this thing is just annoying !
crw = rw_remote_repo.config_writer()
section = "daemon"
try:
crw.add_section(section)
except Exception:
pass
crw.set(section, "receivepack", True)
# release lock
crw.release()
del (crw)
# initialize the remote - first do it as local remote and pull, then
# we change the url to point to the daemon. The daemon should be started
# by the user, not by us
d_remote = Remote.create(rw_repo, "daemon_origin", remote_repo_dir)
d_remote.fetch()
remote_repo_url = "git://localhost:%s%s" % (GIT_DAEMON_PORT,
remote_repo_dir)
d_remote.config_writer.set('url', remote_repo_url)
temp_dir = osp(_mktemp())
# On windows, this will fail ... we deal with failures anyway and default to telling the user to do it
try:
gd = Git().daemon(temp_dir,
enable='receive-pack',
listen='127.0.0.1',
port=GIT_DAEMON_PORT,
as_process=True)
# yes, I know ... fortunately, this is always going to work if sleep time is just large enough
time.sleep(0.5)
except Exception:
gd = None
# end
# try to list remotes to diagnoes whether the server is up
try:
rw_repo.git.ls_remote(d_remote)
except GitCommandError as e:
# We assume in good faith that we didn't start the daemon - but make sure we kill it anyway
# Of course we expect it to work here already, but maybe there are timing constraints
# on some platforms ?
if gd is not None:
os.kill(gd.proc.pid, 15)
print(str(e))
if os.name == 'nt':
msg = "git-daemon needs to run this test, but windows does not have one. "
msg += 'Otherwise, run: git-daemon "%s"' % temp_dir
raise AssertionError(msg)
else:
msg = 'Please start a git-daemon to run this test, execute: git daemon --enable=receive-pack "%s"'
msg += 'You can also run the daemon on a different port by passing --port=<port>'
msg += 'and setting the environment variable GIT_PYTHON_TEST_GIT_DAEMON_PORT to <port>'
msg %= temp_dir
raise AssertionError(msg)
# END make assertion
# END catch ls remote error
# adjust working dir
prev_cwd = os.getcwd()
os.chdir(rw_repo.working_dir)
try:
try:
return func(self, rw_repo, rw_remote_repo)
except:
print(
"Keeping repos after failure: repo_dir = %s, remote_repo_dir = %s"
% (repo_dir, remote_repo_dir),
file=sys.stderr)
repo_dir = remote_repo_dir = None
raise
finally:
# gd.proc.kill() ... no idea why that doesn't work
if gd is not None:
os.kill(gd.proc.pid, 15)
os.chdir(prev_cwd)
rw_repo.git.clear_cache()
rw_remote_repo.git.clear_cache()
if repo_dir:
shutil.rmtree(repo_dir, onerror=_rmtree_onerror)
if remote_repo_dir:
shutil.rmtree(remote_repo_dir, onerror=_rmtree_onerror)
if gd is not None:
gd.proc.wait()
def remote_repo_creator(self):
remote_repo_dir = _mktemp("remote_repo_%s" % func.__name__)
repo_dir = _mktemp("remote_clone_non_bare_repo")
rw_remote_repo = self.rorepo.clone(remote_repo_dir,
shared=True,
bare=True)
# recursive alternates info ?
rw_repo = rw_remote_repo.clone(repo_dir,
shared=True,
bare=False,
n=True)
rw_repo.head.commit = working_tree_ref
rw_repo.head.reference.checkout()
# prepare for git-daemon
rw_remote_repo.daemon_export = True
# this thing is just annoying !
with rw_remote_repo.config_writer() as crw:
section = "daemon"
try:
crw.add_section(section)
except Exception:
pass
crw.set(section, "receivepack", True)
# initialize the remote - first do it as local remote and pull, then
# we change the url to point to the daemon. The daemon should be started
# by the user, not by us
d_remote = Remote.create(rw_repo, "daemon_origin", remote_repo_dir)
d_remote.fetch()
remote_repo_url = "git://localhost:%s%s" % (GIT_DAEMON_PORT,
remote_repo_dir)
with d_remote.config_writer as cw:
cw.set('url', remote_repo_url)
temp_dir = osp(_mktemp())
gd = launch_git_daemon(temp_dir, '127.0.0.1', GIT_DAEMON_PORT)
try:
# yes, I know ... fortunately, this is always going to work if sleep time is just large enough
time.sleep(0.5)
# end
# try to list remotes to diagnoes whether the server is up
try:
rw_repo.git.ls_remote(d_remote)
except GitCommandError as e:
# We assume in good faith that we didn't start the daemon - but make sure we kill it anyway
# Of course we expect it to work here already, but maybe there are timing constraints
# on some platforms ?
try:
gd.proc.terminate()
except Exception as ex:
log.debug(
"Ignoring %r while terminating proc after %r.", ex,
e)
log.warning('git(%s) ls-remote failed due to:%s',
rw_repo.git_dir, e)
if is_win:
msg = textwrap.dedent("""
MINGW yet has problems with paths, and `git-daemon.exe` must be in PATH
(look into .\Git\mingw64\libexec\git-core\);
CYGWIN has no daemon, but if one exists, it gets along fine (has also paths problems)
Anyhow, alternatively try starting `git-daemon` manually:"""
)
else:
msg = "Please try starting `git-daemon` manually:"
msg += textwrap.dedent("""
git daemon --enable=receive-pack '%s'
You can also run the daemon on a different port by passing --port=<port>"
and setting the environment variable GIT_PYTHON_TEST_GIT_DAEMON_PORT to <port>
""" % temp_dir)
from nose import SkipTest
raise SkipTest(msg) if is_win else AssertionError(msg)
# END make assertion
# END catch ls remote error
# adjust working dir
prev_cwd = os.getcwd()
os.chdir(rw_repo.working_dir)
try:
return func(self, rw_repo, rw_remote_repo)
except:
log.info(
"Keeping repos after failure: repo_dir = %s, remote_repo_dir = %s",
repo_dir, remote_repo_dir)
repo_dir = remote_repo_dir = None
raise
finally:
os.chdir(prev_cwd)
finally:
try:
gd.proc.kill()
except:
## Either it has died (and we're here), or it won't die, again here...
pass
rw_repo.git.clear_cache()
rw_remote_repo.git.clear_cache()
rw_repo = rw_remote_repo = None
import gc
gc.collect()
if repo_dir:
rmtree(repo_dir)
if remote_repo_dir:
rmtree(remote_repo_dir)
if gd is not None:
gd.proc.wait()
