ref: 3efb5bbb4061056e523858b134c555949591efe2
dir: /appl/cmd/install/updatelog.b/
implement Updatelog;
include "sys.m";
sys: Sys;
include "draw.m";
include "bufio.m";
bufio: Bufio;
Iobuf: import bufio;
include "daytime.m";
daytime: Daytime;
include "string.m";
str: String;
include "keyring.m";
kr: Keyring;
include "logs.m";
logs: Logs;
Db, Entry, Byname, Byseq: import logs;
S, mkpath: import logs;
Log: type Entry;
include "fsproto.m";
fsproto: FSproto;
Direntry: import fsproto;
include "arg.m";
Updatelog: module
{
init: fn(nil: ref Draw->Context, nil: list of string);
};
now: int;
gen := 0;
changesonly := 0;
uid: string;
gid: string;
debug := 0;
state: ref Db;
rootdir := ".";
scanonly: list of string;
exclude: list of string;
sums := 0;
stderr: ref Sys->FD;
Seen: con 1<<31;
bout: ref Iobuf;
init(nil: ref Draw->Context, args: list of string)
{
sys = load Sys Sys->PATH;
bufio = load Bufio Bufio->PATH;
ensure(bufio, Bufio->PATH);
fsproto = load FSproto FSproto->PATH;
ensure(fsproto, FSproto->PATH);
daytime = load Daytime Daytime->PATH;
ensure(daytime, Daytime->PATH);
str = load String String->PATH;
ensure(str, String->PATH);
logs = load Logs Logs->PATH;
ensure(logs, Logs->PATH);
kr = load Keyring Keyring->PATH;
ensure(kr, Keyring->PATH);
arg := load Arg Arg->PATH;
if(arg == nil)
error(sys->sprint("can't load %s: %r", Arg->PATH));
protofile := "/lib/proto/all";
arg->init(args);
arg->setusage("updatelog [-p proto] [-r root] [-t now gen] [-c] [-x path] x.log [path ...]");
while((o := arg->opt()) != 0)
case o {
'D' =>
debug = 1;
'p' =>
protofile = arg->earg();
'r' =>
rootdir = arg->earg();
'c' =>
changesonly = 1;
'u' =>
uid = arg->earg();
'g' =>
gid = arg->earg();
's' =>
sums = 1;
't' =>
now = int arg->earg();
gen = int arg->earg();
'x' =>
s := arg->earg();
exclude = trimpath(s) :: exclude;
* =>
arg->usage();
}
args = arg->argv();
if(args == nil)
arg->usage();
arg = nil;
stderr = sys->fildes(2);
bout = bufio->fopen(sys->fildes(1), Bufio->OWRITE);
fsproto->init();
logs->init(bufio);
logfile := hd args;
while((args = tl args) != nil)
scanonly = trimpath(hd args) :: scanonly;
checkroot(rootdir, "replica root");
state = Db.new("server state");
#
# replay log to rebuild server state
#
logfd := sys->open(logfile, Sys->OREAD);
if(logfd == nil)
error(sys->sprint("can't open %s: %r", logfile));
f := bufio->fopen(logfd, Sys->OREAD);
if(f == nil)
error(sys->sprint("can't open %s: %r", logfile));
while((log := readlog(f)) != nil)
replaylog(state, log);
#
# walk the set of names produced by the proto file, comparing against the server state
#
now = daytime->now();
doproto(rootdir, protofile);
if(changesonly){
bout.flush();
exit;
}
#
# names in the original state that we didn't see in the walk must have been removed:
# print 'd' log entries for them, in reverse lexicographic order (children before parents)
#
state.sort(Logs->Byname);
for(i := state.nstate; --i >= 0;){
e := state.state[i];
if((e.x & Seen) == 0 && considered(e.path)){
change('d', e, e.seq, e.d, e.path, e.serverpath, e.contents); # TO DO: content
if(debug)
sys->fprint(sys->fildes(2), "remove %q\n", e.path);
}
}
bout.flush();
}
ensure[T](m: T, path: string)
{
if(m == nil)
error(sys->sprint("can't load %s: %r", path));
}
checkroot(dir: string, what: string)
{
(ok, d) := sys->stat(dir);
if(ok < 0)
error(sys->sprint("can't stat %s %q: %r", what, dir));
if((d.mode & Sys->DMDIR) == 0)
error(sys->sprint("%s %q: not a directory", what, dir));
}
considered(s: string): int
{
if(scanonly != nil && !islisted(s, scanonly))
return 0;
return exclude == nil || !islisted(s, exclude);
}
readlog(in: ref Iobuf): ref Log
{
(e, err) := Entry.read(in);
if(err != nil)
error(err);
return e;
}
#
# replay a log to reach the state wrt files previously taken from the server
#
replaylog(db: ref Db, log: ref Log)
{
e := db.look(log.path);
indb := e != nil && !e.removed();
case log.action {
'a' => # add new file
if(indb){
note(sys->sprint("%q duplicate create", log.path));
return;
}
'c' => # contents
if(!indb){
note(sys->sprint("%q contents but no entry", log.path));
return;
}
'd' => # delete
if(!indb){
note(sys->sprint("%q deleted but no entry", log.path));
return;
}
if(e.d.mtime > log.d.mtime){
note(sys->sprint("%q deleted but it's newer", log.path));
return;
}
'm' => # metadata
if(!indb){
note(sys->sprint("%q metadata but no entry", log.path));
return;
}
* =>
error(sys->sprint("bad log entry: %bd %bd", log.seq>>32, log.seq & big 16rFFFFFFFF));
}
update(db, e, log);
}
#
# update file state e to reflect the effect of the log,
# creating a new entry if necessary
#
update(db: ref Db, e: ref Entry, log: ref Entry)
{
if(e == nil)
e = db.entry(log.seq, log.path, log.d);
e.update(log);
}
doproto(tree: string, protofile: string)
{
entries := chan of Direntry;
warnings := chan of (string, string);
err := fsproto->readprotofile(protofile, tree, entries, warnings);
if(err != nil)
error(sys->sprint("can't read %s: %s", protofile, err));
for(;;)alt{
(old, new, d) := <-entries =>
if(d == nil)
return;
if(debug)
sys->fprint(stderr, "old=%q new=%q length=%bd\n", old, new, d.length);
while(new != nil && new[0] == '/')
new = new[1:];
if(!considered(new))
continue;
if(sums && (d.mode & Sys->DMDIR) == 0)
digests := md5sum(old) :: nil;
if(uid != nil)
d.uid = uid;
if(gid != nil)
d.gid = gid;
old = relative(old, rootdir);
db := state.look(new);
if(db == nil){
if(!changesonly){
db = state.entry(nextseq(), new, *d);
change('a', db, db.seq, db.d, db.path, old, digests);
}
}else{
if(!samestat(db.d, *d))
change('c', db, nextseq(), *d, new, old, digests);
if(!samemeta(db.d, *d))
change('m', db, nextseq(), *d, new, old, nil); # need digest?
}
if(db != nil)
db.x |= Seen;
(old, msg) := <-warnings =>
#if(contains(msg, "entry not found") || contains(msg, "not exist"))
# break;
sys->fprint(sys->fildes(2), "updatelog: warning[old=%s]: %s\n", old, msg);
}
}
change(action: int, e: ref Entry, seq: big, d: Sys->Dir, path: string, serverpath: string, digests: list of string)
{
log := ref Entry;
log.seq = seq;
log.action = action;
log.d = d;
log.path = path;
log.serverpath = serverpath;
log.contents = digests;
e.update(log);
bout.puts(log.logtext()+"\n");
}
samestat(a: Sys->Dir, b: Sys->Dir): int
{
# doesn't check permission/ownership, does check QTDIR/QTFILE
if(a.mode & Sys->DMDIR)
return (b.mode & Sys->DMDIR) != 0;
return a.length == b.length && a.mtime == b.mtime && a.qid.qtype == b.qid.qtype; # TO DO: a.name==b.name?
}
samemeta(a: Sys->Dir, b: Sys->Dir): int
{
return a.mode == b.mode && (uid == nil || a.uid == b.uid) && (gid == nil || a.gid == b.gid) && samestat(a, b);
}
nextseq(): big
{
return (big now << 32) | big gen++;
}
error(s: string)
{
sys->fprint(sys->fildes(2), "updatelog: %s\n", s);
raise "fail:error";
}
note(s: string)
{
sys->fprint(sys->fildes(2), "updatelog: note: %s\n", s);
}
contains(s: string, sub: string): int
{
return str->splitstrl(s, sub).t1 != nil;
}
isprefix(a, b: string): int
{
la := len a;
lb := len b;
if(la > lb)
return 0;
if(la == lb)
return a == b;
return a == b[0:la] && b[la] == '/';
}
trimpath(s: string): string
{
while(len s > 1 && s[len s-1] == '/')
s = s[0:len s-1];
while(s != nil && s[0] == '/')
s = s[1:];
return s;
}
relative(name: string, root: string): string
{
if(root == nil || name == nil)
return name;
if(isprefix(root, name)){
name = name[len root:];
while(name != nil && name[0] == '/')
name = name[1:];
}
return name;
}
islisted(s: string, l: list of string): int
{
for(; l != nil; l = tl l)
if(isprefix(hd l, s))
return 1;
return 0;
}
md5sum(file: string): string
{
fd := sys->open(file, Sys->OREAD);
if(fd == nil)
error(sys->sprint("can't open %s: %r", file));
ds: ref Keyring->DigestState;
buf := array[Sys->ATOMICIO] of byte;
while((n := sys->read(fd, buf, len buf)) > 0)
ds = kr->md5(buf, n, nil, ds);
if(n < 0)
error(sys->sprint("error reading %s: %r", file));
digest := array[Keyring->MD5dlen] of byte;
kr->md5(nil, 0, digest, ds);
s: string;
for(i := 0; i < len digest; i++)
s += sys->sprint("%.2ux", int digest[i]);
return s;
}