implement Gitindex;
include "sys.m";
sys : Sys;
include "tables.m";
tables: Tables;
Strhash : import tables;
include "bufio.m";
bufio: Bufio;
Iobuf: import bufio;
include "gitindex.m";
gitindex : Gitindex;
include "utils.m";
utils: Utils;
QIDSZ, BIGSZ, INTSZ, SHALEN: import utils;
bytes2int, bytes2big, big2bytes, int2bytes, filesha1, allocnr,sha2string, copyarray, equalshas: import utils;
include "exclude.m";
exclude: Exclude;
include "keyring.m";
keyring: Keyring;
stderr : ref Sys->FD;
filebuf: array of byte;
REPOPATH: string;
Index.new(repopath: string): ref Index
{
sys = load Sys Sys->PATH;
tables = load Tables Tables->PATH;
if(tables == nil){
sys->print("tables is nil: %r\n");
}
utils = load Utils Utils->PATH;
keyring = load Keyring Keyring->PATH;
exclude = load Exclude Exclude->PATH;
REPOPATH = repopath;
utils->init(REPOPATH);
exclude->init(REPOPATH :: nil);
stderr = sys->fildes(2);
index: Index;
index.header = Header.new();
index.hashcap = 37;
index.entries = Strhash[ref Entry].new(index.hashcap, nil);
return ref index;
}
#FIXME: Use addentry
Index.addfile(index: self ref Index, path : string) : int
{
if(!verifypath(REPOPATH + path)){
sys->fprint(stderr, "wrong path: %r\n");
return -1;
}
if(exclude->excluded(path)) return -1;
index.header.entriescnt++;
if(index.header.entriescnt * CLSBND >= index.hashcap){
oldentries := index.entries.all();
index.hashcap = allocnr(index.hashcap);
index.entries = Strhash[ref Entry].new(index.hashcap, nil);
while(oldentries != nil){
entry := hd oldentries;
index.entries.add(entry.name, entry);
oldentries = tl oldentries;
}
}
sha1 := writeblobfile(REPOPATH + path);
entry := initentry(path);
entry.sha1 = sha1;
if((elem := index.entries.find(entry.name)) != nil){
copyentry(elem, entry);
index.header.entriescnt--;
}
else
index.entries.add(entry.name, entry);
sys->print("File added: %s\n", sha2string(entry.sha1));
return 0;
}
Index.addentry(index: self ref Index, entry: ref Entry)
{
index.header.entriescnt++;
if(index.header.entriescnt * CLSBND >= index.hashcap){
oldentries := index.entries.all();
index.hashcap = allocnr(index.hashcap);
index.entries = Strhash[ref Entry].new(index.hashcap, nil);
while(oldentries != nil){
entry := hd oldentries;
index.entries.add(entry.name, entry);
oldentries = tl oldentries;
}
}
index.entries.add(entry.name, entry);
}
writeblobfile(path: string): array of byte
{
fd := sys->open(path, Sys->OREAD);
(ret, dirstat) := sys->stat(path);
buf := array[Sys->ATOMICIO] of byte;
ch := chan of (int, array of byte);
sha1: array of byte;
sz: int;
temp := array of byte sys->sprint("blob %bd", dirstat.length);
spawn utils->writesha1file(ch);
buf[:] = temp;
buf[len temp] = byte 0;
cnt := len temp + 1;
while(1){
ch <-= (cnt, buf);
if(cnt == 0){
(sz, sha1) = <-ch;
break;
}
cnt = sys->read(fd, buf, len buf);
}
return sha1;
}
Index.rmfile(index: self ref Index, path : string)
{
if(index.entries.find(path) == nil){
sys->fprint(stderr, "there's no such file(%s) in the index\n", path);
return;
}
index.header.entriescnt--;
index.entries.del(path);
}
Header.new(): ref Header
{
header: Header;
header.signature = CACHESIGNATURE;
header.version = 1;
header.entriescnt = 0;
header.sha1 = array[SHALEN] of byte;
return ref header;
}
#return: number of elements read from index file
Index.readindex(index: self ref Index, path : string) : int
{
indexfd := sys->open(REPOPATH + path, Sys->OREAD);
if(indexfd == nil){
sys->fprint(stderr,"file access error: %r\n");
return -1;
}
header := array[HEADERSZ] of byte;
if((ret := sys->read(indexfd, header, HEADERSZ)) != HEADERSZ){
sys->fprint(stderr, "Index format error: %r\n");
return -1;
}
index.header = Header.pack(header);
state: ref Keyring->DigestState = nil;
temp := int2bytes(index.header.signature);
state = keyring->sha1(temp, len temp, nil, state);
temp = int2bytes(index.header.version);
state = keyring->sha1(temp, len temp, nil, state);
temp = int2bytes(index.header.entriescnt);
state = keyring->sha1(temp, len temp, nil, state);
index.hashcap = index.header.entriescnt * CLSBND * 2;
index.entries = Strhash[ref Entry].new(index.hashcap, nil);
for(i := 0; i < index.header.entriescnt; i++){
entrybuf := array[ENTRYSZ] of byte;
ret := sys->read(indexfd, entrybuf, ENTRYSZ);
if(ret != ENTRYSZ){
sys->fprint(stderr,"index file error: %r\n");
return 0;
}
state = keyring->sha1(entrybuf, len entrybuf, nil, state);
entry := Entry.pack(entrybuf);
namebuf := array[entry.namelen] of byte;
sys->read(indexfd, namebuf, entry.namelen);
entry.name = string namebuf;
index.entries.add(entry.name, entry);
state = keyring->sha1(namebuf, len namebuf, nil, state);
#each entry is aligned by 8
remainder : int;
remainder = (ENTRYSZ + entry.namelen + 8) & ~7;
remainder -= ENTRYSZ + entry.namelen;
sys->read(indexfd, entrybuf, remainder);
}
sha1 := array[SHALEN] of byte;
keyring->sha1(temp, 0, sha1, state);
if(!verifyheader(index.header, sha1)){
sys->fprint(stderr, "header is not correct\n");
return -1;
}
return index.header.entriescnt;
}
#return: number of elements written to the index file
Index.writeindex(index: self ref Index, path : string) : int
{
fd := sys->create(REPOPATH + path, Sys->OWRITE, 8r644);
if(fd == nil){
sys->fprint(stderr, "write index error: %r\n");
return 0;
}
state: ref Keyring->DigestState = nil;
temp := int2bytes(index.header.signature);
state = keyring->sha1(temp, len temp, nil, state);
temp = int2bytes(index.header.version);
state = keyring->sha1(temp, len temp, nil, state);
temp = int2bytes(index.header.entriescnt);
state = keyring->sha1(temp, len temp, nil, state);
for(l := index.entries.all(); l != nil; l = tl l){
temp = (hd l).unpack();
state = keyring->sha1(temp, len temp, nil, state);
}
keyring->sha1(temp, 0, index.header.sha1, state);
header := index.header.unpack();
sys->write(fd, header, len header);
entrybuf: array of byte;
cnt := 0;
for(l = index.entries.all(); l != nil; l = tl l)
{
entrybuf = (hd l).unpack();
cnt := sys->write(fd, entrybuf, len entrybuf);
if(cnt != len entrybuf){
sys->print("couldn't write entry to the file: %r\n");
return cnt;
}
#each entry is aligned by 8
remainder : int;
remainder = (ENTRYSZ + (hd l).namelen + 8) & ~7;
remainder -= ENTRYSZ + (hd l).namelen;
sys->write(fd, array[remainder] of byte, remainder);
}
return index.header.entriescnt;
}
Header.pack(buf : array of byte) : ref Header
{
ret : Header;
offset := 0;
ret.signature = bytes2int(buf,offset);
offset += INTSZ;
ret.version = bytes2int(buf,offset);
offset += INTSZ;
ret.entriescnt = bytes2int(buf,offset);
offset += INTSZ;
ret.sha1 = buf[offset: offset + SHALEN];
return ref ret;
}
Header.unpack(header : self ref Header) : array of byte
{
ret := array[HEADERSZ] of byte;
offset := 0;
temp := int2bytes(header.signature);
copyarray(ret, offset, temp, 0, len temp);
offset += len temp;
temp = int2bytes(header.version);
copyarray(ret, offset, temp, 0, len temp);
offset += len temp;
temp = int2bytes(header.entriescnt);
copyarray(ret, offset, temp, 0, len temp);
offset += len temp;
copyarray(ret, offset, header.sha1, 0, SHALEN);
return ret;
}
Entry.unpack(entry : self ref Entry) : array of byte
{
ret := array[ENTRYSZ + entry.namelen] of byte;
offset := 0;
temp := unpackqid(entry.qid);
copyarray(ret, offset, temp, 0, len temp);
offset += QIDSZ;
temp = int2bytes(entry.dtype);
copyarray(ret, offset, temp, 0, len temp);
offset += len temp;
temp = int2bytes(entry.dev);
copyarray(ret, offset, temp, 0, len temp);
offset += len temp;
temp = int2bytes(entry.mtime);
copyarray(ret, offset, temp, 0, len temp);
offset += len temp;
temp = int2bytes(entry.mode);
copyarray(ret, offset, temp, 0, len temp);
offset += len temp;
temp = big2bytes(entry.length);
copyarray(ret, offset, temp, 0, len temp);
offset += len temp;
copyarray(ret, offset, entry.sha1, 0, SHALEN);
offset += SHALEN;
temp = int2bytes(entry.namelen);
copyarray(ret, offset, temp, 0, len temp);
offset += len temp;
temp = array of byte entry.name;
copyarray(ret, offset, temp, 0, len temp);
return ret;
}
Entry.pack(buf : array of byte) : ref Entry
{
entry: Entry;
offset := 0;
entry.qid = packqid(buf, offset);
offset += QIDSZ;
entry.dtype = bytes2int(buf, offset);
offset += INTSZ;
entry.dev = bytes2int(buf, offset);
offset += INTSZ;
entry.mtime = bytes2int(buf, offset);
offset += INTSZ;
entry.mode = bytes2int(buf, offset);
offset += INTSZ;
entry.length = bytes2big(buf, offset);
offset += BIGSZ;
entry.sha1 = buf[offset : offset + SHALEN];
offset += SHALEN;
entry.namelen = bytes2int(buf, offset);
offset += INTSZ;
return ref entry;
}
packqid(buf: array of byte, offset: int): Sys->Qid
{
qid: Sys->Qid;
qid.path = bytes2big(buf, offset);
offset += BIGSZ;
qid.vers = bytes2int(buf, offset);
offset += INTSZ;
qid.qtype = bytes2int(buf, offset);
return qid;
}
initentry(filename: string): ref Entry
{
entry: Entry;
(retval, dirstat) := sys->stat(REPOPATH + filename);
if(retval != 0)
{
sys->fprint(stderr,"stat error: %r\n");
return nil;
}
entry.qid = dirstat.qid;
entry.dtype = dirstat.dtype;
entry.dev = dirstat.dev;
entry.mtime = dirstat.mtime;
entry.mode = dirstat.mode;
entry.length = dirstat.length;
entry.sha1 = filesha1(filename);
entry.namelen = len filename;
entry.name = filename;
return ref entry;
}
verifypath(path : string) : int
{
return sys->open(path, Sys->OREAD) != nil;
}
verifyheader(header: ref Header, sha1: array of byte): int
{
return equalshas(header.sha1, sha1) &&
header.signature == CACHESIGNATURE &&
header.version == 1 &&
header.entriescnt >= 0;
}
unpackqid(qid : Sys->Qid) : array of byte
{
ret := array[QIDSZ] of byte;
offset := 0;
temp := big2bytes(qid.path);
copyarray(ret, 0, temp, 0, len temp);
offset += len temp;
temp = int2bytes(qid.vers);
copyarray(ret, offset, temp, 0, len temp);
offset += len temp;
temp = int2bytes(qid.qtype);
copyarray(ret, offset, temp, 0, len temp);
return ret;
}
copyentry(dst, src: ref Entry)
{
dst.qid = src.qid;
dst.dtype = src.dtype;
dst.dev = src.dev;
dst.mtime = src.mtime;
dst.mode = src.mode;
dst.length = src.length;
dst.sha1 = src.sha1;
dst.namelen = src.namelen;
dst.name = src.name;
}
Entry.compare(e1: self ref Entry, e2: ref Entry): int
{
namelen := e1.namelen;
if(e2.namelen < namelen) namelen = e2.namelen;
for(i := 0; i < namelen; i++)
{
if(e1.name[i] < e2.name[i])
return 1;
else if(e1.name[i] > e2.name[i])
return -1;
}
if(e1.namelen < e2.namelen)
return 1;
else if(e1.namelen > e2.namelen)
return -1;
return 0;
}
Entry.new(): ref Entry
{
entry: Entry;
entry.qid = Sys->Qid(big 0,0,0);
entry.dtype = 0;
entry.dev = 0;
entry.mtime = 0;
entry.mode = 0;
entry.length = big 0;
entry.sha1 = array[SHALEN] of byte;
entry.namelen = 0;
entry.name = "";
return ref entry;
}
