Method openFiles

fdbserver/DiskQueue.actor.cpp:539–594

	}

	ACTOR static Future<Void> openFiles(RawDiskQueue_TwoFiles* self) {
		state std::vector<Future<Reference<IAsyncFile>>> fs;
		fs.reserve(2);
		for (int i = 0; i < 2; i++)
			fs.push_back(IAsyncFileSystem::filesystem()->open(self->filename(i),
			                                                  IAsyncFile::OPEN_READWRITE | IAsyncFile::OPEN_UNCACHED |
			                                                      IAsyncFile::OPEN_UNBUFFERED | IAsyncFile::OPEN_LOCK,
			                                                  0));
		wait(waitForAllReady(fs));

		// Treatment of errors here is important.  If only one of the two files is present
		// (due to a power failure during creation or deletion, or administrative error) we don't want to
		// open the queue!

		if (!fs[0].isError() && !fs[1].isError()) {
			// Both files were opened OK: success
		} else if (fs[0].isError() && fs[0].getError().code() == error_code_file_not_found && fs[1].isError() &&
		           fs[1].getError().code() == error_code_file_not_found) {
			// Neither file was found: we can create a new queue
			// OPEN_ATOMIC_WRITE_AND_CREATE defers creation (using a .part file) until the calls to sync() below
			TraceEvent("DiskQueueCreate").detail("File0", self->filename(0));
			for (int i = 0; i < 2; i++)
				fs[i] = IAsyncFileSystem::filesystem()->open(
				    self->filename(i),
				    IAsyncFile::OPEN_ATOMIC_WRITE_AND_CREATE | IAsyncFile::OPEN_CREATE | IAsyncFile::OPEN_READWRITE |
				        IAsyncFile::OPEN_UNCACHED | IAsyncFile::OPEN_UNBUFFERED | IAsyncFile::OPEN_LOCK,
				    0600);

			// Any error here is fatal
			wait(waitForAll(fs));

			// sync on each file to actually create it will be done below
		} else {
			// One file had a more serious error or one file is present and the other is not.  Die.
			if (!fs[0].isError() || (fs[1].isError() && fs[1].getError().code() != error_code_file_not_found))
				throw fs[1].getError();
			else
				throw fs[0].getError();
		}

		// fsync both files.  This is necessary to trigger atomic file creation in the creation case above.
		// It also permits the recovery code to assume that whatever it reads is durable.  Otherwise a prior
		// process could have written (but not synchronized) data to the file which we will read but which
		// might not survive a reboot.  The recovery code assumes otherwise and could corrupt the disk.
		std::vector<Future<Void>> syncs;
		syncs.reserve(fs.size());
		for (int i = 0; i < fs.size(); i++)
			syncs.push_back(fs[i].get()->sync());
		wait(waitForAll(syncs));

		// Successfully opened or created; fill in self->files[]
		for (int i = 0; i < 2; i++)
			self->files[i].setFile(fs[i].get());

		return Void();
	}

	ACTOR static void shutdown(RawDiskQueue_TwoFiles* self, bool deleteFiles) {