def test_ssh_implicit(self):
c, path = get_transport_and_path('foo:/bar/baz')
self.assertTrue(isinstance(c, SSHGitClient))
self.assertEqual('foo', c.host)
self.assertEqual(None, c.port)
self.assertEqual(None, c.username)
self.assertEqual('/bar/baz', path)
def test_ssh_user_host_relpath(self):
c, path = get_transport_and_path('[email protected]:bar/baz')
self.assertTrue(isinstance(c, SSHGitClient))
self.assertEqual('foo.com', c.host)
self.assertEqual(None, c.port)
self.assertEqual('user', c.username)
self.assertEqual('bar/baz', path)
def test_ssh_abspath_doubleslash(self):
c, path = get_transport_and_path('git+ssh://foo.com//bar/baz')
self.assertTrue(isinstance(c, SSHGitClient))
self.assertEqual('foo.com', c.host)
self.assertEqual(None, c.port)
self.assertEqual(None, c.username)
self.assertEqual('//bar/baz', path)
def test_username_and_port_explicit(self):
c, path = get_transport_and_path(
'ssh://git@server:7999/dply/stuff.git')
self.assertTrue(isinstance(c, SSHGitClient))
self.assertEqual('git', c.username)
self.assertEqual('server', c.host)
self.assertEqual(7999, c.port)
self.assertEqual('/dply/stuff.git', path)
def test_http_no_auth(self):
url = 'https://github.com/jelmer/dulwich'
c, path = get_transport_and_path(url)
self.assertTrue(isinstance(c, HttpGitClient))
self.assertEqual('/jelmer/dulwich', path)
self.assertIs(None, c._username)
self.assertIs(None, c._password)
def ls_remote(remote, config=None, **kwargs):
"""List the refs in a remote.
:param remote: Remote repository location
:param config: Configuration to use
:return: Dictionary with remote refs
"""
if config is None:
config = StackedConfig.default()
client, host_path = get_transport_and_path(remote, config=config, **kwargs)
return client.get_refs(host_path)
def push(repo,
remote_location,
refspecs,
outstream=default_bytes_out_stream,
errstream=default_bytes_err_stream,
**kwargs):
"""Remote push with dulwich via dulwich.client
:param repo: Path to repository
:param remote_location: Location of the remote
:param refspecs: Refs to push to remote
:param outstream: A stream file to write output
:param errstream: A stream file to write errors
"""
# Open the repo
with open_repo_closing(repo) as r:
# Get the client and path
client, path = get_transport_and_path(remote_location,
config=r.get_config_stack(),
**kwargs)
selected_refs = []
def update_refs(refs):
selected_refs.extend(parse_reftuples(r.refs, refs, refspecs))
new_refs = {}
# TODO: Handle selected_refs == {None: None}
for (lh, rh, force) in selected_refs:
if lh is None:
new_refs[rh] = ZERO_SHA
else:
new_refs[rh] = r.refs[lh]
return new_refs
err_encoding = getattr(errstream, 'encoding', None) or DEFAULT_ENCODING
remote_location_bytes = client.get_url(path).encode(err_encoding)
try:
client.send_pack(
path,
update_refs,
generate_pack_data=r.object_store.generate_pack_data,
progress=errstream.write)
errstream.write(b"Push to " + remote_location_bytes +
b" successful.\n")
except (UpdateRefsError, SendPackError) as e:
errstream.write(b"Push to " + remote_location_bytes +
b" failed -> " + e.message.encode(err_encoding) +
b"\n")
def pull(repo,
remote_location=None,
refspecs=None,
outstream=default_bytes_out_stream,
errstream=default_bytes_err_stream,
**kwargs):
"""Pull from remote via dulwich.client
:param repo: Path to repository
:param remote_location: Location of the remote
:param refspec: refspecs to fetch
:param outstream: A stream file to write to output
:param errstream: A stream file to write to errors
"""
# Open the repo
with open_repo_closing(repo) as r:
if remote_location is None:
# TODO(jelmer): Lookup 'remote' for current branch in config
raise NotImplementedError(
"looking up remote from branch config not supported yet")
if refspecs is None:
refspecs = [b"HEAD"]
selected_refs = []
def determine_wants(remote_refs):
selected_refs.extend(parse_reftuples(remote_refs, r.refs,
refspecs))
return [remote_refs[lh] for (lh, rh, force) in selected_refs]
client, path = get_transport_and_path(remote_location,
config=r.get_config_stack(),
**kwargs)
fetch_result = client.fetch(path,
r,
progress=errstream.write,
determine_wants=determine_wants)
for (lh, rh, force) in selected_refs:
r.refs[rh] = fetch_result.refs[lh]
if selected_refs:
r[b'HEAD'] = fetch_result.refs[selected_refs[0][1]]
# Perform 'git checkout .' - syncs staged changes
tree = r[b"HEAD"].tree
r.reset_index(tree=tree)
def fetch(repo,
remote_location,
remote_name=b'origin',
outstream=sys.stdout,
errstream=default_bytes_err_stream,
message=None,
**kwargs):
"""Fetch objects from a remote server.
:param repo: Path to the repository
:param remote_location: String identifying a remote server
:param remote_name: Name for remote server
:param outstream: Output stream (defaults to stdout)
:param errstream: Error stream (defaults to stderr)
:param message: Reflog message (defaults to b"fetch: from <remote_name>")
:return: Dictionary with refs on the remote
"""
if message is None:
message = b'fetch: from ' + remote_location.encode("utf-8")
with open_repo_closing(repo) as r:
client, path = get_transport_and_path(remote_location,
config=r.get_config_stack(),
**kwargs)
fetch_result = client.fetch(path, r, progress=errstream.write)
stripped_refs = strip_peeled_refs(fetch_result.refs)
branches = {
n[len(b'refs/heads/'):]: v
for (n, v) in stripped_refs.items() if n.startswith(b'refs/heads/')
}
r.refs.import_refs(b'refs/remotes/' + remote_name,
branches,
message=message)
tags = {
n[len(b'refs/tags/'):]: v
for (n, v) in stripped_refs.items() if n.startswith(b'refs/tags/')
and not n.endswith(ANNOTATED_TAG_SUFFIX)
}
r.refs.import_refs(b'refs/tags', tags, message=message)
return fetch_result.refs
def test_http(self):
url = 'https://github.com/jelmer/dulwich'
c, path = get_transport_and_path(url)
self.assertTrue(isinstance(c, HttpGitClient))
self.assertEqual('/jelmer/dulwich', path)
def test_error(self):
# Need to use a known urlparse.uses_netloc URL scheme to get the
# expected parsing of the URL on Python versions less than 2.6.5
c, path = get_transport_and_path('prospero://bar/baz')
self.assertTrue(isinstance(c, SSHGitClient))
def test_local_abs_windows_path(self):
c, path = get_transport_and_path('C:\\foo.bar\\baz')
self.assertTrue(isinstance(c, LocalGitClient))
self.assertEqual('C:\\foo.bar\\baz', path)
def test_local(self):
c, path = get_transport_and_path('foo.bar/baz')
self.assertTrue(isinstance(c, LocalGitClient))
self.assertEqual('foo.bar/baz', path)
def test_ssh_port(self):
c, path = get_transport_and_path('git+ssh://foo.com:1234/bar/baz')
self.assertTrue(isinstance(c, SSHGitClient))
self.assertEqual('foo.com', c.host)
self.assertEqual(1234, c.port)
self.assertEqual('/bar/baz', path)
def test_username_and_port_explicit_unknown_scheme(self):
c, path = get_transport_and_path(
'unknown://git@server:7999/dply/stuff.git')
self.assertTrue(isinstance(c, SSHGitClient))
self.assertEqual('unknown', c.host)
self.assertEqual('//git@server:7999/dply/stuff.git', path)
def test_tcp_port(self):
c, path = get_transport_and_path('git://foo.com:1234/bar/baz')
self.assertTrue(isinstance(c, TCPGitClient))
self.assertEqual('foo.com', c._host)
self.assertEqual(1234, c._port)
self.assertEqual('/bar/baz', path)
