ReturnStatus
FileMetaDAO::isdir(const std::string &path)
{
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
int rt = 0;
FileAttr st;
rt = DataNS->Stat(path.c_str(), &st);
if (0 == rt) {
if (MU_DIRECTORY == st.m_Type) {
return ReturnStatus(MU_SUCCESS);
} else {
ERROR_LOG("path %s, not directory", path.c_str());
return ReturnStatus(MU_FAILED, NOT_DIRECTORY);
}
}
int error = errno;
ERROR_LOG("path %s, stat() error, %s", path.c_str(), strerror(error));
if (ENOENT == error || ENOTDIR == error) {
return checkPrefix(path);
} else {
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
}
bool MultiNameSpace::writeToNameServer(PortWriter& cmd,
PortReader& reply,
const ContactStyle& style) {
NameSpace *ns = HELPER(this).getOne();
if (!ns) return false;
return ns->writeToNameServer(cmd,reply,style);
}
bool MultiNameSpace::disconnectPortToPortPersistently(const Contact& src,
const Contact& dest,
ContactStyle style) {
NameSpace *ns = HELPER(this).getOne();
if (!ns) return false;
return ns->disconnectPortToPortPersistently(src,dest,style);
}
bool MultiNameSpace::disconnectTopicFromPort(const Contact& src,
const Contact& dest,
ContactStyle style) {
NameSpace *ns = HELPER(this).getOne();
if (!ns) return false;
return ns->disconnectTopicFromPort(src,dest,style);
}
void
FileMetaDAO::addFileSizeToDelta(const std::string &path, uint64_t *pDelta)
{
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
int rt = 0;
Args fd;
// read file size
fd = DataNS->Open(path.c_str(), O_RDONLY);
if (false == fd.valid) {
ERROR_LOG("path %s, open() error, %s", path.c_str(), strerror(errno));
return ;
}
//int fd = rt;
FileAttr attr;
rt = DataNS->readn(&fd, &attr, sizeof(attr));
DataNS->Close(&fd);
if (sizeof(attr) != rt) {
ERROR_LOG("path %s, readn() error", path.c_str());
return ;
}
*pDelta += attr.m_Size;
}
void scan() {
// reset flags
_localOnly = true;
_usesCentralServer = false;
_serverAllocatesPortNumbers = true;
// now scan each namespace
for (int i=0; i<(int)spaces.size(); i++) {
NameSpace *ns = spaces[i];
if (!ns) continue;
// if any namespace is nonlocal, combination is nonlocal
if (!ns->localOnly()) _localOnly = false;
// if any namespace uses a central server, combination also does
if (ns->usesCentralServer()) _usesCentralServer = true;
// if any namespace doesn't allocate port numbers, combination
// cannot be relied on to do so either
if (!ns->serverAllocatesPortNumbers()) {
_serverAllocatesPortNumbers = false;
}
// if any namespace lacks informed connections, combination
// cannot be relied on to be informed either
if (!ns->connectionHasNameOfEndpoints()) {
_connectionHasNameOfEndpoints = false;
}
}
}
ReturnStatus
FileMetaDAO::checkPrefix(const std::string &path)
{
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
int rt = 0;
FileAttr st;
rt = DataNS->Stat(prefix(path).c_str(), &st);
if (0 == rt) {
if (st.m_Type == MU_DIRECTORY) {//如果path是个存在的目录
// prefix path is existed and refers to a directory
return ReturnStatus(MU_FAILED, PATH_NOT_EXIST);
} else {//如果path是个存在的文件
return ReturnStatus(MU_FAILED, PATH_INVALID);
}
} else {
if (errno == ENOENT || errno == ENOTDIR) {//如果这个路径不存在
return ReturnStatus(MU_FAILED, PATH_INVALID);
} else {//
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
}
}
ReturnStatus
FileMetaDAO::putDir(const std::string &path)
{
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
int rt = 0;
rt = DataNS->MkDir(path.c_str(),
S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
if (0 == rt) {
return ReturnStatus(MU_SUCCESS);
}
// error occurred
int error = errno;
ERROR_LOG("path %s, mkdir() error, %s.", path.c_str(), strerror(error));
if (EEXIST == error) {
ERROR_LOG("path %s, path exist", path.c_str());
return ReturnStatus(MU_FAILED, PATH_EXIST);
} else if (ENOENT == error || ENOTDIR == error) {
ERROR_LOG("path %s, path invalid", path.c_str());
return ReturnStatus(MU_FAILED, PATH_INVALID);
} else {
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
return ReturnStatus(MU_SUCCESS); // make compiler happy
}
ReturnStatus
FileMetaDAO::movFile(const std::string &srcPath,
const std::string &destPath)
{
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
int rt = 0;
int error = 0;
ReturnStatus rs;
// check src path
rs = isfile(srcPath);
if (!rs.success()) {
if (IS_DIRECTORY == rs.errorCode) {
return ReturnStatus(MU_FAILED, SRC_PATH_IS_DIRECTORY);
} else if (PATH_INVALID == rs.errorCode) {
return ReturnStatus(MU_FAILED, SRC_PATH_INVALID);
} else if (PATH_NOT_EXIST == rs.errorCode) {
return ReturnStatus(MU_FAILED, SRC_PATH_NOT_EXIST);
}
return rs;
}
// check dest path
rs = isdir(prefix(destPath));
if (!rs.success()) {
if (MU_UNKNOWN_ERROR != rs.errorCode) {
return ReturnStatus(MU_FAILED, DEST_PATH_INVALID);
}
return rs;
}
rt = DataNS->Move(srcPath.c_str(), destPath.c_str());
if (-1 == rt) {
error = errno;
ERROR_LOG("src path %s, dest path %s, rename() error, %s.",
srcPath.c_str(), destPath.c_str(), strerror(error));
if (EISDIR == error) {
return ReturnStatus(MU_FAILED, DEST_PATH_IS_DIRECTORY);
} else {
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
}
return ReturnStatus(MU_SUCCESS);
}
ReturnStatus
FileMetaDAO::getDir(const std::string &path, std::list<PDEntry> *pEntryList)
{
assert(pEntryList);
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
int rt = 0;
int error = 0;
std::string entryName;
Args st;
rt = DataNS->OpenDir(path.c_str(), &st);
if (false == st.valid) {
error = errno;
ERROR_LOG("path %s, opendir() error, %s.",
path.c_str(), strerror(errno));
if (ENOTDIR == error) {
return ReturnStatus(MU_FAILED, NOT_DIRECTORY);
} else if (ENOENT == error) {
return checkPrefix(path);
}
}
Dirent dirent;
while(DataNS->ReadDirNext(&st, &dirent)){
entryName = dirent.filename;
// omit "." and ".."
// omit user info file in user root dir
if (entryName == DENTRY_CURRENT_DIR
|| entryName == DENTRY_PARENT_DIR
|| entryName == USER_INFO_FILE_NAME) {
continue;
}
PDEntry ent;
ent.m_Name = entryName;
if (MU_DIRECTORY == dirent.filetype) {
ent.m_Type = MU_DIRECTORY;
} else {
ent.m_Type = MU_REGULAR_FILE;
}
pEntryList->push_back(ent);
}
return ReturnStatus(MU_SUCCESS);
}
/**
* Parses the keyword "class" from the given token stack
*/
int CodeParser::parseKeyword_Class( Scope* scope, TokenStack* stack ) {
Class* classdef;
const char* name;
Token* t;
// validate incoming scope
if( scope->getScopeType() != NAMESPACE_SCOPE ) {
SYNTAX_ERROR( "Classes cannot be defined in this scope", stack->last() );
return -1;
}
// the next token must be the identifier
if( !( name = state->getIdentifierName( stack, "class" ) ) ) {
return -2;
}
// get the name space
NameSpace* ns = (NameSpace*)scope;
printf( "class '%s' in namespace '%s' modifiers = %s\n", name, ns->getName(), toBinary( modifiers ) );
// TODO check for inheritance! multiple inheritance?
// - class MyChild extends MyParent { ... }
// - class StrobeLamp extends Lamp, Strobe { ... }
// create the class
classdef = new Class( name, ns->getName(), ns, modifiers );
this->modifiers = 0;
// add the name space to the state
if( !ns->addClass( classdef ) ) {
char* error = new char[256];
sprintf( error, "Class '%s' already exists in namespace '%s'\n", name, ns->getName() );
SYNTAX_ERROR( error, stack->last() );
delete error;
return -4;
}
// the next element must be a code block
if( !stack->hasNext() || !( t = stack->peek() ) || ( t->getType() != tok::CODE_BLOCK ) ) {
SYNTAX_ERROR( "unexpected token", t );
return -5;
}
// process the code block
int errorCode = parse( classdef, ((ComplexToken*)t)->getChildren() );
// register the class
state->addClass( classdef );
// reset the class-level counters
state->resetCounters();
return errorCode;
}
Contact queryName(const ConstString& name) {
activate();
for (int i=0; i<(int)spaces.size(); i++) {
NameSpace *ns = spaces[i];
if (!ns) continue;
if (ns->getNameServerName()==name) {
return ns->getNameServerContact();
}
Contact result = ns->queryName(name);
if (result.isValid()) return result;
}
return Contact();
}
bool ApexResourceProvider::checkResource(ResID nameSpace, const char* name)
{
/* Return true is named resource has known non-null pointer */
uint32_t nsIndex = getNSIndex(nameSpace);
if (nsIndex < mNameSpaces.size())
{
NameSpace* ns = mNameSpaces[nsIndex];
ResID id = ns->getOrCreateID(name, mResources[ns->getID()].name);
PX_ASSERT(id < mResources.size());
return checkResource(id);
}
return false;
}
ReturnStatus
FileMetaDAO::delFile(const std::string &path, int *pDelta)
{
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
int rt = 0;
Args fd;
ReturnStatus rs;
rs = isfile(path);
if (!rs.success()) {
return rs;
}
// read file size
fd = DataNS->Open(path.c_str(), O_RDONLY);
if (false == fd.valid) {
ERROR_LOG("path %s, open() error, %s", path.c_str(), strerror(errno));
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
FileAttr attr;
rt = DataNS->readn(&fd, &attr, sizeof(attr));
DataNS->Close(&fd);
if (sizeof(attr) != rt) {
ERROR_LOG("path %s, readn() error", path.c_str());
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
*pDelta = attr.m_Size;
// do delete action
rt = DataNS->Unlink(path.c_str());
if (-1 == rt) {
ERROR_LOG("path %s, unlink() error, %s.",
path.c_str(), strerror(errno));
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
return ReturnStatus(MU_SUCCESS);
}
Contact queryName(const char *name) {
activate();
for (int i=0; i<(int)spaces.size(); i++) {
NameSpace *ns = spaces[i];
if (!ns) continue;
if (ns->getNameServerName()==name) {
return ns->getNameServerContact();
}
//printf("Query from %s\n", spaces[i]->getNameServerName().c_str());
Contact result = ns->queryName(name);
//printf("Got %s\n", result.toString().c_str());
if (result.isValid()) return result;
}
return Contact();
}
Contact whereDelegate()
{
if (!space) {
return Contact();
}
return space->getNameServerContact();
}
void scan() {
_localOnly = true;
_usesCentralServer = false;
_serverAllocatesPortNumbers = true;
for (int i=0; i<(int)spaces.size(); i++) {
NameSpace *ns = spaces[i];
if (!ns) continue;
if (!ns->localOnly()) _localOnly = false;
if (ns->usesCentralServer()) _usesCentralServer = true;
if (!ns->serverAllocatesPortNumbers()) {
_serverAllocatesPortNumbers = false;
}
if (!ns->connectionHasNameOfEndpoints()) {
_connectionHasNameOfEndpoints = false;
}
}
}
Contact queryName(const ConstString& name) {
activate();
// try query against each namespace in order
for (int i=0; i<(int)spaces.size(); i++) {
NameSpace *ns = spaces[i];
if (!ns) continue;
if (ns->getNameServerName()==name) {
// optimization: return cached server address for
// port names that match name of namespace
return ns->getNameServerContact();
}
Contact result = ns->queryName(name);
// return a result once we get one, skipping any remaining
// namespaces
if (result.isValid()) return result;
}
return Contact();
}
ResID ApexResourceProvider::createResource(ResID nameSpace, const char* name, bool refCount)
{
uint32_t nsIndex = getNSIndex(nameSpace);
if (nsIndex < mNameSpaces.size())
{
NameSpace* ns = mNameSpaces[nsIndex];
ResID id = ns->getOrCreateID(name, mResources[ns->getID()].name);
PX_ASSERT(id < mResources.size());
if (id < mResources.size() && refCount)
{
mResources[id].refCount++;
}
return id;
}
else
{
return INVALID_RESOURCE_ID;
}
}
ReturnStatus
FileMetaDAO::getFile(const std::string &path, FileMeta *pMeta)
{
assert(pMeta);
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
// clear possible data
pMeta->m_BlockList.clear();
ReturnStatus rs;
rs = isfile(path);
if (!rs.success()) {
return rs;
}
int rt = 0;
Args fd;
fd = DataNS->Open(path.c_str(), O_RDONLY);
if (false == fd.valid) {
ERROR_LOG("path %s, open() error, %s.", path.c_str(), strerror(errno));
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
rs = readFileMeta(&fd, pMeta);
DataNS->Close(&fd);
if (!rs.success()) {
ERROR_LOG("path %s, readFileMeta() error", path.c_str());
}
return rs;
}
ReturnStatus
FileMetaDAO::updateFile(const std::string &path, const FileMeta &meta,
FileMeta *pMeta, int *pDelta)
{
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
int rt = 0;
Args fd;
ReturnStatus rs;
rs = isfile(path);
if (!rs.success()) {
return rs;
}
fd = DataNS->Open(path.c_str(), O_RDWR);
if (-1 == rt) {
ERROR_LOG("path %s, open() error, %s.", path.c_str(), strerror(errno));
// already check path errors in isfile()
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
// check file version
FileAttr attr;
rt = DataNS->readn(&fd, &attr, sizeof(attr));
if (sizeof(attr) != rt) {
ERROR_LOG("readn() error");
DataNS->Close(&fd);
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
if (meta.m_Attr.m_Version != attr.m_Version + 1) {
ERROR_LOG("version outdated, current version %" PRIu64 ", "
"received version %" PRIu64,
attr.m_Version, meta.m_Attr.m_Version);
DataNS->Close(&fd);
pMeta->m_Attr = attr;
return ReturnStatus(MU_FAILED, VERSION_OUTDATED);
}
// write metadata
rs = writeFileMeta(&fd, meta);
DataNS->Close(&fd);;
// return file size delta
*pDelta = meta.m_Attr.m_Size - attr.m_Size;
return rs;
}
ReturnStatus
FileMetaDAO::statDir(const std::string &path, FileMeta *pMeta)
{
assert(pMeta);
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
int rt = 0;
int error = 0;
FileAttr st;
rt = DataNS->Stat(path.c_str(), &st);
if (-1 == rt) {
error = errno;
ERROR_LOG("path %s, stat() error, %s.", path.c_str(), strerror(error));
if (ENOENT == error || ENOTDIR == error) {
return checkPrefix(path);
} else {
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
}
if (st.m_Type != MU_DIRECTORY) {
ERROR_LOG("path %s, not directory", path.c_str());
return ReturnStatus(MU_FAILED, NOT_DIRECTORY);
}
pMeta->m_Attr.m_Mode = st.m_Mode;
pMeta->m_Attr.m_CTime = st.m_CTime;
pMeta->m_Attr.m_MTime = st.m_MTime;
pMeta->m_Attr.m_Size = st.m_Size;
return ReturnStatus(MU_SUCCESS);
}
Value *MultiNameSpace::getProperty(const ConstString& name, const ConstString& key) {
NameSpace *ns = HELPER(this).getOne();
if (!ns) return NULL;
return ns->getProperty(name,key);
}
bool MultiNameSpace::setProperty(const ConstString& name, const ConstString& key,
const Value& value) {
NameSpace *ns = HELPER(this).getOne();
if (!ns) return false;
return ns->setProperty(name,key,value);
}
ReturnStatus
FileMetaDAO::rmdirRecursive(const std::string &path, uint64_t *pDelta)
{
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
int rt = 0;
ReturnStatus rs;
int error = 0;
std::string entryName;
std::string npath;
Args st;
rt = DataNS->OpenDir(path.c_str(), &st);
if (rt < 0) {
error = errno;
ERROR_LOG("path %s, opendir() error, %s.",
path.c_str(), strerror(errno));
if (ENOTDIR == error) {
ERROR_LOG("path %s, opendir() error, no directory");
return ReturnStatus(MU_FAILED, NOT_DIRECTORY);
} else if (ENOENT == error) {
return checkPrefix(path);
}
}
// delete its children
Dirent dirent;
while(DataNS->ReadDirNext(&st, &dirent)){
entryName = dirent.filename;
// omit "." and ".."
// omit user info file in user root dir
if (entryName == DENTRY_CURRENT_DIR
|| entryName == DENTRY_PARENT_DIR
|| entryName == USER_INFO_FILE_NAME) {
continue;
}
npath = path + PATH_SEPARATOR_STRING + entryName;
if (MU_DIRECTORY == dirent.filetype) {
// directory, call myself to delete it
rs = rmdirRecursive(npath, pDelta);
if (!rs.success()) {
ERROR_LOG("path %s, rmdirRecursive() error", npath.c_str());
return rs;
}
} else {
// add file size to changed user quota
addFileSizeToDelta(npath, pDelta);
// delete it directly
rt = DataNS->Unlink(npath.c_str());
if (-1 == rt) {
ERROR_LOG("path %s, unlink() error, %s.",
npath.c_str(), strerror(errno));
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
}
}
// delete path
// do not delete user root
if (path.substr(path.length() - 1) == ROOT_PATH) {
return ReturnStatus(MU_SUCCESS);
}
rt = DataNS->RmDir(path.c_str());
if (-1 == rt) {
ERROR_LOG("path %s, rmdir() error, %s.",
path.c_str(), strerror(errno));
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
return ReturnStatus(MU_SUCCESS);
}
ReturnStatus
FileMetaDAO::getDir2(const std::string &path,
std::list<EDEntry> *pEntryList)
{
assert(pEntryList);
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
int rt = 0;
int error = 0;
std::string entryName;
std::string npath;
Args st;
rt = DataNS->OpenDir(path.c_str(), &st);
if (false == st.valid) {
error = errno;
ERROR_LOG("path %s, opendir() error, %s.",
path.c_str(), strerror(errno));
if (ENOTDIR == error) {
return ReturnStatus(MU_FAILED, NOT_DIRECTORY);
} else if (ENOENT == error) {
return checkPrefix(path);
}
}
FileMeta meta;
ReturnStatus rs;
Dirent dirent;
while(DataNS->ReadDirNext(&st, &dirent)){
entryName = dirent.filetype;
npath = path + PATH_SEPARATOR_STRING + entryName;
// omit "." and ".."
// omit user info file in user root dir
if (entryName == DENTRY_CURRENT_DIR
|| entryName == DENTRY_PARENT_DIR
|| entryName == USER_INFO_FILE_NAME) {
continue;
}
EDEntry ent;
ent.m_Name = entryName;
if (MU_DIRECTORY == dirent.filetype) {
ent.m_Type = MU_DIRECTORY;
rs = statDir(npath, &meta);
if (!rs.success()) {
ERROR_LOG("path %s, statDir() error", npath.c_str());
return rs;
}
ent.m_Mode = meta.m_Attr.m_Mode;
ent.m_CTime = meta.m_Attr.m_CTime;
ent.m_MTime = meta.m_Attr.m_MTime;
ent.m_Size = meta.m_Attr.m_Size;
} else {
// clear data of last entry
meta.m_BlockList.clear();
rs = getFile(npath, &meta);
if (!rs.success()) {
ERROR_LOG("path %s, getFile() error", npath.c_str());
return rs;
}
ent.m_Mode = meta.m_Attr.m_Mode;
ent.m_CTime = meta.m_Attr.m_CTime;
ent.m_MTime = meta.m_Attr.m_MTime;
ent.m_Size = meta.m_Attr.m_Size;
ent.m_Version = meta.m_Attr.m_Version;
ent.m_Type = meta.m_Attr.m_Type;
ent.m_BlockList = meta.m_BlockList;
}
pEntryList->push_back(ent);
}
return ReturnStatus(MU_SUCCESS);
}
ReturnStatus
FileMetaDAO::readFileMeta(Args *fd, FileMeta *pMeta)
{
/*
assert(pMeta);
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
int rt = 0;
rt = DataNS->readn(fd, &(pMeta->m_Attr), sizeof(pMeta->m_Attr));
if (sizeof(pMeta->m_Attr) != rt) {
ERROR_LOG("read attr, readn() error");
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
int blocks = pMeta->m_Attr.m_Size / FIXED_BLOCK_SIZE;
if (pMeta->m_Attr.m_Size % FIXED_BLOCK_SIZE != 0) {
++blocks;
}
char *pBlockList = new char[blocks * FIXED_BLOCK_CHECKSUM_LEN];
rt = DataNS->readn(fd, pBlockList, blocks * FIXED_BLOCK_CHECKSUM_LEN);
if (blocks * FIXED_BLOCK_CHECKSUM_LEN != rt) {
ERROR_LOG("read block list, readn() error");
delete [] pBlockList;
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
BlockMeta bmeta;
for (int i = 0; i < blocks; ++i) {
bmeta.m_Checksum =
std::string(pBlockList + i * FIXED_BLOCK_CHECKSUM_LEN,
FIXED_BLOCK_CHECKSUM_LEN);
pMeta->m_BlockList.push_back(bmeta);
}
delete [] pBlockList;
return ReturnStatus(MU_SUCCESS);
*/
//----------------
assert(pMeta);
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
int rt = 0;
//TODO
int max_blocks = 512;//max file size is 256MB
char *buffer = new char[max_blocks * FIXED_BLOCK_CHECKSUM_LEN];
rt = DataNS->readn(fd, buffer, max_blocks * FIXED_BLOCK_CHECKSUM_LEN);
memcpy(&(pMeta->m_Attr), buffer, sizeof(pMeta->m_Attr));
int blocks = pMeta->m_Attr.m_Size / FIXED_BLOCK_SIZE;
if (pMeta->m_Attr.m_Size % FIXED_BLOCK_SIZE != 0) {
++blocks;
}
if ((sizeof(pMeta->m_Attr) + blocks * FIXED_BLOCK_CHECKSUM_LEN) != rt) {
ERROR_LOG("read file meta, readn() error");
delete [] buffer;
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
BlockMeta bmeta;
for(int i = 0; i < blocks; ++i){
bmeta.m_Checksum =
std::string(buffer + sizeof(pMeta->m_Attr) + i * FIXED_BLOCK_CHECKSUM_LEN,
FIXED_BLOCK_CHECKSUM_LEN);
pMeta->m_BlockList.push_back(bmeta);
}
delete [] buffer;
return ReturnStatus(MU_SUCCESS);
}
ReturnStatus
FileMetaDAO::writeFileMeta(Args *fd, const FileMeta &meta)
{
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
int rt = 0;
rt = DataNS->Lseek(fd, 0, SEEK_SET);
if (-1 == rt) {
ERROR_LOG("lseek() error, %s.", strerror(errno));
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
int blocks = meta.m_BlockList.size();
int attrLen = sizeof(FileAttr);
char *pBuf = new char[
attrLen + FIXED_BLOCK_CHECKSUM_LEN * blocks];
int bufIdx = 0;
memcpy(pBuf + bufIdx, &(meta.m_Attr), attrLen);
bufIdx += attrLen;
for (std::list<BlockMeta>::const_iterator it = meta.m_BlockList.begin();
it != meta.m_BlockList.end(); ++it) {
memcpy(pBuf + bufIdx,
it->m_Checksum.c_str(),
FIXED_BLOCK_CHECKSUM_LEN);
bufIdx += FIXED_BLOCK_CHECKSUM_LEN;
}
rt = DataNS->writen(fd, pBuf, bufIdx);
delete [] pBuf;
pBuf = NULL;
if (bufIdx != rt) {
ERROR_LOG("writen() error");
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
//int iovcnt = blocks + 1;
//struct iovec iov[iovcnt];
//int iovIdx = 0;
//iov[iovIdx].iov_base = const_cast<FileAttr *>(&(meta.m_Attr));
//iov[iovIdx].iov_len = sizeof(meta.m_Attr);
//++iovIdx;
//for (std::list<BlockMeta>::const_iterator it = meta.m_BlockList.begin();
//it != meta.m_BlockList.end(); ++it) {
//iov[iovIdx].iov_base = const_cast<char *>(it->m_Checksum.c_str());
//iov[iovIdx].iov_len = FIXED_BLOCK_CHECKSUM_LEN;
//++iovIdx;
//}
//rt = ::writev(fd, iov, iovcnt);
//if (sizeof(meta.m_Attr) + blocks * FIXED_BLOCK_CHECKSUM_LEN != rt) {
//ERROR_LOG("writev() error, %s.", strerror(errno));
//return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
//}
return ReturnStatus(MU_SUCCESS);
}
bool SubscriberOnSql::welcome(const ConstString& port, int activity) {
mutex.wait();
NameSpace *ns = getDelegate();
if (ns) {
NestedContact nc(port);
if (nc.getNestedName().size()>0) {
NameStore *store = getStore();
if (store!=NULL) {
Contact node = store->query(nc.getNodeName());
Contact me = store->query(port);
if (node.isValid() && me.isValid()) {
if (activity>0) {
ns->registerAdvanced(me,store);
} else {
ns->unregisterAdvanced(port,store);
}
}
}
}
}
char *msg = NULL;
char *query;
if (activity>0) {
query = sqlite3_mprintf("INSERT OR IGNORE INTO live (name,stamp) VALUES(%Q,DATETIME('now'))",
port.c_str());
} else {
// Port not responding. Mark as non-live.
if (activity==0) {
query = sqlite3_mprintf("DELETE FROM live WHERE name=%Q AND stamp < DATETIME('now','-30 seconds')",
port.c_str());
} else {
// activity = -1 -- definite dodo
query = sqlite3_mprintf("DELETE FROM live WHERE name=%Q",
port.c_str());
}
}
if (verbose) {
printf("Query: %s\n", query);
}
bool ok = true;
int result = sqlite3_exec(SQLDB(implementation), query,
NULL, NULL, &msg);
if (result!=SQLITE_OK) {
ok = false;
if (msg!=NULL) {
fprintf(stderr,"Error: %s\n", msg);
sqlite3_free(msg);
}
}
sqlite3_free(query);
mutex.post();
if (activity>0) {
hookup(port);
} else if (activity<0) {
breakdown(port);
}
return ok;
}
ReturnStatus
FileMetaDAO::createFile(
const std::string &path,
const FileMeta &meta,
FileMeta *pMeta,
int *pDelta)
{
int rt = 0;
int error = 0;
Args fd;
Channel* pDataChannel = ChannelManager::getInstance()->Mapping(m_BucketId);
NameSpace *DataNS = pDataChannel->m_DataNS;
fd = DataNS->Open(path.c_str(), O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR);
if (false == fd.valid) {
error = errno;
ERROR_LOG("path %s, open() error, %s.", path.c_str(), strerror(error));
if (EEXIST == error) {
ERROR_LOG("path %s, file exist", path.c_str());
// is a regular file?
ReturnStatus rs = isfile(path);
if (!rs.success()) {
return rs;
}
fd = DataNS->Open(path.c_str(), O_RDONLY);
if (false == fd.valid) {
ERROR_LOG("path %s, open() error, %s",
path.c_str(), strerror(errno));
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
// check file version
FileAttr attr;
rt = DataNS->readn(&fd, &attr, sizeof(attr));
DataNS->Close(&fd);
if (sizeof(attr) != rt) {
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
pMeta->m_Attr.m_Version = attr.m_Version;
return ReturnStatus(MU_FAILED, PATH_EXIST);
} else if (ENOENT == error || ENOTDIR == error) {
ERROR_LOG("path %s, path invalid", path.c_str());
return ReturnStatus(MU_FAILED, PATH_INVALID);
} else {
return ReturnStatus(MU_FAILED, MU_UNKNOWN_ERROR);
}
}
ReturnStatus rs = writeFileMeta(&fd, meta);
DataNS->Close(&fd);
// return file size delta
*pDelta = meta.m_Attr.m_Size;
return rs;
}
