implement Myfs;
include "sys.m";
sys: Sys;
include "draw.m";
include "styx.m";
styx: Styx;
Tmsg, Rmsg: import styx;
include "styxservers.m";
styxservers: Styxservers;
Navop, Navigator, Fid, Styxserver: import styxservers;
include "daytime.m";
daytime: Daytime;
include "string.m";
stringmod: String;
include "log.m";
log: Log;
include "cat-file.m";
catfile: Catfile;
include "readdir.m";
readdir: Readdir;
include "lists.m";
lists: Lists;
include "tables.m";
tables: Tables;
Strhash: import tables;
include "init.m";
initmod: Initgit;
include "update-index.m";
indexmod: Updateindex;
include "write-tree.m";
include "read-tree.m";
include "show-diff.m";
include "diff-tree.m";
include "commit-tree.m";
include "checkrepo.m";
include "checkout-index.m";
include "workdir.m";
repopath: string;
srv: ref Styxserver;
nav: ref Navigator;
QRoot, QRootCtl, QRootData, QRootLog, QRootConfig, QRootExclude, QRootObjects, QRootFiles, QStaticMax: con iota;
INITSIZE: con 17;
QMax := big QStaticMax;
QObjectLBound, QObjectUBound: big;
Item: adt{
parentqid: big;
path: string;
dirstat: ref Sys->Dir;
};
table: ref Strhash[ref Item];
REPOPATH: string;
Myfs: module
{
init: fn(nil: ref Draw->Context, args: list of string);
};
init(nil: ref Draw->Context, args: list of string)
{
sys = load Sys Sys->PATH;
daytime = load Daytime Daytime->PATH;
lists = load Lists Lists->PATH;
tables = load Tables Tables->PATH;
stringmod = load String String->PATH;
log = load Log Log->PATH;
catfile = load Catfile Catfile->PATH;
readdir = load Readdir Readdir->PATH;
initmod = load Initgit Initgit->PATH;
indexmod = load Updateindex Updateindex->PATH;
if(len args != 2)
usage();
REPOPATH = makeabsolute(hd (tl args));
repopath = REPOPATH;
if(REPOPATH[len REPOPATH - 1] != '/'){
REPOPATH += "/";
}
sys->print("repopath: %s\n", REPOPATH);
sys->pctl(Sys->NEWPGRP, nil);
inittable();
styx = load Styx Styx->PATH;
styx->init();
styxservers = load Styxservers Styxservers->PATH;
styxservers->init(styx);
#styxservers->traceset(1);
navch := chan of ref Navop;
nav = Navigator.new(navch);
spawn navigate(navch);
tmsgchan: chan of ref Tmsg;
(tmsgchan, srv) = Styxserver.new(sys->fildes(0), nav, big QRoot);
spawn process(srv, tmsgchan);
}
inittable()
{
table = Strhash[ref Item].new(INITSIZE, nil);
dirstat: Sys->Dir;
ret: int;
dirstat = sys->stat(REPOPATH).t1;
uid := dirstat.uid;
gid := dirstat.gid;
atime := dirstat.atime;
mtime := dirstat.mtime;
time := daytime->now();
qid := Sys->Qid(big QRoot, 0, Sys->QTDIR);
d := ref Sys->Dir(".", uid, gid, "", qid, 8r755|Sys->DMDIR, atime, mtime, big 0, 0, 0);
droot := ref Item(big QRoot, nil, d);
table.add(string QRoot, droot);
qid = Sys->Qid(big QRootCtl,0,0);
d = ref Sys->Dir("ctl", uid, gid, "", qid, 8r222, time, time, big 0, 0, 0);
ditem := ref Item(big QRoot, nil, d);
table.add(string QRootCtl, ditem);
qid = Sys->Qid(big QRootData,0,0);
d = ref Sys->Dir("data", uid, gid, "", qid, 8r644, time, time, big 0, 0, 0);
ditem = ref Item(big QRoot, nil, d);
table.add(string QRootData, ditem);
qid = Sys->Qid(big QRootLog,0,0);
d = ref Sys->Dir("log", uid, gid, "", qid, 8r644, time, time, big 0, 0, 0);
ditem = ref Item(big QRoot, nil, d);
table.add(string QRootLog, ditem);
(ret, dirstat) = sys->stat(repopath + "/config");
qid = Sys->Qid(big QRootConfig,0,0);
d = ref Sys->Dir("config", uid, gid, "", qid, 8r644, dirstat.atime, dirstat.mtime, dirstat.length, 0, 0);
ditem = ref Item(big QRoot, nil, d);
table.add(string QRootConfig, ditem);
(ret, dirstat) = sys->stat(repopath + "/exclude");
qid = Sys->Qid(big QRootExclude,0,0);
d = ref Sys->Dir("exclude", uid, gid, "", qid, 8r644, dirstat.atime, dirstat.mtime, dirstat.length, 0, 0);
ditem = ref Item(big QRoot, nil, d);
table.add(string QRootExclude, ditem);
(ret, dirstat) = sys->stat(repopath + "/objects");
qid = Sys->Qid(big QRootObjects,0,Sys->QTDIR);
d = ref Sys->Dir("objects", uid, gid, "", qid, 8r755|Sys->DMDIR, dirstat.atime, dirstat.mtime, dirstat.length, 0, 0);
ditem = ref Item(big QRoot, REPOPATH + "objects", d);
table.add(string QRootObjects, ditem);
QObjectLBound = QMax;
readdirectory(REPOPATH + "objects", big QRootObjects, ditem);
QObjectUBound = QMax;
(ret, dirstat) = sys->stat(repopath);
qid = Sys->Qid(big QRootFiles,0,Sys->QTDIR);
d = ref Sys->Dir("files", uid, gid, "", qid, 8r755|Sys->DMDIR, dirstat.atime, dirstat.mtime, dirstat.length, 0, 0);
ditem = ref Item(big QRoot, REPOPATH, d);
table.add(string QRootFiles, ditem);
readdirectory(REPOPATH + "files", big QRootFiles, ditem);
# qid = Sys->Qid(big QRoot,0,Sys->QTDIR);
# d = ref Sys->Dir("..", uid, gid, "", qid, 8r755|Sys->DMDIR, dirstat.atime, dirstat.mtime, dirstat.length, 0, 0);
# ditem = ref Item(big QRootObjects, REPOPATH, d);
# table.add(string QRoot, ditem);
}
process(srv: ref Styxserver, tmsgchan: chan of ref Tmsg)
{
mainloop:
while((gm := <-tmsgchan) != nil){
pick m := gm{
Read =>
fid := srv.getfid(m.fid);
buf := array[m.count] of byte;
if(fid.path == big QRootConfig || fid.path == big QRootExclude){
fd := sys->open(repopath + table.find(string fid.path).dirstat.name, Sys->OREAD);
sys->seek(fd, m.offset, Sys->SEEKSTART);
cnt := sys->read(fd, buf, len buf);
buf = buf[:cnt];
srv.reply(ref Rmsg.Read(m.tag, buf));
}
else if(fid.path == big QRootLog){
logch := chan of array of byte;
fd := sys->open(REPOPATH + "head", Sys->OREAD);
if(fd == nil){
sys->print("head is not found\n");
srv.reply(ref Rmsg.Read(m.tag, nil));
continue mainloop;
}
headbuf := array[40] of byte;
sys->read(fd, headbuf, len headbuf);
head := string headbuf;
sys->print("REPOPATH = %s; head is %s\n", REPOPATH, head);
spawn log->init(logch, REPOPATH :: head :: nil);
offset := m.offset;
temp: array of byte;
while(offset > big 0){
temp = <-logch;
offset -= big len temp;
}
if(m.offset != big 0 && temp == nil){
srv.reply(ref Rmsg.Read(m.tag, nil));
continue mainloop;
}
buf = array[0] of byte;
if(offset < big 0){
buf = array[int -offset] of byte;
buf[:] = temp[len temp + int offset:];
}
while(m.count > 0){
temp = <-logch;
if(temp == nil){
break;
}
oldbuf := buf[:];
buf = array[len oldbuf + len temp] of byte;
buf[:] = oldbuf;
buf[len oldbuf:] = temp;
m.count -= len temp;
}
srv.reply(ref Rmsg.Read(m.tag, buf));
}
else{
item1 := table.find(string fid.path);
item2 := table.find(string item1.parentqid);
sys->print("myfs: reading file under objects\n");
#if objects is git object;FIXME: should be added code for checking zlib header
if(item2 != nil && item2.parentqid == big QRootObjects){
path := item2.dirstat.name + item1.dirstat.name;
catch := chan of array of byte;
spawn catfile->init(REPOPATH, 0, path, catch);
filetype := <-catch;
msg := <-catch;
buf = array[len filetype + len msg] of byte;
buf[:] = filetype;
buf[len filetype:] = msg;
srv.reply(styxservers->readbytes(m, buf));
}
else{
srv.read(m);
}
}
Write =>
fid := srv.getfid(m.fid);
cnt := len m.data;
if(fid.path == big QRootCtl){
ctl(m);
}
else if(fid.path == big QRootConfig || fid.path == big QRootExclude){
fd := sys->open(REPOPATH + table.find(string fid.path).dirstat.name, Sys->OWRITE);
sys->seek(fd, m.offset, Sys->SEEKSTART);
cnt = sys->write(fd, m.data, len m.data);
}
srv.reply(ref Rmsg.Write(m.tag, cnt));
* => srv.default(gm);
}
}
}
ctl(m: ref Tmsg.Write)
{
s := string m.data;
if(s != nil && s[len s - 1] == '\n')
s = s[:len s - 1];
command: string;
(command, s) = stringmod->splitl(s, " ");
if(s != nil)
s = s[1:];
args: list of string = nil;
elem: string;
while(s != ""){
(elem, s) = stringmod->splitl(s, " ");
sys->print("==>%s\n", elem);
args = elem :: args;
if(s != nil)
s = s[1:];
}
args = lists->reverse(args);
case command{
"init" => sys->print("init\n");
spawn initmod->init(REPOPATH :: nil);
"add" => sys->print("add\n");
spawn indexmod->init(REPOPATH :: "-a" ::args);
"print" => sys->print("print\n");
spawn indexmod->init(REPOPATH :: nil);
"remove" => sys->print("remove\n");
spawn indexmod->init(REPOPATH :: "-r" :: args);
"show-diff" => sys->print("show-diff\n");
showdiff := load Showdiff Showdiff->PATH;
spawn showdiff->init(REPOPATH :: nil);
"write-tree" => sys->print("write-tree\n");
writetree := load Writetree Writetree->PATH;
spawn writetree->init(REPOPATH :: nil);
"read-tree" => sys->print("read-tree\n");
readtree := load Readtree Readtree->PATH;
readtree->init(REPOPATH :: args);
"checkrepo" => sys->print("checkrepo\n");
checkrepo := load Checkrepo Checkrepo->PATH;
checkrepo->init(REPOPATH :: args);
"checkoutindex" => sys->print("checkoutindex\n");
checkoutindex := load Checkoutindex Checkoutindex->PATH;
checkoutindex->init(REPOPATH :: args);
"diff-tree" => sys->print("diff-tree\n");
difftree := load Difftree Difftree->PATH;
difftree->init(REPOPATH :: args);
"commit" => sys->print("commit\n");
committree := load Committree Committree->PATH;
committree->init(REPOPATH :: args);
* => sys->print("default\n");
}
}
navigate(navch: chan of ref Navop)
{
mainloop:
while(1){
pick navop := <-navch
{
Stat =>
sys->print("in stat:\n");
item := table.find(string navop.path);
if(item.dirstat == nil)
item.dirstat = ref sys->stat(item.path).t1;
navop.reply <-= (item.dirstat, "");
Walk =>
sys->print("in walk\n");
for(l := table.all(); l != nil; l = tl l){
dirstat := (hd l).dirstat;
if(dirstat == nil)
dirstat = ref sys->stat((hd l).path).t1;
if(dirstat.name == navop.name ){
navop.reply <-= (dirstat, nil);
continue mainloop;
}
}
navop.reply <-= (nil, "not found");
Readdir =>
sys->print("in readdir\n");
if(navop.path == big QRoot){
l1 := table.all();
l: list of ref Item = nil;
while(l1 != nil){
if((hd l1).dirstat != nil)
l = hd l1 :: l;
l1 = tl l1;
}
offset := navop.offset;
while(l != nil && offset > 0){
if((hd l).parentqid == big QRoot)
offset--;
l = tl l;
}
count := navop.count;
while(l != nil && count-- > 0){
#if(table[i + navop.offset].t0 != navop.path || i == QRoot) continue;
navop.reply <-= ((hd l).dirstat, nil);
l = tl l;
}
navop.reply <-= (nil, nil);
}
# else if (navop.path == big QRootObjects){
# (dirs, ret) := readdir->init(REPOPATH + "objects", readdir->NAME);
# sys->print("cnt is: %d; %d\n", len dirs, navop.count);
# for(i := 0; i + navop.offset < len dirs && i < navop.count; i++){
# navop.reply <-= (dirs[i], nil);
# }
#
# navop.reply <-= (nil, nil);
# }
else{
item := table.find(string navop.path);
if(item != nil){
(dirs, ret) := readdir->init(item.path, Readdir->NAME);
for(i := navop.offset; i < len dirs && i < navop.count + navop.offset; i++){
navop.reply <-= (dirs[i], nil);
}
}
navop.reply <-= (nil, nil);
}
}
}
}
readdirectory(path: string, parentqid: big, parent: ref Item)
{
(dirs, ret) := readdir->init(path, Readdir->NAME);
for(i := 0; i < len dirs; i++){
item := ref Item(parentqid, path + "/" + dirs[i].name, nil);
table.add(string dirs[i].qid.path, item);
readdirectory(path + "/" + dirs[i].name, dirs[i].qid.path, item);
}
}
min(a, b: int): int
{
if(a < b) return a;
return b;
}
usage()
{
sys->fprint(sys->fildes(2), "mount {myfs dir} mntpt");
exit;
}
makeabsolute(path: string): string
{
if(path == "" || path[0] == '/') return path;
gwd := load Workdir Workdir->PATH;
pwd := gwd->init();
if(path[0] == '.'){
if(len path <= 2)
return pwd;
return pwd + path[2:];
}
return pwd + "/" + path;
}
