fileobjectsmanageri.cpp

GiPS是一个面向数据密集型应用的分布式文件系统

#pragma once
#include "FileObjectsManagerI.h"
#include "IntegralityManager.h"
#include <IceUtil/IceUtil.h>
#include <iostream>

using namespace std;
using namespace Cluster;

#define REPLICA_NUM 2

Ice::ObjectAdapterPtr FileObjectsManagerI::_adapter;

FileObjectsManagerI::FileObjectsManagerI(const Ice::CommunicatorPtr & ic, GDirectory* root, BlockTable* blockTable, Cluster::ClerkMap* clerkMap, Cluster::LoadTable* loadTable, ClerkFileList* clerkFileList) :
	m_root(root), m_blockTable(blockTable), m_clerkMap(clerkMap), m_loadTable(loadTable), m_clerkFileList(clerkFileList)
{
	_adapter->add(this, ic->stringToIdentity("FileObjectsManager"));
	this->m_loadBalancer = new GLoadBalancer(m_loadTable);
}

bool FileObjectsManagerI::getFileObjectStorageInformation(const ::std::string& fileName, ::ClientMaster::FileObject& fileObj, const ::Ice::Current&){
	GFNode* fnode = m_root->locate(fileName);
	// check if whether the file exists
	if (!fnode)
		return false;

	// make sure that the file is not a directory
	string fid = fnode->blockTableName();
	if (fid.size() > 0) {
		BlockTable::iterator it = m_blockTable->find(fid);
		if (it != m_blockTable->end()) {
			FileObject* fobj = it->second;
			for (FileObject::iterator it = fobj->begin(); it != fobj->end(); it++)
				fileObj.push_back(*it);
			return true;
		}

		return false;		
	}

	return false;
}


bool FileObjectsManagerI::setFileObjectStorageInformation(const ::std::string& fileName, const ::ClientMaster::FileObject& fileObj, const ::Ice::Current&){

	string fid = IceUtil::generateUUID();
	m_root->createFile(fileName, 0, &fid);
	FileObject* fobj = new FileObject();
	int size = fileObj.size();

	desIPList *iplist = m_loadBalancer->chooseClerk(REPLICA_NUM-1, fileObj[0].IPs);
	cout << "choose clerks to do backup" << endl;
	cout << iplist->size() << endl;
	ClerkMap::iterator mit = m_clerkMap->find(fileObj[0].IPs[0]);

	for (int i = 0; i < size; i++) {
		FileBlock* fb = new FileBlock();
		fb->blockID = fileObj[i].blockID;
		fb->indexID = fileObj[i].indexID;

		ReplicaInfo replicaInfo;
		replicaInfo.replicaID = fileObj[i].indexID;

		for (desIPList::iterator dit = iplist->begin(); dit != iplist->end(); dit++) {
			replicaInfo.clerkIP = *dit;
			if (mit->second->replicaCopy(replicaInfo))
				fb->IPs.push_back(*dit);
		}
		fb->IPs.push_back(fileObj[i].IPs[0]);
		fobj->push_back(*fb);
	}

	for (desIPList::iterator dit = iplist->begin(); dit != iplist->end(); dit++) {
		cout << "now backup clerk is " << *dit << endl;
		for (LoadTable::iterator lit = m_loadTable->begin(); lit != m_loadTable->end(); lit++) {
			if (!dit->compare((*lit)->clerkIP)) {
				(*lit)->blockNum += size;
			}
		}

		ClerkFileList::iterator cit = m_clerkFileList->find(*dit);
		
		if (cit == m_clerkFileList->end()) {
			SubFileList* sflist = new SubFileList();
			for (int i = 0; i < size; i++) {
				PCFBlock pcfb = new ClerkFileBlock();
				pcfb->blockid = i;
				pcfb->fid = fid;
				sflist->push_back(pcfb);
			}
			m_clerkFileList->insert(ClerkFileList::value_type(*dit, sflist));
		} else {
			for (int i = 0; i < size; i++) {
				PCFBlock pcfb = new ClerkFileBlock();
				pcfb->blockid = i;
				pcfb->fid = fid;
				cit->second->push_back(pcfb);
			}
		}
	}

	ClerkFileList::iterator cit = m_clerkFileList->find(fileObj[0].IPs[0]);
	if (cit == m_clerkFileList->end()) {
		SubFileList* sflist = new SubFileList();
		for (int i = 0; i < size; i++) {
			PCFBlock pcfb = new ClerkFileBlock();
			pcfb->blockid = i;
			pcfb->fid = fid;
			sflist->push_back(pcfb);
		}
		m_clerkFileList->insert(ClerkFileList::value_type(fileObj[0].IPs[0], sflist));
	} else {
		for (int i = 0; i < size; i++) {
			PCFBlock pcfb = new ClerkFileBlock();
			pcfb->blockid = i;
			pcfb->fid = fid;
			cit->second->push_back(pcfb);
		}
	}

	m_blockTable->insert(BlockTable::value_type(fid, fobj));
	return true;
}

::ClientMaster::desIPList FileObjectsManagerI::getStorageNodes(const ::Ice::Current&){
	::ClientMaster::desIPList ips;
	ips = *(m_loadBalancer->chooseClerk(2));
	return ips;
}

bool FileObjectsManagerI::createFolder(const ::std::string& folderName, const ::Ice::Current&){
	m_root->createFile(folderName, 1, NULL);
	return true;
}

bool FileObjectsManagerI::deleteFolder(const ::std::string& folderName, const ::Ice::Current&)
{
//	cout << "Delete request: " << folderName << endl;
	this->rmDirectory(folderName);
	return true;
}

bool FileObjectsManagerI::deleteFile(const ::std::string& fileName, const ::Ice::Current&){
	this->rmFile(fileName);
	return true;
}

::ClientMaster::list
FileObjectsManagerI::getFSList(const ::Ice::Current&)
{
	::ClientMaster::list flist;
	vector<GFNode*> children = m_root->allChildren();

	for (vector<GFNode*>::iterator cit = children.begin(); cit != children.end(); cit++) {
		flist.push_back((*cit)->absolutePath());
	}
	return flist;
}

void
FileObjectsManagerI::rmDirectory(string folderName)
{
//	cout << "begin del directory: " << folderName << endl;
	GFNode* dir = m_root->locate(folderName);
//	cout << "The dir is: " << dir->absolutePath() << endl;
	vector<GFNode*> children = dir->allChildren();
	for (vector<GFNode*>::iterator cit = children.begin(); cit != children.end(); cit++) {
		if (!(*cit)->isDirectory())
			rmFile((*cit)->absolutePath());
	}

	dir->destory();
	m_root->deleteFile(folderName);
}

void
FileObjectsManagerI::rmFile(string fileName)
{
	GFNode* file = m_root->locate(fileName);
	if (!file->isDirectory()) {
		BlockTable::iterator bit = m_blockTable->find(file->blockTableName());
		if (bit != m_blockTable->end()) {
			for (FileObject::iterator fit = bit->second->begin(); fit != bit->second->end(); fit++) {
				for (desIPList::iterator dit = fit->IPs.begin(); dit != fit->IPs.end(); dit++) {
					ClerkMap::iterator mit = m_clerkMap->find(*dit);
					if (mit != m_clerkMap->end()) {
						mit->second->replicaDelete(fit->indexID);
					}
				}
			}
		}

		m_blockTable->erase(bit);
		m_root->deleteFile(fileName);
	}
}