ref: 42dfac6916ebbdac65cbec8b3e1a80c3ee41423c
dir: /appl/spree/spree.b/
implement Spree; include "sys.m"; sys: Sys; include "readdir.m"; readdir: Readdir; include "styx.m"; Rmsg, Tmsg: import Styx; include "styxservers.m"; styxservers: Styxservers; Styxserver, Fid, Eperm, Navigator: import styxservers; nametree: Nametree; include "draw.m"; include "arg.m"; include "sets.m"; sets: Sets; Set, set, A, B, All, None: import sets; include "spree.m"; archives: Archives; Archive: import archives; stderr: ref Sys->FD; myself: Spree; Debug: con 0; Update: adt { pick { Set => o: ref Object; objid: int; # member-specific id attr: ref Attribute; Transfer => srcid: int; # parent object from: Range; # range within src to transfer dstid: int; # destination object index: int; # insertion point Create => objid: int; parentid: int; visibility: Sets->Set; objtype: string; Delete => parentid: int; r: Range; objs: array of int; Setvisibility => objid: int; visibility: Sets->Set; # set of members that can see it Action => s: string; objs: list of int; rest: string; Break => # break in transmission } }; T: type ref Update; Queue: adt { h, t: list of T; put: fn(q: self ref Queue, s: T); get: fn(q: self ref Queue): T; isempty: fn(q: self ref Queue): int; peek: fn(q: self ref Queue): T; }; Openfid: adt { fid: int; uname: string; fileid: int; member: ref Member; # nil for non-clique files. updateq: ref Queue; readreq: ref Tmsg.Read; hungup: int; # alias: string; # could use this to allow a member to play themselves new: fn(fid: ref Fid, file: ref Qfile): ref Openfid; find: fn(fid: int): ref Openfid; close: fn(fid: self ref Openfid); # cmd: fn(fid: self ref Openfid, cmd: string): string; }; Qfile: adt { id: int; # index into files array owner: string; qid: Sys->Qid; ofids: list of ref Openfid; # list of all fids that are holding this open needsupdate: int; # updates have been added since last updateall create: fn(parent: big, d: Sys->Dir): ref Qfile; delete: fn(f: self ref Qfile); }; # which updates do we send even though the clique isn't yet started? alwayssend := array[] of { tagof(Update.Set) => 0, tagof(Update.Transfer) => 0, tagof(Update.Create) => 0, tagof(Update.Delete) => 0, tagof(Update.Setvisibility) => 0, tagof(Update.Action) => 1, tagof(Update.Break) => 1, }; srv: ref Styxserver; tree: ref Nametree->Tree; cliques: array of ref Clique; qfiles: array of ref Qfile; fids := array[47] of list of ref Openfid; # hash table lobby: ref Clique; Qroot: big; sequence := 0; fROOT, fGAME, fNAME, fGAMEDIR, fGAMEDATA: con iota; GAMEDIR: con "/n/remote"; ENGINES: con "/dis/spree/engines"; ARCHIVEDIR: con "/lib/spreearchive"; badmod(p: string) { sys->fprint(stderr, "spree: cannot load %s: %r\n", p); raise "fail:bad module"; } init(nil: ref Draw->Context, nil: list of string) { sys = load Sys Sys->PATH; stderr = sys->fildes(2); myself = load Spree "$self"; styx := load Styx Styx->PATH; if (styx == nil) badmod(Styx->PATH); styx->init(); styxservers = load Styxservers Styxservers->PATH; if (styxservers == nil) badmod(Styxservers->PATH); styxservers->init(styx); nametree = load Nametree Nametree->PATH; if (nametree == nil) badmod(Nametree->PATH); nametree->init(); sets = load Sets Sets->PATH; if (sets == nil) badmod(Sets->PATH); sets->init(); readdir = load Readdir Readdir->PATH; if (readdir == nil) badmod(Readdir->PATH); archives = load Archives Archives->PATH; if (archives == nil) badmod(Archives->PATH); archives->init(myself); initrand(); navop: chan of ref Styxservers->Navop; (tree, navop) = nametree->start(); tchan: chan of ref Tmsg; Qroot = mkqid(fROOT, 0); (tchan, srv) = Styxserver.new(sys->fildes(0), Navigator.new(navop), Qroot); nametree->tree.create(Qroot, dir(Qroot, ".", 8r555|Sys->DMDIR, "spree")); nametree->tree.create(Qroot, dir(mkqid(fNAME, 0), "name", 8r444, "spree")); (lobbyid, nil, err) := lobby.new(ref Archive("lobby" :: nil, nil, nil, nil), "spree"); if (lobbyid == -1) { sys->fprint(stderr, "spree: couldn't start lobby: %s\n", err); raise "fail:no lobby"; } sys->pctl(Sys->FORKNS, nil); for (;;) { gm := <-tchan; if (gm == nil || tagof(gm) == tagof(Tmsg.Readerror)) { if (gm != nil) { pick m := gm { Readerror => sys->print("spree: read error: %s\n", m.error); } } sys->print("spree: exiting\n"); exit; } else { e := handletmsg(gm); if (e != nil) srv.reply(ref Rmsg.Error(gm.tag, e)); } } } dir(qidpath: big, name: string, perm: int, owner: string): Sys->Dir { DM2QT: con 24; d := Sys->zerodir; d.name = name; d.uid = owner; d.gid = owner; d.qid.path = qidpath; d.qid.qtype = (perm >> DM2QT) & 16rff; d.mode = perm; # d.atime = now; # d.mtime = now; return d; } handletmsg(tmsg: ref Tmsg): string { pick m := tmsg { Open => (fid, omode, d, err) := srv.canopen(m); if (fid == nil) return err; if (d.qid.qtype & Sys->QTDIR) { srv.default(m); return nil; } case qidkind(d.qid.path) { fGAMEDATA => fid.open(m.mode, Sys->Qid(fid.path, fid.qtype, 0)); srv.reply(ref Rmsg.Open(m.tag, Sys->Qid(fid.path, fid.qtype, 0), 0)); fGAME => f := qid2file(d.qid.path); if (f == nil) return "cannot find qid"; ofid := Openfid.new(fid, f); err = openfile(ofid); if (err != nil) { ofid.close(); return err; } fid.open(m.mode, f.qid); srv.reply(ref Rmsg.Open(m.tag, Sys->Qid(fid.path, fid.qtype, 0), 0)); * => srv.default(m); } updateall(); Read => (fid, err) := srv.canread(m); if (fid == nil) return err; if (fid.qtype & Sys->QTDIR) { srv.default(m); return nil; } case qidkind(fid.path) { fGAMEDATA => f := qidindex(fid.path); id := f & 16rffff; f = (f >> 16) & 16rffff; data := cliques[id].mod->readfile(f, m.offset, m.count); srv.reply(ref Rmsg.Read(m.tag, data)); fGAME => ff := Openfid.find(m.fid); if (ff.readreq != nil) return "duplicate read"; ff.readreq = m; sendupdate(ff); fNAME => srv.reply(styxservers->readstr(m, fid.uname)); * => return "darn rats!"; } Write => (fid, err) := srv.canwrite(m); if (fid == nil) return err; ff := Openfid.find(m.fid); err = command(ff, string m.data); if (err != nil) { updateall(); return err; } srv.reply(ref Rmsg.Write(m.tag, len m.data)); updateall(); # XXX might we need to do this on error too? Clunk => fid := srv.clunk(m); if (fid != nil) { clunked(fid); updateall(); } Flush => for (i := 0; i < len qfiles; i++) { if (qfiles[i] == nil) continue; for (ol := qfiles[i].ofids; ol != nil; ol = tl ol) { ofid := hd ol; if (ofid.readreq != nil && ofid.readreq.tag == m.oldtag) ofid.readreq = nil; } } srv.reply(ref Rmsg.Flush(m.tag)); # Removed => clunked too. * => srv.default(tmsg); } return nil; } clunked(fid: ref Fid) { if (!fid.isopen || (fid.qtype & Sys->QTDIR)) return; ofid := Openfid.find(fid.fid); if (ofid == nil) return; if (ofid.member != nil) memberleaves(ofid.member); ofid.close(); f := qfiles[ofid.fileid]; # if it's the last close, and clique is hung up, then remove clique from # directory hierarchy. if (f.ofids == nil && qidkind(f.qid.path) == fGAME) { g := cliques[qidindex(f.qid.path)]; if (g.hungup) { stopclique(g); nametree->tree.remove(mkqid(fGAMEDIR, g.id)); f.delete(); cliques[g.id] = nil; } } } mkqid(kind, i: int): big { return big kind | (big i << 4); } qidkind(qid: big): int { return int (qid & big 16rf); } qidindex(qid: big): int { return int (qid >> 4); } qid2file(qid: big): ref Qfile { for (i := 0; i < len qfiles; i++) { f := qfiles[i]; if (f != nil && f.qid.path == qid) return f; } return nil; } Qfile.create(parent: big, d: Sys->Dir): ref Qfile { nametree->tree.create(parent, d); for (i := 0; i < len qfiles; i++) if (qfiles[i] == nil) break; if (i == len qfiles) qfiles = (array[len qfiles + 1] of ref Qfile)[0:] = qfiles; f := qfiles[i] = ref Qfile(i, d.uid, d.qid, nil, 0); return f; } Qfile.delete(f: self ref Qfile) { nametree->tree.remove(f.qid.path); qfiles[f.id] = nil; } Openfid.new(fid: ref Fid, file: ref Qfile): ref Openfid { i := fid.fid % len fids; ofid := ref Openfid(fid.fid, fid.uname, file.id, nil, ref Queue, nil, 0); fids[i] = ofid :: fids[i]; file.ofids = ofid :: file.ofids; return ofid; } Openfid.find(fid: int): ref Openfid { for (ol := fids[fid % len fids]; ol != nil; ol = tl ol) if ((hd ol).fid == fid) return hd ol; return nil; } Openfid.close(ofid: self ref Openfid) { i := ofid.fid % len fids; newol: list of ref Openfid; for (ol := fids[i]; ol != nil; ol = tl ol) if (hd ol != ofid) newol = hd ol :: newol; fids[i] = newol; newol = nil; for (ol = qfiles[ofid.fileid].ofids; ol != nil; ol = tl ol) if (hd ol != ofid) newol = hd ol :: newol; qfiles[ofid.fileid].ofids = newol; } openfile(ofid: ref Openfid): string { name := ofid.uname; f := qfiles[ofid.fileid]; if (qidkind(f.qid.path) == fGAME) { if (cliques[qidindex(f.qid.path)].hungup) return "hungup"; i := 0; for (o := f.ofids; o != nil; o = tl o) { if ((hd o) != ofid && (hd o).uname == name) return "you cannot join a clique twice"; i++; } if (i > MAXPLAYERS) return "too many members"; } return nil; } # process a client's command; return a non-nil string on error. command(ofid: ref Openfid, cmd: string): string { err: string; f := qfiles[ofid.fileid]; qid := f.qid.path; if (ofid.hungup) return "hung up"; if (cmd == nil) { ofid.hungup = 1; sys->print("hanging up file %s for user %s, fid %d\n", nametree->tree.getpath(f.qid.path), ofid.uname, ofid.fid); return nil; } case qidkind(qid) { fGAME => clique := cliques[qidindex(qid)]; if (ofid.member == nil) err = newmember(clique, ofid, cmd); else err = cliquerequest(clique, ref Rq.Command(ofid.member, cmd)); * => err = "invalid command " + string qid; # XXX dud error message } return err; } Clique.notify(src: self ref Clique, dstid: int, cmd: string) { if (cmd == nil) return; # don't allow faking of clique exit. if (dstid < 0 || dstid >= len cliques) { if (dstid != -1) sys->fprint(stderr, "%d cannot notify invalid %d: '%s'\n", src.id, dstid, cmd); return; } dst := cliques[dstid]; if (dst.parentid != src.id && dstid != src.parentid) { sys->fprint(stderr, "%d cannot notify %d: '%s'\n", src.id, dstid, cmd); return; } src.notes = (src.id, dstid, cmd) :: src.notes; } # add a new member to a clique. # it should already have been checked that the member's name # isn't a duplicate of another in the same clique. newmember(clique: ref Clique, ofid: ref Openfid, cmd: string): string { name := ofid.uname; # check if member was suspended, and give them their old id back # if so, otherwise find first free id. for (s := clique.suspended; s != nil; s = tl s) if ((hd s).name == name) break; id: int; suspended := 0; member: ref Member; if (s != nil) { member = hd s; # remove from suspended list q := tl s; for (t := clique.suspended; t != s; t = tl t) q = hd t :: q; clique.suspended = q; suspended = 1; member.suspended = 0; } else { for (id = 0; clique.memberids.holds(id); id++) ; member = ref Member(id, clique.id, nil, nil, nil, name, 0, 0); clique.memberids = clique.memberids.add(member.id); } q := ofid.updateq; ofid.member = member; started := clique.started; err := cliquerequest(clique, ref Rq.Join(member, cmd, suspended)); if (err != nil) { member.del(0); if (suspended) { member.suspended = 1; clique.suspended = member :: clique.suspended; } return err; } if (started) { qrecreateobject(q, member, clique.objects[0], nil); qfiles[ofid.fileid].needsupdate = 1; } member.updating = 1; return nil; } Clique.start(clique: self ref Clique) { if (clique.started) return; for (ol := qfiles[clique.fileid].ofids; ol != nil; ol = tl ol) if ((hd ol).member != nil) qrecreateobject((hd ol).updateq, (hd ol).member, clique.objects[0], nil); clique.started = 1; } Blankclique: Clique; maxcliqueid := 0; Clique.new(parent: self ref Clique, archive: ref Archive, owner: string): (int, string, string) { for (id := 0; id < len cliques; id++) if (cliques[id] == nil) break; if (id == len cliques) cliques = (array[len cliques + 1] of ref Clique)[0:] = cliques; mod := load Engine ENGINES +"/" + hd archive.argv + ".dis"; if (mod == nil) return (-1, nil, sys->sprint("cannot load engine: %r")); dirq := mkqid(fGAMEDIR, id); fname := string maxcliqueid++; e := nametree->tree.create(Qroot, dir(dirq, fname, 8r555|Sys->DMDIR, owner)); if (e != nil) return (-1, nil, e); f := Qfile.create(dirq, dir(mkqid(fGAME, id), "ctl", 8r666, owner)); objs: array of ref Object; if (archive.objects != nil) { objs = archive.objects; for (i := 0; i < len objs; i++) objs[i].cliqueid = id; } else objs = array[] of {ref Object(0, Attributes.new(), All, -1, nil, id, nil)}; memberids := None; suspended: list of ref Member; for (i := 0; i < len archive.members; i++) { suspended = ref Member(i, id, nil, nil, nil, archive.members[i], 0, 1) :: suspended; memberids = memberids.add(i); } archive = ref *archive; archive.objects = nil; g := cliques[id] = ref Clique( id, # id f.id, # fileid fname, # fname objs, # objects archive, # archive nil, # freelist mod, # mod memberids, # memberids suspended, chan of ref Rq, # request chan of string, # reply 0, # hungup 0, # started -1, # parentid nil # notes ); if (parent != nil) { g.parentid = parent.id; g.notes = parent.notes; } spawn cliqueproc(g); e = cliquerequest1(g, ref Rq.Init); if (e != nil) { stopclique(g); nametree->tree.remove(dirq); f.delete(); cliques[id] = nil; return (-1, nil, e); } # only send notifications if the clique was successfully created, otherwise # pretend it never existed. if (parent != nil) { parent.notes = g.notes; g.notes = nil; } return (g.id, fname, nil); } # as a special case, if parent is nil, we use the root object. Clique.newobject(clique: self ref Clique, parent: ref Object, visibility: Set, objtype: string): ref Object { if (clique.freelist == nil) (clique.objects, clique.freelist) = makespace(clique.objects, clique.freelist); id := hd clique.freelist; clique.freelist = tl clique.freelist; if (parent == nil) parent = clique.objects[0]; obj := ref Object(id, Attributes.new(), visibility, parent.id, nil, clique.id, objtype); n := len parent.children; newchildren := array[n + 1] of ref Object; newchildren[0:] = parent.children; newchildren[n] = obj; parent.children = newchildren; clique.objects[id] = obj; applycliqueupdate(clique, ref Update.Create(id, parent.id, visibility, objtype), All); if (Debug) sys->print("new %d, parent %d, visibility %s\n", obj.id, parent.id, visibility.str()); return obj; } Clique.hangup(clique: self ref Clique) { if (clique.hungup) return; sys->print("clique.hangup(%s)\n", clique.fname); f := qfiles[clique.fileid]; for (ofids := f.ofids; ofids != nil; ofids = tl ofids) (hd ofids).hungup = 1; f.needsupdate = 1; clique.hungup = 1; if (clique.parentid != -1) { clique.notes = (clique.id, clique.parentid, nil) :: clique.notes; clique.parentid = -1; } # orphan children # XXX could be more efficient for childless cliques by keeping child count for(i := 0; i < len cliques; i++) if (cliques[i] != nil && cliques[i].parentid == clique.id) cliques[i].parentid = -1; } stopclique(clique: ref Clique) { clique.hangup(); if (clique.request != nil) clique.request <-= nil; } Clique.breakmsg(clique: self ref Clique, whoto: Set) { applycliqueupdate(clique, ref Update.Break, whoto); } Clique.action(clique: self ref Clique, cmd: string, objs: list of int, rest: string, whoto: Set) { applycliqueupdate(clique, ref Update.Action(cmd, objs, rest), whoto); } Clique.member(clique: self ref Clique, id: int): ref Member { for (ol := qfiles[clique.fileid].ofids; ol != nil; ol = tl ol) if ((hd ol).member != nil && (hd ol).member.id == id) return (hd ol).member; for (s := clique.suspended; s != nil; s = tl s) if ((hd s).id == id) return hd s; return nil; } Clique.membernamed(clique: self ref Clique, name: string): ref Member { for (ol := qfiles[clique.fileid].ofids; ol != nil; ol = tl ol) if ((hd ol).uname == name) return (hd ol).member; for (s := clique.suspended; s != nil; s = tl s) if ((hd s).name == name) return hd s; return nil; } Clique.owner(clique: self ref Clique): string { return qfiles[clique.fileid].owner; } Clique.fcreate(clique: self ref Clique, f: int, parent: int, d: Sys->Dir): string { pq: big; if (parent == -1) pq = mkqid(fGAMEDIR, clique.id); else pq = mkqid(fGAMEDATA, clique.id | (parent<<16)); d.qid.path = mkqid(fGAMEDATA, clique.id | (f<<16)); d.mode &= ~8r222; return nametree->tree.create(pq, d); } Clique.fremove(clique: self ref Clique, f: int): string { return nametree->tree.remove(mkqid(fGAMEDATA, clique.id | (f<<16))); } # debugging... Clique.show(nil: self ref Clique, nil: ref Member) { # sys->print("**************** all objects:\n"); # showobject(clique, clique.objects[0], p, 0, ~0); # if (p == nil) { # f := qfiles[clique.fileid]; # for (ol := f.ofids; ol != nil; ol = tl ol) { # p = (hd ol).member; # if (p == nil) { # sys->print("lurker (name '%s')\n", # (hd ol).uname); # continue; # } # sys->print("member %d, '%s': ext->obj ", p.id, p.name); # for (j := 0; j < len p.ext2obj; j++) # if (p.ext2obj[j] != nil) # sys->print("%d->%d[%d] ", j, p.ext2obj[j].id, p.ext(p.ext2obj[j].id)); # sys->print("\n"); # } # } } cliquerequest(clique: ref Clique, rq: ref Rq): string { e := cliquerequest1(clique, rq); sendnotifications(clique); return e; } cliquerequest1(clique: ref Clique, rq: ref Rq): string { if (clique.request == nil) return "clique has exited"; clique.request <-= rq; err := <-clique.reply; if (clique.hungup && clique.request != nil) { clique.request <-= nil; clique.request = nil; } return err; } sendnotifications(clique: ref Clique) { notes, pending: list of (int, int, string); (pending, clique.notes) = (clique.notes, nil); n := 0; while (pending != nil) { for (notes = nil; pending != nil; pending = tl pending) notes = hd pending :: notes; for (; notes != nil; notes = tl notes) { (srcid, dstid, cmd) := hd notes; dst := cliques[dstid]; if (!dst.hungup) { dst.notes = pending; cliquerequest1(dst, ref Rq.Notify(srcid, cmd)); (pending, dst.notes) = (dst.notes, nil); } } if (n++ > 50) panic("probable loop in clique notification"); # XXX probably shouldn't panic, but useful for debugging } } cliqueproc(clique: ref Clique) { wfd := sys->open("/prog/" + string sys->pctl(0, nil) + "/wait", Sys->OREAD); spawn cliqueproc1(clique); buf := array[Sys->ATOMICIO] of byte; n := sys->read(wfd, buf, len buf); sys->print("spree: clique '%s' exited: %s\n", clique.fname, string buf[0:n]); clique.hangup(); clique.request = nil; clique.reply <-= "clique exited"; } cliqueproc1(clique: ref Clique) { for (;;) { rq := <-clique.request; if (rq == nil) break; reply := ""; pick r := rq { Init => reply = clique.mod->init(myself, clique, clique.archive.argv); Join => reply = clique.mod->join(r.member, r.cmd, r.suspended); Command => reply = clique.mod->command(r.member, r.cmd); Leave => if (clique.mod->leave(r.member) == 0) reply = "suspended"; Notify => clique.mod->notify(r.srcid, r.cmd); * => panic("unknown engine request, tag " + string tagof(rq)); } clique.reply <-= reply; } sys->print("spree: clique '%s' exiting\n", clique.fname); } Member.ext(member: self ref Member, id: int): int { obj2ext := member.obj2ext; if (id >= len obj2ext || id < 0) return -1; return obj2ext[id]; } Member.obj(member: self ref Member, ext: int): ref Object { if (ext < 0 || ext >= len member.ext2obj) return nil; return member.ext2obj[ext]; } # allocate an object in a member's map. memberaddobject(p: ref Member, o: ref Object) { if (p.freelist == nil) (p.ext2obj, p.freelist) = makespace(p.ext2obj, p.freelist); ext := hd p.freelist; p.freelist = tl p.freelist; if (o.id >= len p.obj2ext) { oldmap := p.obj2ext; newmap := array[o.id + 10] of int; newmap[0:] = oldmap; for (i := len oldmap; i < len newmap; i++) newmap[i] = -1; p.obj2ext = newmap; } p.obj2ext[o.id] = ext; p.ext2obj[ext] = o; if (Debug) sys->print("addobject member %d, internal %d, external %d\n", p.id, o.id, ext); } # delete an object from a member's map. memberdelobject(member: ref Member, id: int) { if (id >= len member.obj2ext) { sys->fprint(stderr, "spree: bad delobject (member %d, id %d, len obj2ext %d)\n", member.id, id, len member.obj2ext); return; } ext := member.obj2ext[id]; member.ext2obj[ext] = nil; member.obj2ext[id] = -1; member.freelist = ext :: member.freelist; if (Debug) sys->print("delobject member %d, internal %d, external %d\n", member.id, id, ext); } memberleaves(member: ref Member) { clique := cliques[member.cliqueid]; sys->print("member %d leaving clique %d\n", member.id, member.cliqueid); suspend := 0; if (!clique.hungup) suspend = cliquerequest(clique, ref Rq.Leave(member)) != nil; member.del(suspend); } resetvisibilities(o: ref Object, id: int) { o.visibility = setreset(o.visibility, id); a := o.attrs.a; for (i := 0; i < len a; i++) { for (al := a[i]; al != nil; al = tl al) { (hd al).visibility = setreset((hd al).visibility, id); (hd al).needupdate = setreset((hd al).needupdate, id); } } for (i = 0; i < len o.children; i++) resetvisibilities(o.children[i], id); } # remove a member from their clique. # the client is still there, but won't get any clique updates. Member.del(member: self ref Member, suspend: int) { clique := cliques[member.cliqueid]; if (!member.suspended) { for (ofids := qfiles[clique.fileid].ofids; ofids != nil; ofids = tl ofids) if ((hd ofids).member == member) { (hd ofids).member = nil; (hd ofids).hungup = 1; # XXX purge update queue? } # go through all clique objects and attributes, resetting # permissions for member id to their default values. if (suspend) { member.obj2ext = nil; member.ext2obj = nil; member.freelist = nil; member.updating = 0; member.suspended = 1; clique.suspended = member :: clique.suspended; } } else if (!suspend) { ns: list of ref Member; for (s := clique.suspended; s != nil; s = tl s) if (hd s != member) ns = hd s :: ns; clique.suspended = ns; } if (!suspend) { resetvisibilities(clique.objects[0], member.id); clique.memberids = clique.memberids.del(member.id); } } Clique.members(clique: self ref Clique): list of ref Member { pl := clique.suspended; for (ofids := qfiles[clique.fileid].ofids; ofids != nil; ofids = tl ofids) if ((hd ofids).member != nil) pl = (hd ofids).member :: pl; return pl; } Object.delete(o: self ref Object) { clique := cliques[o.cliqueid]; if (o.parentid != -1) { parent := clique.objects[o.parentid]; siblings := parent.children; for (i := 0; i < len siblings; i++) if (siblings[i] == o) break; if (i == len siblings) panic("object " + string o.id + " not found in parent"); parent.deletechildren((i, i+1)); } else sys->fprint(stderr, "spree: cannot delete root object\n"); } Object.deletechildren(parent: self ref Object, r: Range) { if (len parent.children == 0) return; clique := cliques[parent.cliqueid]; n := r.end - r.start; objs := array[r.end - r.start] of int; children := parent.children; for (i := r.start; i < r.end; i++) { o := children[i]; objs[i - r.start] = o.id; o.deletechildren((0, len o.children)); clique.objects[o.id] = nil; clique.freelist = o.id :: clique.freelist; o.id = -1; o.parentid = -1; } children[r.start:] = children[r.end:]; for (i = len children - n; i < len children; i++) children[i] = nil; if (n < len children) parent.children = children[0:len children - n]; else parent.children = nil; if (Debug) { sys->print("+del from %d, range [%d %d], objs: ", parent.id, r.start, r.end); for (i = 0; i < len objs; i++) sys->print("%d ", objs[i]); sys->print("\n"); } applycliqueupdate(clique, ref Update.Delete(parent.id, r, objs), All); } # move a range of objects from src and insert them at index in dst. Object.transfer(src: self ref Object, r: Range, dst: ref Object, index: int) { if (index == -1) index = len dst.children; if (src == dst && index >= r.start && index <= r.end) return; n := r.end - r.start; objs := src.children[r.start:r.end]; newchildren := array[len src.children - n] of ref Object; newchildren[0:] = src.children[0:r.start]; newchildren[r.start:] = src.children[r.end:]; src.children = newchildren; if (Debug) { sys->print("+transfer from %d[%d,%d] to %d[%d], objs: ", src.id, r.start, r.end, dst.id, index); for (x := 0; x < len objs; x++) sys->print("%d ", objs[x].id); sys->print("\n"); } nindex := index; # if we've just removed some cards from the destination, # then adjust the destination index accordingly. if (src == dst && nindex > r.start) { if (nindex < r.end) nindex = r.start; else nindex -= n; } newchildren = array[len dst.children + n] of ref Object; newchildren[0:] = dst.children[0:index]; newchildren[nindex + n:] = dst.children[nindex:]; newchildren[nindex:] = objs; dst.children = newchildren; for (i := 0; i < len objs; i++) objs[i].parentid = dst.id; clique := cliques[src.cliqueid]; applycliqueupdate(clique, ref Update.Transfer(src.id, r, dst.id, index), All); } # visibility is only set when the attribute is newly created. Object.setattr(o: self ref Object, name, val: string, visibility: Set) { (changed, attr) := o.attrs.set(name, val, visibility); if (changed) { attr.needupdate = All; applycliqueupdate(cliques[o.cliqueid], ref Update.Set(o, o.id, attr), objvisibility(o)); } } Object.getattr(o: self ref Object, name: string): string { attr := o.attrs.get(name); if (attr == nil) return nil; return attr.val; } # set visibility of an object - reveal any uncovered descendents # if necessary. Object.setvisibility(o: self ref Object, visibility: Set) { if (o.visibility.eq(visibility)) return; o.visibility = visibility; applycliqueupdate(cliques[o.cliqueid], ref Update.Setvisibility(o.id, visibility), objvisibility(o)); } Object.setattrvisibility(o: self ref Object, name: string, visibility: Set) { attr := o.attrs.get(name); if (attr == nil) { sys->fprint(stderr, "spree: setattrvisibility, no attribute '%s', id %d\n", name, o.id); return; } if (attr.visibility.eq(visibility)) return; # send updates to anyone that has needs updating, # is in the new visibility list, but not in the old one. ovisibility := objvisibility(o); before := ovisibility.X(A&B, attr.visibility); after := ovisibility.X(A&B, visibility); attr.visibility = visibility; applycliqueupdate(cliques[o.cliqueid], ref Update.Set(o, o.id, attr), before.X(~A&B, after)); } # an object's visibility is the intersection # of the visibility of all its parents. objvisibility(o: ref Object): Set { clique := cliques[o.cliqueid]; visibility := All; for (id := o.parentid; id != -1; id = o.parentid) { o = clique.objects[id]; visibility = visibility.X(A&B, o.visibility); } return visibility; } makespace(objects: array of ref Object, freelist: list of int): (array of ref Object, list of int) { if (freelist == nil) { na := array[len objects + 10] of ref Object; na[0:] = objects; for (j := len na - 1; j >= len objects; j--) freelist = j :: freelist; objects = na; } return (objects, freelist); } updateall() { for (i := 0; i < len qfiles; i++) { f := qfiles[i]; if (f != nil && f.needsupdate) { for (ol := f.ofids; ol != nil; ol = tl ol) sendupdate(hd ol); f.needsupdate = 0; } } } applyupdate(f: ref Qfile, upd: ref Update) { for (ol := f.ofids; ol != nil; ol = tl ol) (hd ol).updateq.put(upd); f.needsupdate = 1; } # send update to members in the clique in the needupdate set. applycliqueupdate(clique: ref Clique, upd: ref Update, needupdate: Set) { always := alwayssend[tagof(upd)]; if (needupdate.isempty() || (!clique.started && !always)) return; f := qfiles[clique.fileid]; for (ol := f.ofids; ol != nil; ol = tl ol) { ofid := hd ol; member := ofid.member; if (member != nil && needupdate.holds(member.id) && (member.updating || always)) queueupdate(ofid.updateq, member, upd); } f.needsupdate = 1; } # transform an outgoing update according to the visibility # of the object(s) concerned. # the update concerned has already occurred. queueupdate(q: ref Queue, p: ref Member, upd: ref Update) { clique := cliques[p.cliqueid]; pick u := upd { Set => if (p.ext(u.o.id) != -1 && u.attr.needupdate.holds(p.id)) { q.put(ref Update.Set(u.o, p.ext(u.o.id), u.attr)); u.attr.needupdate = u.attr.needupdate.del(p.id); } else u.attr.needupdate = u.attr.needupdate.add(p.id); Transfer => # if moving from an invisible object, create the objects # temporarily in the source object, and then transfer from that. # if moving to an invisible object, delete the objects. # if moving from invisible to invisible, do nothing. src := clique.objects[u.srcid]; dst := clique.objects[u.dstid]; fromvisible := objvisibility(src).X(A&B, src.visibility).holds(p.id); tovisible := objvisibility(dst).X(A&B, dst.visibility).holds(p.id); if (fromvisible || tovisible) { # N.B. objects are already in destination object at this point. (r, index, srcid) := (u.from, u.index, u.srcid); # XXX this scheme is all very well when the parent of src # or dst is visible, but not when it's not... in that case # we should revert to the old scheme of deleting objects in src # or recreating them in dst as appropriate. if (!tovisible) { # transfer objects to destination, then delete them, # so client knows where they've gone. q.put(ref Update.Transfer(p.ext(srcid), r, p.ext(u.dstid), 0)); qdelobjects(q, p, dst, (u.index, u.index + r.end - r.start), 0); break; } if (!fromvisible) { # create at the end of source object, # then transfer into correct place in destination. n := r.end - r.start; for (i := 0; i < n; i++) { o := dst.children[index + i]; qrecreateobject(q, p, o, src); } r = (0, n); } if (p.ext(srcid) == -1 || p.ext(u.dstid) == -1) panic("external objects do not exist"); q.put(ref Update.Transfer(p.ext(srcid), r, p.ext(u.dstid), index)); } Create => dst := clique.objects[u.parentid]; if (objvisibility(dst).X(A&B, dst.visibility).holds(p.id)) { memberaddobject(p, clique.objects[u.objid]); q.put(ref Update.Create(p.ext(u.objid), p.ext(u.parentid), u.visibility, u.objtype)); } Delete => # we can only get this update when all the children are # leaf nodes. o := clique.objects[u.parentid]; if (objvisibility(o).X(A&B, o.visibility).holds(p.id)) { r := u.r; extobjs := array[len u.objs] of int; for (i := 0; i < len u.objs; i++) { extobjs[i] = p.ext(u.objs[i]); memberdelobject(p, u.objs[i]); } q.put(ref Update.Delete(p.ext(o.id), u.r, extobjs)); } Setvisibility => # if the object doesn't exist for this member, don't do anything. # else if there are children, check whether they exist, and # create or delete them as necessary. if (p.ext(u.objid) != -1) { o := clique.objects[u.objid]; if (len o.children > 0) { visible := u.visibility.holds(p.id); made := p.ext(o.children[0].id) != -1; if (!visible && made) qdelobjects(q, p, o, (0, len o.children), 0); else if (visible && !made) for (i := 0; i < len o.children; i++) qrecreateobject(q, p, o.children[i], nil); } q.put(ref Update.Setvisibility(p.ext(u.objid), u.visibility)); } Action => s := u.s; for (ol := u.objs; ol != nil; ol = tl ol) s += " " + string p.ext(hd ol); s += " " + u.rest; q.put(ref Update.Action(s, nil, nil)); * => q.put(upd); } } # queue deletions for o; we pretend to the client that # the deletions are at index. qdelobjects(q: ref Queue, p: ref Member, o: ref Object, r: Range, index: int) { if (r.start >= r.end) return; children := o.children; extobjs := array[r.end - r.start] of int; for (i := r.start; i < r.end; i++) { c := children[i]; qdelobjects(q, p, c, (0, len c.children), 0); extobjs[i - r.start] = p.ext(c.id); memberdelobject(p, c.id); } q.put(ref Update.Delete(p.ext(o.id), (index, index + (r.end - r.start)), extobjs)); } # parent visibility now allows o to be seen, so recreate # it for the member. (if parent is non-nil, pretend we're creating it there) qrecreateobject(q: ref Queue, p: ref Member, o: ref Object, parent: ref Object) { memberaddobject(p, o); parentid := o.parentid; if (parent != nil) parentid = parent.id; q.put(ref Update.Create(p.ext(o.id), p.ext(parentid), o.visibility, o.objtype)); recreateattrs(q, p, o); if (o.visibility.holds(p.id)) { a := o.children; for (i := 0; i < len a; i++) qrecreateobject(q, p, a[i], nil); } } recreateattrs(q: ref Queue, p: ref Member, o: ref Object) { a := o.attrs.a; for (i := 0; i < len a; i++) { for (al := a[i]; al != nil; al = tl al) { attr := hd al; q.put(ref Update.Set(o, p.ext(o.id), attr)); } } } CONTINUATION := array[] of {byte '\n', byte '*'}; # send the client as many updates as we can fit in their read request # (if there are some updates to send and there's an outstanding read request) sendupdate(ofid: ref Openfid) { clique: ref Clique; if (ofid.readreq == nil || (ofid.updateq.isempty() && !ofid.hungup)) return; m := ofid.readreq; q := ofid.updateq; if (ofid.hungup) { srv.reply(ref Rmsg.Read(m.tag, nil)); q.h = q.t = nil; return; } data := array[m.count] of byte; nb := 0; plid := -1; if (ofid.member != nil) { plid = ofid.member.id; clique = cliques[ofid.member.cliqueid]; } avail := len data - len CONTINUATION; Putdata: for (; !q.isempty(); q.get()) { upd := q.peek(); pick u := upd { Set => if (plid != -1 && !objvisibility(u.o).X(A&B, u.attr.visibility).holds(plid)) { u.attr.needupdate = u.attr.needupdate.add(plid); continue Putdata; } Break => if (nb > 0) { q.get(); break Putdata; } continue Putdata; } d := array of byte update2s(upd, plid); if (len d + nb > avail) break; data[nb:] = d; nb += len d; } err := ""; if (nb == 0) { if (q.isempty()) return; err = "short read"; } else if (!q.isempty()) { data[nb:] = CONTINUATION; nb += len CONTINUATION; } data = data[0:nb]; if (err != nil) srv.reply(ref Rmsg.Error(m.tag, err)); else srv.reply(ref Rmsg.Read(m.tag, data)); ofid.readreq = nil; } # convert an Update adt to a string. update2s(upd: ref Update, plid: int): string { s: string; pick u := upd { Create => objtype := u.objtype; if (objtype == nil) objtype = "nil"; s = sys->sprint("create %d %d %d %s\n", u.objid, u.parentid, u.visibility.holds(plid) != 0, objtype); Transfer => # tx src dst dstindex start end if (u.srcid == -1 || u.dstid == -1) panic("src or dst object is -1"); s = sys->sprint("tx %d %d %d %d %d\n", u.srcid, u.dstid, u.from.start, u.from.end, u.index); Delete => s = sys->sprint("del %d %d %d", u.parentid, u.r.start, u.r.end); for (i := 0; i < len u.objs; i++) s += " " + string u.objs[i]; s[len s] = '\n'; Set => s = sys->sprint("set %d %s %s\n", u.objid, u.attr.name, u.attr.val); Setvisibility => s = sys->sprint("vis %d %d\n", u.objid, u.visibility.holds(plid) != 0); Action => s = u.s + "\n"; * => sys->fprint(stderr, "unknown update tag %d\n", tagof(upd)); } return s; } Queue.put(q: self ref Queue, s: T) { q.t = s :: q.t; } Queue.get(q: self ref Queue): T { s: T; if(q.h == nil){ q.h = revlist(q.t); q.t = nil; } if(q.h != nil){ s = hd q.h; q.h = tl q.h; } return s; } Queue.peek(q: self ref Queue): T { s: T; if (q.isempty()) return s; s = q.get(); q.h = s :: q.h; return s; } Queue.isempty(q: self ref Queue): int { return q.h == nil && q.t == nil; } revlist(ls: list of T) : list of T { rs: list of T; for (; ls != nil; ls = tl ls) rs = hd ls :: rs; return rs; } Attributes.new(): ref Attributes { return ref Attributes(array[7] of list of ref Attribute); } Attributes.get(attrs: self ref Attributes, name: string): ref Attribute { for (al := attrs.a[strhash(name, len attrs.a)]; al != nil; al = tl al) if ((hd al).name == name) return hd al; return nil; } # return (haschanged, attr) Attributes.set(attrs: self ref Attributes, name, val: string, visibility: Set): (int, ref Attribute) { h := strhash(name, len attrs.a); for (al := attrs.a[h]; al != nil; al = tl al) { attr := hd al; if (attr.name == name) { if (attr.val == val) return (0, attr); attr.val = val; return (1, attr); } } attr := ref Attribute(name, val, visibility, All); attrs.a[h] = attr :: attrs.a[h]; return (1, attr); } setreset(set: Set, i: int): Set { if (set.msb()) return set.add(i); return set.del(i); } # from Aho Hopcroft Ullman strhash(s: string, n: int): int { h := 0; m := len s; for(i := 0; i<m; i++){ h = 65599 * h + s[i]; } return (h & 16r7fffffff) % n; } panic(s: string) { cliques[0].show(nil); sys->fprint(stderr, "panic: %s\n", s); raise "panic"; } randbits: chan of int; initrand() { randbits = chan of int; spawn randproc(); } randproc() { fd := sys->open("/dev/notquiterandom", Sys->OREAD); if (fd == nil) { sys->print("cannot open /dev/random: %r\n"); exit; } randbits <-= sys->pctl(0, nil); buf := array[1] of byte; while ((n := sys->read(fd, buf, len buf)) > 0) { b := buf[0]; for (i := byte 1; i != byte 0; i <<= 1) randbits <-= (b & i) != byte 0; } } rand(n: int): int { x: int; for (nbits := 0; (1 << nbits) < n; nbits++) x ^= <-randbits << nbits; x ^= <-randbits << nbits; x &= (1 << nbits) - 1; i := 0; while (x >= n) { x ^= <-randbits << i; i = (i + 1) % nbits; } return x; } archivenum := -1; newarchivename(): string { if (archivenum == -1) { (d, nil) := readdir->init(ARCHIVEDIR, Readdir->MTIME|Readdir->COMPACT); for (i := 0; i < len d; i++) { name := d[i].name; if (name != nil && name[0] == 'a') { for (j := 1; j < len name; j++) if (name[j] < '0' || name[j] > '9') break; if (j == len name && int name[1:] > archivenum) archivenum = int name[1:]; } } archivenum++; } return ARCHIVEDIR + "/a" + string archivenum++; } archivenames(): list of string { names: list of string; (d, nil) := readdir->init(ARCHIVEDIR, Readdir->MTIME|Readdir->COMPACT); for (i := 0; i < len d; i++) if (len d[i].name < 4 || d[i].name[len d[i].name - 4:] != ".old") names = ARCHIVEDIR + "/" + d[i].name :: names; return names; }