483 lines
15 KiB
JavaScript
483 lines
15 KiB
JavaScript
'use strict';
|
|
|
|
var crypto = require('crypto');
|
|
var dns = require('dns');
|
|
var os = require('os');
|
|
var path = require('path');
|
|
|
|
var pathResolvers = {
|
|
'.': function fromCwd(relPath) {
|
|
return path.join(process.cwd(), relPath);
|
|
},
|
|
'~': function fromHomedir(relPath) {
|
|
if (!os.homedir) {
|
|
throw new Error(
|
|
'Resolving home directory relative paths is not supported in this version of node.'
|
|
);
|
|
}
|
|
return path.join(os.homedir(), relPath);
|
|
},
|
|
noop: function (p) { return p; }
|
|
}
|
|
|
|
module.exports.create = function (opts) {
|
|
// opts = { filepath };
|
|
// `opts.filepath` is a module id or path to a module that contains a store plugin or file
|
|
var pathFn = pathResolvers[opts.filepath[0]] || pathResolvers.noop;
|
|
var storeId = pathFn(opts.filepath);
|
|
var pathToStore = require.resolve(storeId);
|
|
|
|
var engine = { db: null };
|
|
|
|
function notDeleted(r) {
|
|
return !r.revokedAt && !r.deletedAt;
|
|
}
|
|
|
|
// instantiate the DB module
|
|
var db = (pathToStore.slice(-5) === '.json') ?
|
|
// JSON files should be loaded using our built in store.json.js
|
|
require('./store.json.js')(pathToStore) :
|
|
// everything else should be loaded as a module and passed our opts object
|
|
require(storeId)(opts);
|
|
|
|
// TODO: examine usage of engine.primaryNameservers to see if we are supporting it right
|
|
engine.primaryNameservers = db.primaryNameservers.list;
|
|
|
|
engine.peers = {
|
|
all: function (cb) {
|
|
var pNS = db.primaryNameservers.list();
|
|
|
|
function getRecord(ns, done) {
|
|
dns.resolve4(ns.name, function (err, addresses) {
|
|
console.log('ns addresses:');
|
|
console.log(addresses);
|
|
if (err) { console.error(err); done(); return; }
|
|
ns.type = 'A';
|
|
ns.address = addresses[0];
|
|
done();
|
|
});
|
|
}
|
|
|
|
// resolve addreses for all of the primary nameservers in parallel
|
|
pNS.forEach(function (ns) {
|
|
var status = { pending: true };
|
|
function done() {
|
|
status.pending = false;
|
|
// TODO: determine if the locally stored records should get updated
|
|
var incomplete = tasks.filter(function (s) { return s.pending; });
|
|
if (incomplete.length < 1) {
|
|
cb(null, pNS);
|
|
}
|
|
}
|
|
getRecord(ns, done);
|
|
return status;
|
|
});
|
|
}
|
|
};
|
|
|
|
engine.zones = {
|
|
_immutableKeys: [ 'id', 'name', 'primary', 'serial', 'revokedAt', 'changedAt', 'insertedAt', 'updatedAt', 'deletedAt' ]
|
|
, _mutableKeys: [ 'admin', 'expiration', 'minimum', 'refresh', 'retry', 'ttl', 'vanity' ]
|
|
, _dateToSerial: function (date) {
|
|
// conventionally the format is YYYYMMDDxx,
|
|
// but since it's an integer and I don't want to keep track of incrementing xx,
|
|
// epoch in seconds will do
|
|
return parseInt(Math.round(date/1000).toString().slice(-10), 10);
|
|
}
|
|
// NOTE/TODO: despite the _, _toSoa is used outside this file (in lib/digd.js and lib/httpd.js)
|
|
, _toSoa: function (domain) {
|
|
var nameservers = domain.vanityNs || engine.primaryNameservers().map(function (n) { return n.name; });
|
|
|
|
var index = Math.floor(Math.random() * nameservers.length) % nameservers.length;
|
|
var nameserver = nameservers[index];
|
|
return {
|
|
id: domain.id
|
|
, name: domain.name
|
|
, typeName: 'SOA'
|
|
, className: 'IN'
|
|
, ttl: domain.ttl || 60
|
|
|
|
// nameserver -- select an NS at random if they're all in sync
|
|
, primary: nameserver
|
|
, name_server: nameserver
|
|
|
|
// admin -- email address or domain for admin
|
|
// default is effectively admin@{domain name}
|
|
, admin: domain.admin || ('admin.' + domain.name)
|
|
, email_addr: domain.admin || ('admin.' + domain.name)
|
|
|
|
// serial -- the version, for cache-busting of secondary nameservers. suggested format: YYYYMMDDnn
|
|
, serial: domain.serial || engine.zones._dateToSerial(domain.updatedAt || domain.createdAt || Date.now())
|
|
, sn: domain.serial || engine.zones._dateToSerial(domain.updatedAt || domain.createdAt || Date.now())
|
|
|
|
// refresh -- only used when nameservers following the DNS NOTIFY spec talk
|
|
, refresh: domain.refresh || 1800
|
|
, ref: domain.refresh || 1800
|
|
|
|
// retry -- only used when nameservers following the DNS NOTIFY spec talk
|
|
, retry: domain.retry || 600
|
|
, ret: domain.retry || 600
|
|
|
|
// expiration -- how long other nameservers should continue when the primary goes down
|
|
, expiration: domain.expiration || 2419200 // 4 weeks
|
|
, ex: domain.expiration || 2419200 // 4 weeks
|
|
|
|
// minimum -- how long to cache a non-existent domain (also the default ttl for BIND)
|
|
, minimum: domain.minimum || 5
|
|
, nx: domain.minimum || 5
|
|
};
|
|
}
|
|
, all: function (cb) {
|
|
process.nextTick(function () {
|
|
cb(null, db.zones().filter(notDeleted));
|
|
});
|
|
}
|
|
, get: function (queries, cb) {
|
|
if (!Array.isArray(queries)) {
|
|
queries = queries.names.map(function (n) {
|
|
return { name: n };
|
|
});
|
|
}
|
|
var myDomains = db.zones().filter(function (d) {
|
|
return queries.some(function (q) {
|
|
return (d.name.toLowerCase() === q.name) && notDeleted(d);
|
|
});
|
|
});
|
|
process.nextTick(function () {
|
|
cb(null, myDomains);
|
|
});
|
|
}
|
|
, touch: function (zone, cb) {
|
|
db.zones.get(zone, function (err, existing) {
|
|
if (err || !existing) {
|
|
cb(err, null);
|
|
return;
|
|
}
|
|
existing.updatedAt = new Date().valueOf(); // toISOString();
|
|
console.log('touch saving...');
|
|
db.zone.update(existing, function (err) {
|
|
cb(err, !err && existing || null);
|
|
});
|
|
return;
|
|
});
|
|
}
|
|
, save: function (zone, cb) {
|
|
if (zone.id) {
|
|
console.log('update zone!');
|
|
engine.zones.update(zone, cb);
|
|
} else {
|
|
engine.zones.create(zone, cb);
|
|
}
|
|
}
|
|
, update: function (zone, cb) {
|
|
db.zones.get({ id: zone.id }, function (err, found) {
|
|
var dirty;
|
|
|
|
if (err) {
|
|
console.log('error finding zone');
|
|
cb(new Error("Error finding zone for '" + zone.id + "'"), null);
|
|
return;
|
|
}
|
|
|
|
if (!found) {
|
|
console.log('no existing zone');
|
|
cb(new Error("zone for '" + zone.id + "' does not exist"), null);
|
|
return;
|
|
}
|
|
|
|
console.log('found existing zone');
|
|
console.log(found);
|
|
console.log(zone);
|
|
Object.keys(zone).forEach(function (key) {
|
|
if (-1 !== engine.zones._immutableKeys.indexOf(key)) { return; }
|
|
if (found[key] !== zone[key]) {
|
|
dirty = true;
|
|
console.log('existing key', key, found[key], zone[key]);
|
|
found[key] = zone[key];
|
|
}
|
|
});
|
|
|
|
found.updatedAt = new Date().valueOf(); // toISOString(); // Math.round(Date.now() / 1000);
|
|
if (dirty) {
|
|
found.changedAt = found.updatedAt;
|
|
}
|
|
|
|
console.log('saving...');
|
|
db.zones.update(found, function (err) {
|
|
cb(err, !err && found || null);
|
|
});
|
|
});
|
|
}
|
|
, create: function (zone, cb) {
|
|
var zoneName = (zone.name||'').toLowerCase();
|
|
db.zones.get({ name: zoneName }, function (err, found) {
|
|
if (err) {
|
|
console.error(err);
|
|
cb(new Error("error attempting to create new zone '" + zoneName + "'"));
|
|
return;
|
|
}
|
|
if (found) {
|
|
cb(new Error("tried to create new zone, but '" + found.name + "' already exists"));
|
|
return;
|
|
}
|
|
|
|
var newZone = {
|
|
id: crypto.randomBytes(16).toString('hex'),
|
|
name: zoneName
|
|
};
|
|
var nss = [];
|
|
|
|
newZone.createdAt = Date.now();
|
|
newZone.updatedAt = newZone.createdAt;
|
|
|
|
/*
|
|
Set only the mutable keys in the new zone from the proposed zone object
|
|
*/
|
|
Object.keys(zone).forEach(function (key) {
|
|
//if (-1 !== engine.zones._immutableKeys.indexOf(key)) { return; }
|
|
if (-1 === engine.zones._mutableKeys.indexOf(key)) { return; }
|
|
newZone[key] = zone[key];
|
|
});
|
|
|
|
// TODO create NS and A records for normal and vanity nameservers
|
|
if (zone.vanity) {
|
|
newZone.vanity = true;
|
|
} else {
|
|
newZone.vanity = false;
|
|
}
|
|
|
|
// TODO: distinguish between primary and secondary zones
|
|
// TODO: determine if we need to do anything special for delegation
|
|
|
|
// create records for the primary nameservers (or vanity name servers)
|
|
db.primaryNameservers.list().forEach(function (ns, i) {
|
|
var nsx = 'ns' + (i + 1);
|
|
var nsZone;
|
|
var ttl = 43200; // 12h // TODO pick a well-reasoned number
|
|
var now = Date.now();
|
|
|
|
if (zone.vanity) {
|
|
nsZone = nsx + '.' + newZone.name;
|
|
} else {
|
|
nsZone = ns.name;
|
|
}
|
|
|
|
// NS example.com ns1.example.com 43200
|
|
nss.push({
|
|
id: crypto.randomBytes(16).toString('hex')
|
|
, createdAt: Date.now()
|
|
, updatedAt: Date.now()
|
|
, changedAt: Date.now()
|
|
, zone: newZone.name
|
|
, soa: true
|
|
, type: 'NS'
|
|
, data: nsZone
|
|
, name: newZone.name
|
|
, ttl: ttl
|
|
});
|
|
// A ns1.example.com 127.0.0.1 43200
|
|
nss.push({
|
|
id: crypto.randomBytes(16).toString('hex')
|
|
, createdAt: now
|
|
, updatedAt: now
|
|
, changedAt: now
|
|
, zone: newZone.name
|
|
, soa: true
|
|
, type: ns.type
|
|
, name: nsZone
|
|
, address: ns.address
|
|
, ttl: 43200 // 12h // TODO pick a good number
|
|
});
|
|
});
|
|
|
|
db.zones.create(newZone, function (err) {
|
|
// WIP: going to need to figure out how to manage this as a transaction
|
|
// Significant benefit to having records owned by the zone is we won't have
|
|
// records for zones that don't otherwise exist - at least at the engine level.
|
|
|
|
// every line below this one is not yet modified...
|
|
});
|
|
nss.forEach(function (ns) {
|
|
db.records.push(ns);
|
|
});
|
|
|
|
console.log('[zone] [create] saving...');
|
|
db.save(function (err) {
|
|
cb(err, !err && newZone || null);
|
|
});
|
|
}
|
|
, destroy: function (zoneId, cb) {
|
|
var zone;
|
|
var records;
|
|
var now = Date.now();
|
|
|
|
db.zones.filter(notDeleted).some(function (z) {
|
|
if (zoneId === z.id) {
|
|
zone = z;
|
|
z.deletedAt = now;
|
|
return true;
|
|
}
|
|
});
|
|
|
|
if (!zone) {
|
|
process.nextTick(function () {
|
|
cb(null, null);
|
|
});
|
|
return;
|
|
}
|
|
|
|
records = [];
|
|
db.records.filter(notDeleted).forEach(function (r) {
|
|
if (zone.name === r.zone) {
|
|
r.deletedAt = now;
|
|
records.push(r);
|
|
}
|
|
});
|
|
|
|
console.log('[zone] [destroy] saving...');
|
|
db.save(function (err) {
|
|
zone.records = records;
|
|
cb(err, !err && zone || null);
|
|
});
|
|
}
|
|
};
|
|
engine.records = {
|
|
all: function (cb) {
|
|
process.nextTick(function () {
|
|
cb(null, db.records.slice(0).filter(notDeleted));
|
|
});
|
|
}
|
|
, one: function (id, cb) {
|
|
var myRecord;
|
|
db.records.slice(0).some(function (r) {
|
|
if (id && id === r.id) {
|
|
if (notDeleted(r)) {
|
|
myRecord = r;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
});
|
|
process.nextTick(function () {
|
|
cb(null, myRecord);
|
|
});
|
|
}
|
|
, get: function (query, cb) {
|
|
var myRecords = db.records.slice(0).filter(function (r) {
|
|
|
|
if ('string' !== typeof r.name) {
|
|
return false;
|
|
}
|
|
|
|
// TODO use IN in masterquest (or implement OR)
|
|
// Only return single-level wildcard?
|
|
if (query.name === r.name || ('*.' + query.name.split('.').slice(1).join('.')) === r.name) {
|
|
if (notDeleted(r)) {
|
|
return true;
|
|
}
|
|
}
|
|
});
|
|
process.nextTick(function () {
|
|
cb(null, myRecords);
|
|
});
|
|
}
|
|
, save: function (record, cb) {
|
|
function touchZone(err, r) {
|
|
if (err) { cb(err); }
|
|
if (!r) { cb(null, null); }
|
|
engine.zones.touch({ name: r.zone }, cb);
|
|
}
|
|
|
|
if (record.id) {
|
|
console.log('update record!');
|
|
engine.records.update(record, touchZone);
|
|
} else {
|
|
engine.records.create(record, touchZone);
|
|
}
|
|
}
|
|
, update: function (record, cb) {
|
|
var existing;
|
|
var dirty;
|
|
|
|
db.records.some(function (r) {
|
|
if (r.id === record.id) {
|
|
existing = r;
|
|
return true;
|
|
}
|
|
});
|
|
|
|
if (!existing) {
|
|
console.log('no existing record');
|
|
cb(new Error("record for '" + record.id + "' does not exist"), null);
|
|
return;
|
|
}
|
|
|
|
console.log('found existing record');
|
|
console.log(existing);
|
|
console.log(record);
|
|
Object.keys(record).forEach(function (key) {
|
|
var keys = [ 'name', 'id', 'zone', 'revokedAt', 'changedAt', 'insertedAt', 'updatedAt', 'deletedAt' ];
|
|
if (-1 !== keys.indexOf(key)) { return; }
|
|
if (existing[key] !== record[key]) {
|
|
dirty = true;
|
|
console.log(existing[key], record[key]);
|
|
existing[key] = record[key];
|
|
}
|
|
});
|
|
|
|
record.updatedAt = new Date().valueOf(); // toISOString(); // Math.round(Date.now() / 1000);
|
|
if (dirty) {
|
|
record.changedAt = record.updatedAt;
|
|
}
|
|
|
|
console.log('saving...');
|
|
db.save(function (err) {
|
|
cb(err, !err && existing || null);
|
|
});
|
|
}
|
|
, create: function (record, cb) {
|
|
var obj = { id: crypto.randomBytes(16).toString('hex') };
|
|
console.log('found existing record');
|
|
console.log(record);
|
|
//var keys = [ 'name', 'id', 'zone', 'revokedAt', 'changedAt', 'insertedAt', 'updatedAt', 'deletedAt' ];
|
|
//var okeys = [ 'name', 'zone', 'admin', 'data', 'expiration', 'minimum', 'serial', 'retry', 'refresh', 'ttl', 'type' ]; // primary
|
|
var okeys = [ 'name', 'zone', 'type', 'data', 'class', 'ttl', 'address'
|
|
, 'exchange', 'priority', 'port', 'value', 'tag', 'flag', 'aname' ];
|
|
okeys.forEach(function (key) {
|
|
if ('undefined' !== typeof record[key]) {
|
|
obj[key] = record[key];
|
|
}
|
|
});
|
|
|
|
record.updatedAt = new Date().valueOf(); // toISOString(); // Math.round(Date.now() / 1000);
|
|
//record.changedAt = record.updatedAt;
|
|
record.insertedAt = record.updatedAt;
|
|
record.createdAt = record.updatedAt;
|
|
|
|
console.log('saving new...');
|
|
db.records.push(record);
|
|
db.save(function (err) {
|
|
cb(err, record);
|
|
});
|
|
}
|
|
, destroy: function (id, cb) {
|
|
var record;
|
|
db.records.some(function (r/*, i*/) {
|
|
if (id === r.id) {
|
|
record = r;
|
|
r.deletedAt = Date.now();
|
|
//record = db.records.splice(i, 1);
|
|
return true;
|
|
}
|
|
});
|
|
process.nextTick(function () {
|
|
db.save(function (err) {
|
|
cb(err, record);
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
return engine;
|
|
};
|