/**
** ==============================
** O O O OOOO
** O O O O O O
** O O O O O O
** OOOO OOOO O OOO OOOO
** O O O O O O O
** O O O O O O O
** OOOO OOOO O O OOOO
** ==============================
** BSSLAB, Dr. Stefan Bosse http://www.bsslab.de
**
** COPYRIGHT: THIS SOFTWARE, EXECUTABLE AND SOURCE CODE IS OWNED
** BY THE AUTHOR(S).
** THIS SOURCE CODE MAY NOT BE COPIED, EXTRACTED,
** MODIFIED, OR OTHERWISE USED IN A CONTEXT
** OUTSIDE OF THE SOFTWARE SYSTEM.
**
** $AUTHORS: Stefan Bosse
** $INITIAL: (C) 2015-2017 bLAB
** $CREATED: 23-4-15 by sbosse.
** $VERSION: 1.3.8
**
** $INFO:
** DNS Server with local file system storage and row capability cache.
*
* $ENDINFO
*/
"use strict";
var util = Require('util');
var Io = Require('com/io');
var Net = Require('dos/network');
var Std = Require('dos/std');
var Sch = Require('dos/scheduler');
var Buf = Require('dos/buf');
var Rpc = Require('dos/rpc');
var Cs = Require('dos/capset');
var Comp = Require('com/compat');
var String = Comp.string;
var Array = Comp.array;
var Perv = Comp.pervasives;
var Printf = Comp.printf;
var div = Perv.div;
var assert = Comp.assert;
var Rand = Comp.random;
var Status = Net.Status;
var Command = Net.Command;
var Rights = Net.Rights;
var AfsInt = Require('dos/afs');
var Afs = Require('dos/afs_srv_common');
var Dns = Require('dos/dns_srv_common');
var DnsInt = Require('dos/dns');
var Fs = Require('fs');
var Fcache = Require('dos/fcache');
var Cache = Require('dos/cache');
var Afs_file_state = Afs.Afs_file_state;
var log = 0;
var CACHETMO = 30; // seconds
/** DNS Dns_server
*
* @param {rpcint} rpc
* @constructor
* @typedef {{rpc,afs,std,cs,dns_super:dns_super,dns_part:string,dns_part_fd,cache_inode,cache_data,inode_cache_entry,
* rootdir:dns_dir,fs_default,
* block,to_block,of_block,
* live_set,live_get,live_read,live_write,
* read_inode,write_inode,sync_inode,
* inode_of_obj,cap_of_obj,update_inode,
* iocachebypass,sync_write_mode,
* stats}} dns_server~obj
* @see dns_server~obj
* @see dns_server~meth
*/
var dns_server = function (rpc,options) {
this.verbose=options.verbose||0;
this.rpc=rpc;
this.afs=AfsInt.AfsInt(rpc);
this.std=Std.StdInt(rpc);
this.cs=Cs.CsInt(rpc);
/**
*
* @type {dns_super|undefined}
*/
this.dns_super=undefined;
this.dns_part=''; // DNS inode partition file path
this.dns_part_fd=undefined;
/**
*
* @type {fsc_cache|undefined}
*/
this.cache_inode = undefined;
/**
*
* @type {cache|undefined}
*/
this.cache_data = undefined;
this.inode_cache_entry=undefined;
/** Capability cache to speed-up row
* capability restriction using a column mask.
* Key: cap-key+mask
* Value: Restricted cap
*
*/
this.cache_cap = Cache.Cache(1000);
this.rootdir=undefined;
this.fs_default=0;
this.block=function() {};
this.to_block=function() {};
this.of_block=function() {};
/**
*
* @param {number} obj
* @param {number} time
* @param {number} flag
*/
this.live_set=function (obj,time,flag) {};
/**
*
* @param {number} obj
* @returns {{time: number, flag: number}}
*/
this.live_get=function (obj) {return {time:0,flag:0}};
/**
*
* @returns {(Status.STD_OK|*)}
*/
this.live_read=function () {return 0;};
/**
*
* @returns {(Status.STD_OK|*)}
*/
this.live_write=function () {return 0;};
/**
*
* @param obj
* @param addr
* @param data
* @param size
* @returns {number}
*/
this.read_inode=function(obj,addr,data,size) {return 0};
/**
*
* @param obj
* @param addr
* @param data
* @param size
* @returns {number}
*/
this.write_inode=function(obj,addr,data,size) {return 0};
this.sync_inode=function() {};
/**
*
* @param {number} obj
* @returns {{stat:(Status.STD_OK|*),inode:(dns_inode|undefined)}}
*/
this.inode_of_obj=function(obj){return {stat:0,inode:undefined}};
/**
*
* @param {number} obj
* @returns {{stat:(Status.STD_OK|*),cap:(capability|undefined),inode:(dns_inode|undefined)}}
*/
this.cap_of_obj=function(obj){return {stat:0,cap:undefined,inode:undefined}};
this.update_inode=function(){};
this.iocache_bypass=false;
this.sync_write_mode=false;
this.stats = {
op_read:0,
op_modify:0,
op_create:0,
op_destroy:0,
op_touch:0,
op_age:0
}
};
/** Initialite and start up services
*
*/
dns_server.prototype.init = function () {
var self=this;
Sch.AddTimer(1000,'DNS Server Garbage Collector',function () {
self.cache_cap.refresh(function (key,data) {
if (data.tmo) { data.tmo--; return data.tmo>0}
else return true;
});
});
}
/** Get the current system time in 10s units
*
* @returns {number}
*/
dns_server.prototype.time =function () {
var self=this;
return div(Perv.time(),10);
};
/** Acquire and lock a directory [BLOCKING]
*
* @param {number} obj
* @param {function((Status.STD_OK|*),(dns_dir|undefined))} callback
*/
dns_server.prototype.acquire_dir = function (obj,callback) {
var self=this;
var dir=undefined;
var stat;
Sch.ScheduleBlock([
function () {self.dns_super.lock();},
function () {
var res;
res=self.read_dir(obj,function (_stat,_dir) {
stat=_stat;
dir=_dir;
});
if (stat==Status.STD_OK) {
dir.lock();
}
},
function () {
self.dns_super.unlock();
Io.log((log < 1) || ('Dns_srv.acquire_dir: done ' + obj));
callback(stat,dir);
}
],function (e) {
if (typeof e == 'number') callback(e,undefined); else {
Io.printstack(e,'Dns_server.acquire_dir');
callback(Status.STD_SYSERR,undefined);
}
});
};
/** Release an acquired directory. Flush all pending writes - the
** super structure and the i-node table, and the directory itself
** if modified. Return the status of the operation. [BLOCKING]
*
*
* @param {dns_dir} dir
* @param {function(Status.STD_OK|*)} callback
*/
dns_server.prototype.release_dir = function (dir,callback) {
var stat=Status.STD_OK;
Io.log((log < 1) || ('dns_srv.release_dir: ' + util.inspect(dir)));
if (dir != undefined) {
if ((dir.dd_state == Dns.Dns_dir_state.DD_unlocked ||
dir.dd_state == Dns.Dns_dir_state.DD_modified)) {
this.modify_dir(dir, function (_stat) {
callback(_stat);
});
}
else {
stat = Status.STD_OK;
dir.unlock();
if (callback) callback(stat);
}
} else {
stat=Status.STD_ARGBAD;
if (callback!=undefined) callback(stat);
}
};
/** Release an acquired but unmodified directory. Flush all pending writes - the
** super structure and the i-node table.
** Return the status of the operation.
*
*
* @param {dns_dir} dir
* @returns {(Status.STD_OK|*)}
*
* @param dir
*/
dns_server.prototype.release_unmodified_dir = function (dir) {
var stat=Status.STD_OK;
Io.log((log < 1) || ('dns_srv.release_unmodified_dir: ' + util.inspect(dir)));
if (dir != undefined) {
if ((dir.dd_state == Dns.Dns_dir_state.DD_unlocked ||
dir.dd_state == Dns.Dns_dir_state.DD_modified)) {
Io.out('Dns_srv.release_unmodified_dir: Directory '+dir.dd_objnum+' was modified!');
return Status.STD_SYSERR;
}
else {
stat = Status.STD_OK;
dir.unlock();
return stat;
}
} else {
return Status.STD_ARGBAD;
}
};
/** Lookup a directory object (priv.prv_obj) and check the required rights.
* The directory is returned unlocked!
*
* @param {privat} priv
* @param {number} req
* @param {function((Status.STD_OK|*),(dns_dir|undefined))} callback
*/
dns_server.prototype.lookup_dir = function(priv,req,callback) {
var self = this;
var obj = Net.prv_number(priv);
var stat;
var dir;
if (obj < 1 || obj >= this.dirs_top) {
callback(Status.STD_ARGBAD,undefined);
} else Sch.ScheduleBlock([
function () {
Io.log((log<1)||('Dns_server.lookup_dir: read_dir('+obj+')'));
self.read_dir(obj,function (_stat,_dir) {
stat=_stat;
dir=_dir;
})
},
function () {
if (stat!=Status.STD_OK) throw stat;
if (!Net.prv_decode(priv, dir.dd_random)) {
throw Status.STD_DENIED;
}
/*
** When checking the presence of column rights, only take the
** *actual*
** columns present into acount (i.e., do not use dns_COLMASK here)
*/
var ncols=dir.dd_ncols;
var rights = Net.prv_rights(priv);
var colbits = Dns.dns_col_bits[ncols];
var colmask = colbits-1;
Io.log((log<1)||('Dns_server.lookup_dir: '+Net.Print.private(priv))+' req='+req+' colmask='+colmask+' rights='+rights);
if ((rights & colmask) == 0 ||
(rights & req) != req) {
throw Status.STD_DENIED;
}
callback(Status.STD_OK,dir);
}
],function (e) {
if (typeof e == 'number') callback(e,undefined); else {
Io.printstack(e,'Dns_server.lookup_dir');
callback(Status.STD_SYSERR,undefined);
}
});
};
/** A client request arrived. Enter the critical section. Check the capability.
** If it is correct, check whether the required rights are present or not.
** Return the directory structure, but only if the required rights are present.
*
* @param priv
* @param req
* @param callback
*/
dns_server.prototype.request_dir = function(priv,req,callback) {
var self = this;
var obj = Net.prv_number(priv);
var stat;
var dir;
if (obj < 1 || obj >= this.dirs_top) {
callback(Status.STD_ARGBAD,undefined);
} else Sch.ScheduleBlock([
function () {
Io.log((log<1)||('Dns_server.request_dir: acquire_dir('+obj+')'));
self.acquire_dir(obj,function (_stat,_dir) {
stat=_stat;
dir=_dir;
})
},
function () {
if (stat!=Status.STD_OK) throw stat;
if (!Net.prv_decode(priv, dir.dd_random)) {
self.release_unmodified_dir(dir);
throw Status.STD_DENIED;
}
/*
** When checking the presence of column rights, only take the
** *actual*
** columns present into acount (i.e., do not use dns_COLMASK here)
*/
var ncols=dir.dd_ncols;
var rights = Net.prv_rights(priv);
var colbits = Dns.dns_col_bits[ncols];
var colmask = colbits-1;
Io.log((log<1)||('Dns_server.request_dir: '+Net.Print.private(priv))+' req='+req+' colmask='+colmask+' rights='+rights);
if ((rights & colmask) == 0 ||
(rights & req) != req) {
self.release_unmodified_dir(dir);
throw Status.STD_DENIED;
}
callback(Status.STD_OK,dir);
}
],function (e) {
if (typeof e == 'number') callback(e,undefined); else {
Io.printstack(e,'Dns_server.request_dir');
callback(Status.STD_SYSERR,undefined);
}
});
};
/**
** With a given directory capability set check if this directory belongs
** to this server.
*
*
* @param {capset} dir
* @returns {private|undefined}
*/
dns_server.prototype.check_dir = function(dir) {
var self=this;
Io.log((log<1)||('Dns_server.check_dir: '+Cs.Print.capset(dir)));
if (dir==undefined) return undefined;
for (var i = 0; i<dir.cs_final;i++) {
var s = dir.cs_suite[i];
if (s.s_current == true) {
var cap = s.s_object;
if (Net.Equal.port(cap.cap_port, self.dns_super.dns_putport) == true &&
Net.prv_number(cap.cap_priv) != 0) {
/*
** A capability for me. Check it.
*/
return cap.cap_priv;
}
}
}
Io.log((log<1)||'Dns_server.check_dir: not for me');
return undefined;
};
/** Calculate the size of a directory structure.
*
* @param {dns_dir} dir
* @returns {number}
*/
dns_server.prototype.dir_size = function (dir) {
return dir.size();
};
/** Return a free objnum in the directory table (index).
** Note: protect this function with the server lock untill
** the directory creation is finished.
*
* @returns {number}
*/
dns_server.prototype.get_freeobjnum = function () {
var self=this;
var sup=this.dns_super;
var obj=-1;
Array.match(sup.dns_freeobjnums,
function(hd,tl){
sup.dns_freeobjnums=tl;
obj=hd;
},
function () {
obj=sup.dns_nextfree;
if((obj+1)==sup.dns_ndirs) {
Io.out('[DNS] Out of directory slots.');
throw Status.STD_NOSPACE;
}
sup.dns_nextfree=obj+1;
});
return obj;
};
/** Convert a directory structure into a capset with maybe
** restricted rights.
*
* @param {dns_dir} dir
* @returns {capset}
*/
dns_server.prototype.capset_of_dir = function(dir,rights) {
var self=this;
var sup=this.dns_super;
var cs;
var cap = Net.Capability(
sup.dns_putport,
Net.prv_encode(dir.dd_objnum,rights,dir.dd_random)
);
cs=this.cs.cs_singleton(cap);
return cs;
};
/** Restrict a directory capability set.
* The directoty structure from capability set 'dir' must be unlocked to avoid.
*
* @param {capset} cs
* @param mask
* @param {function((Status.STD_OK|*),capset|undefined)} callback
*/
dns_server.prototype.restrict = function(cs,mask,callback) {
var self=this,
cs=Cs.Copy.capset(cs),
stat=Status.STD_CAPBAD,
index=0;
Sch.ScheduleLoop(function() {
return (stat!=Status.STD_OK && index<cs.cs_final);
},[
function () {
var s = cs.cs_suite[index],
cap,key,cache;
index++;
if (s.s_current == true) {
cap = s.s_object;
if (Net.Equal.port(cap.cap_port, self.dns_super.dns_putport) == true &&
Net.prv_number(cap.cap_priv) != 0) {
/*
** A capability for me. Restrict it.
*/
self.lookup_dir(cap.cap_priv,0,function (_stat,_dir) {
if (_stat==Status.STD_OK) {
cap.cap_priv=Net.prv_encode(cap.cap_priv.prv_obj,
cap.cap_priv.prv_rights & mask,
_dir.dd_random);
}
stat=_stat;
}); // dir is unlocked, no release!
} else {
Io.log((log<1)||('Dns_server.restrict: doing std_restrict for '+Net.Print.capability(cap)+' with mask='+mask));
// Try to use capability cache - but can be outdated
key=Net.key(cap);
cache=self.cache_cap.lookup(key);
if (cache && cache.restrict && cache.restrict[mask]) {
Net.Copy.private(cache.restrict[mask].cap_priv,cap.cap_priv);
stat=cache.stat;
} else self.std.std_restrict(cap,mask,function (_stat,_cap) {
Io.log((log<1)||('Dns_server.restrict: std_restrict returned: '+Status.print(_stat)));
stat=_stat;
if (stat==Status.STD_OK) {
if (cache && cache.restrict) {
cache.stat=stat;
cache.restrict[mask]=_cap;
cache.tmo=CACHETMO;
} else
self.cache_cap.add(key,{restrict:self.cache_cap.map(mask,_cap),
tmo:CACHETMO,stat:stat});
Net.Copy.private(_cap.cap_priv,cap.cap_priv);
} else {
if (cache && cache.restrict) {
cache.stat=stat;
cache.restrict[mask]=Net.nilcap;
cache.cap=cap
} else
self.cache_cap.add(key,{restrict:self.cache_cap.map(mask,Net.nilcap),
tmo:CACHETMO,stat:stat,cap:cap});
}
});
}
}
}
],[
function () {
callback(stat,cs);
}
],function (e) {
if (typeof e != 'number') {Io.printstack(e,'Dns_server.restrict');}
if (typeof e == 'number') callback(e,undefined); else callback(Status.STD_SYSERR,undefined);
});
};
/** Get defualt file server.
*
*
*
* @param {function((Status.STD_OK|*),(Dns_mode.DNSMODE_ONECOPY|*))} callback
*/
dns_server.prototype.get_def_fs = function (callback) {
var self=this;
var sup = this.dns_super;
var fs = sup.dns_fs;
var cap = undefined;
var stat;
var goods = 0;
var goodcap = undefined;
var mode;
var index = 0;
Sch.ScheduleLoop(
function() {
return index<2;
}, [
function () {
cap = fs.fs_cap[index];
if (cap != undefined) {
self.std.std_info(cap,function (_stat,_info) {
stat=_stat;
})
} else stat=Status.STD_CAPBAD;
},
function () {
if (cap!=undefined) {
if (stat == Status.STD_OK) {
fs.fs_state[index] = Dns.Fs_state.FS_up;
goods++;
if (goodcap==undefined) {
goodcap=cap;
fs.fs_default=index;
}
}
else
fs.fs_state[index] = Dns.Fs_state.FS_down;
}
}
],[
function () {
if (goodcap==undefined) stat=Status.STD_NOTFOUND;
if (goods==1) mode = Dns.Dns_mode.DNSMODE_ONECOPY;
if (goods==2) mode = Dns.Dns_mode.DNSMODE_TWOCOPY;
callback(stat,mode);
}
],
function (e) {
if (typeof e == 'number') callback(e,undefined); else {
Io.printstack(e,'Dns_server.get_def_fs');
callback(Status.STD_SYSERR,undefined);
}
})
};
/**
** The create, read, modify and utility functions needed
** for the Dns_server module.
**
** Note:
** After a directory is locked, any modification of this
** directory leads to a new AFS file object and a new
** directory capability!
** In one copy mode, the old cap will be destroyed, after
** the new one is committed and the i-node mapping was
** updated.
*/
/** Read the directory content from an AFS file. [BLOCKING]
*
*/
dns_server.prototype.read_dir_file = function (inode,callback) {
var self=this;
var stat,dir;
var fs_default = self.dns_super.dns_fs.fs_default;
var buf = Buf.Buffer();
Sch.ScheduleBlock([
function () {
assert((inode.i_size>0)||('Dns_srv.read_dir_file: inode.i_size is zero'));
Io.log((log<1)||('Dns_server.read_dir_file cap='+Net.Print.capability(inode.i_caps[fs_default])+' '+util.inspect(inode)));
self.afs.afs_read(inode.i_caps[fs_default],buf,0,inode.i_size, function (_stat) {
stat=_stat;
if (stat==Status.STD_OK) dir=Dns.buf_get_dir(buf); else dir=undefined;
})
},
function () {
callback(stat,dir);
}
],function (e) {
if (typeof e == 'number') callback(e,undefined); else {
Io.printstack(e,'Dns_server.read_dir_file');
callback(Status.STD_SYSERR,undefined);
}
});
};
/** Read a directory specified with his object number (index) number.
* Either the directory is currently cached, or the directory is read from an AFS file.
*
* @param {number} obj
* @param {function((Status.STD_OK|*), dns_dir)} callback
*/
dns_server.prototype.read_dir = function (obj,callback) {
var self=this;
var stat,dir,inode;
this.stats.op_read++;
var si=this.inode_of_obj(obj);
stat=si.stat;inode=si.inode;
Io.log((log<1)||('Dns_server.read_dir obj='+obj));
if (stat!=Status.STD_OK) callback(stat,undefined);
else Sch.ScheduleBlock([
function () {
dir=self.cache_data.lookup(inode.i_objnum);
if(dir==undefined) stat=Status.STD_NOTFOUND; else stat=Status.STD_OK;
},
function () {
if (stat==Status.STD_NOTFOUND) self.read_dir_file(inode,function (_stat,_dir) {
stat = _stat;
dir = _dir;
})
},
function () {
if (stat==Status.STD_OK) {
var tf=self.live_get(dir.dd_objnum);
dir.dd_live=tf.time;
}
callback(stat,dir);
}
],function (e) {
if (typeof e == 'number') callback(e,undefined); else {
Io.printstack(e,'Dns_server.read_dir');
callback(Status.STD_SYSERR,undefined);
}
});
};
/**
* Write an existing directory (only if modified).
*
* @param {dns_dir} dir
* @param {function(Status.STD_OK|*)} callback
*/
dns_server.prototype.modify_dir = function (dir,callback) {
var i;
var stat;
var self = this;
var oldcaps;
var cap = undefined;
var obj = dir.dd_objnum;
var inode,inode2,dirsize;
var fs = this.dns_super.dns_fs;
var fs_default=fs.fs_default;
var buf = Buf.Buffer();
var si=this.inode_of_obj(obj);
stat=si.stat;inode=si.inode;
Io.log((log<1)||('Dns_server.modify_dir dir='+util.inspect(dir)));
this.stats.op_modify++;
/*
** Distinguish these two cases:
** dd_state = DD_modified -> a new AFS object must be created
** dd_state = DD_unlocked -> commit the AFS object
*/
if (stat!=Status.STD_OK) callback(stat);
else
{
if (dir.dd_state==Dns.Dns_dir_state.DD_modified)
Sch.ScheduleBlock([
/*
** Create a new AFS object. If in two copy mode,
** the copy will be duplicated later.
** Destroy the old capabilities after this oepration
** succeeded.
*/
function () {
oldcaps = Array.map(inode.i_caps,function (cap) {return Net.Copy.capability(cap)});
dirsize=dir.size();
Dns.buf_put_dir(buf,dir);
self.afs.afs_create(fs.fs_cap[fs_default],buf,dirsize,Afs.Afs_commit_flag.AFS_SAFETY,function (_stat,_cap) {
stat=_stat;
cap=_cap;
})
},
function () {
if (stat!=Status.STD_OK) throw stat;
dir.dd_state=Dns.Dns_dir_state.DD_locked;
var caps=[Net.nilcap,Net.nilcap];
caps[fs_default]=cap;
inode2=Dns.Dns_inode(obj,caps,dirsize,Afs.Afs_file_state.FF_locked);
Buf.buf_init(buf);
Dns.buf_put_inode(buf,inode2);
/*
** Write the inode data through the cache to disk ...
*/
stat=self.cache_inode.cache_write(self.inode_cache_entry,buf,Dns.off_of_inode(obj),Dns.DNS_INODE_SIZE);
if (stat!=Status.STD_OK) throw stat;
i=0;
Sch.ScheduleLoop(function(index) {
i=index;
return index<2;
},[
/*
** Destroy the old caps.
*/
function () {
if(!Net.Equal.capability(oldcaps[i],Net.nilcap)) {
self.std.std_destroy(oldcaps[i],function (_stat) {
stat=_stat;
})
}
}
],[
function () {
stat=Status.STD_OK;
}
])
},
function () {
callback(stat)
}
],function (e) {
if (typeof e == 'number') callback(e); else {
Io.printstack(e,'Dns_server.modify_dir');
callback(Status.STD_SYSERR);
}
});
else // dir.dd_state = DD_unlocked
Sch.ScheduleBlock([
function () {
dirsize=self.dir_size(dir);
Dns.buf_put_dir(buf,dir);
self.afs.afs_modify(inode.i_caps[fs_default],buf,dirsize,0,Afs.Afs_commit_flag.AFS_SAFETY,function (_stat,_cap) {
stat=_stat;
cap=_cap;
})
},
function () {
if (stat!=Status.STD_OK) throw stat;
dir.dd_state=Dns.Dns_dir_state.DD_locked;
inode.i_size=dirsize;
inode.i_state=Afs.Afs_file_state.FF_locked;
Buf.buf_init(buf);
Dns.buf_put_inode(buf,inode);
stat=self.cache_inode.cache_write(self.inode_cache_entry,buf,Dns.off_of_inode(obj),Dns.DNS_INODE_SIZE);
},
function () {
callback(stat)
}
],function (e) {
if (typeof e == 'number') callback(e); else {
Io.printstack(e,'Dns_server.modify_dir');
callback(Status.STD_SYSERR);
}
});
}
};
/** Insert a new created directory into the DNS table.
*
* @param {dns_dir} dir
* @param {function((Status.STD_OK|*))} callback
*/
dns_server.prototype.create_dir = function (dir,callback) {
var stat;
var self = this;
var cap = undefined;
var obj = dir.dd_objnum;
var fs = this.dns_super.dns_fs;
var fs_default=fs.fs_default;
var buf = Buf.Buffer();
this.stats.op_create++;
Sch.ScheduleBlock([
function () {
/*
** Create a new AFS object. If in two copy mode,
** the copy will be duplicated later.
*/
self.afs.afs_create(fs.fs_cap[fs_default],buf,0,Afs.Afs_commit_flag.AFS_UNCOMMIT,function (_stat,_cap) {
stat=_stat;
cap=_cap;
})
},
function () {
if (stat!=Status.STD_OK) throw stat;
dir.dd_state=Dns.Dns_dir_state.DD_unlocked;
self.live_set(obj,Dns.DNS_MAX_LIVE,1);
/*
** First read the inode from disk to update
** the inode cache (reads/writes always full blocks!).
*/
stat=self.cache_inode.cache_read(self.inode_cache_entry,buf,Dns.off_of_inode(obj),Dns.DEF_INODE_SIZE);
if (stat!=Status.STD_OK) throw stat;
var fs_caps = [Net.nilcap,Net.nilcap];
fs_caps[fs_default]=cap;
var inode = Dns.Dns_inode(obj,fs_caps,0,Afs.Afs_file_state.FF_unlocked);
Buf.buf_init(buf);
Dns.buf_put_inode(buf,inode);
stat=self.cache_inode.cache_write(self.inode_cache_entry,buf,Dns.off_of_inode(obj),Dns.DEF_INODE_SIZE);
self.cache_data.add(obj,dir);
callback(stat);
}
],function (e) {
if (typeof e == 'number') callback(e); else {
Io.printstack(e,'Dns_server.create_dir');
callback(Status.STD_SYSERR);
}
})
};
/** Create a new directory. Return the directory structure and
** the status returned by the server create function. The super structure
** is already modified by this function. The new directory remains
** locked.
*
* @param colnames
* @param {function ((Status.STD_OK|*),(dns_dir|undefined))} callback
*/
dns_server.prototype.alloc_dir = function (colnames,callback) {
var self=this;
var sup=this.dns_super;
Sch.ScheduleBlock([
function () {
sup.lock();
},
function () {
var obj=self.get_freeobjnum();
var dir = Dns.Dns_dir(obj,colnames.length,0,colnames,Net.uniqport(),[],
Dns.Dns_dir_state.DD_unlocked,self.time(),Dns.DNS_MAX_LIVE);
assert(dir.try_lock());
sup.unlock();
self.create_dir(dir,function (_stat) {
if (_stat==Status.STD_OK) callback(_stat,dir);
else callback(_stat,undefined);
})
}
]);
};
/** Delete a directory. Destroy associated AFS objects.
*
* @param {dns_dir} dir
* @param {function(Status.STD_OK|*)} callback
*/
dns_server.prototype.delete_dir = function (dir,callback) {
var stat;
var i;
var self = this;
var cap = undefined;
var obj = dir.dd_objnum;
var fs = this.dns_super.dns_fs;
var fs_default=fs.fs_default;
var buf = Buf.Buffer();
var oldcaps;
/*
** Get the i-node mapping
*/
var inode;
this.stats.op_destroy++;
var si=this.inode_of_obj(obj);
stat=si.stat;inode=si.inode;
if (stat!=Status.STD_OK) callback(stat);
else {
self.live_set(obj,0,0);
oldcaps = Array.map(inode.i_caps,function (cap) {return Net.Copy.capability(cap)});
/*
** Destroy first the old caps
*/
i=0;
Sch.ScheduleLoop(function(index) {
i=index;
return index<2;
},[
/*
** Destroy the old caps.
*/
function () {
if(!Net.Equal.capability(oldcaps[i],Net.nilcap)) {
self.std.std_destroy(oldcaps[i],function (_stat) {
stat=_stat;
})
}
}
],[
function () {
stat=Status.STD_OK;
/*
** Now destroy ourself!
** Write the i-node data through the cache to disk ...
*/
inode.i_state=Afs_file_state.FF_invalid;
inode.i_size=0;
inode.i_caps=[Net.nilcap,Net.nilcap];
Dns.buf_put_inode(buf,inode);
stat=self.cache_inode.cache_write(self.inode_cache_entry,buf,Dns.off_of_inode(obj),Dns.DNS_INODE_SIZE);
/*
** Invalidate cache entry.
*/
self.cache_data.invalidate(inode.i_objnum);
callback(stat);
}
], function(e) {
if (typeof e == 'number') callback(e); else {
Io.printstack(e,'Dns_server.delete_dir');
callback(Status.STD_SYSERR);
}
})
}
};
dns_server.prototype.dir_modified = function (dir) {
if (dir.dd_state == Dns.Dns_dir_state.DD_locked)
dir.dd_state = Dns.Dns_dir_state.DD_modified;
};
/**
* Delete an i-node without destroying AFS objects.
*
* @param {number} obj
* @param {function(Status.STD_OK|*)} callback
*/
dns_server.prototype.delete_inode = function (obj,callback) {
var stat;
var self = this;
var buf = Buf.Buffer();
/*
** Get the inode mapping
*/
var inode;
this.stats.op_destroy++;
var si=this.inode_of_obj(obj);
stat=si.stat;inode=si.inode;
if (stat!=Status.STD_OK) callback(stat);
else {
/*
** Destroy ourself without destroying AFS objects!
** Write the i-node data through the cache to disk ...
*/
inode.i_state=Afs_file_state.FF_invalid;
inode.i_size=0;
inode.i_caps=[Net.nilcap,Net.nilcap];
Dns.buf_put_inode(buf,inode);
stat=self.cache_inode.cache_write(self.inode_cache_entry,buf,Dns.off_of_inode(obj),Dns.DNS_INODE_SIZE);
/*
** Invalidate cache entry.
*/
self.cache_data.invalidate(inode.i_objnum);
callback(stat);
}
};
/**
* Create generic server statistics informations.
*
* @returns {string}
*/
dns_server.prototype.stat = function () {
var self=this;
var stats,res;
stats=self.stats;
res = 'DNS server status\n';
res = res + 'Inode cache statistics:\n' +
(self.cache_inode.cache_stat()) +
'\nServer statistics\n\n'+
'Read: '+Printf.sprintf2([['%8d',stats.op_read]])+
' Modify: '+Printf.sprintf2([['%8d',stats.op_modify]])+
' Create: '+Printf.sprintf2([['%8d',stats.op_create]])+'\n'+
'Touch: '+Printf.sprintf2([['%8d',stats.op_touch]])+
' Age: '+Printf.sprintf2([['%8d',stats.op_age]])+
' Destroy:'+Printf.sprintf2([['%8d',stats.op_destroy]])+'\n';
return res;
};
/**
* Touch directory and AFS content table objects
*
* @param {dns_dir} dir
* @param {function(Status.STD_OK|*)} callback
*/
dns_server.prototype.touch = function (dir,callback) {
var self=this,
stat,
cap,inode,
i;
this.stats.op_touch++;
/*
** Keep object internally alive.
*/
dir.dd_live=Dns.DNS_MAX_LIVE;
self.live_set(dir.dd_objnum,Dns.DNS_MAX_LIVE,1);
/*
** Keep object(s) externally alive.
*/
var sci = self.cap_of_obj(dir.dd_objnum);
stat=sci.stat;inode=sci.inode;
i=0;
if (stat!=Status.STD_OK) callback(stat);
else Sch.ScheduleLoop(function(index) {
i=index;
return index < 2;
},[
function () {
cap=inode.i_caps[i];
if (!Net.Equal.capability(cap,Net.nilcap)) {
self.std.std_touch(cap,function (_stat) {
stat=_stat;
})
}
}
],[
function () {
callback(Status.STD_OK);
}
],function(e) {
if (typeof e == 'number') callback(e); else {
Io.printstack(e,'Dns_server.touch');
callback(Status.STD_SYSERR);
}
});
};
/** Age all objects (used and unused inodes). Destroy directories
** with live time equal zero (only valid files). Remember that
** the root dirctory (obj=1) can't be aged or deleted.
*
* @param {function(Status.STD_OK|*)} callback
*/
dns_server.prototype.age = function (callback) {
var self=this,
sup = this.dns_super,
stat=Status.STD_OK,
i=2,
lt,
dir,
gone=0,
aged=0,
scavenge=[];
this.stats.op_age++;
if (self.verbose) Io.out('[DNS] Aging ..');
for(i=2;i<sup.dns_ndirs;i++) {
lt = self.live_get(i);
if (lt.flag == 1 && lt.time > 1 ) {
self.live_set(i,lt.time-1,lt.flag);
aged++;
} else {
self.live_set(i,0,lt.flag);
}
if (lt.flag==1 && lt.time==0) scavenge.push(i);
}
if (scavenge.length) Sch.ScheduleLoop(function() {
return i < scavenge.length;
},[
function () {
dir=undefined;
self.acquire_dir(scavenge[i],function (_stat,_dir) {
stat=_stat;
dir=_dir;
});
},
function () {
if (stat==Status.STD_OK) {
self.delete_dir(dir,function (_stat) {
stat=_stat;
gone++;
})
} else if (stat!=Status.STD_NOTNOW) {
/*
** Maybe already deleted AFS object.
*/
self.delete_inode(scavenge[i],function (_stat) {
stat=_stat;
gone++;
})
}
},
function () {
i++;
if (dir!=undefined) self.release_dir(dir,function (_stat) {
stat=_stat;
});
}
],[
function () {
// sup.unlock();
if (self.verbose) Io.out('[DNS] '+aged+' aged, '+gone+' directories(s) deleted.');
else if (gone) Io.out('[DNS] '+gone+' directories(s) deleted.');
callback(Status.STD_OK);
}
],function(e) {
// sup.unlock();
if (typeof e == 'number') callback(e); else {
Io.printstack(e,'Dns_server.age');
callback(Status.STD_SYSERR);
}
});
else callback(stat);
};
/** Append a row to a directory.
*
* @param {dns_dir} dir
* @param {dns_row} row
*/
dns_server.prototype.append_row = function (dir,row) {
var self=this;
dir.dd_rows.push(row);
dir.dd_nrows++;
this.dir_modified(dir);
};
/** Append a row to a directory.
*
* @param {dns_dir} dir
* @param {string} oldname
* @param {string} newname
* @returns {(Status.STD_OK|*)}
*/
dns_server.prototype.rename_row = function (dir,oldname,newname) {
var self=this;
var row = Array.find(dir.dd_rows,function(_row) {
return String.equal(_row.dr_name,oldname);
});
if (row!=undefined) {
row.dr_name=newname;
self.dir_modified(dir);
return Status.STD_OK;
} else return Status.STD_NOTFOUND;
};
/** Delete a row of a directory.
*
* @param {dns_dir} dir
* @param {string} name
*/
dns_server.prototype.delete_row = function (dir,name) {
var self=this;
dir.dd_rows=Array.filter(dir.dd_rows,function (_row) {
return !(String.equal(_row.dr_name,name));
});
dir.dd_nrows=Array.length(dir.dd_rows);
this.dir_modified(dir);
};
/** Replace a row in a directory.
*
* @param {dns_dir} dir
* @param {string} name
* @param {capset} newcs
* @returns {(Status.STD_OK|*)}
*/
dns_server.prototype.replace_row = function (dir,name,newcs) {
var self=this;
var row = Array.find(dir.dd_rows,function(_row) {
return String.equal(_row.dr_name,oldname);
});
if (row!=undefined) {
row.dr_capset=newcs;
this.dir_modified(dir);
} else return Status.STD_NOTFOUND;
};
/** Search a row in a directory.
*
* @param {dns_dir} dir
* @param {string} name
* @returns {(dns_row|undefined)}
*/
dns_server.prototype.search_row = function (dir,name) {
var self=this;
var row = Array.find(dir.dd_rows,function(_row) {
return String.equal(_row.dr_name,name);
});
return row;
};
/**
* @returns {dns_super}
*/
dns_server.prototype.read_super = function () {
return this.dns_super;
};
/** Returns (used,lifetime) tuple. This functions first probes for an
** used i-node, and in the case of a used i-node was found, it ages the live time.
** If the lifetime reaches zero, the object must be destroyed.
** (by this module).
*
*
* @param {number} obj
* @param {function(number,number)} callback function(used,live)
* @returns {{used: boolean, live: number}}
*/
dns_server.prototype.age_obj = function (obj,callback) {
var used,live,dir;
this.stats.op_age++;
Sch.ScheduleBlock([
function () {
self.dns_super.lock();
},
function () {
var tf = self.live_get(obj);
if (tf.flag == 1 && tf.time>1) {
self.live_set(obj,tf.time-1,1);
used=true;live=tf.time-1;
} else if (tf.flag==1) {
self.live_set(obj,0,1);
used=true;live=0;
} else {
used=false;live=0;
}
self.dns_super.unlock();
callback (used,live);
}
]);
};
/**
* Flush the caches (if any).
*
* @returns {(Status.STD_OK|*)}
*/
dns_server.prototype.sync = function () {
var stat;
// TODO
return stat;
};
/**
* Exit the server.
*
* @returns {(Status.STD_OK|*)}
*/
dns_server.prototype.exit = function () {
Io.out('[DNS] Exit. Writing live table...');
return this.live_write();
};
/** Create the directory filesystem (one partition = UNIX file). [BLOCKING]
**
** Args:
** label: the filesystem label string [max 256 chars]
** ninodes: number of i-nodes ( = maximal number of directories)
** cols: Column name array (dns_colnames)
** colmasks: Column mask array (dns_generic_colmask)
** part_inode: Partition path and name
** fs_caps: AFS server(s). All directories are saved there. Up to
** two file servers can be specified. The first is the default.
**
** Return:
** status
** dns_super
*
*
* @param {string} label
* @param {number} ninodes
* @param {number} blocksize
* @param {string []} cols
* @param {number []} colmasks
* @param {string} part_inode
* @param {capability []} fs_caps
* @param {boolean} overwrite
* @param {function(Status.STD_OK|*)} callback
*/
dns_server.prototype.create_fs = function (label,ninodes,blocksize,cols,colmasks,part_inode,fs_caps,overwrite,callback) {
var self = this;
function create (callback) {
var i, n;
var stat = Status.STD_OK;
if (fs_caps==undefined || Array.empty(fs_caps) || Net.Equal.capability(fs_caps[0],Net.nilcap)) {
Io.out('[DNS] Cannot create DNS file system. No file server capability provided. Fatal.');
throw Status.STD_ARGBAD;
}
Io.out('[DNS] Creating DNS tree...');
Io.out('[DNS] Blocksize: ' + blocksize + ' [bytes]');
Io.out('[DNS] Number of total inodes (dirs): ' + ninodes);
/*
** First create a server port and derive the public port.
*/
var privport = Net.uniqport();
var pubport = Net.prv2pub(privport);
var checkfield = Net.uniqport();
var ncols = cols.length;
Io.out('[DNS] Private Port: ' + Net.Print.port(privport));
Io.out('[DNS] Public Port: ' + Net.Print.port(pubport));
Io.out('[DNS] Checkfield: ' + Net.Print.port(checkfield));
Io.out('[DNS] AFS server [1]: '+Net.Print.capability(fs_caps[0]) + ' (default)');
Io.out('[DNS] AFS server [2]: '+Net.Print.capability(fs_caps[1]));
self.fs_default=0;
if (!Io.exists(part_inode)) {
Io.out('[DNS] Creating directory partition ' + part_inode);
} else if (overwrite) {
Io.out('[DNS] Overwriting existing directory partition ' + part_inode);
} else {
Io.err('[DNS] Found existing directory partition ' + part_inode);
}
var part_fd = Io.open(part_inode, (overwrite ? 'w+' : 'r+'));
self.dns_part = part_inode;
self.dns_part_fd = part_fd;
/*
** The partition magic headers. After the magic string,
** the value 0xaa is written.
*/
var magic1 = Buf.Buffer();
Buf.buf_put_string(magic1, Dns.MAGIC_STR);
Buf.buf_pad(magic1, Dns.DEF_MAGIC_SIZE, 0xaa);
Io.out('[DNS] Writing partition magic header... ');
n = Buf.buf_write(part_fd, magic1);
if (n != Dns.DEF_MAGIC_SIZE) throw Status.STD_IOERR;
/*
** The disk super structure.
*/
var super1 = Buf.Buffer();
Buf.buf_put_string(super1, label);
Buf.buf_pad(super1, 256, 0xaa);
Buf.buf_put_int32(super1, ninodes);
Buf.buf_put_int32(super1, blocksize);
Buf.buf_put_port(super1, privport);
Buf.buf_put_port(super1, pubport);
Buf.buf_put_port(super1, checkfield);
Buf.buf_put_int32(super1, ncols);
for (i = 0; i < ncols; i++) {
Buf.buf_put_string(super1, cols[i]);
}
for (i = 0; i < ncols; i++) {
DnsInt.buf_put_rights(super1, colmasks[i]);
}
for (i=0;i<2;i++) {
Buf.buf_put_cap(super1,fs_caps[i]);
}
Io.out('[DNS] Done. ');
Io.out('[DNS] Writing super block ... ');
Buf.buf_pad(super1, Dns.DEF_BLOCK_SIZE - Dns.DEF_MAGIC_SIZE, 0xaa);
n = Buf.buf_write(part_fd, super1);
if (n != (Dns.DEF_BLOCK_SIZE - Dns.DEF_MAGIC_SIZE)) throw Status.STD_IOERR;
Io.out('[DNS] Done. ');
Io.out('[DNS] Writing i-nodes... ');
var buf = Buf.Buffer();
var inode = Dns.Dns_inode(0, [Net.nilcap, Net.nilcap], 0, Afs.Afs_file_state.FF_invalid);
for (i = 0; i < ninodes; i++) {
inode.i_objnum = i;
Buf.buf_init(buf);
Dns.buf_put_inode(buf, inode);
Buf.buf_pad(buf, Dns.DNS_INODE_SIZE);
n = Buf.buf_write(part_fd, buf);
if (n != Dns.DNS_INODE_SIZE) throw Status.STD_IOERR;
}
self.dns_super = Dns.Dns_super(label, blocksize, privport, pubport, checkfield, ncols, cols, colmasks,
Dns.Fs_server(fs_caps, [Dns.Fs_state.FS_unknown, Dns.Fs_state.FS_unknown],
0, Dns.Dns_mode.DNSMODE_ONECOPY));
Io.out('[DNS] Done. ');
/*
** The live time table. It's a fixed size bitfield table build with
** a string of sufficient size.
**
** Assumption: Maximale Live time value < 128, therefore
** 7 bit are used for each object. The MSB is
** the used flag (=1 -> inode used).
**
** The first entry (obj=0) is used for the lock status
** of the live table.
**
*/
Io.out('[DNS] Writing live table... ');
var live_size = ninodes + 1;
var live_table = Buf.Buffer();
var live_off = Dns.DEF_BLOCK_SIZE + (ninodes * Dns.DNS_INODE_SIZE);
function live_set(obj, time, flag) {
Buf.buf_set(live_table, obj, ((time & 0x7f) | ((flag << 7) & 0x80)));
}
function live_write() {
/*
** Unlock the live table
*/
live_set(0, 0, 1);
n = Buf.buf_write(part_fd, live_table, live_off);
if (n != live_size) throw Status.STD_IOERR;
}
for (i = 0; i <= ninodes; i++) {
live_set(i, Dns.DNS_MAX_LIVE, 0);
}
Buf.buf_pad(live_table, live_size);
live_write();
Io.out('[DNS] Done. ');
// w/o cache version, used ony to create the root directory...
function write_inode(obj, data, size) {
/*
** Read and write full blocks!
*/
var buf = Buf.Buffer();
var off = 512 + Dns.off_of_inode(obj);
var fileoff = div(off,blocksize)*blocksize;
var blockoff = off % blocksize;
var n = Buf.buf_read(self.dns_part_fd, buf, fileoff,blocksize);
if (n != blocksize)
return Status.STD_IOERR;
Buf.buf_blit(buf,blockoff,data,0,size);
n = Buf.buf_write(self.dns_part_fd, buf, fileoff, blocksize);
if (self.sync_write_mode) Io.sync(self.dns_part_fd);
if (n == blocksize)
return Status.STD_OK;
else
return Status.STD_IOERR;
}
var rootinode;
var rootcap;
function create_dir(dir,callback) {
var stat;
var cap = undefined;
var obj = dir.dd_objnum;
var fs = self.dns_super.dns_fs;
var fs_default=fs.fs_default;
var buf = Buf.Buffer();
self.stats.op_create++;
Sch.ScheduleBlock([
function () {
self.afs.afs_create(fs.fs_cap[fs_default],buf,0,Afs.Afs_commit_flag.AFS_UNCOMMIT,function (_stat,_cap) {
stat=_stat;
cap=_cap;
})
},
function () {
if (stat!=Status.STD_OK) throw stat;
dir.dd_state=Dns.Dns_dir_state.DD_unlocked;
var fs_caps = [Net.nilcap,Net.nilcap];
fs_caps[fs_default]=cap;
rootinode = Dns.Dns_inode(obj,fs_caps,0,Afs.Afs_file_state.FF_unlocked);
Buf.buf_init(buf);
Dns.buf_put_inode(buf,rootinode);
stat=write_inode(obj,buf,Dns.DNS_INODE_SIZE);
callback(stat);
}
],function (e) {
if (typeof e == 'number') callback(e); else callback(Status.STD_SYSERR);
})
}
function modify_dir(dir,callback) {
var stat;
var cap = undefined;
var obj = dir.dd_objnum;
var fs = self.dns_super.dns_fs;
var fs_default=fs.fs_default;
var dirsize = dir.size();
var buf = Buf.Buffer();
Dns.buf_put_dir(buf,dir);
self.stats.op_create++;
Sch.ScheduleBlock([
function () {
self.afs.afs_modify(rootinode.i_caps[fs_default],buf,dirsize,0,Afs.Afs_commit_flag.AFS_SAFETY,function (_stat,_cap) {
stat=_stat;
cap=_cap;
})
},
function () {
if (stat!=Status.STD_OK) throw stat;
dir.dd_state=Dns.Dns_dir_state.DD_locked;
rootinode.i_size=dirsize;
rootinode.i_state=Afs.Afs_file_state.FF_locked;
rootcap=Net.Capability(self.dns_super.dns_putport,
Net.prv_encode(rootinode.i_objnum,Rights.PRV_ALL_RIGHTS,dir.dd_random));
Buf.buf_init(buf);
Dns.buf_put_inode(buf,rootinode);
stat=write_inode(obj,buf,Dns.DNS_INODE_SIZE);
callback(stat);
}
],function (e) {
if (typeof e == 'number') callback(e); else callback(Status.STD_SYSERR);
})
}
/** Create the root directory (Object number 1) and return it and the status
** of the server create function. All pending writes are already done here.
**
** Note: the root directory can't be deleted. Therefore, it's not
** garbage collected.
*
*/
function create_root(callback) {
var stat;
var sup=self.dns_super;
self.stats.op_create++;
assert(sup.try_lock());
if (sup.dns_nextfree!=1) {
sup.unlock();
callback(Status.STD_EXISTS);
return;
}
sup.dns_nextfree++;
var rootdir = Dns.Dns_dir(1,sup.dns_ncols,0,sup.dns_colnames,Net.uniqport(),[],
Dns.Dns_dir_state.DD_unlocked,self.time(),Dns.DNS_MAX_LIVE);
rootdir.dd_lock.acquire(); // Non-blocking, we're the first one
sup.unlock();
Sch.ScheduleBlock([
function () {
create_dir(rootdir,function (_stat) {stat=_stat});
},
function () {
if (stat!=Status.STD_OK) {
throw stat;
}
modify_dir(rootdir,function (_stat) {
stat=_stat;
});
}, function () {
rootdir.dd_lock.release();
callback(stat,rootdir);
}
], function (e) {
if (rootdir!=undefined) rootdir.dd_lock.release();
if (typeof e == 'number') callback(e,undefined); else callback(Status.STD_SYSERR,undefined);
});
}
var dir = undefined;
Sch.ScheduleBlock([
function () {
Io.out('[DNS] Creating the root directory ... ');
create_root(function (_stat,_dir) {
stat = _stat;
dir = _dir;
})
},
function () {
if (stat == Status.STD_OK) {
Io.out('[DNS] Done.');
self.rootdir = dir;
}
else Io.out('[DNS] Creation of root directory failed: ' + Status.print(stat));
Io.close(part_fd);
self.dns_part_fd=undefined;
Io.out('[DNS] Finished.');
callback(stat);
}
])
}
try {
create (callback);
} catch (e) {
if (self.dns_part_fd) Io.close(self.dns_part_fd);
self.dns_part_fd=undefined;
if (typeof e == 'number') callback(e); else {
Io.printstack(e,'Dns_server.create_fs');
callback(Status.STD_IOERR);
}
throw Error(e);
}
};
/** Open the DNS system (one inode partition, UNIX file) [BLOCKING]
**
** part_inode: Directory Mapping Partition File
** cache: Cache parameters
*
*
* @param {string} part_inode
* @param {dns_cache_parameter} cache_params
* @param {function(Status.STD_OK|*)} callback
*/
dns_server.prototype.open_fs = function (part_inode,cache_params,callback) {
/**
*
* @type {dns_server}
*/
var self = this;
self.dns_super=Dns.Dns_super();
var sup;
function open(callback) {
var n, i,j;
self.dns_super=Dns.Dns_super();
sup = self.dns_super;
var stat = Status.STD_OK;
Io.out('[DNS] Opening DNS ...');
if (Io.exists(part_inode)) {
Io.out('[DNS] Using directory i-node partition ' + part_inode);
} else {
Io.out('[DNS] No existing directory i-node partition ' + part_inode);
throw Status.STD_IOERR;
}
self.dns_part = part_inode;
self.dns_part_fd = Io.open(part_inode, (self.iocache_bypass ? 'rs+' : 'r+'));
/*
** Either the filesystem is read only or we have an
** inconsistent filesystem. In that case, only read
** request are allowed.
*/
var readonly = false;
Io.out('[DNS] Reading the super block...');
var superbuf = Buf.Buffer();
n = Buf.buf_read(self.dns_part_fd, superbuf, 0, Dns.DEF_BLOCK_SIZE);
if (n != Dns.DEF_BLOCK_SIZE) {
Io.out('[DNS] Cannot read super block.');
Io.close(self.dns_part_fd);
throw Status.STD_IOERR;
}
var magic1 = Buf.buf_get_string(superbuf);
if (!String.equal(magic1, Dns.MAGIC_STR)) {
Io.out('[DNS] Invalid i-node partition magic found, got ' + magic1 + ', but exptected ' + Dns.MAGIC_STR);
throw Status.STD_IOERR;
} else {
Io.out('[DNS] Found i-node partition magic ' + magic1);
}
Buf.buf_set_pos(superbuf, Dns.DEF_MAGIC_SIZE);
sup.dns_name = Buf.buf_get_string(superbuf);
Buf.buf_set_pos(superbuf, 256 + Dns.DEF_MAGIC_SIZE);
sup.dns_ndirs = Buf.buf_get_int32(superbuf);
sup.dns_block_size = Buf.buf_get_int32(superbuf);
sup.dns_getport = Buf.buf_get_port(superbuf);
sup.dns_putport = Buf.buf_get_port(superbuf);
sup.dns_checkfield = Buf.buf_get_port(superbuf);
sup.dns_ncols = Buf.buf_get_int32(superbuf);
var cols=[];
var colmasks=[];
for(i=0;i<sup.dns_ncols;i++) {
cols.push(Buf.buf_get_string(superbuf));
}
for(i=0;i<sup.dns_ncols;i++) {
colmasks.push(DnsInt.buf_get_rights(superbuf));
}
var fs_caps=[];
for(i=0;i<2;i++) {
var cap=Buf.buf_get_cap(superbuf);
if (!Net.Equal.capability(cap,Net.nilcap)) Io.out('[DNS] Using AFS ' + Net.Print.capability(cap));
fs_caps.push(cap);
}
sup.dns_colnames=cols;
sup.dns_generic_colmask=colmasks;
sup.dns_fs=Dns.Fs_server(fs_caps, [Dns.Fs_state.FS_unknown, Dns.Fs_state.FS_unknown],
0, Dns.Dns_mode.DNSMODE_ONECOPY);
/*
** Defaulf file server and supported mode must be located later (get_def_fs)
*/
Io.out(' DNS: Label: '+sup.dns_name);
Io.out(' DNS: Maximal number of directories: '+sup.dns_ndirs);
Io.out(' DNS: Blocksize: '+sup.dns_block_size);
/*
** The livtime table. It's a fixed size bitfield table build with
** a string of sufficient size.
**
** Assumption: Maximale Live time value < 128, therefore
** 7 bit are used for each object. The MSB is
** the used flag (=1 -> inode used).
**
** The first entry (obj=0) is used for the lock status
** of the live table.
*/
var live_size = sup.dns_ndirs+1;
var live_table = Buf.Buffer();
var live_off = 512 + (sup.dns_ndirs*Dns.DNS_INODE_SIZE)
/**
*
* @param {number} obj
* @param {number} time
* @param {number} flag
*/
function live_set(obj, time, flag) {
Buf.buf_set(live_table, obj, ((time & 0x7f) | ((flag << 7) & 0x80)));
}
/**
*
* @param {number} obj
* @returns {{time: number, flag: number}}
*/
function live_get(obj) {
var v = Buf.buf_get(live_table, obj);
return {time: (v & 0x7f), flag: ((v & 0x80) >> 7)}
}
/**
*
* @returns {number}
*/
function live_read() {
var n = Buf.buf_read(self.dns_part_fd, live_table, live_off, live_size);
if (n != live_size) {
return Status.STD_IOERR;
}
var live = live_get(0);
if (live.time == 0 && live.flag == 1) {
/*
** Now lock the live table. After a server crash,
** the restarted server will found the lock and must
** discard the live table. All server objects got
** the maximal live time!
*/
live_set(0, 1, 1);
n = Buf.buf_write(self.dns_part_fd, live_table, live_off, 1);
if (n != 1) return Status.STD_IOERR;
else return Status.STD_OK;
} else return Status.STD_ARGBAD;
}
/**
*
* @returns {number}
*/
function live_write() {
/*
** Unlock the live table
*/
live_set(0, 0, 1);
n = Buf.buf_write(self.dns_part_fd, live_table, live_off);
if (n != live_size) return Status.STD_IOERR;
if (self.sync_write_mode) Io.sync(self.dns_part_fd);
return Status.STD_OK;
}
self.live_set = live_set;
self.live_get = live_get;
self.live_read = live_read;
self.live_write = live_write;
/*
** Read the live table
*/
Io.out('[DNS] Reading the live time table...');
stat = live_read();
if (stat == Status.STD_ARGBAD) {
Io.out('[DNS] Found locked live table: Reinitialize...');
for (i = 0; i < sup.dns_ndirs - 1; i++) {
live_set(i, Dns.DNS_MAX_LIVE, 0);
}
} else if (stat == Status.STD_IOERR) {
Io.out('[DNS] IO Error.');
Io.close(self.dns_part_fd);
throw Status.STD_IOERR;
}
Io.out('[DNS] Ok.');
stat=Status.STD_OK;
/**
** Raw disk Read and Write functions for the cache module.
**
** Units:
** addr: blocks
** size: bytes
**
*/
/**
*
* @param obj
* @param addr
* @param data
* @param size
* @returns {number}
*/
self.read_inode = function (obj, addr, data, size) {
var off = addr * sup.dns_block_size;
Io.log((log < 10) || ('read_inode obj=' + obj + ' addr=' + addr + ' size=' + size));
var n = Buf.buf_read(self.dns_part_fd, data, off, size);
if (n == size)
return Status.STD_OK;
else
return Status.STD_SYSERR;
};
/**
*
* @param obj
* @param addr
* @param data
* @param size
* @returns {number}
*/
self.write_inode = function (obj, addr, data, size) {
var off = addr * sup.dns_block_size;
Io.log((log < 10) || ('write_inode obj=' + obj + ' addr=' + addr + ' size=' + size));
var n = Buf.buf_write(self.dns_part_fd, data, off, size);
if (self.sync_write_mode) Io.sync(self.dns_part_fd);
if (n == size)
return Status.STD_OK;
else
return Status.STD_SYSERR;
};
self.sync_inode = function (obj) {
};
Io.out('[DNS] Creating inode cache ' + cache_params.c_inode_size + '[' + cache_params.c_inode_buffers + '] ... ');
/*
** Note: I-nodes are handled only on buffer block level
** #i-node=cache_params.c_inode_size/DEF_INODE_SIZE
*/
var cache_inode =
Fcache.Fcache(
'DNS Inode',
cache_params.c_inode_buffers,
Dns.DEF_BLOCK_SIZE,
cache_params.c_inode_size,
self.read_inode,
self.write_inode,
self.sync_inode,
Fcache.Fs_cache_mode.Cache_R);
self.cache_inode = cache_inode;
if (self.cache_inode == undefined) {
Io.out('[DNS] IO Error.');
Io.close(self.dns_part_fd);
throw Status.STD_IOERR;
}
/*
** The i-node cache object. One object for all i-nodes!
** Disk address = obj = 1 [blocks]
*/
var res = cache_inode.cache_lookup(1, 1, Dns.off_of_inode(sup.dns_ndirs), Afs.Afs_file_state.FF_unlocked);
var inode_fse = res.fse;
self.inode_cache_entry = inode_fse;
/*
** Some i-node utils
*/
self.inode_of_obj = function(obj) {
try {
var inode = undefined;
var buf = Buf.Buffer();
var stat = cache_inode.cache_read(inode_fse, buf, Dns.off_of_inode(obj), Dns.DNS_INODE_SIZE);
if (stat != Status.STD_OK) return {stat: stat, inode: undefined};
inode = Dns.buf_get_inode(buf);
return {stat: stat, inode: inode};
} catch (e) {
return {stat: Status.STD_SYSERR, inode: undefined};
}
};
/**
*
* @param {number} obj
* @returns {{stat:(Status.STD_OK|*),cap:(capability|undefined),inode:(dns_inode|undefined)}}
*/
self.cap_of_obj = function(obj) {
var stat;
var si = self.inode_of_obj(obj);
if (si.stat != Status.STD_OK) return {stat:stat,cap:undefined,inode:undefined};
var cap = si.inode.i_caps[self.fs_default];
if (si.inode.i_state == Afs.Afs_file_state.FF_locked ||
si.inode.i_state == Afs.Afs_file_state.FF_unlocked) stat=Status.STD_OK;
else stat=Status.STD_SYSERR;
return {stat:stat,cap:cap,inode:si.inode};
};
/**
*
* @param {dns_inode} inode
* @returns {Status.STD_OK|*}
*/
self.update_inode = function(inode) {
try {
var buf = Buf.Buffer();
Dns.buf_put_inode(buf, inode);
var stat = cache_inode.cache_write(inode_fse, buf, Dns.off_of_inode(inode.i_objnum),Dns.DEF_INODE_SIZE);
return stat;
} catch (e) {
return Status.STD_SYSERR;
}
};
var cache_data = Cache.Cache(cache_params.c_dir_buffers);
self.cache_data = cache_data;
if (cache_data == undefined) {
Io.out('[DNS] IO Error.');
Io.close(self.dns_part_fd);
throw Status.STD_IOERR;
}
/*
** Round up the value x to block_size
*/
function block(x) {
return Dns.ceil_block_bytes(x, sup.dns_block_size);
}
function to_block(x) {
return div(x, sup.dns_block_size);
}
function of_block(x) {
return (x * sup.dns_block_size);
}
self.block = block;
self.to_block = to_block;
self.of_block = of_block;
/*
** Read the i-node table.
** Build a list with free i-node object numbers below the
** nextfree boundary (above nextfree there are all
** free i-nodes, if any).
*/
Io.out('[DNS] reading the i-node table ...');
var freeino=[];
var firstfree=-1;
var nextfree=-1;
var nused=0;
var inodeb = Buf.Buffer();
for(i=1;i<sup.dns_ndirs;i++) {
stat = cache_inode.cache_read(inode_fse, inodeb, Dns.off_of_inode(i), Dns.DEF_INODE_SIZE);
if (stat != Status.STD_OK) {
Io.out('[DNS] Failed to read i-node ' + i + ': ' + Status.print(stat));
throw stat;
}
inodeb.pos = 0;
var inode = Dns.buf_get_inode(inodeb);
/*
** Some sanity checks first
*/
if (inode.i_objnum != i) {
Fs.closeSync(self.dns_part_fd);
Io.out('[DNS] got invalid i-node ' + i + ': ' + util.inspect(inode));
Io.out('[DNS] Abort.');
throw Status.STD_SYSERR;
}
if (inode.i_state == Afs_file_state.FF_invalid ||
inode.i_state == Afs_file_state.FF_unlocked) {
live_set(i, 0, 0);
if (nextfree != -1 && nextfree != (i - 1)) {
for (j = firstfree; j <= nextfree; j++) {
freeino.push(j);
}
firstfree = i;
nextfree = i;
} else {
nextfree = i;
if (firstfree == -1)
firstfree = i;
}
if (inode.i_state == Afs_file_state.FF_unlocked) {
Io.out('[DNS] Unlocked/uncommitted directory found. Destroy it: ' + inode.print());
inode.i_state = Afs_file_state.FF_invalid;
inodeb.pos = 0;
Dns.buf_put_inode(inodeb, inode);
stat = cache_inode.cache_write(inode_fse, inodeb, Dns.off_of_inode(i), Dns.DEF_INODE_SIZE);
if (stat != Status.STD_OK)
throw stat;
}
} else {
var tf = live_get(i);
live_set(i, tf.time, 1);
nused++;
}
}
Io.out('[DNS] Ok.');
if (nextfree != -1 && nextfree < (sup.dns_ndirs - 1)) {
/*
** There are only used i-nodes at the end of the i-node table.
*/
for (j = firstfree; j <= nextfree; j++) {
freeino.push(j);
}
nextfree = -1;
} else if (firstfree == 0 && nextfree == (sup.dns_ndirs - 1)) {
/*
** Empty filesystem.
*/
nextfree = 1;
} else if (firstfree > 0) {
/*
** There are free i-nodes at the end of the i-node table.
*/
nextfree = firstfree;
}
sup.dns_nused = nused;
sup.dns_freeobjnums = freeino;
sup.dns_nextfree = nextfree;
Io.out('[DNS] Found ' + sup.dns_nused + ' used Inode(s)');
Io.log((log < 0) || (self.dns_super.print()));
/*
** Read the root directory...
*/
self.acquire_dir(1,function (_stat,_dir) {
stat=_stat;
self.rootdir=_dir;
callback(stat);
});
}
try {
open(callback);
} catch (e) {
if (typeof e == 'number') callback(e); else {
Io.printstack(e,'Dns_server.open_fs');
callback(Status.STD_IOERR);
}
// throw Error(e);
}
};
/*
** ================
** PUBLIC INTERFACE
** ================
*/
var DnsRpc = Require('dos/dns_srv_rpc');
//afs_server.prototype=new AfsRpc.afs_server_rpc();
dns_server.prototype.dns_lookup=DnsRpc.dns_server_rpc.prototype.dns_lookup;
dns_server.prototype.dns_create=DnsRpc.dns_server_rpc.prototype.dns_create;
dns_server.prototype.dns_delete=DnsRpc.dns_server_rpc.prototype.dns_delete;
dns_server.prototype.dns_delete_dir=DnsRpc.dns_server_rpc.prototype.dns_delete_dir;
dns_server.prototype.dns_append=DnsRpc.dns_server_rpc.prototype.dns_append;
dns_server.prototype.dns_rename=DnsRpc.dns_server_rpc.prototype.dns_rename;
dns_server.prototype.dns_replace=DnsRpc.dns_server_rpc.prototype.dns_replace;
dns_server.prototype.dns_info=DnsRpc.dns_server_rpc.prototype.dns_info;
dns_server.prototype.dns_stat=DnsRpc.dns_server_rpc.prototype.dns_stat;
dns_server.prototype.dns_touch=DnsRpc.dns_server_rpc.prototype.dns_touch;
dns_server.prototype.dns_age=DnsRpc.dns_server_rpc.prototype.dns_age;
dns_server.prototype.dns_restrict=DnsRpc.dns_server_rpc.prototype.dns_restrict;
dns_server.prototype.dns_exit=DnsRpc.dns_server_rpc.prototype.dns_exit;
dns_server.prototype.dns_list=DnsRpc.dns_server_rpc.prototype.dns_list;
dns_server.prototype.dns_setlookup=DnsRpc.dns_server_rpc.prototype.dns_setlookup;
dns_server.prototype.dns_start_server=DnsRpc.dns_server_rpc.prototype.dns_start_server;
module.exports = {
/**
*
* @param rpc
* @returns {dns_server}
*/
Server: function(rpc,options) {
var obj = new dns_server(rpc,options);
Object.preventExtensions(obj);
return obj;
}
};