static void CompactifyDatafiles (TRI_document_collection_t* document,
TRI_vector_t const* compactions) {
TRI_datafile_t* compactor;
TRI_primary_collection_t* primary;
compaction_initial_context_t initial;
compaction_context_t context;
size_t i, j, n;
n = compactions->_length;
assert(n > 0);
initial = InitCompaction(document, compactions);
if (initial._failed) {
LOG_ERROR("could not create initialise compaction");
return;
}
LOG_TRACE("compactify called for collection '%llu' for %d datafiles of total size %llu",
(unsigned long long) document->base.base._info._cid,
(int) n,
(unsigned long long) initial._targetSize);
// now create a new compactor file
// we are re-using the _fid of the first original datafile!
compactor = CreateCompactor(document, initial._fid, initial._targetSize);
if (compactor == NULL) {
// some error occurred
LOG_ERROR("could not create compactor file");
return;
}
LOG_DEBUG("created new compactor file '%s'", compactor->getName(compactor));
memset(&context._dfi, 0, sizeof(TRI_doc_datafile_info_t));
// these attributes remain the same for all datafiles we collect
context._document = document;
context._compactor = compactor;
context._dfi._fid = compactor->_fid;
// now compact all datafiles
for (i = 0; i < n; ++i) {
compaction_info_t* compaction;
TRI_datafile_t* df;
bool ok;
compaction = TRI_AtVector(compactions, i);
df = compaction->_datafile;
LOG_DEBUG("compacting datafile '%s' into '%s', number: %d, keep deletions: %d",
df->getName(df),
compactor->getName(compactor),
(int) i,
(int) compaction->_keepDeletions);
// if this is the first datafile in the list of datafiles, we can also collect
// deletion markers
context._keepDeletions = compaction->_keepDeletions;
// run the actual compaction of a single datafile
ok = TRI_IterateDatafile(df, Compactifier, &context, false, false);
if (! ok) {
LOG_WARNING("failed to compact datafile '%s'", df->getName(df));
// compactor file does not need to be removed now. will be removed on next startup
// TODO: Remove
return;
}
} // next file
// locate the compactor
// must acquire a write-lock as we're about to change the datafiles vector
primary = &document->base;
TRI_WRITE_LOCK_DATAFILES_DOC_COLLECTION(primary);
if (! LocateDatafile(&primary->base._compactors, compactor->_fid, &j)) {
// not found
TRI_WRITE_UNLOCK_DATAFILES_DOC_COLLECTION(primary);
LOG_ERROR("logic error in CompactifyDatafiles: could not find compactor");
return;
}
if (! TRI_CloseCompactorPrimaryCollection(primary, j)) {
TRI_WRITE_UNLOCK_DATAFILES_DOC_COLLECTION(primary);
LOG_ERROR("could not close compactor file");
// TODO: how do we recover from this state?
return;
}
TRI_WRITE_UNLOCK_DATAFILES_DOC_COLLECTION(primary);
if (context._dfi._numberAlive == 0 &&
context._dfi._numberDead == 0 &&
context._dfi._numberDeletion == 0 &&
context._dfi._numberTransaction == 0) {
TRI_barrier_t* b;
if (n > 1) {
// create .dead files for all collected files
for (i = 0; i < n; ++i) {
compaction_info_t* compaction;
TRI_datafile_t* datafile;
compaction = TRI_AtVector(compactions, i);
datafile = compaction->_datafile;
if (datafile->isPhysical(datafile)) {
char* filename = TRI_Concatenate2String(datafile->getName(datafile), ".dead");
if (filename != NULL) {
TRI_WriteFile(filename, "", 0);
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
}
}
}
}
// compactor is fully empty. remove it
RemoveCompactor(document, compactor);
for (i = 0; i < n; ++i) {
compaction_info_t* compaction;
compaction = TRI_AtVector(compactions, i);
// datafile is also empty after compaction and thus useless
RemoveDatafile(document, compaction->_datafile);
// add a deletion marker to the result set container
b = TRI_CreateBarrierDropDatafile(&primary->_barrierList, compaction->_datafile, DropDatafileCallback, primary);
if (b == NULL) {
LOG_ERROR("out of memory when creating datafile-drop barrier");
}
}
}
else {
if (n > 1) {
// create .dead files for all collected files but the first
for (i = 1; i < n; ++i) {
compaction_info_t* compaction;
TRI_datafile_t* datafile;
compaction = TRI_AtVector(compactions, i);
datafile = compaction->_datafile;
if (datafile->isPhysical(datafile)) {
char* filename = TRI_Concatenate2String(datafile->getName(datafile), ".dead");
if (filename != NULL) {
TRI_WriteFile(filename, "", 0);
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
}
}
}
}
for (i = 0; i < n; ++i) {
TRI_barrier_t* b;
compaction_info_t* compaction;
compaction = TRI_AtVector(compactions, i);
if (i == 0) {
// add a rename marker
void* copy;
copy = TRI_Allocate(TRI_CORE_MEM_ZONE, sizeof(compaction_context_t), false);
memcpy(copy, &context, sizeof(compaction_context_t));
b = TRI_CreateBarrierRenameDatafile(&primary->_barrierList, compaction->_datafile, RenameDatafileCallback, copy);
if (b == NULL) {
LOG_ERROR("out of memory when creating datafile-rename barrier");
TRI_Free(TRI_CORE_MEM_ZONE, copy);
}
}
else {
// datafile is empty after compaction and thus useless
RemoveDatafile(document, compaction->_datafile);
// add a drop datafile marker
b = TRI_CreateBarrierDropDatafile(&primary->_barrierList, compaction->_datafile, DropDatafileCallback, primary);
if (b == NULL) {
LOG_ERROR("out of memory when creating datafile-drop barrier");
}
}
}
}
}
static bool CloseJournalPrimaryCollection (TRI_primary_collection_t* primary,
size_t position,
bool compactor) {
TRI_datafile_t* journal;
TRI_collection_t* collection;
TRI_vector_pointer_t* vector;
int res;
collection = &primary->base;
// either use a journal or a compactor
if (compactor) {
vector = &collection->_compactors;
}
else {
vector = &collection->_journals;
}
// no journal at this position
if (vector->_length <= position) {
TRI_set_errno(TRI_ERROR_ARANGO_NO_JOURNAL);
return false;
}
// seal and rename datafile
journal = vector->_buffer[position];
res = TRI_SealDatafile(journal);
if (res != TRI_ERROR_NO_ERROR) {
LOG_ERROR("failed to seal datafile '%s': %s", journal->getName(journal), TRI_last_error());
TRI_RemoveVectorPointer(vector, position);
TRI_PushBackVectorPointer(&collection->_datafiles, journal);
return false;
}
if (journal->isPhysical(journal)) {
// rename the file
char* dname;
char* filename;
char* number;
bool ok;
number = TRI_StringUInt64(journal->_fid);
dname = TRI_Concatenate3String("datafile-", number, ".db");
filename = TRI_Concatenate2File(collection->_directory, dname);
TRI_FreeString(TRI_CORE_MEM_ZONE, dname);
TRI_FreeString(TRI_CORE_MEM_ZONE, number);
ok = TRI_RenameDatafile(journal, filename);
if (! ok) {
LOG_ERROR("failed to rename datafile '%s' to '%s': %s", journal->getName(journal), filename, TRI_last_error());
TRI_RemoveVectorPointer(vector, position);
TRI_PushBackVectorPointer(&collection->_datafiles, journal);
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return false;
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
LOG_TRACE("closed journal '%s'", journal->getName(journal));
}
TRI_RemoveVectorPointer(vector, position);
TRI_PushBackVectorPointer(&collection->_datafiles, journal);
return true;
}
static void RenameDatafileCallback (TRI_datafile_t* datafile,
void* data) {
compaction_context_t* context;
TRI_datafile_t* compactor;
TRI_primary_collection_t* primary;
bool ok;
context = data;
compactor = context->_compactor;
primary = &context->_document->base;
ok = false;
assert(datafile->_fid == compactor->_fid);
if (datafile->isPhysical(datafile)) {
char* number;
char* jname;
char* tempFilename;
char* realName;
realName = TRI_DuplicateString(datafile->_filename);
// construct a suitable tempname
number = TRI_StringUInt64(datafile->_fid);
jname = TRI_Concatenate3String("temp-", number, ".db");
tempFilename = TRI_Concatenate2File(primary->base._directory, jname);
TRI_FreeString(TRI_CORE_MEM_ZONE, number);
TRI_FreeString(TRI_CORE_MEM_ZONE, jname);
if (! TRI_RenameDatafile(datafile, tempFilename)) {
LOG_ERROR("unable to rename datafile '%s' to '%s'", datafile->getName(datafile), tempFilename);
}
else {
if (! TRI_RenameDatafile(compactor, realName)) {
LOG_ERROR("unable to rename compaction file '%s' to '%s'", compactor->getName(compactor), realName);
}
else {
ok = true;
}
}
TRI_FreeString(TRI_CORE_MEM_ZONE, tempFilename);
TRI_FreeString(TRI_CORE_MEM_ZONE, realName);
}
else {
ok = true;
}
if (ok) {
TRI_doc_datafile_info_t* dfi;
size_t i;
// must acquire a write-lock as we're about to change the datafiles vector
TRI_WRITE_LOCK_DATAFILES_DOC_COLLECTION(primary);
if (! LocateDatafile(&primary->base._datafiles, datafile->_fid, &i)) {
TRI_WRITE_UNLOCK_DATAFILES_DOC_COLLECTION(primary);
LOG_ERROR("logic error: could not locate datafile");
return;
}
// put the compactor in place of the datafile
primary->base._datafiles._buffer[i] = compactor;
// update dfi
dfi = TRI_FindDatafileInfoPrimaryCollection(primary, compactor->_fid, false);
if (dfi != NULL) {
memcpy(dfi, &context->_dfi, sizeof(TRI_doc_datafile_info_t));
}
else {
LOG_ERROR("logic error: could not find compactor file information");
}
if (! LocateDatafile(&primary->base._compactors, compactor->_fid, &i)) {
TRI_WRITE_UNLOCK_DATAFILES_DOC_COLLECTION(primary);
LOG_ERROR("logic error: could not locate compactor");
return;
}
// remove the compactor from the list of compactors
TRI_RemoveVectorPointer(&primary->base._compactors, i);
TRI_WRITE_UNLOCK_DATAFILES_DOC_COLLECTION(primary);
DropDatafileCallback(datafile, primary);
}
TRI_Free(TRI_CORE_MEM_ZONE, context);
}
static bool CheckSyncDocumentCollection (TRI_document_collection_t* doc) {
TRI_collection_t* base;
TRI_datafile_t* journal;
bool ok;
bool worked;
char const* synced;
char* written;
size_t i;
size_t n;
worked = false;
base = &doc->base.base;
// .............................................................................
// the only thread MODIFYING the _journals variable is this thread,
// therefore no locking is required to access the _journals
// .............................................................................
n = base->_journals._length;
for (i = 0; i < n; ++i) {
journal = base->_journals._buffer[i];
// we only need to care about physical datafiles
if (! journal->isPhysical(journal)) {
// anonymous regions do not need to be synced
continue;
}
TRI_LOCK_JOURNAL_ENTRIES_DOC_COLLECTION(doc);
synced = journal->_synced;
written = journal->_written;
TRI_UNLOCK_JOURNAL_ENTRIES_DOC_COLLECTION(doc);
if (synced < written) {
worked = true;
ok = journal->sync(journal, synced, written);
TRI_LOCK_JOURNAL_ENTRIES_DOC_COLLECTION(doc);
if (ok) {
journal->_synced = written;
}
else {
journal->_state = TRI_DF_STATE_WRITE_ERROR;
}
TRI_BROADCAST_JOURNAL_ENTRIES_DOC_COLLECTION(doc);
TRI_UNLOCK_JOURNAL_ENTRIES_DOC_COLLECTION(doc);
if (ok) {
LOG_TRACE("msync succeeded %p, size %lu", synced, (unsigned long)(written - synced));
}
else {
LOG_ERROR("msync failed with: %s", TRI_last_error());
}
}
}
return worked;
}
static TRI_datafile_t* CreateJournal (TRI_primary_collection_t* primary, bool compactor) {
TRI_col_header_marker_t cm;
TRI_collection_t* collection;
TRI_datafile_t* journal;
TRI_df_marker_t* position;
int res;
char* filename;
collection = &primary->base;
if (collection->_info._isVolatile) {
// in-memory collection
filename = NULL;
}
else {
char* jname;
char* number;
// construct a suitable filename
number = TRI_StringUInt64(TRI_NewTickVocBase());
if (compactor) {
jname = TRI_Concatenate3String("journal-", number, ".db");
}
else {
jname = TRI_Concatenate3String("compactor-", number, ".db");
}
filename = TRI_Concatenate2File(collection->_directory, jname);
TRI_FreeString(TRI_CORE_MEM_ZONE, number);
TRI_FreeString(TRI_CORE_MEM_ZONE, jname);
}
// create journal file
journal = TRI_CreateDatafile(filename, collection->_info._maximalSize);
if (filename != NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
}
if (journal == NULL) {
if (TRI_errno() == TRI_ERROR_OUT_OF_MEMORY_MMAP) {
collection->_lastError = TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY_MMAP);
collection->_state = TRI_COL_STATE_READ;
}
else {
collection->_lastError = TRI_set_errno(TRI_ERROR_ARANGO_NO_JOURNAL);
collection->_state = TRI_COL_STATE_WRITE_ERROR;
}
return NULL;
}
LOG_TRACE("created a new primary journal '%s'", journal->getName(journal));
if (journal->isPhysical(journal)) {
char* jname;
char* number;
bool ok;
// and use the correct name
number = TRI_StringUInt64(journal->_fid);
if (compactor) {
jname = TRI_Concatenate3String("compactor-", number, ".db");
}
else {
jname = TRI_Concatenate3String("journal-", number, ".db");
}
filename = TRI_Concatenate2File(collection->_directory, jname);
TRI_FreeString(TRI_CORE_MEM_ZONE, number);
TRI_FreeString(TRI_CORE_MEM_ZONE, jname);
ok = TRI_RenameDatafile(journal, filename);
if (! ok) {
LOG_WARNING("failed to rename the journal to '%s': %s", filename, TRI_last_error());
}
else {
LOG_TRACE("renamed journal to '%s'", filename);
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
}
// create a collection header
res = TRI_ReserveElementDatafile(journal, sizeof(TRI_col_header_marker_t), &position);
if (res != TRI_ERROR_NO_ERROR) {
collection->_lastError = journal->_lastError;
LOG_ERROR("cannot create document header in journal '%s': %s", journal->getName(journal), TRI_last_error());
TRI_FreeDatafile(journal);
return NULL;
}
memset(&cm, 0, sizeof(cm));
cm.base._size = sizeof(TRI_col_header_marker_t);
cm.base._type = TRI_COL_MARKER_HEADER;
cm.base._tick = TRI_NewTickVocBase();
cm._cid = collection->_info._cid;
TRI_FillCrcMarkerDatafile(journal, &cm.base, sizeof(cm), 0, 0, 0, 0);
res = TRI_WriteElementDatafile(journal, position, &cm.base, sizeof(cm), 0, 0, 0, 0, true);
if (res != TRI_ERROR_NO_ERROR) {
collection->_lastError = journal->_lastError;
LOG_ERROR("cannot create document header in journal '%s': %s", journal->getName(journal), TRI_last_error());
TRI_FreeDatafile(journal);
return NULL;
}
// that's it
if (compactor) {
TRI_PushBackVectorPointer(&collection->_compactors, journal);
}
else {
TRI_PushBackVectorPointer(&collection->_journals, journal);
}
return journal;
}
static bool CheckJournalDocumentCollection (TRI_document_collection_t* doc) {
TRI_collection_t* base;
TRI_datafile_t* journal;
bool worked;
size_t i;
size_t n;
worked = false;
base = &doc->base.base;
if (base->_state != TRI_COL_STATE_WRITE) {
return false;
}
// .............................................................................
// the only thread MODIFYING the _journals variable is this thread,
// therefore no locking is required to access the _journals
// .............................................................................
TRI_LOCK_JOURNAL_ENTRIES_DOC_COLLECTION(doc);
n = base->_journals._length;
for (i = 0; i < n;) {
journal = base->_journals._buffer[i];
if (journal->_full) {
worked = true;
LOG_DEBUG("closing full journal '%s'", journal->getName(journal));
TRI_CloseJournalPrimaryCollection(&doc->base, i);
n = base->_journals._length;
i = 0;
}
else {
++i;
}
}
if (base->_journals._length == 0) {
journal = TRI_CreateJournalDocumentCollection(doc);
if (journal != NULL) {
worked = true;
LOG_DEBUG("created new journal '%s'", journal->getName(journal));
TRI_BROADCAST_JOURNAL_ENTRIES_DOC_COLLECTION(doc);
}
else {
// an error occurred when creating the journal file
LOG_ERROR("could not create journal file");
// we still must wake up the other thread from time to time, otherwise we'll deadlock
TRI_BROADCAST_JOURNAL_ENTRIES_DOC_COLLECTION(doc);
}
}
TRI_UNLOCK_JOURNAL_ENTRIES_DOC_COLLECTION(doc);
return worked;
}
static TRI_datafile_t* CreateJournal (TRI_primary_collection_t* primary,
TRI_voc_size_t maximalSize) {
TRI_col_header_marker_t cm;
TRI_collection_t* collection;
TRI_datafile_t* journal;
TRI_df_marker_t* position;
TRI_voc_fid_t fid;
int res;
collection = &primary->base;
fid = (TRI_voc_fid_t) TRI_NewTickServer();
if (collection->_info._isVolatile) {
// in-memory collection
journal = TRI_CreateDatafile(NULL, fid, maximalSize);
}
else {
char* jname;
char* number;
char* filename;
// construct a suitable filename (which is temporary at the beginning)
number = TRI_StringUInt64(fid);
jname = TRI_Concatenate3String("temp-", number, ".db");
filename = TRI_Concatenate2File(collection->_directory, jname);
TRI_FreeString(TRI_CORE_MEM_ZONE, number);
TRI_FreeString(TRI_CORE_MEM_ZONE, jname);
journal = TRI_CreateDatafile(filename, fid, maximalSize);
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
}
if (journal == NULL) {
if (TRI_errno() == TRI_ERROR_OUT_OF_MEMORY_MMAP) {
collection->_lastError = TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY_MMAP);
collection->_state = TRI_COL_STATE_READ;
}
else {
collection->_lastError = TRI_set_errno(TRI_ERROR_ARANGO_NO_JOURNAL);
collection->_state = TRI_COL_STATE_WRITE_ERROR;
}
return NULL;
}
LOG_TRACE("created new journal '%s'", journal->getName(journal));
// create a collection header, still in the temporary file
res = TRI_ReserveElementDatafile(journal, sizeof(TRI_col_header_marker_t), &position, maximalSize);
if (res != TRI_ERROR_NO_ERROR) {
collection->_lastError = journal->_lastError;
LOG_ERROR("cannot create document header in journal '%s': %s", journal->getName(journal), TRI_last_error());
TRI_FreeDatafile(journal);
return NULL;
}
TRI_InitMarker((char*) &cm, TRI_COL_MARKER_HEADER, sizeof(TRI_col_header_marker_t));
cm.base._tick = (TRI_voc_tick_t) fid;
cm._type = (TRI_col_type_t) collection->_info._type;
cm._cid = collection->_info._cid;
res = TRI_WriteCrcElementDatafile(journal, position, &cm.base, sizeof(cm), true);
if (res != TRI_ERROR_NO_ERROR) {
collection->_lastError = journal->_lastError;
LOG_ERROR("cannot create document header in journal '%s': %s", journal->getName(journal), TRI_last_error());
TRI_FreeDatafile(journal);
return NULL;
}
assert(fid == journal->_fid);
// if a physical file, we can rename it from the temporary name to the correct name
if (journal->isPhysical(journal)) {
char* jname;
char* number;
char* filename;
bool ok;
// and use the correct name
number = TRI_StringUInt64(journal->_fid);
jname = TRI_Concatenate3String("journal-", number, ".db");
filename = TRI_Concatenate2File(collection->_directory, jname);
TRI_FreeString(TRI_CORE_MEM_ZONE, number);
TRI_FreeString(TRI_CORE_MEM_ZONE, jname);
ok = TRI_RenameDatafile(journal, filename);
if (! ok) {
LOG_ERROR("failed to rename the journal to '%s': %s", filename, TRI_last_error());
TRI_FreeDatafile(journal);
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
return NULL;
}
else {
LOG_TRACE("renamed journal from %s to '%s'", journal->getName(journal), filename);
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
}
TRI_PushBackVectorPointer(&collection->_journals, journal);
return journal;
}
static TRI_datafile_t* CreateCompactor (TRI_primary_collection_t* primary,
TRI_voc_fid_t fid,
TRI_voc_size_t maximalSize) {
TRI_col_header_marker_t cm;
TRI_collection_t* collection;
TRI_datafile_t* journal;
TRI_df_marker_t* position;
int res;
collection = &primary->base;
if (collection->_info._isVolatile) {
// in-memory collection
journal = TRI_CreateDatafile(NULL, fid, maximalSize);
}
else {
char* jname;
char* number;
char* filename;
number = TRI_StringUInt64(fid);
jname = TRI_Concatenate3String("compaction-", number, ".db");
filename = TRI_Concatenate2File(collection->_directory, jname);
TRI_FreeString(TRI_CORE_MEM_ZONE, number);
TRI_FreeString(TRI_CORE_MEM_ZONE, jname);
if (TRI_ExistsFile(filename)) {
// remove any existing temporary file first
TRI_UnlinkFile(filename);
}
journal = TRI_CreateDatafile(filename, fid, maximalSize);
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
}
if (journal == NULL) {
if (TRI_errno() == TRI_ERROR_OUT_OF_MEMORY_MMAP) {
collection->_lastError = TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY_MMAP);
collection->_state = TRI_COL_STATE_READ;
}
else {
collection->_lastError = TRI_set_errno(TRI_ERROR_ARANGO_NO_JOURNAL);
collection->_state = TRI_COL_STATE_WRITE_ERROR;
}
return NULL;
}
LOG_TRACE("created new compactor '%s'", journal->getName(journal));
// create a collection header, still in the temporary file
res = TRI_ReserveElementDatafile(journal, sizeof(TRI_col_header_marker_t), &position, maximalSize);
if (res != TRI_ERROR_NO_ERROR) {
collection->_lastError = journal->_lastError;
LOG_ERROR("cannot create document header in compactor '%s': %s", journal->getName(journal), TRI_last_error());
TRI_FreeDatafile(journal);
return NULL;
}
TRI_InitMarker((char*) &cm, TRI_COL_MARKER_HEADER, sizeof(TRI_col_header_marker_t));
cm.base._tick = (TRI_voc_tick_t) fid;
cm._type = (TRI_col_type_t) collection->_info._type;
cm._cid = collection->_info._cid;
res = TRI_WriteCrcElementDatafile(journal, position, &cm.base, sizeof(cm), false);
if (res != TRI_ERROR_NO_ERROR) {
collection->_lastError = journal->_lastError;
LOG_ERROR("cannot create document header in compactor '%s': %s", journal->getName(journal), TRI_last_error());
TRI_FreeDatafile(journal);
return NULL;
}
assert(fid == journal->_fid);
return journal;
}
static bool CheckJournalDocumentCollection (TRI_document_collection_t* document) {
TRI_collection_t* base;
TRI_datafile_t* journal;
bool worked;
size_t i;
size_t n;
worked = false;
base = &document->base.base;
if (base->_state != TRI_COL_STATE_WRITE) {
return false;
}
// .............................................................................
// the only thread MODIFYING the _journals variable is this thread,
// therefore no locking is required to access the _journals
// .............................................................................
TRI_LOCK_JOURNAL_ENTRIES_DOC_COLLECTION(document);
n = base->_journals._length;
for (i = 0; i < n;) {
journal = static_cast<TRI_datafile_t*>(base->_journals._buffer[i]);
if (journal->_full) {
worked = true;
LOG_DEBUG("closing full journal '%s'", journal->getName(journal));
TRI_CloseJournalPrimaryCollection(&document->base, i);
n = base->_journals._length;
i = 0;
}
else {
++i;
}
}
// create a new journal if we do not have one, AND, if there was a request to create one
// (sometimes we don't need a journal, e.g. directly after db._create(collection); when
// the collection is still empty)
if (base->_journals._length == 0 &&
document->_requestedJournalSize > 0) {
TRI_voc_size_t targetSize = document->base.base._info._maximalSize;
if (document->_requestedJournalSize > 0 &&
document->_requestedJournalSize > targetSize) {
targetSize = document->_requestedJournalSize;
}
journal = TRI_CreateJournalDocumentCollection(document, targetSize);
if (journal != NULL) {
worked = true;
document->_requestedJournalSize = 0;
document->_rotateRequested = false;
LOG_DEBUG("created new journal '%s'", journal->getName(journal));
}
else {
// an error occurred when creating the journal file
LOG_ERROR("could not create journal file");
}
}
else if (document->_rotateRequested) {
// only a rotate was requested
document->_rotateRequested = false;
}
// always broadcast, otherwise other threads waiting for the broadcast might deadlock!
TRI_BROADCAST_JOURNAL_ENTRIES_DOC_COLLECTION(document);
TRI_UNLOCK_JOURNAL_ENTRIES_DOC_COLLECTION(document);
return worked;
}
static bool CreateJournal (TRI_shape_collection_t* collection) {
TRI_col_header_marker_t cm;
TRI_datafile_t* journal;
TRI_df_marker_t* position;
char* filename;
int res;
if (collection->base._info._isVolatile) {
// in memory collection
filename = NULL;
}
else {
char* jname;
char* number;
number = TRI_StringUInt32(TRI_NewTickVocBase());
if (! number) {
return false;
}
jname = TRI_Concatenate3String("journal-", number, ".db");
TRI_FreeString(TRI_CORE_MEM_ZONE, number);
filename = TRI_Concatenate2File(collection->base._directory, jname);
TRI_FreeString(TRI_CORE_MEM_ZONE, jname);
}
journal = TRI_CreateDatafile(filename, collection->base._info._maximalSize);
if (filename != NULL) {
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
}
// check that a journal was created
if (journal == NULL) {
if (TRI_errno() == TRI_ERROR_OUT_OF_MEMORY_MMAP) {
collection->base._lastError = TRI_set_errno(TRI_ERROR_OUT_OF_MEMORY_MMAP);
collection->base._state = TRI_COL_STATE_READ;
}
else {
collection->base._lastError = TRI_set_errno(TRI_ERROR_ARANGO_NO_JOURNAL);
collection->base._state = TRI_COL_STATE_WRITE_ERROR;
}
return false;
}
LOG_TRACE("created a new shape journal '%s'", journal->getName(journal));
if (journal->isPhysical(journal)) {
char* jname;
char* number;
bool ok;
// and use the correct name
number = TRI_StringUInt32(journal->_fid);
jname = TRI_Concatenate3String("journal-", number, ".db");
filename = TRI_Concatenate2File(collection->base._directory, jname);
TRI_FreeString(TRI_CORE_MEM_ZONE, number);
TRI_FreeString(TRI_CORE_MEM_ZONE, jname);
ok = TRI_RenameDatafile(journal, filename);
if (! ok) {
// TODO: remove disastrous call to exit() here
LOG_FATAL_AND_EXIT("failed to rename the journal to '%s': %s", filename, TRI_last_error());
}
else {
LOG_TRACE("renamed journal to '%s'", filename);
}
TRI_FreeString(TRI_CORE_MEM_ZONE, filename);
}
// create a collection header
res = TRI_ReserveElementDatafile(journal, sizeof(TRI_col_header_marker_t), &position);
if (res != TRI_ERROR_NO_ERROR) {
LOG_ERROR("cannot create document header in journal '%s': %s",
journal->getName(journal),
TRI_last_error());
TRI_FreeDatafile(journal);
return false;
}
// create a header
memset(&cm, 0, sizeof(cm));
cm.base._size = sizeof(TRI_col_header_marker_t);
cm.base._type = TRI_COL_MARKER_HEADER;
cm.base._tick = TRI_NewTickVocBase();
cm._cid = collection->base._info._cid;
TRI_FillCrcMarkerDatafile(journal, &cm.base, sizeof(cm), 0, 0, 0, 0);
// on journal creation, always use waitForSync = true
res = TRI_WriteElementDatafile(journal, position, &cm.base, sizeof(cm), 0, 0, 0, 0, true);
if (res != TRI_ERROR_NO_ERROR) {
LOG_ERROR("cannot create document header in journal '%s': %s",
journal->getName(journal),
TRI_last_error());
TRI_FreeDatafile(journal);
return false;
}
// that's it
TRI_PushBackVectorPointer(&collection->base._journals, journal);
return true;
}
