[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
#include "cache.h"
|
|
|
|
#include "refs.h"
|
|
|
|
#include "object.h"
|
|
|
|
#include "commit.h"
|
2005-07-29 01:33:17 +04:00
|
|
|
#include "tag.h"
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
|
|
|
|
/* refs */
|
|
|
|
static FILE *info_ref_fp;
|
|
|
|
|
2006-09-21 09:02:01 +04:00
|
|
|
static int add_info_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
{
|
2005-10-14 05:57:40 +04:00
|
|
|
struct object *o = parse_object(sha1);
|
|
|
|
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
fprintf(info_ref_fp, "%s %s\n", sha1_to_hex(sha1), path);
|
2006-07-12 07:45:31 +04:00
|
|
|
if (o->type == OBJ_TAG) {
|
2005-11-03 02:19:13 +03:00
|
|
|
o = deref_tag(o, path, 0);
|
|
|
|
if (o)
|
|
|
|
fprintf(info_ref_fp, "%s %s^{}\n",
|
|
|
|
sha1_to_hex(o->sha1), path);
|
2005-10-14 05:57:40 +04:00
|
|
|
}
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int update_info_refs(int force)
|
|
|
|
{
|
2006-09-02 08:16:31 +04:00
|
|
|
char *path0 = xstrdup(git_path("info/refs"));
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
int len = strlen(path0);
|
|
|
|
char *path1 = xmalloc(len + 2);
|
|
|
|
|
|
|
|
strcpy(path1, path0);
|
|
|
|
strcpy(path1 + len, "+");
|
|
|
|
|
|
|
|
safe_create_leading_directories(path0);
|
|
|
|
info_ref_fp = fopen(path1, "w");
|
|
|
|
if (!info_ref_fp)
|
|
|
|
return error("unable to update %s", path0);
|
2006-09-21 08:47:42 +04:00
|
|
|
for_each_ref(add_info_ref, NULL);
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
fclose(info_ref_fp);
|
|
|
|
rename(path1, path0);
|
|
|
|
free(path0);
|
|
|
|
free(path1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* packs */
|
2005-08-01 23:11:53 +04:00
|
|
|
static struct pack_info {
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
struct packed_git *p;
|
|
|
|
int old_num;
|
|
|
|
int new_num;
|
|
|
|
int nr_alloc;
|
|
|
|
int nr_heads;
|
|
|
|
unsigned char (*head)[20];
|
|
|
|
} **info;
|
|
|
|
static int num_pack;
|
|
|
|
static const char *objdir;
|
|
|
|
static int objdirlen;
|
|
|
|
|
|
|
|
static struct pack_info *find_pack_by_name(const char *name)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < num_pack; i++) {
|
|
|
|
struct packed_git *p = info[i]->p;
|
|
|
|
/* skip "/pack/" after ".git/objects" */
|
|
|
|
if (!strcmp(p->pack_name + objdirlen + 6, name))
|
|
|
|
return info[i];
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns non-zero when we detect that the info in the
|
|
|
|
* old file is useless.
|
|
|
|
*/
|
|
|
|
static int parse_pack_def(const char *line, int old_cnt)
|
|
|
|
{
|
|
|
|
struct pack_info *i = find_pack_by_name(line + 2);
|
|
|
|
if (i) {
|
|
|
|
i->old_num = old_cnt;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
else {
|
2005-12-05 09:52:19 +03:00
|
|
|
/* The file describes a pack that is no longer here */
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns non-zero when we detect that the info in the
|
|
|
|
* old file is useless.
|
|
|
|
*/
|
|
|
|
static int read_pack_info_file(const char *infofile)
|
|
|
|
{
|
|
|
|
FILE *fp;
|
|
|
|
char line[1000];
|
|
|
|
int old_cnt = 0;
|
|
|
|
|
|
|
|
fp = fopen(infofile, "r");
|
|
|
|
if (!fp)
|
2006-07-09 11:44:30 +04:00
|
|
|
return 1; /* nonexistent is not an error. */
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
|
|
|
|
while (fgets(line, sizeof(line), fp)) {
|
|
|
|
int len = strlen(line);
|
|
|
|
if (line[len-1] == '\n')
|
2005-12-22 00:48:47 +03:00
|
|
|
line[--len] = 0;
|
|
|
|
|
|
|
|
if (!len)
|
|
|
|
continue;
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
|
|
|
|
switch (line[0]) {
|
|
|
|
case 'P': /* P name */
|
|
|
|
if (parse_pack_def(line, old_cnt++))
|
|
|
|
goto out_stale;
|
|
|
|
break;
|
2005-12-05 09:52:19 +03:00
|
|
|
case 'D': /* we used to emit D but that was misguided. */
|
|
|
|
goto out_stale;
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
break;
|
2005-12-05 10:12:36 +03:00
|
|
|
case 'T': /* we used to emit T but nobody uses it. */
|
|
|
|
goto out_stale;
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
error("unrecognized: %s", line);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
return 0;
|
|
|
|
out_stale:
|
|
|
|
fclose(fp);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int compare_info(const void *a_, const void *b_)
|
|
|
|
{
|
|
|
|
struct pack_info * const* a = a_;
|
|
|
|
struct pack_info * const* b = b_;
|
|
|
|
|
|
|
|
if (0 <= (*a)->old_num && 0 <= (*b)->old_num)
|
|
|
|
/* Keep the order in the original */
|
|
|
|
return (*a)->old_num - (*b)->old_num;
|
|
|
|
else if (0 <= (*a)->old_num)
|
|
|
|
/* Only A existed in the original so B is obviously newer */
|
|
|
|
return -1;
|
|
|
|
else if (0 <= (*b)->old_num)
|
|
|
|
/* The other way around. */
|
|
|
|
return 1;
|
|
|
|
|
2005-12-05 10:02:54 +03:00
|
|
|
/* then it does not matter but at least keep the comparison stable */
|
2005-12-09 04:29:11 +03:00
|
|
|
if ((*a)->p == (*b)->p)
|
|
|
|
return 0;
|
|
|
|
else if ((*a)->p < (*b)->p)
|
|
|
|
return -1;
|
|
|
|
else
|
|
|
|
return 1;
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void init_pack_info(const char *infofile, int force)
|
|
|
|
{
|
|
|
|
struct packed_git *p;
|
|
|
|
int stale;
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
objdir = get_object_directory();
|
|
|
|
objdirlen = strlen(objdir);
|
|
|
|
|
|
|
|
prepare_packed_git();
|
|
|
|
for (p = packed_git; p; p = p->next) {
|
|
|
|
/* we ignore things on alternate path since they are
|
|
|
|
* not available to the pullers in general.
|
|
|
|
*/
|
2005-12-05 21:39:17 +03:00
|
|
|
if (!p->pack_local)
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
continue;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
num_pack = i;
|
|
|
|
info = xcalloc(num_pack, sizeof(struct pack_info *));
|
|
|
|
for (i = 0, p = packed_git; p; p = p->next) {
|
2005-12-05 21:39:17 +03:00
|
|
|
if (!p->pack_local)
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
continue;
|
2005-12-05 09:52:19 +03:00
|
|
|
info[i] = xcalloc(1, sizeof(struct pack_info));
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
info[i]->p = p;
|
|
|
|
info[i]->old_num = -1;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (infofile && !force)
|
|
|
|
stale = read_pack_info_file(infofile);
|
|
|
|
else
|
|
|
|
stale = 1;
|
|
|
|
|
|
|
|
for (i = 0; i < num_pack; i++) {
|
|
|
|
if (stale) {
|
|
|
|
info[i]->old_num = -1;
|
|
|
|
info[i]->nr_heads = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-12-05 09:52:19 +03:00
|
|
|
/* renumber them */
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
qsort(info, num_pack, sizeof(info[0]), compare_info);
|
|
|
|
for (i = 0; i < num_pack; i++)
|
|
|
|
info[i]->new_num = i;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void write_pack_info_file(FILE *fp)
|
|
|
|
{
|
2005-12-05 10:12:36 +03:00
|
|
|
int i;
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
for (i = 0; i < num_pack; i++)
|
|
|
|
fprintf(fp, "P %s\n", info[i]->p->pack_name + objdirlen + 6);
|
2005-12-21 23:09:17 +03:00
|
|
|
fputc('\n', fp);
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int update_info_packs(int force)
|
|
|
|
{
|
|
|
|
char infofile[PATH_MAX];
|
|
|
|
char name[PATH_MAX];
|
|
|
|
int namelen;
|
|
|
|
FILE *fp;
|
|
|
|
|
|
|
|
namelen = sprintf(infofile, "%s/info/packs", get_object_directory());
|
|
|
|
strcpy(name, infofile);
|
|
|
|
strcpy(name + namelen, "+");
|
|
|
|
|
|
|
|
init_pack_info(infofile, force);
|
|
|
|
|
|
|
|
safe_create_leading_directories(name);
|
|
|
|
fp = fopen(name, "w");
|
|
|
|
if (!fp)
|
|
|
|
return error("cannot open %s", name);
|
|
|
|
write_pack_info_file(fp);
|
|
|
|
fclose(fp);
|
|
|
|
rename(name, infofile);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* public */
|
|
|
|
int update_server_info(int force)
|
|
|
|
{
|
|
|
|
/* We would add more dumb-server support files later,
|
|
|
|
* including index of available pack files and their
|
|
|
|
* intended audiences.
|
|
|
|
*/
|
|
|
|
int errs = 0;
|
|
|
|
|
|
|
|
errs = errs | update_info_refs(force);
|
|
|
|
errs = errs | update_info_packs(force);
|
|
|
|
|
2005-12-05 09:52:19 +03:00
|
|
|
/* remove leftover rev-cache file if there is any */
|
|
|
|
unlink(git_path("info/rev-cache"));
|
|
|
|
|
[PATCH] Add update-server-info.
The git-update-server-info command prepares informational files
to help clients discover the contents of a repository, and pull
from it via a dumb transport protocols. Currently, the
following files are produced.
- The $repo/info/refs file lists the name of heads and tags
available in the $repo/refs/ directory, along with their
SHA1. This can be used by git-ls-remote command running on
the client side.
- The $repo/info/rev-cache file describes the commit ancestry
reachable from references in the $repo/refs/ directory. This
file is in an append-only binary format to make the server
side friendly to rsync mirroring scheme, and can be read by
git-show-rev-cache command.
- The $repo/objects/info/pack file lists the name of the packs
available, the interdependencies among them, and the head
commits and tags contained in them. Along with the other two
files, this is designed to help clients to make smart pull
decisions.
The git-receive-pack command is changed to invoke it at the end,
so just after a push to a public repository finishes via "git
push", the server info is automatically updated.
In addition, building of the rev-cache file can be done by a
standalone git-build-rev-cache command separately.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-07-24 04:54:41 +04:00
|
|
|
return errs;
|
|
|
|
}
|