lfs | linux utility to get information | File Utils library

The GH001: Large file detected (seen in the screenshot) seems to indicate the connection fails because your pushed commit is too big.

As mentioned, using LFS, or filtering large object from your history (using git filter-repo as in here), are two alternatives.

Git stores certain information in the index, which reflects things like the file size, device and inode numbers, modification and inode change times, and various other attributes. If this information is changed, or is potentially stale, then Git will re-read the file to see if it's modified. This is potentially expensive, as you've noticed, and Git's detection here is the reason that Git LFS has this same performance problem: Git is telling Git LFS to reprocess the file.

What you want to do is find out what's modifying the attributes of your files. For example, if you have some sort of file monitoring or backup software, then that can cause this problem, or if you're using some sort of cloud syncing service (which you should avoid anyway because it will probably corrupt your repository). This can also happen if you mount the repository into a container, since the container will have different device and inode numbers, and then each time you alternate in which environment you run git status, the entire repository must be re-read.

For example, on my systems, I don't have this problem and my system performs just fine. However, if you really can't figure it out, you can try setting core.trustctime to false and/or core.checkstat to minimal (which you should try in that order). That will put less data in the index, and then it's less likely to become stale when nothing's changed. However, it also means that it's more likely that Git will fail to detect a legitimate change, so if you can avoid needing to do this, you should.

If the files are in the lfs folder, it's that git needed them at a moment to populate your working directory.

So, no, there is no way to prevent git to cache them (except maybe by doing a sparse checkout if you really don't need to have the files handled by git-lfs in your working directory).

But you have an easy way to clean this cache directory (git will keep only the currently used files and delete the others unused) with the command:

You can't do uninit().assume_init() — it's definitely not initialized. assume_init() is only to be called once the data has been initialized with real values. The idea behind calling it is that you're promising, "Yes, I know this value is marked as maybe initialized. I promise that it is initialized now. It's not just a maybe."

You'll need to change the types of lfs and lfs_config:

In addition of ignoring .angular/cache, you can consider using git filter-repo instead of the obsolete git filter-branch or BFG.

That way, you would:

• install git filter-repo (python-based)
• delete any large file in your history: git filter-repo --strip-blobs-bigger-than 2M for instance. (content-based filtering)
• ignore .angular/cache
• force push (git push --force: make sure to notify any collaborator on that repository)

Git LFS uses a different HTTP and TLS library than the one in Git. Git uses libcurl, and Git LFS uses the Go HTTP library. As a result, the supported authentication logic is different, although both programs will use the Git credential helpers and other credential lookup logic.

Since you mention Azure DevOps, my guess is that you're using NTLM. In 3.0, Git LFS removed NTLM because it had known bugs and nobody was interested in fixing them, and because it uses cryptography known to be insecure since 1995. Azure DevOps is the only major site known to use NTLM, and the Git LFS maintainers asked if they'd like to be involved in helping maintain it, and they declined.

NTLM can be handled in one of two ways: via the NTLM authentication scheme or the Negotiate scheme. The latter is also used by Kerberos, which both Git and Git LFS do support, and which is secure. Currently, if you have NTLM set up to use Negotiate, Git LFS simply won't work, since it prioritizes Negotiate over Basic. In the upcoming 3.1, expected out this month or next, Git LFS will fall back to Basic if Negotiate fails, so you'll be able to work even if you have NTLM enabled on your instance.

I strongly encourage everyone to get rid of NTLM because it's so insecure. There's really no defensible reason to use it anymore: even Microsoft tells you to turn it off. If you turn off NTLM on your instance, or switch to Kerberos, things should just work. Otherwise, you'll need to wait for Git LFS 3.1 or explicitly set the authentication method to basic in the configuration.

After enough debug. I found out what was going on.

By default the Git plugin won't provide credentials to most of the git commands (only fetch it appears), so when it does a checkout it freezes waiting for credentials to access LFS.

By good design, though to my frustration, git/jenkins does not save the password anywhere on the machine and LFS objects are downloaded as part of the fetch. Setting up Jenkins to do LFS pull after checkout does not solve the issue as it is trying to do the LFS pull during the checkout.

The solution is to set GIT_LFS_SKIP_SMUDGE=1 in the global environment variables and add the LFS pull to the checkout steps to explicitly pull in LFS objects.

Your file was working a few weeks ago but is now moved to their Git Large File Storage which means that assets/animation/star_burst.mp4 is now a text file pointing to the storage location.

Try to specify direct access link. Something like https://media.githubusercontent.com/media/AnnaxT/AnnaxT.github.io/main/assets/animation/star_burst.mp4.

You can get it by clicking on "view raw" button on https://github.com/AnnaxT/AnnaxT.github.io/blob/main/assets/animation/star_burst.mp4

Or just upload less larger file.

use the following commands to install git-lfs