How can I tell if a file has been updated upstream?

Is there a way for me to tell if a particular file in my repository has an update in the upstream repository? For example, the SHA of the HEAD is different in the remote repository than it is of the HEAD in the local repository.

The reason I ask is that I have a set of Python scripts that I distribute via git (other people in the company clone my repository). I want my script, every time it's run, to check if an update is available, and ask the user to do "git pull".

Timur Tabi <timur@freescale.com> wrote:

You can't tell a particular file, but you could use something like `git ls-remote refs/heads/master` to see what the branch is at, and compare that to the last known commit. If its changed, then suggest the user do a fetch.

I do this in repo, only I run `git fetch` once per day for the end-user. That way the objects are local, and I can use a local check to see if there are updates that need to be pulled into the executable working directory.

On Fri, Feb 5, 2010 at 10:44 AM, Shawn O. Pearce <spearce@spearce.org> wrote:

$ git ls-remote refs/heads/master fatal: 'refs/heads/master' does not appear to be a git repository fatal: The remote end hung up unexpectedly

So maybe you meant this:

$ git ls-remote ssh://git.am.freescale.net/git/timur/bin refs/heads/master 20fbe12069038057cbd0d66c5a673956f7792c7d refs/heads/master

I can use this to compare with the local HEAD. However, this only tells me that the repository as a whole has changed. I was hoping there would be a way to see if just the one file has change. I.e. how can I get the HEAD of a *file* in a remote repository.

Yeah, I'm not keen on performing an actual download, even if it's just a fetch.

On Fri, 5 Feb 2010, Timur Tabi wrote:

You can't.

You must perform a fetch and then use whatever method to compare with origin/master:foobar.py which is the file you're looking for.

Why? It is not like if a fetch was terribly more costly than any method that could get the version of a file on the remote.

Nicolas

Timur Tabi <timur@freescale.com> writes:

So whenever I run your script it calls home, spend a roundtrip time, and nags me to update? I don't want to be working with you unless I can go without running that script less often than once a week ;-)

You need to teach it how to call home. How do your users "clone"? Some over git://, some others over ssh://, yet some others over local filesystem? Also how do they run the script? Directly out of the repository work tree, or is there a "make install" step involved?

If your users are running from the work tree copy unmodified, then you would need to look at sys.argv[0] to find out where it is, use that to find the repository, and using its .git/config learn how the user pulls from your repository (i.e. git config remote.origin.url), and at the same time which version it is (i.e. git rev-parse HEAD). If "make install" is involved, then you would hardcode the necessary information during the build process to the script your users would run.

At runtime, you would run "ls-remote HEAD" and compare with the version you are running. It may be stale, or it may not be.

How big is the script? It _might_ be faster to distribute a launcher that downloads the real script every time it runs and runs that fresh copy that is guaranteed to be the latest than doing all the hassle of the above.

On Fri, Feb 5, 2010 at 10:50 AM, Junio C Hamano <gitster@pobox.com> wrote:

Yes.  Fortunately, it's all on an internal network, so the overhead is low.

That's about how often most people will run the script.

git clone git://....

Only I have ssh access to my repository.

Directly out of the repository.  It's just a Python script.

Ok.

Ok.

I don't want to force an update, and I don't want to have to email everyone whenever there is an update. This seems to be the least intrusive approach.

On Fri, Feb 5, 2010 at 10:23 AM, Timur Tabi <timur@freescale.com> wrote:

Thanks to everyone who replied.  Here's what I came up with:

def check_for_updates():
    # Get the path to our script.  This should be a git repository.
    script_path = os.path.dirname(os.path.realpath(__file__))

    # Determine the upstream URL
    p = subprocess.Popen(['git', 'config', '-f', script_path + '/.git/config',
        '--get', 'remote.origin.url'],
        shell=False, stdout=subprocess.PIPE, stderr=open(os.devnull, 'w'))
    url = p.communicate()[0].strip()
    if not url:
        # The script is not running from a git repository
        return

    # Determine the HEAD of the upstream repository
    p = subprocess.Popen(['git', 'ls-remote', url, 'HEAD'],
        shell=False, stdout=subprocess.PIPE, stderr=open(os.devnull, 'w'))
    sha = p.communicate()[0].split()
    if not sha:
        # Something is wrong with the upstream repository
        return
    sha = sha[0] # The SHA of the upstream head

    # Check if the remote SHA is in the local repository.
    # git --git-dir=/home/b04825/bin/.git show-ref HEAD
    p = subprocess.Popen(['git', '--git-dir=' + script_path + '/.git',
        'log', '-1', sha],
        shell=False, stdout=subprocess.PIPE, stderr=open(os.devnull, 'w'))
    if not p.communicate()[0]:
        # If we can't find the SHA locally, then it means that the local
        # repository is out of date.  We pretend that it means that this script
        # is out of date.
        print 'There is an update for this script available.  Please
pull from the remote'
        print 'repository (e.g. "cd %s; git pull")' % script_path