packfile | Dockerfile alternative , built on Cloud Native Buildpacks | Continuous Deployment library

Based on your git log output, the two commits that are on master but not on origin/master are a290975977b819d6719cd4e2e96f5d0ba9b3bc76 and 11d13f421f3f6c7f8ff8e18cf0d95a005c0465bb.

Commit a290975977b819d6719cd4e2e96f5d0ba9b3bc76 is the commit that you have, currently, as the tip commit of your master branch. The tip commit is the commit that is the last commit on that branch at the moment. To understand this, see the notes below.

Commit a290975977b819d6719cd4e2e96f5d0ba9b3bc76 is a merge commit, with two parents. We see this here:

TFS 2018 doesn't support git server side hooks.

So your really great idea it's impossible.

I suggest to open a feature request about it like there is about pre-receive hook.

If the file is unchanged between the commit being sent, and one which was discovered to be common, this can be handled without further negotiation: if the client has commit X, it must also have all the blobs in the tree of commit X.

If a blob with the same hash happens to exist in a commit which was not part of the negotiation, it would be possible to negotiate not to send it. In practice, though, this would probably be rare: you'd need a file on the server and a file in the client which were identical, but which had not appeared in the history which was already shared.

More common is that the file to be sent can be described by some delta from a previous version of the file. That's handled by the pack format - the server can send a delta with a base object it knows the client has.

If the server had a perfect view of the client's list of objects, it could optimise both the blobs it sent and how to deltify them, but the bandwidth to transmit that complete list would often be higher than the bandwidth saved.

If you do a standard git gc in a repository with no changes, this is expected. Git names its packfiles by a hash of their contents. Because Git doesn't recompute deltas for existing packs, when you git gc and there's only one pack and no loose objects, it's very likely that it will pack all the data into one pack that's the same as the old one.

When this happens, Git still has a file descriptor to the old pack open because it doesn't close packs immediately. This is because often it's necessary to access them again, so it will try to leave them open a little while. The old pack, which is still open, is renamed to the old name, and the new pack is renamed into place; the old pack is then deleted. On a Unix system, it's completely possible to delete a file for which you have the file descriptor open; when the last process closes its file descriptor, the storage is freed.

So this all seems completely normal for the scenario you're describing. Usually git gc is not a no-op, since additional objects are added to or removed from the pack or multiple packs are combined into one. But, if you do run a git gc immediately after running one with no intermediate changes, this is expected.

Alas, no: the controls available are only the following:

• core.bigFileThreshold: files that exceed this size are not packed, merely zlib-compressed.

• pack.island and several related settings: these set up so-called delta islands, as described in the git pack-objects documentation.

These do not come anywhere close to what you want. (Note: there is also core.compression and two related items, but these are strictly global, not per-object.)

git gc is a wrapper for a whole series of smaller maintenance operations:

• git reflog expire
• git repack
• git prune-packed (actually done by git repack automatically when you use -d)
• git prune
• any others I may have forgotten

and git prune is the one that specifically removes unreferenced objects. Note that git gc supplies an expiry time so that git prune won't remove unreferenced objects that are still being constructed. If you have no active Git commands that might be constructing objects, and don't want to provide the gc default grace period, you don't need to worry about this.

The header was clearly created from a pre-Unicode Delphi time. It suppose char = AnsiChar which is not true since Delphi 2009.

IIRC from forums, TotalCommander 32-bit is still compiled with Delphi 2 or Delphi 3, with a lot of custom RTL, to keep it small and efficient.

If you are using an Unicode version of Delphi, try to change char into AnsiChar, and use the *W() exports with Unicode support.

Also don't use global variables to maintain the state of the packer access: you should use the THandle value to open/close a given archive file. Two archives may be opened at the same time.

Edit: since you are using Delphi 7, this is not an Unicode problem. But I would try