ref: 1018d7a7091fd5e0433f501a3474cdc3fec322cc
dir: /appl/cmd/vixenplumb.b/
# keep track of vixen instances, register plumb dst "edit" and forward plumb messages implement Vixenplumb; include "sys.m"; sys: Sys; sprint: import sys; include "draw.m"; draw: Draw; include "arg.m"; include "string.m"; str: String; include "plumbmsg.m"; plumbmsg: Plumbmsg; Msg: import plumbmsg; include "sh.m"; sh: Sh; include "names.m"; names: Names; Vixenplumb: module { init: fn(ctxt: ref Draw->Context, argv: list of string); }; dflag := 0; Client: adt { fid: int; path: string; # path being edited rc: Sys->Rread; # for read pending: string; # pending string for next rc text: fn(c: self ref Client): string; }; Client.text(c: self ref Client): string { return sprint("Client(fid %d, path %q, rc nil %d, pending %q)", c.fid, c.path, c.rc == nil, c.pending); } clients: list of ref Client; drawcontext: ref Draw->Context; Iomax: con 8*1024; # max file2chan message size, also in vixenplumbreader() in vixen init(ctxt: ref Draw->Context, args: list of string) { sys = load Sys Sys->PATH; if(ctxt == nil) fail("no window context"); drawcontext = ctxt; draw = load Draw Draw->PATH; arg := load Arg Arg->PATH; str = load String String->PATH; plumbmsg = load Plumbmsg Plumbmsg->PATH; sh = load Sh Sh->PATH; sh->initialise(); names = load Names Names->PATH; sys->pctl(Sys->NEWPGRP, nil); arg->init(args); arg->setusage(arg->progname()+" [-d] [path]"); while((c := arg->opt()) != 0) case c { 'd' => dflag++; * => arg->usage(); } args = arg->argv(); pathpat: string; case len args { 0 => {} 1 => pathpat = hd args; * => arg->usage(); } if(plumbmsg->init(0, "edit", 0) < 0) fail(sprint("plumb init: %r")); fio := sys->file2chan("/chan", "vixenplumb"); if(fio == nil) fail(sprint("file2chan: %r")); msgc := chan of ref Msg; spawn plumbreceiver(msgc); if(pathpat != nil) { wd := workdir(); spawn edit(wd, pathget(wd, pathpat)); } spawn serve(fio, msgc); } serve(fio: ref Sys->FileIO, msgc: chan of ref Msg) { for(;;) alt { m := <-msgc => if(m == nil) fail("nil plumbmsg received"); handle(m); (nil, count, fid, rc) := <-fio.read => if(rc == nil) { del(fid); } else if(count < Iomax) { rc <-= (nil, sprint("read > Iomax (%d)", Iomax)); } else { putrc(fid, rc); } (nil, data, fid, rc) := <-fio.write => if(rc == nil) del(fid); else { err := set(fid, string data); rc <-= (len data, err); } } } # given a working dir and a pathpat consisting of either absolute or relative path # and an optional colon and address, return the final path and the pattern pathget(wd, pathpat: string): (string, string) { (path, pat) := str->splitstrr(pathpat, ":"); if(path == nil) { path = pat; pat = nil; } else path = path[:len path-1]; if(!str->prefix("/", path) && !str->prefix("#", path)) path = wd+"/"+path; if(pat == nil) pat = "."; path = names->cleanname(path); return (path, pat); } edit(wd: string, pathpat: (string, string)) { sys->pctl(Sys->FORKNS, nil); # separate working directory (path, pat) := pathpat; sys->chdir(wd); say(sprint("edit, wd %q, path %q, pat %q", wd, path, pat)); if(pat == nil) args := list of {"wm/vixen", path}; else args = list of {"wm/vixen", "-c", ":"+pat, path}; sh->run(drawcontext, args); } write(fd: ref Sys->FD, s: string, pidc: chan of int, rc: chan of (int, string)) { pidc <-= pid(); if(sys->write(fd, buf := array of byte s, len buf) != len buf) rc <-= (0, sprint("write: %r")); } runeditnew(fd0: ref Sys->FD, dir: string, pidc: chan of int, rc: chan of (int, string)) { pidc <-= pid(); sys->pctl(Sys->NEWFD|Sys->FORKNS|Sys->FORKENV, list of {fd0.fd, 1, 2}); sys->dup(fd0.fd, 0); err := sh->run(drawcontext, list of {"wm/vixen", "-i", dir}); rc <-= (1, err); } editnew(dir, data: string) { sys->pctl(Sys->FORKNS, nil); # separate working directory if(sys->chdir(dir) < 0) return warn(sprint("chdir %q: %r", dir)); sys->pctl(Sys->NEWFD, list of {1, 2}); if(sys->pipe(fd0 := array[2] of ref Sys->FD) < 0) return warn(sprint("pipe: %r")); pidc := chan of int; rc := chan of (int, string); # done, err spawn write(fd0[0], data, pidc, rc); writepid := <-pidc; spawn runeditnew(fd0[1], dir, pidc, rc); runpid := <-pidc; fd0 = nil; (done, err) := <-rc; if(err != nil) warn(err); kill(writepid); if(!done) killgrp(runpid); } handle(m: ref Msg) { # see if it exists, if so, send it the pattern # otherwise, start a new wm/vixen say(sprint("msg: %s", string m.pack())); case m.kind { "text" => (path, pat) := pathget(m.dir, string m.data); c := findpath(path); if(c == nil) { spawn edit(m.dir, (path, pat)); } else { c.pending = pat; respond(c); } "newtext" => c := findpath(m.dir); if(c == nil) { spawn editnew(names->cleanname(m.dir), string m.data); } else { c.pending = string m.data; respond(c); } * => return warn(sprint("kind %q ignored", m.kind)); } } respond(c: ref Client) { say(sprint("respond, c %s", c.text())); if(c.rc != nil && c.pending != nil) { c.rc <-= (array of byte c.pending, nil); c.rc = nil; c.pending = nil; } } putrc(fid: int, rc: Sys->Rread) { say(sprint("putrc, fid %d", fid)); for(l := clients; l != nil; l = tl l) { c := hd l; if(c.fid == fid) { if(c.rc != nil) rc <-= (nil, "one read at a time please"); else { c.rc = rc; respond(c); } return; } } c := ref Client (fid, nil, rc, ""); clients = c::clients; say(sprint("putrc, new client %s", c.text())); } del(fid: int) { nc: list of ref Client; for(l := clients; l != nil; l = tl l) if((hd l).fid != fid) nc = hd l::nc; clients = nc; } findpath(path: string): ref Client { for(l := clients; l != nil; l = tl l) if((hd l).path == path) return hd l; return nil; } set(fid: int, path: string): string { o := findpath(path); for(l := clients; l != nil; l = tl l) { c := hd l; if(c.fid == fid) { if(o != nil && o != c) return "file already open"; say(sprint("new path for client, fid %d, old path %q, new path %q", fid, c.path, path)); c.path = path; return nil; } } c := ref Client (fid, path, nil, ""); clients = c::clients; say(sprint("set, new client %s", c.text())); return nil; } plumbreceiver(msgc: chan of ref Msg) { for(;;) msgc <-= Msg.recv(); } workdir(): string { return sys->fd2path(sys->open(".", Sys->OREAD)); } pid(): int { return sys->pctl(0, nil); } progctl(pid: int, s: string) { sys->fprint(sys->open(sprint("/prog/%d/ctl", pid), sys->OWRITE), "%s", s); } kill(pid: int) { progctl(pid, "kill"); } killgrp(pid: int) { progctl(pid, "killgrp"); } say(s: string) { if(dflag) warn(s); } warn(s: string) { sys->fprint(sys->fildes(2), "%s\n", s); } fail(s: string) { warn(s); killgrp(pid()); raise "fail:"+s; }