| Name |
Description |
| BaseConnection |
Base helper class for implementing operations connections. |
| BasePackConnection |
|
| BasePackFetchConnection |
|
| BasePackFetchConnection.NegotiateBeginRevFilter |
|
| BasePackPushConnection |
Push implementation using the native Git pack transfer service. This is the canonical implementation for transferring objects to the remote repository from the local repository by talking to the 'git-receive-pack' service. Objects are packed on the local side into a pack file and then sent to the remote repository. This connection requires only a bi-directional pipe or socket, and thus is easily wrapped up into a local process pipe, anonymous TCP socket, or a command executed through an SSH tunnel. This implementation honors Transport.get_PushThin option. Concrete implementations should just call BasePackConnection.init(System.IO.Stream,System.IO.Stream) and BasePackConnection.readAdvertisedRefs methods in constructor or before any use. They should also handle resources releasing in BasePackConnection.Close method if needed. |
| BundleFetchConnection |
|
| BundleWriter |
|
| Daemon |
Basic daemon for the anonymous git:// transport protocol. |
| Daemon.ReceivePackService |
|
| Daemon.UploadPackService |
|
| FetchHeadRecord |
|
| FetchProcess |
|
| IndexPack |
|
| IndexPack.DeltaChain |
|
| IndexPack.UnresolvedDelta |
|
| NULLReceiveHook |
|
| OpenSshConfig |
|
| OpenSshConfig.Host |
|
| OperationResult |
Class holding result of operation on remote repository. This includes refs advertised by remote repo and local tracking refs updates. |
| PackedObjectInfo |
Description of an object stored in a pack file, including offset. When objects are stored in packs Git needs the ObjectId and the offset (starting position of the object data) to perform random-access reads of objects from the pack. This extension of ObjectId includes the offset. |
| PacketLineIn |
|
| PacketLineOut |
Write Git style pkt-line formatting to an output stream. This class is not thread safe and may issue multiple writes to the underlying stream for each method call made. This class performs no buffering on its own. This makes it suitable to interleave writes performed by this class with writes performed directly against the underlying OutputStream. |
| PostReceiveHook |
|
| PushProcess |
Class performing push operation on remote repository. |
| PushResult |
|
| ReceiveCommand |
|
| RefAdvertiser |
Support for the start of UploadPack and ReceivePack. |
| RefSpec |
|
| RemoteConfig |
A remembered remote repository, including URLs and RefSpecs. A remote configuration remembers one or more URLs for a frequently accessed remote repository as well as zero or more fetch and push specifications describing how refs should be transferred between this repository and the remote repository. |
| RemoteRefUpdate |
|
| SideBandInputStream |
Unmultiplexes the data portion of a side-band channel. Reading from this input stream obtains data from channel 1, which is typically the bulk data stream. Channel 2 is transparently unpacked and "scraped" to update a progress monitor. The scraping is performed behind the scenes as part of any of the read methods offered by this stream. Channel 3 results in an exception being thrown, as the remote side has issued an unrecoverable error. SideBandOutputStream |
| SideBandOutputStream |
Multiplexes data and progress messages. This stream is buffered at packet sizes, so the caller doesn't need to wrap it in yet another buffered stream. |
| SideBandProgressMonitor |
Write progress messages out to the sideband channel. |
| SshConfigSessionFactory |
The base session factory that loads known hosts and private keys from $HOME/.ssh. This is the default implementation used by JGit and provides most of the compatibility necessary to match OpenSSH, a popular implementation of SSH used by C Git. The factory does not provide UI behavior. Override the method configure to supply appropriate {@link UserInfo} to the session. |
| SshSessionFactory |
Creates and destroys SSH connections to a remote system. Different implementations of the session factory may be used to control communicating with the end-user as well as reading their personal SSH configuration settings, such as known hosts and private keys. A Session must be returned to the factory that created it. Callers are encouraged to retain the SshSessionFactory for the duration of the period they are using the Session. |
| SshTransport |
|
| TagOpt |
|
| TrackingRefUpdate |
|
| Transport |
Connects two Git repositories together and copies objects between them. A transport can be used for either fetching (copying objects into the caller's repository from the remote repository) or pushing (copying objects into the remote repository from the caller's repository). Each transport implementation is responsible for the details associated with establishing the network connection(s) necessary for the copy, as well as actually shuffling data back and forth. Transport instances and the connections they Create are not thread-safe. Callers must ensure a transport is accessed by only one thread at a time. |
| TransportAmazonS3 |
|
| TransportBundleFile |
|
| TransportBundleStream |
Single shot fetch from a streamed Git bundle. The bundle is Read from an unbuffered input stream, which limits the transport to opening at most one FetchConnection before needing to recreate the transport instance. |
| TransportGitAnon |
Transport through a git-daemon waiting for anonymous TCP connections. This transport supports the git:// protocol, usually run on the IANA registered port 9418. It is a popular means for distributing open source projects, as there are no authentication or authorization overheads. |
| TransportGitAnon.TcpFetchConnection |
|
| TransportGitAnon.TcpPushConnection |
|
| TransportGitSsh |
Transport through an SSH tunnel. The SSH transport requires the remote side to have Git installed, as the transport logs into the remote system and executes a Git helper program on the remote side to read (or write) the remote repository's files. This transport does not support direct SCP style of copying files, as it assumes there are Git specific smarts on the remote side to perform object enumeration, save file modification and hook execution. |
| TransportGitSsh.GitSshErrorStream |
|
| TransportGitSsh.SshFetchConnection |
|
| TransportGitSsh.SshPushConnection |
|
| TransportHttp |
|
| TransportHttp.HttpObjectDatabase |
|
| TransportLocal |
|
| TransportSftp |
|
| TransportSftp.SftpObjectDatabase |
|
| URIish |
This URI like construct used for referencing Git archives over the net, as well as locally stored archives. The most important difference compared to RFC 2396 URI's is that no URI encoding/decoding ever takes place. A space or any special character is written as-is. |
| UploadPack |
|
| WalkFetchConnection |
|
| WalkFetchConnection.RemotePack |
|
| WalkPushConnection |
Generic push support for dumb transport protocols. Since there are no Git-specific smarts on the remote side of the connection the client side must handle everything on its own. The generic push support requires being able to delete, create and overwrite files on the remote side, as well as create any missing directories (if necessary). Typically this can be handled through an FTP style protocol. Objects not on the remote side are uploaded as pack files, using one pack file per invocation. This simplifies the implementation as only two data files need to be written to the remote repository. Push support supplied by this class is not multiuser safe. Concurrent pushes to the same repository may yield an inconsistent reference database which may confuse fetch clients. A single push is concurrently safe with multiple fetch requests, due to the careful order of operations used to update the repository. Clients fetching may receive transient failures due to short reads on certain files if the protocol does not support atomic file replacement. see WalkRemoteObjectDatabase. |
| WalkPushConnection.PushRefWriter |
|
| WalkRemoteObjectDatabase |
Transfers object data through a dumb transport. Implementations are responsible for resolving path names relative to the objects/ subdirectory of a single remote Git repository or naked object database and make the content available as a Java input stream for reading during fetch. The actual object traversal logic to determine the names of files to retrieve is handled through the generic, protocol independent WalkFetchConnection. |