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;}