Skip to content

Latest commit

 

History

History
362 lines (323 loc) · 14 KB

crate-status.md

File metadata and controls

362 lines (323 loc) · 14 KB
Raw

git-actor

  • read and write a signature that uniquely identifies an actor within a git repository

git-hash

  • types to represent hash digests to identify git objects.
  • used to abstract over different kinds of hashes, like SHA1 and the upcoming SHA256
  • API documentation
    • Some examples

git-object

  • decode (zero-copy) borrowed objects
    • commit
    • tree
  • encode owned objects
  • transform borrowed to owned objects
  • API documentation
    • Some examples

git-pack

  • packs
    • traverse pack index
    • 'object' abstraction
      • decode (zero copy)
      • verify checksum
    • simple and fast pack traversal
    • decode
      • full objects
      • deltified objects
    • decode
      • decode a pack from Read input
        • Add support for zlib-ng for 20% faster decompression performance
        • Read to Iterator of entries
          • read as is, verify hash, and restore partial packs
      • create index from pack alone (much faster than git)
        • resolve 'thin' packs
    • encode
      • Add support for zlib-ng for 2.5x compression performance
      • objects to entries iterator
        • input objects as-is
        • pack only changed objects as derived from input
        • base object compression
        • delta compression
          • create 'thin' pack, i.e. deltas that are based on objects the other side has.
        • parallel implementation that scales perfectly
      • entries to pack data iterator
    • verify pack with statistics
      • brute force - less memory
      • indexed - faster, but more memory
    • advanced
  • API documentation
    • Some examples

git-odb

  • loose object store
    • traverse
    • read
      • into memory
      • streaming
      • verify checksum
    • streaming write for blobs
    • buffer write for small in-memory objects/non-blobs to bring IO down to open-read-close == 3 syscalls
  • compound store
    • everything loose object stores can do
    • lookup objects in packs
  • linked store
    • everything the first loose object store can do
    • lookup objects in multiple linked object stores
  • sink
    • write objects and obtain id
  • alternates
    • resolve links between object databases
    • safe with cycles and recursive configurations
    • multi-line with comments and quotes
  • promisor
    • It's vague, but these seems to be like index files allowing to fetch objects from a server on demand.
  • API documentation
    • Some examples

git-diff

Check out the performance discussion as well.

  • tree
    • changes needed to obtain other tree
    • case-insensitive comparisons
    • rename and copy tracking
    • readily available caching for 4x+ speedups
  • patches
    • There are various ways to generate a patch from two blobs.
    • any
  • diffing, merging, working with hunks of data
  • find differences between various states, i.e. index, working tree, commit-tree
  • Parallel stat calls to check/update objects in index
  • API documentation
    • Examples

git-traverse

Check out the performance discussion as well.

  • trees
    • nested traversal
  • commits
    • ancestor graph traversal similar to git revlog
  • API documentation
    • Examples
  • tree

git-url

  • As documented here: https://www.git-scm.com/docs/git-clone#_git_urls
  • parse
    • ssh URLs and SCP like syntax
    • file, git, and SSH
    • paths (OS paths, without need for UTF-8)
  • username expansion for ssh and git urls
  • convert URL to string
  • API documentation
    • Some examples

git-protocol

  • abstract over protocol versions to allow delegates to deal only with a single way of doing things
  • credentials
    • via git-credentials
    • via pure Rust implementation if no git is installed
  • fetch & clone
    • detailed progress
    • control credentials provider to fill, approve and reject
    • command: ls-ref
      • parse V1 refs as provided during handshake
      • parse V2 refs
      • handle empty refs, AKA PKT-LINE(zero-id SP "capabilities^{}" NUL capability-list)
    • initialize and validate command arguments and features sanely
    • abort early for ls-remote capabilities
    • packfile negotiation
      • delegate can support for all fetch features, including shallow, deepen, etc.
      • receive parsed shallow refs
  • push
  • API documentation
    • Some examples

git-packetline

git-transport

  • No matter what we do here, timeouts must be supported to prevent hanging forever and to make interrupts destructor-safe.
  • client
    • general purpose connect(…) for clients
      • file:// launches service application
      • ssh:// launches service application in a remote shell using ssh
      • git:// establishes a tcp connection to a git daemon
      • http(s):// establishes connections to web server
      • pass context for scheme specific configuration, like timeouts
    • git://
      • V1 handshake
        • send values + receive data with sidebands
        • support for receiving 'shallow' refs in case the remote repository is shallow itself (I presume)
          • Since V2 doesn't seem to support that, let's skip this until there is an actual need. No completionist :D
      • V2 handshake
        • send command request, receive response with sideband support
    • http(s)://
      • set identity for basic authentication
      • V1 handshake
        • send values + receive data with sidebands
      • V2 handshake
        • send command request, receive response with sideband support
      • 'dumb' - we opt out using this protocol seems too slow to be useful, unless it downloads entire packs for clones?
    • authentication failures are communicated by io::ErrorKind::PermissionDenied, allowing other layers to retry with authentication
  • server
    • general purpose accept(…) for servers
  • API documentation
    • Some examples

git-index

  • read and write a git-index file
  • add and remove entries
  • API documentation
    • Some examples

git-commitgraph

  • read-only access
    • Graph lookup of commit information to obtain timestamps, generation and parents, and extra edges
    • Bloom filter index
    • Bloom filter data
  • create and update graphs and graph files
  • API documentation
    • Some examples

git-tempfile

Use tempfiles to minimize the risk of resource leakage when preparing to overwrite or create a file with new content in a signal-safe way, making the change atomic.

Tempfiles can also be used as locks as only one tempfile can exist at a given path at a time.

  • registered temporary files which are deleted automatically as the process terminates or on drop
    • write to temorary file and persist it under new name
    • close temporary files to convert them into a marker while saving system resources
    • mark paths with a closed temporary file
  • persist temporary files to prevent them from perishing.
  • signal-handler integration with git-repository to clean lockfiles before the process is aborted.

git-lock

Use lock-files in the way git does with auto-cleanup being the most notable feature.

  • writable lock files that can be committed to atomically replace the resource they lock
  • read-only markers that lock a resource without the intend to overwrite it
  • auto-removal of the lockfiles and intermediate directories on drop or on signal

git-config

  • read
    • line-wise parsing with decent error messages
    • decode value
      • boolean
      • integer
      • color
      • path (incl. resolution)
      • include
      • includeIf
  • write
    • keep comments and whitespace, and only change lines that are affected by actual changes, to allow truly non-destructive editing
  • Config type which integrates multiple files into one interface to support system, user and repository levels for config files
  • API documentation
    • Some examples

git-repository

  • utilities for applications to make long running operations interruptiple gracefully and to support timeouts in servers.
  • discovery
    • option to not cross file systems
    • handle git-common-dir
  • Repository
    • discovery
      • handle other non-discovery modes and provide control over environment variable usage required in applications
    • instantiation
      • a way to handle .git files with gitdir: <path> in it
      • handle gitdir and commondir files
  • access to refs and objects
  • traverse
    • commit graphs
    • tree entries
  • diffs/changes
    • tree with tree
    • tree with index
    • index with working tree
  • initialize
    • Proper configuration depending on platform (e.g. ignorecase, filemode, …)
  • All mutations are multi-process safe and this is tested and configurable (i.e. abort or wait if lock is encountered)
  • Signed commits and tags
  • clone
    • shallow
    • namespaces support
  • sparse checkout support
  • execute hooks
  • .gitignore handling
  • checkout/stage conversions clean + smudge as in .gitattributes
  • rev-parsing and ref history
  • refs
    • run transaction hooks and handle special repository states like quarantine
    • support for different backends like files and reftable
  • worktrees
  • remotes with push and pull
  • mailmap
  • configuration
  • merging
  • stashing
  • Use Commit Graph to speed up certain queries
  • API documentation
    • Some examples

git-bundle

  • create a bundle from an archive
  • extract a branch from a bundle into a repository
  • API documentation
    • Some examples

git-validate

git-ref

  • Prepare code for arrival of longer hashes like Sha256. It's part of the V2 proposal but should work for loose refs as well.
  • Stores
    • disable transactions during quarantine
    • loose file
      • ref validation
      • find single ref by name
      • special handling of FETCH_HEAD and MERGE_HEAD
      • iterate refs with optional prefix
      • worktree support
      • symbolic ref support, using symbolic links
        • This is a legacy feature which is not in use anymore.
      • transactions
        • delete, create or update single ref or multiple refs while handling the reflog
        • set any valid ref value (not just object ids)
        • reflog changes can be entirely disabled (i.e. for bare repos)
        • rename or copy references
        • transparent handling of packed-refs
        • initial transaction optimization (a faster way to create clones with a lot of refs)
      • log
        • forward iteration
        • backward iteration
        • expire
      • ref
        • peel to id
      • packed
        • find single ref by name
        • iterate
    • reftable,
  • API documentation
    • Some examples

git-features

  • io-pipe feature toggle
    • a unix like pipeline for bytes
  • parallel feature toggle
    • When on…
      • in_parallel
      • join
    • When off all functions execute serially
  • fast-sha1
    • provides a faster SHA1 implementation using CPU intrinsics
  • API documentation

git-tui

  • a terminal user interface seeking to replace and improve on tig
  • Can display complex history in novel ways to make them graspable. Maybe this post can be an inspiration.