1. 13 Jun, 2017 4 commits
  2. 12 Jun, 2017 4 commits
    • tests: odb: add tests with multiple backends · f148258a
      Previous to pulling out and extending the fake backend, it was quite
      cumbersome to write tests for very specific scenarios regarding
      backends. But as we have made it more generic, it has become much easier
      to do so. As such, this commit adds multiple tests for scenarios with
      multiple backends for the ODB.
      
      The changes also include a test for a very targeted scenario. When one
      backend found a matching object via `read_prefix`, but the last backend
      returns `GIT_ENOTFOUND` and when object hash verification is turned off,
      we fail to reset the error code to `GIT_OK`. This causes us to segfault
      later on, when doing a double-free on the returned object.
      Patrick Steinhardt committed
    • tests: odb: allow passing fake objects to the fake backend · 6e010bb1
      Right now, the fake backend is quite restrained in the way how it
      works: we pass it an OID which it is to return later as well as an error
      code we want it to return. While this is sufficient for existing tests,
      we can make the fake backend a little bit more generic in order to allow
      us testing for additional scenarios.
      
      To do so, we change the backend to not accept an error code and OID
      which it is to return for queries, but instead a simple array of OIDs
      with their respective blob contents. On each query, the fake backend
      simply iterates through this array and returns the first matching
      object.
      Patrick Steinhardt committed
    • tests: do not reuse OID from backend · 369cb45f
      In order to make the fake backend more useful, we want to enable it
      holding multiple object references. To do so, we need to decouple it
      from the single fake OID it currently holds, which we simply move up
      into the calling tests.
      Patrick Steinhardt committed
    • tests: odb: move fake backend into its own file · 2add34d0
      The fake backend used by the test suite `odb::backend::nonrefreshing` is
      useful to have some low-level tests for the ODB layer. As such, we move
      the implementation into its own `backend_helpers` module.
      Patrick Steinhardt committed
  3. 08 Jun, 2017 1 commit
    • settings: rename `GIT_OPT_ENABLE_SYNCHRONOUS_OBJECT_CREATION` · 6c23704d
      Initially, the setting has been solely used to enable the use of
      `fsync()` when creating objects. Since then, the use has been extended
      to also cover references and index files. As the option is not yet part
      of any release, we can still correct this by renaming the option to
      something more sensible, indicating not only correlation to objects.
      
      This commit renames the option to `GIT_OPT_ENABLE_FSYNC_GITDIR`. We also
      move the variable from the object to repository source code.
      Patrick Steinhardt committed
  4. 28 Apr, 2017 2 commits
    • odb: verify object hashes · 28a0741f
      The upstream git.git project verifies objects when looking them up from
      disk. This avoids scenarios where objects have somehow become corrupt on
      disk, e.g. due to hardware failures or bit flips. While our mantra is
      usually to follow upstream behavior, we do not do so in this case, as we
      never check hashes of objects we have just read from disk.
      
      To fix this, we create a new error class `GIT_EMISMATCH` which denotes
      that we have looked up an object with a hashsum mismatch. `odb_read_1`
      will then, after having read the object from its backend, hash the
      object and compare the resulting hash to the expected hash. If hashes do
      not match, it will return an error.
      
      This obviously introduces another computation of checksums and could
      potentially impact performance. Note though that we usually perform I/O
      operations directly before doing this computation, and as such the
      actual overhead should be drowned out by I/O. Running our test suite
      seems to confirm this guess. On a Linux system with best-of-five
      timings, we had 21.592s with the check enabled and 21.590s with the
      ckeck disabled. Note though that our test suite mostly contains very
      small blobs only. It is expected that repositories with bigger blobs may
      notice an increased hit by this check.
      
      In addition to a new test, we also had to change the
      odb::backend::nonrefreshing test suite, which now triggers a hashsum
      mismatch when looking up the commit "deadbeef...". This is expected, as
      the fake backend allocated inside of the test will return an empty
      object for the OID "deadbeef...", which will obviously not hash back to
      "deadbeef..." again. We can simply adjust the hash to equal the hash of
      the empty object here to fix this test.
      Patrick Steinhardt committed
    • tests: odb: make hash of fake backend configurable · e29e8029
      In the odb::backend::nonrefreshing test suite, we set up a fake backend
      so that we are able to determine if backend functions are called
      correctly. During the setup, we also parse an OID which is later on used
      to read out the pseudo-object. While this procedure works right now, it
      will create problems later when we implement hash verification for
      looked up objects. The current OID ("deadbeef") will not match the hash
      of contents we give back to the ODB layer and thus cannot be verified.
      
      Make the hash configurable so that we can simply switch the returned for
      single tests.
      Patrick Steinhardt committed
  5. 05 Apr, 2017 1 commit
  6. 03 Mar, 2017 1 commit
  7. 02 Mar, 2017 1 commit
  8. 28 Feb, 2017 2 commits
  9. 29 Dec, 2016 1 commit
  10. 06 Oct, 2016 1 commit
  11. 05 Aug, 2016 1 commit
    • odb: only provide the empty tree · becadafc
      Only provide the empty tree internally, which matches git's behavior.
      If we provide the empty blob then any users trying to write it with
      libgit2 would omit it from actually landing in the odb, which appear
      to git proper as a broken repository (missing that object).
      Edward Thomson committed
  12. 04 Aug, 2016 2 commits
  13. 09 Mar, 2016 1 commit
  14. 08 Mar, 2016 2 commits
  15. 07 Mar, 2016 1 commit
  16. 14 Oct, 2015 1 commit
    • odb: Prioritize alternate backends · a0a1b19a
      For most real use cases, repositories with alternates use them as main
      object storage. Checking the alternate for objects before the main
      repository should result in measurable speedups.
      
      Because of this, we're changing the sorting algorithm to prioritize
      alternates *in cases where two backends have the same priority*. This
      means that the pack backend for the alternate will be checked before the
      pack backend for the main repository *but* both of them will be checked
      before any loose backends.
      Vicent Marti committed
  17. 30 Sep, 2015 1 commit
    • refdb and odb backends must provide `free` function · d3b29fb9
      As refdb and odb backends can be allocated by client code, libgit2
      can’t know whether an alternative memory allocator was used, and thus
      should not try to call `git__free` on those objects.
      
      Instead, odb and refdb backend implementations must always provide
      their own `free` functions to ensure memory gets freed correctly.
      Arthur Schreiber committed
  18. 17 Sep, 2015 1 commit
    • git_futils_mkdir_*: make a relative-to-base mkdir · ac2fba0e
      Untangle git_futils_mkdir from git_futils_mkdir_ext - the latter
      assumes that we own everything beneath the base, as if it were
      being called with a base of the repository or working directory,
      and is tailored towards checkout and ensuring that there is no
      bogosity beneath the base that must be cleaned up.
      
      This is (at best) slow and (at worst) unsafe in the larger context
      of a filesystem where we do not own things and cannot do things like
      unlink symlinks that are in our way.
      Edward Thomson committed
  19. 06 Jun, 2015 1 commit
  20. 21 Nov, 2014 1 commit
  21. 08 Nov, 2014 1 commit
    • odb: hardcode the empty blob and tree · e1ac0101
      git hardocodes these as objects which exist regardless of whether they
      are in the odb and uses them in the shell interface as a way of
      expressing the lack of a blob or tree for one side of e.g. a diff.
      
      In the library we use each language's natural way of declaring a lack of
      value which makes a workaround like this unnecessary. Since git uses it,
      it does however mean each shell application would need to perform this
      check themselves.
      
      This makes it common work across a range of applications and an issue
      with compatibility with git, which fits right into what the library aims
      to provide.
      
      Thus we introduce the hard-coded empty blob and tree in the odb
      frontend. These hard-coded objects are checked for before going to the
      backends, but after the cache check, which means the second time they're
      used, they will be treated as normal cached objects instead of creating
      new ones.
      Carlos Martín Nieto committed
  22. 26 Sep, 2014 1 commit
  23. 01 Jul, 2014 1 commit
  24. 20 May, 2014 1 commit
  25. 05 May, 2014 1 commit
  26. 10 Mar, 2014 1 commit
    • Fix a number of git_odb_exists_prefix bugs · 89499078
      The git_odb_exists_prefix API was not dealing correctly when a
      later backend returned GIT_ENOTFOUND even if an earlier backend
      had found the object.
      
      Additionally, the unit tests were not properly exercising the API
      and had a couple mistakes in checking the results.
      
      Lastly, since the backends are not expected to behavior correctly
      unless all bytes of the short id are zero except for the prefix,
      this makes the ODB prefix APIs explicitly clear out the extra
      bytes so the user doesn't have to be as careful.
      Russell Belfer committed
  27. 07 Mar, 2014 1 commit
  28. 05 Mar, 2014 1 commit
  29. 04 Mar, 2014 1 commit
  30. 11 Dec, 2013 1 commit
    • Remove converting user error to GIT_EUSER · 25e0b157
      This changes the behavior of callbacks so that the callback error
      code is not converted into GIT_EUSER and instead we propagate the
      return value through to the caller.  Instead of using the
      giterr_capture and giterr_restore functions, we now rely on all
      functions to pass back the return value from a callback.
      
      To avoid having a return value with no error message, the user
      can call the public giterr_set_str or some such function to set
      an error message.  There is a new helper 'giterr_set_callback'
      that functions can invoke after making a callback which ensures
      that some error message was set in case the callback did not set
      one.
      
      In places where the sign of the callback return value is
      meaningful (e.g. positive to skip, negative to abort), only the
      negative values are returned back to the caller, obviously, since
      the other values allow for continuing the loop.
      
      The hardest parts of this were in the checkout code where positive
      return values were overloaded as meaningful values for checkout.
      I fixed this by adding an output parameter to many of the internal
      checkout functions and removing the overload.  This added some
      code, but it is probably a better implementation.
      
      There is some funkiness in the network code where user provided
      callbacks could be returning a positive or a negative value and
      we want to rely on that to cancel the loop.  There are still a
      couple places where an user error might get turned into GIT_EUSER
      there, I think, though none exercised by the tests.
      Russell Belfer committed