Raven Scott
01acfb766c
Implement comprehensive P2P domain conflict resolution allowing users to choose between local claim hashes and consensus-resolved hashes for domains where they have local claims but another claimant won consensus. Key features: - P2P Domain Conflicts UI tab in Local DNS section - Hash preference toggle (local vs resolved) with automatic client restart - Extended selector_cache.json to store hashPreferences alongside versionPreferences - DNS cache invalidation for immediate preference application - REST API endpoints for conflict detection and preference management - Automatic Holesail client restart when hash preferences change - Complete documentation updates across README, API docs, and glossary Resolves conflicts between local claims and consensus resolution by giving users control over which hash their domain resolves to, with seamless client management ensuring immediate effect.
280 lines
10 KiB
JavaScript
280 lines
10 KiB
JavaScript
const fs = require('fs').promises;
|
|
const dns = require('dns').promises;
|
|
const state = require('../../../infrastructure/state');
|
|
const { logError, logWarn, logInfo } = require('../../../infrastructure/logger');
|
|
const { saveSelectorCache } = require('../cache');
|
|
const { broadcast } = require('../websocket');
|
|
const { getConsensusState, getLocalClaimHash, getAllEntries } = require('../../../core/core');
|
|
const { getPersistentPublicKey } = require('../../../infrastructure/utils');
|
|
|
|
const localDnsFile = process.env.LOCAL_DNS_FILE || 'cache/local_dns.json';
|
|
|
|
async function handleLocalDnsRoutes(req, res) {
|
|
const urlPath = req.urlPath || new URL(req.url, `https://${req.headers.host}`).pathname;
|
|
const method = req.method;
|
|
|
|
if (method === 'GET' && urlPath === '/api/local-dns') {
|
|
try {
|
|
let records = state.localDnsRecords || [];
|
|
let conflicts = [];
|
|
const domains = new Set([...state.domainsWithBoth, ...state.versionPreferences.keys()]);
|
|
for (const domain of domains) {
|
|
let publicIP = state.publicIpForDomain[domain];
|
|
if (!publicIP && state.versionPreferences.has(domain)) {
|
|
try {
|
|
const ips = await dns.resolve4(domain);
|
|
publicIP = ips[0] || 'N/A';
|
|
state.publicIpForDomain[domain] = publicIP;
|
|
} catch (err) {
|
|
logWarn('Admin', `Failed to resolve public IP for ${domain}: ${err.message}`);
|
|
publicIP = 'N/A';
|
|
}
|
|
}
|
|
conflicts.push({
|
|
domain,
|
|
version: state.versionPreferences.get(domain) || 'p2p',
|
|
publicIP: publicIP || 'N/A'
|
|
});
|
|
}
|
|
records = records.map((rec, index) => ({ ...rec, index }));
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ records, conflicts }));
|
|
} catch (err) {
|
|
logError('Admin', `Failed to fetch local DNS and conflicts: ${err.message}`);
|
|
res.writeHead(500);
|
|
res.end(JSON.stringify({ error: 'Failed to fetch local DNS and conflicts' }));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (method === 'GET' && urlPath === '/api/selector-cache') {
|
|
try {
|
|
const preferences = Object.fromEntries(state.versionPreferences);
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify(preferences));
|
|
} catch (err) {
|
|
logError('Admin', `Failed to fetch selector cache: ${err.message}`);
|
|
res.writeHead(500);
|
|
res.end(JSON.stringify({ error: 'Failed to fetch selector cache' }));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (method === 'POST' && urlPath === '/api/add-local-dns') {
|
|
let body = '';
|
|
req.on('data', chunk => { body += chunk; });
|
|
req.on('end', async () => {
|
|
try {
|
|
const record = JSON.parse(body);
|
|
if (!record.name || !record.type || !record.ttl || isNaN(record.ttl)) {
|
|
throw new Error('Missing or invalid required fields: name, type, ttl');
|
|
}
|
|
record.class = record.class || 'IN';
|
|
let records = state.localDnsRecords || [];
|
|
records.push(record);
|
|
await fs.writeFile(localDnsFile, JSON.stringify(records, null, 2));
|
|
state.localDnsRecords = records;
|
|
broadcast({ type: 'update-local-dns' });
|
|
res.writeHead(200, { 'Content-Type': 'text/plain' });
|
|
res.end('OK');
|
|
} catch (err) {
|
|
logError('Admin', `Failed to add local DNS record: ${err.message}`);
|
|
res.writeHead(500);
|
|
res.end(err.message);
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
if (method === 'POST' && urlPath === '/api/update-local-dns') {
|
|
let body = '';
|
|
req.on('data', chunk => { body += chunk; });
|
|
req.on('end', async () => {
|
|
try {
|
|
const { index, record } = JSON.parse(body);
|
|
if (!record.name || !record.type || !record.ttl || isNaN(record.ttl)) {
|
|
throw new Error('Missing or invalid required fields: name, type, ttl');
|
|
}
|
|
let records = state.localDnsRecords || [];
|
|
if (index >= 0 && index < records.length) {
|
|
record.class = record.class || 'IN';
|
|
records[index] = record;
|
|
await fs.writeFile(localDnsFile, JSON.stringify(records, null, 2));
|
|
state.localDnsRecords = records;
|
|
broadcast({ type: 'update-local-dns' });
|
|
res.writeHead(200, { 'Content-Type': 'text/plain' });
|
|
res.end('OK');
|
|
} else {
|
|
res.writeHead(400);
|
|
res.end('Invalid index');
|
|
}
|
|
} catch (err) {
|
|
logError('Admin', `Failed to update local DNS record: ${err.message}`);
|
|
res.writeHead(500);
|
|
res.end(err.message);
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
if (method === 'POST' && urlPath === '/api/delete-local-dns') {
|
|
let body = '';
|
|
req.on('data', chunk => { body += chunk; });
|
|
req.on('end', async () => {
|
|
try {
|
|
const { index } = JSON.parse(body);
|
|
let records = state.localDnsRecords || [];
|
|
if (index >= 0 && index < records.length) {
|
|
records.splice(index, 1);
|
|
await fs.writeFile(localDnsFile, JSON.stringify(records, null, 2));
|
|
state.localDnsRecords = records;
|
|
broadcast({ type: 'update-local-dns' });
|
|
res.writeHead(200, { 'Content-Type': 'text/plain' });
|
|
res.end('OK');
|
|
} else {
|
|
res.writeHead(400);
|
|
res.end('Invalid index');
|
|
}
|
|
} catch (err) {
|
|
logError('Admin', `Failed to delete local DNS record: ${err.message}`);
|
|
res.writeHead(500);
|
|
res.end(err.message);
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
if (method === 'POST' && urlPath === '/api/update-version-preference') {
|
|
let body = '';
|
|
req.on('data', chunk => { body += chunk; });
|
|
req.on('end', async () => {
|
|
try {
|
|
const { domain, version } = JSON.parse(body);
|
|
if (version !== 'p2p' && version !== 'public') {
|
|
res.writeHead(400);
|
|
res.end('Invalid version, must be "p2p" or "public"');
|
|
return;
|
|
}
|
|
state.versionPreferences.set(domain, version);
|
|
await saveSelectorCache();
|
|
broadcast({ type: 'update-local-dns' });
|
|
logInfo('Admin', `Updated version preference for ${domain} to ${version}`);
|
|
res.writeHead(200, { 'Content-Type': 'text/plain' });
|
|
res.end('OK');
|
|
} catch (err) {
|
|
logError('Admin', `Failed to update version preference: ${err.message}`);
|
|
res.writeHead(500);
|
|
res.end(err.message);
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
if (method === 'GET' && urlPath === '/api/p2p-domain-conflicts') {
|
|
try {
|
|
const localWriter = getPersistentPublicKey();
|
|
if (!localWriter) {
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ conflicts: [] }));
|
|
return true;
|
|
}
|
|
|
|
const allEntries = await getAllEntries(state.dnsPass, false); // Don't use cache for fresh conflict detection
|
|
const domainClaimants = new Map();
|
|
|
|
// Collect all claimants for each domain
|
|
for (const entry of allEntries) {
|
|
if (entry.key.startsWith('claim:')) {
|
|
const parts = entry.key.split(':');
|
|
if (parts.length === 3) {
|
|
const domain = parts[1];
|
|
const claimant = parts[2];
|
|
if (!domainClaimants.has(domain)) domainClaimants.set(domain, new Set());
|
|
domainClaimants.get(domain).add(claimant);
|
|
}
|
|
}
|
|
}
|
|
|
|
const conflicts = [];
|
|
for (const [domain, claimants] of domainClaimants) {
|
|
// Check if user has a local claim
|
|
if (claimants.has(localWriter)) {
|
|
const consensusState = await getConsensusState(domain);
|
|
// Check if consensus is resolved but user is not the resolved claimant
|
|
if (consensusState.status === 'resolved' && consensusState.resolvedClaimant !== localWriter) {
|
|
const localHash = await getLocalClaimHash(domain, localWriter);
|
|
conflicts.push({
|
|
domain,
|
|
localHash,
|
|
resolvedHash: consensusState.hash,
|
|
resolvedClaimant: consensusState.resolvedClaimant,
|
|
localClaimant: localWriter,
|
|
consensusStatus: consensusState.status,
|
|
hashPreference: state.hashPreferences.get(domain) || 'resolved' // Default to resolved
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
res.writeHead(200, { 'Content-Type': 'application/json' });
|
|
res.end(JSON.stringify({ conflicts }));
|
|
} catch (err) {
|
|
logError('Admin', `Failed to fetch P2P domain conflicts: ${err.message}`);
|
|
res.writeHead(500);
|
|
res.end(JSON.stringify({ error: 'Failed to fetch P2P domain conflicts' }));
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (method === 'POST' && urlPath === '/api/update-hash-preference') {
|
|
let body = '';
|
|
req.on('data', chunk => { body += chunk; });
|
|
req.on('end', async () => {
|
|
try {
|
|
const { domain, preference } = JSON.parse(body);
|
|
if (preference !== 'local' && preference !== 'resolved') {
|
|
res.writeHead(400);
|
|
res.end('Invalid preference, must be "local" or "resolved"');
|
|
return;
|
|
}
|
|
state.hashPreferences.set(domain, preference);
|
|
await saveSelectorCache();
|
|
broadcast({ type: 'update-local-dns' });
|
|
logInfo('Admin', `Updated hash preference for ${domain} to ${preference}`);
|
|
res.writeHead(200, { 'Content-Type': 'text/plain' });
|
|
res.end('OK');
|
|
} catch (err) {
|
|
logError('Admin', `Failed to update hash preference: ${err.message}`);
|
|
res.writeHead(500);
|
|
res.end(err.message);
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
if (method === 'POST' && urlPath === '/api/clear-dns-cache') {
|
|
let body = '';
|
|
req.on('data', chunk => { body += chunk; });
|
|
req.on('end', async () => {
|
|
try {
|
|
const { domain } = JSON.parse(body);
|
|
const { clearDNSCacheForDomain } = require('../../../networking/dns');
|
|
clearDNSCacheForDomain(domain);
|
|
logInfo('Admin', `Cleared DNS cache for domain ${domain}`);
|
|
res.writeHead(200, { 'Content-Type': 'text/plain' });
|
|
res.end('OK');
|
|
} catch (err) {
|
|
logError('Admin', `Failed to clear DNS cache: ${err.message}`);
|
|
res.writeHead(500);
|
|
res.end(err.message);
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
module.exports = { handleLocalDnsRoutes };
|
|
|