void
bytearray_output_stream_init(u8* array, u32 size, output_stream* out_stream)
{
bytearray_output_stream_init_ex(array, size, out_stream, 0);
}
ya_result
zdb_icmtl_replay(zdb_zone *zone)
{
ya_result return_value;
u32 serial;
zdb_zone_double_lock(zone, ZDB_ZONE_MUTEX_SIMPLEREADER, ZDB_ZONE_MUTEX_LOAD);
return_value = zdb_zone_getserial(zone, &serial); // zone is locked
if(FAIL(return_value))
{
zdb_zone_double_unlock(zone, ZDB_ZONE_MUTEX_SIMPLEREADER, ZDB_ZONE_MUTEX_LOAD);
log_err("journal: %{dnsname}: error reading serial for zone: %r", zone->origin, return_value);
return return_value;
}
input_stream is;
#if ICMTL_DUMP_JOURNAL_RECORDS
log_debug("journal: zdb_icmtl_replay(%{dnsname})", zone->origin);
logger_flush();
#endif
u32 first_serial;
u32 last_serial;
if(FAIL(return_value = zdb_zone_journal_get_serial_range(zone, &first_serial, &last_serial)))
{
zdb_zone_double_unlock(zone, ZDB_ZONE_MUTEX_SIMPLEREADER, ZDB_ZONE_MUTEX_LOAD);
if(return_value == ZDB_ERROR_ICMTL_NOTFOUND)
{
return_value = SUCCESS;
}
else
{
log_err("journal: %{dnsname}: error opening journal for zone: %r", zone->origin, return_value);
}
return return_value;
}
log_debug("journal: %{dnsname}: zone serial is %i, journal covers serials from %i to %i", zone->origin, serial, first_serial, last_serial);
if(last_serial == serial)
{
zdb_zone_double_unlock(zone, ZDB_ZONE_MUTEX_SIMPLEREADER, ZDB_ZONE_MUTEX_LOAD);
log_debug("journal: %{dnsname}: nothing to read from the journal", zone->origin);
return 0;
}
if(serial_lt(serial, first_serial))
{
zdb_zone_double_unlock(zone, ZDB_ZONE_MUTEX_SIMPLEREADER, ZDB_ZONE_MUTEX_LOAD);
log_warn("journal: %{dnsname}: first serial from the journal is after the zone", zone->origin);
// should invalidate the journal
zdb_zone_journal_delete(zone);
return 0;
}
if(serial_gt(serial, last_serial))
{
zdb_zone_double_unlock(zone, ZDB_ZONE_MUTEX_SIMPLEREADER, ZDB_ZONE_MUTEX_LOAD);
log_warn("journal: %{dnsname}: last serial from the journal is before the zone", zone->origin);
// should invalidate the journal
zdb_zone_journal_delete(zone);
return 0;
}
if(FAIL(return_value = zdb_zone_journal_get_ixfr_stream_at_serial(zone, serial, &is, NULL)))
{
zdb_zone_double_unlock(zone, ZDB_ZONE_MUTEX_SIMPLEREADER, ZDB_ZONE_MUTEX_LOAD);
log_err("journal: %{dnsname}: error reading journal from serial %d: %r",zone->origin, serial, return_value);
return return_value;
}
log_info("journal: %{dnsname}: replaying from serial %u",zone->origin, serial);
buffer_input_stream_init(&is, &is, ZDB_ICMTL_REPLAY_BUFFER_SIZE);
u16 shutdown_test_countdown = ZDB_ICMTL_REPLAY_SHUTDOWN_POLL_PERIOD;
u32 current_serial = serial;
/*
* Read all records from [ SOA ... SOA ... [ SOA in memory
*/
output_stream baos;
input_stream bais;
dns_resource_record rr;
int baos_rr_count = 0;
int baos_soa_count = 0;
bool was_nsec3 = zdb_zone_is_nsec3(zone);
bytearray_output_stream_init_ex(&baos, NULL, ZDB_ICMTL_REPLAY_BUFFER_SIZE, BYTEARRAY_DYNAMIC);
dns_resource_record_init(&rr);
// 0: gather, 1: commit, 2: commit & stop
for(int replay_state = ZDB_ICMTL_REPLAY_GATHER; replay_state != ZDB_ICMTL_REPLAY_COMMIT_AND_STOP;)
{
// ensure it's not supposed to shutdown (every few iterations)
if(--shutdown_test_countdown <= 0)
{
if(dnscore_shuttingdown())
{
return_value = STOPPED_BY_APPLICATION_SHUTDOWN;
break;
}
shutdown_test_countdown = ZDB_ICMTL_REPLAY_SHUTDOWN_POLL_PERIOD;
}
// read the next record
if((return_value = dns_resource_record_read(&rr, &is)) <= 0)
{
if(ISOK(return_value))
{
log_info("journal: %{dnsname}: reached the end of the journal file", zone->origin);
replay_state = ZDB_ICMTL_REPLAY_COMMIT_AND_STOP;
}
else
{
log_err("journal: broken journal: %r", return_value);
logger_flush(); // broken journal (flush is slow, but this is bad, so : keep it)
replay_state = ZDB_ICMTL_REPLAY_STOP;
}
}
else // first record must be an SOA (or it's wrong)
if(baos_rr_count == 0) // first record ?
{
if(rr.tctr.qtype != TYPE_SOA) // must be SOA
{
// expected an SOA
return_value = ERROR;
break;
}
++baos_soa_count; // 0 -> 1 // this is not mandatory but clearer to read
}
else // the page ends with an SOA or end of stream
if(rr.tctr.qtype == TYPE_SOA)
{
if(baos_soa_count == 2)
{
// this record is the start of the next stream, keep it for the next iteration
replay_state = ZDB_ICMTL_REPLAY_COMMIT;
}
++baos_soa_count;
}
++baos_rr_count;
if((replay_state & ZDB_ICMTL_REPLAY_COMMIT) != 0)
{
log_info("journal: %{dnsname}: committing changes", zone->origin);
u64 ts_start = timeus();
zdb_zone_exchange_locks(zone, ZDB_ZONE_MUTEX_SIMPLEREADER, ZDB_ZONE_MUTEX_LOAD);
bytearray_input_stream_init_const(&bais, bytearray_output_stream_buffer(&baos), bytearray_output_stream_size(&baos));
return_value = zdb_icmtl_replay_commit(zone, &bais, ¤t_serial);
zdb_zone_exchange_locks(zone, ZDB_ZONE_MUTEX_LOAD, ZDB_ZONE_MUTEX_SIMPLEREADER);
input_stream_close(&bais);
u64 ts_stop = timeus();
if(ts_stop < ts_start) // time change
{
ts_stop = ts_start;
}
u64 ts_delta = ts_stop - ts_start;
if(ISOK(return_value))
{
if(ts_delta < 1000)
{
log_info("journal: %{dnsname}: committed changes (%lluus)", zone->origin, ts_delta);
}
else if(ts_delta < 1000000)
{
double ts_delta_s = ts_delta;
ts_delta_s /= 1000.0;
log_info("journal: %{dnsname}: committed changes (%5.2fms)", zone->origin, ts_delta_s);
}
else
{
double ts_delta_s = ts_delta;
ts_delta_s /= 1000000.0;
log_info("journal: %{dnsname}: committed changes (%5.2fs)", zone->origin, ts_delta_s);
}
}
else
{
log_err("journal: %{dnsname}: failed to committed changes", zone->origin);
break;
}
// the current page has been processed
if(replay_state == ZDB_ICMTL_REPLAY_COMMIT_AND_STOP)
{
// no more page to read
break;
}
// reset the state for the next page
// note: the next written record will be the last read SOA
baos_rr_count = 1;
baos_soa_count = 1;
replay_state = ZDB_ICMTL_REPLAY_GATHER;
bytearray_output_stream_reset(&baos);
} // end if replay_state is ZDB_ICMTL_REPLAY_COMMIT (mask)
dns_resource_record_write(&rr, &baos);
}
input_stream_close(&is);
output_stream_close(&baos);
dns_resource_record_clear(&rr);
// cleanup destroyed nsec3 chains
if(ISOK(return_value))
{
bool is_nsec3 = zdb_zone_is_nsec3(zone);
if(is_nsec3 && !was_nsec3)
{
// the chain has just been created, but is probably missing internal links
log_debug("journal: %{dnsname}: zone switched to NSEC3 by reading the journal: updating links", zone->origin);
zdb_zone_exchange_locks(zone, ZDB_ZONE_MUTEX_SIMPLEREADER, ZDB_ZONE_MUTEX_LOAD);
nsec3_zone_update_chain0_links(zone);
zdb_zone_exchange_locks(zone, ZDB_ZONE_MUTEX_LOAD, ZDB_ZONE_MUTEX_SIMPLEREADER);
log_debug("journal: %{dnsname}: zone switched to NSEC3 by reading the journal: links updated", zone->origin);
}
if(FAIL(return_value = zdb_zone_getserial(zone, &serial))) // zone is locked
{
zdb_zone_double_unlock(zone, ZDB_ZONE_MUTEX_SIMPLEREADER, ZDB_ZONE_MUTEX_LOAD);
log_err("journal: %{dnsname}: error reading confirmation serial for zone: %r",zone->origin, return_value);
return return_value;
}
if(serial != last_serial)
{
log_warn("journal: %{dnsname}: expected serial to be %i but it is %i instead",zone->origin, last_serial, serial);
}
#if 0 // ICMTL_DUMP_JOURNAL_RECORDS
if(is_nsec)
{
nsec_logdump_tree(zone);
logger_flush();
}
#endif
}
zdb_zone_double_unlock(zone, ZDB_ZONE_MUTEX_SIMPLEREADER, ZDB_ZONE_MUTEX_LOAD);
log_info("journal: %{dnsname}: done", zone->origin);
return return_value;
}
