request.cc

nandflash文件系统源代码

	// Meta server <-> Chunk server ops
	gParseHandlers["HELLO"] = parseHandlerHello;

	gParseHandlers["PING"] = parseHandlerPing;
	gParseHandlers["UPSERVERS"] = parseHandlerUpServers;
	gParseHandlers["TOGGLE_WORM"] = parseHandlerToggleWORM;
	gParseHandlers["STATS"] = parseHandlerStats;
	gParseHandlers["DUMP_CHUNKTOSERVERMAP"] = parseHandlerDumpChunkToServerMap;
	gParseHandlers["OPEN_FILES"] = parseHandlerOpenFiles;
}

/*!
 * \brief request queue initialization
 */
void
KFS::initialize_request_handlers()
{
	setup_handlers();
}

/*!
 * \brief remove successive requests for the queue and carry them out.
 */
void
KFS::process_request()
{
	MetaRequest *r = requestList.dequeue();
	map <MetaOp, ReqHandler>::iterator h = handler.find(r->op);
	if (h == handler.end())
		r->status = -ENOSYS;
	else
		((*h).second)(r);

	if (!r->suspended) {
		UpdateCounter(r->op);
		oplog.add_pending(r);
	}
}

/*!
 * \brief add a new request to the queue
 * \param[in] r the request
 */
void
KFS::submit_request(MetaRequest *r)
{
	requestList.enqueue(r);
}

/*!
 * \brief print out the leaf nodes for debugging
 */
void
KFS::printleaves()
{
	metatree.printleaves();
}

/*!
 * \brief log lookup request (nop)
 */
int
MetaLookup::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log lookup path request (nop)
 */
int
MetaLookupPath::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log a file create
 */
int
MetaCreate::log(ofstream &file) const
{
	// use the log entry time as a proxy for when the file was created
	struct timeval t;
	gettimeofday(&t, NULL);

	file << "create/dir/" << dir << "/name/" << name <<
		"/id/" << fid << "/numReplicas/" << (int) numReplicas << 
		"/ctime/" << showtime(t) << '\n';
	return file.fail() ? -EIO : 0;
}

/*!
 * \brief log a directory create
 */
int
MetaMkdir::log(ofstream &file) const
{
	struct timeval t;
	gettimeofday(&t, NULL);

	file << "mkdir/dir/" << dir << "/name/" << name <<
		"/id/" << fid << "/ctime/" << showtime(t) << '\n';
	return file.fail() ? -EIO : 0;
}

/*!
 * \brief log a file deletion
 */
int
MetaRemove::log(ofstream &file) const
{
	file << "remove/dir/" << dir << "/name/" << name << '\n';
	return file.fail() ? -EIO : 0;
}

/*!
 * \brief log a directory deletion
 */
int
MetaRmdir::log(ofstream &file) const
{
	file << "rmdir/dir/" << dir << "/name/" << name << '\n';
	return file.fail() ? -EIO : 0;
}

/*!
 * \brief log directory read (nop)
 */
int
MetaReaddir::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log directory read (nop)
 */
int
MetaReaddirPlus::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log getalloc (nop)
 */
int
MetaGetalloc::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log getlayout (nop)
 */
int
MetaGetlayout::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log getdirsummary (nop)
 */
int
MetaGetDirSummary::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log a chunk allocation
 */
int
MetaAllocate::log(ofstream &file) const
{
	// use the log entry time as a proxy for when the block was created/file
	// was modified
	struct timeval t;
	gettimeofday(&t, NULL);

	file << "allocate/file/" << fid << "/offset/" << offset
	     << "/chunkId/" << chunkId
	     << "/chunkVersion/" << chunkVersion 
	     << "/mtime/" << showtime(t) << '\n';
	return file.fail() ? -EIO : 0;
}

/*!
 * \brief log a file truncation
 */
int
MetaTruncate::log(ofstream &file) const
{
	// use the log entry time as a proxy for when the file was modified
	struct timeval t;
	gettimeofday(&t, NULL);

	file << "truncate/file/" << fid << "/offset/" << offset 
	     << "/mtime/" << showtime(t) << '\n';
	return file.fail() ? -EIO : 0;
}

/*!
 * \brief log a rename
 */
int
MetaRename::log(ofstream &file) const
{
	file << "rename/dir/" << dir << "/old/" <<
		oldname << "/new/" << newname << '\n';
	return file.fail() ? -EIO : 0;
}

/*!
 * \brief Log a chunk-version-increment change to disk.
*/
int
MetaChangeChunkVersionInc::log(ofstream &file) const
{
	file << "chunkVersionInc/" << cvi << '\n';
	return file.fail() ? -EIO : 0;
}

/*!
 * \brief log change file replication (nop)
 */
int
MetaChangeFileReplication::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log retire chunkserver (nop)
 */
int
MetaRetireChunkserver::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log toggling of chunkserver rebalancing state (nop)
 */
int
MetaToggleRebalancing::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log toggling of metaserver WORM state (nop)
 */
int
MetaToggleWORM::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log execution of rebalance plan (nop)
 */
int
MetaExecuteRebalancePlan::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief close log and open a new one
 */
int
MetaLogRollover::log(ofstream &file) const
{
	return oplog.finishLog();
}

/*!
 * \brief for a chunkserver hello, there is nothing to log
 */
int
MetaHello::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief for a chunkserver's death, there is nothing to log
 */
int
MetaBye::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief for a chunkserver allocate, there is nothing to log
 */
int
MetaChunkAllocate::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log a chunk delete; (nop)
 */
int
MetaChunkDelete::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log a chunk truncation; (nop)
 */
int
MetaChunkTruncate::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log a heartbeat to a chunk server; (nop)
 */
int
MetaChunkHeartbeat::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log a stale notify to a chunk server; (nop)
 */
int
MetaChunkStaleNotify::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief log a chunk server retire; (nop)
 */
int
MetaChunkRetire::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief when a chunkserver tells us of a corrupted chunk, there is nothing to log
 */
int
MetaChunkCorrupt::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief When notifying a chunkserver of a version # change, there is
 * nothing to log.
 */
int
MetaChunkVersChange::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief When asking a chunkserver to replicate a chunk, there is
 * nothing to log.
 */
int
MetaChunkReplicate::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief When asking a chunkserver for a chunk's size, there is
 * nothing to log.
 */
int
MetaChunkSize::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief for a ping, there is nothing to log
 */
int
MetaPing::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief for a request of upserver, there is nothing to log
 */
int
MetaUpServers::log(ofstream &file) const
{
    return 0;
}

/*!
 * \brief for a stats request, there is nothing to log
 */
int
MetaStats::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief for a map dump request, there is nothing to log
 */
int
MetaDumpChunkToServerMap::log(ofstream &file) const
{
	return 0;
}


/*!
 * \brief for an open files request, there is nothing to log
 */
int
MetaOpenFiles::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief for a lease acquire request, there is nothing to log
 */
int
MetaLeaseAcquire::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief for a lease renew request, there is nothing to log
 */
int
MetaLeaseRenew::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief for a lease renew relinquish, there is nothing to log
 */
int
MetaLeaseRelinquish::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief for a lease cleanup request, there is nothing to log
 */
int
MetaLeaseCleanup::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief This is an internally generated op.  There is
 * nothing to log.
 */
int
MetaChunkReplicationCheck::log(ofstream &file) const
{
	return 0;
}

/*!
 * \brief parse a command sent by a client
 *
 * Commands are of the form:
 * <COMMAND NAME> \r\n
 * {header: value \r\n}+\r\n
 *
 * The general model in parsing the client command:
 * 1. Each command has its own parser
 * 2. Extract out the command name and find the parser for that
 * command
 * 3. Dump the header/value pairs into a properties object, so that we
 * can extract the header/value fields in any order.
 * 4. Finally, call the parser for the command sent by the client.
 *
 * @param[in] cmdBuf: buffer containing the request sent by the client
 * @param[in] cmdLen: length of cmdBuf
 * @param[out] res: A piece of memory allocated by calling new that
 * contains the data for the request.  It is the caller's
 * responsibility to delete the memory returned in res.
 * @retval 0 on success;  -1 if there is an error
 */
int
KFS::ParseCommand(char *cmdBuf, int cmdLen, MetaRequest **res)
{
	const char *delims = " \r\n";
	// header/value pairs are separated by a :
	const char separator = ':';
	string cmdStr;
	string::size_type cmdEnd;
	Properties prop;
	istringstream ist(cmdBuf);
	ParseHandlerMapIter entry;
	ParseHandler handler;

	// get the first line and find the command name
	ist >> cmdStr;
	// trim the command
	cmdEnd = cmdStr.find_first_of(delims);
	if (cmdEnd != cmdStr.npos) {
		cmdStr.erase(cmdEnd);
	}

	// find the parse handler and parse the thing
	entry = gParseHandlers.find(cmdStr);
	if (entry == gParseHandlers.end())
		return -1;
	handler = entry->second;

	prop.loadProperties(ist, separator, false);