• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMFileSystemManager.cpp

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

//
// Inner includes
//

#include "../include/PCMFileSystemManager.h"

#include "../include/PCMApplication.h"

//
// Outer includes
//

#include <dirent.h>
#include <errno.h>
#include <sys/stat.h>
#include <iostream>
#include <fstream>

extern int errno;

namespace ParCompMark
{

  // Inherited static attribute initialization
  template <> FileSystemManager * Singleton < FileSystemManager >::mInstance = 0;

  //
  // Class constants
  //

  const u32 FileSystemManager::MAX_PATH = 1024;
  const std::string FileSystemManager::PATH_SEPARATOR = "/";

  //
  // Constructors & destructor
  //

   FileSystemManager::FileSystemManager(const std::string & appDirectory, const std::string & iniFile)
        // You have to initialize the following attributes:
        // - mInitialized
        // - mAppDirectory
        // - mDataDirectory
        // - mHomeDirectory
        // - mCurrentDirectory
        // - mIniFile
  {
        mInitialized = false;
        mAppDirectory = appDirectory;
        mDataDirectory = "(unknown)";
        mHomeDirectory = "(unknown)";
        mCurrentDirectory = "(unknown)";
        mIniFile = iniFile;

        //if(Logger::getInstance()) Logger::getInstance()->log(Logger::NOTICE, "File system manager has been created.");
  }

 /*----------------------------------------------------------------------*/

  FileSystemManager::~FileSystemManager()
  {
        if(mInitialized)
         finalize();

        Logger::getInstance()->log(Logger::NOTICE, "File system manager has been destroyed.");
  }

 /*----------------------------------------------------------------------*/

  //
  // Class methods
  //

  FileSystemManager *FileSystemManager::getInstance()
  {
        return Singleton < FileSystemManager >::getInstance();
  }

 /*----------------------------------------------------------------------*/

  void FileSystemManager::closeFile(FileSystemManager::CppFilePointer & fp)
  {
        fp.lock();
        fp->close();
        fp.unlock();
  }

 /*----------------------------------------------------------------------*/

  void FileSystemManager::closeFile(FileSystemManager::CFilePointer & fp)
  {
        // Zero pointer to avoid double-free in Pointer destructor
        fp.lock();
        fclose(fp.getPtr());
        fp.unlock();
        fp.setNull(true);
  }

 /*----------------------------------------------------------------------*/

  //
  // Methods
  //

  void FileSystemManager::initialize()
  {
        Assert(!mInitialized, INVALID_OPERATION_ERROR, "FileSystemManager::initialize()");

        // Find the home directory of the user on the filesystem
        _findHomeDirectory();

        // Get full path of current directory
        mCurrentDirectory = Application::getInstance()->getEnvironmentVariable("PWD") + '/';

        // Convert application directory
        mAppDirectory = _replaceHomeChar(mAppDirectory);

        // Create user-level application directory and ini file
        _createAppDirectory();

        mInitialized = true;

        //if(Logger::getInstance()) Logger::getInstance()->log(Logger::DEBUG, "File system manager has been initialized.");
  }

 /*----------------------------------------------------------------------*/

  void FileSystemManager::finalize()
  {
        Assert(mInitialized, INVALID_OPERATION_ERROR, "FileSystemManager::finalize()");

        mInitialized = false;
        Logger::getInstance()->log(Logger::DEBUG, "File system manager has been finalized.");
  }

 /*----------------------------------------------------------------------*/

  bool FileSystemManager::existsDirectory(const std::string & name) const
  {
        std::string _name = _replaceHomeChar(name);
        return::opendir(_name.c_str()) != 0;
  }

 /*----------------------------------------------------------------------*/

  bool FileSystemManager::createDirectory(const std::string & name) const
  {
        if(existsDirectory(name))
         return false;

        std::string _name = _replaceHomeChar(name);

        if(::mkdir(_name.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IRWXO) == -1)
        {
         switch (errno)
         {
                case EACCES:
                 Except(FILE_IO_ERROR, "FileSystemManager::createDirectory",
                         "Write permission is denied for the parent directory in which the new directory `" + _name +
                         "\' is to be added.");
                 break;
                case EEXIST:
                 // Already exists (something went wrong)
                 Logger::getInstance()->log(Logger::WARNING,
                                           "Directory `" + _name + "\' already exists (something went wrong).");
                 return false;
                 break;
                case EMLINK:
                 Except(FILE_IO_ERROR, "FileSystemManager::createDirectory",
                         "The parent directory has too many links (entries). Unable to create `" + _name + "\'.");
                 break;
                case ENOSPC:
                 Except(FILE_IO_ERROR, "FileSystemManager::createDirectory",
                         "The file system doesn't have enough room to create the new directory `" + _name + "\'.");
                 break;
                case EROFS:
                 Except(FILE_IO_ERROR, "FileSystemManager::createDirectory",
                         "The parent directory of the directory being created is on a read-only file system and cannot be modified. Unable to create `"
                         + name + "\'.");
                 break;
         }
        }

        if(Logger::getInstance())
         Logger::getInstance()->log(Logger::DEBUG, "Directory `" + _name + "\' has been created.");

        return true;
  }

 /*----------------------------------------------------------------------*/

  std::string FileSystemManager::findDataDirectory()const
  {
        std::string guess[] =
        {
        "/usr/share/ParCompMark/", "/usr/lib/ParCompMark/", "/usr/local/ParCompMark/",
                "/usr/local/share/ParCompMark/", "./data/", "../data/"};
        u32 guessSize = sizeof(guess) / sizeof(guess[0]);

        for(u32 i = 0; i < guessSize; i++)
         if(existsDirectory(guess[i]))
                return _translateToAbsolutePath(guess[i]);

        if(existsAppFile(mIniFile))
         Except(FILE_IO_ERROR, "FileSystemManager::findDataDirectory()",
                 "Application data directory was not found. Please check the application configuration file `" +
                 mAppDirectory + mIniFile + "\'");
        else
         Except(FILE_IO_ERROR, "FileSystemManager::findDataDirectory()",
                 "Application data directory was not found. It seems you have to reinstall ParCompMark.");
  }

 /*----------------------------------------------------------------------*/

  bool FileSystemManager::existsLibrary(const std::string & library,
                                        const std::vector < std::string > &additionalPaths) const
  {
        try
        {
         findLibraryPath(library, additionalPaths);
        }
        catch(Exception & e)
        {
         return false;
        }

        return true;
  }

 /*----------------------------------------------------------------------*/

  std::string FileSystemManager::findLibraryPath(const std::string & library,
                                                 const std::vector < std::string > &additionalPaths) const
  {
        std::list < std::string > guess;

        // Append the set paths first
        for(std::vector < std::string >::const_iterator i = additionalPaths.begin(); i != additionalPaths.end();
         i++)
         guess.push_back(*i + (i->substr(i->length() - 1) != "/" ? "/" : ""));

        // Default guesses
        guess.push_back("/usr/lib/");
        guess.push_back("/usr/local/lib/");
        guess.push_back("/lib/");
        guess.push_back("./");

        // Check LD_LIBRARY_PATH
        if(Application::getInstance()->hasEnvironmentVariable("LD_LIBRARY_PATH"))
        {
         std::vector < std::string > paths =
                StringConverter::tokenize(Application::getInstance()->getEnvironmentVariable("LD_LIBRARY_PATH"), ":");
         for(std::vector < std::string >::iterator i = paths.begin(); i != paths.end(); i++)
                guess.push_back(*i + (i->substr(i->length() - 1) != "/" ? "/" : ""));
        }

        for(std::list < std::string >::iterator i = guess.begin(); i != guess.end(); i++)
        {
         std::cerr << "check " << (*i + library) << std::endl;
         if(existsFile(*i + library))
                return _translateToAbsolutePath(*i);
        }

        Except(FILE_IO_ERROR, "FileSystemManager::findLibraryPath()",
           "Library `" + library +
           "' not found on your system (default library directories, LD_LIBRARY_PATH environment variable). Please install this library or move/link to the search path, or add to LD_LIBRARY_PATH.");
  }

 /*----------------------------------------------------------------------*/

  std::list < std::string > FileSystemManager::listDirectory(const std::string & directory) const
  {
        std::list < std::string > files;

        struct dirent buf,
         *file;
        DIR *dir = opendir(directory.c_str());

        if(!dir)
         Except(FILE_IO_ERROR, "FileSystemManager::listDirectory",
                 "Unable to open directory `" + directory + "\' for listing");

        // Read files
        do
        {
         readdir_r(dir, &buf, &file);
         if(file)
                files.push_back(directory + file->d_name);
        } while(file);

        closedir(dir);

        return files;
  }

 /*----------------------------------------------------------------------*/

  std::list < std::string > FileSystemManager::listDataDirectory(const std::string & directory) const
  {
        std::list < std::string > files = listDirectory(mDataDirectory + directory);
        for(std::list < std::string >::iterator i = files.begin(); i != files.end(); i++)
         (*i) = (*i).substr(mDataDirectory.length());

        return files;
  }

 /*----------------------------------------------------------------------*/

  bool FileSystemManager::existsFile(const std::string & name) const
  {
        std::string _name = _replaceHomeChar(name);
        struct stat buf;

        if(stat(_name.c_str(), &buf) == -1)
        {
         switch (errno)
         {
                case ENOTDIR:
                 Except(FILE_IO_ERROR, "FileSystemManager::existsFile",
                         "A component of the path prefix is not a directory.");
                 break;
                case ENAMETOOLONG:
                 Except(FILE_IO_ERROR, "FileSystemManager::existsFile",
                         "A component of a pathname exceeded {NAME_MAX} characters, or an entire path name exceeded {PATH_MAX} characters.");
                 break;
                case ENOENT:
                 // The named file does not exist.
                 return false;
                 break;
                case EACCES:
                 Except(FILE_IO_ERROR, "FileSystemManager::existsFile",
                         "Search permission is denied for a component of the path prefix.");
                 break;
                case ELOOP:
                 Except(FILE_IO_ERROR, "FileSystemManager::existsFile",
                         "Too many symbolic links were encountered in translating the pathname.");
                 break;
                case EFAULT:
                 Except(FILE_IO_ERROR, "FileSystemManager::existsFile", "Sb or name points to an invalid address.");
                 break;
                case EIO:
                 Except(FILE_IO_ERROR, "FileSystemManager::existsFile",
                         "An I/O error occurred while reading from or writing to the file system.");
                 break;
         }
        }

        return true;
  }

 /*----------------------------------------------------------------------*/

  bool FileSystemManager::existsAppFile(const std::string & name) const
  {
        return existsFile(mAppDirectory + name);
  }

 /*----------------------------------------------------------------------*/

  bool FileSystemManager::existsDataFile(const char *name) const
  {
        return existsFile(mDataDirectory + std::string(name));
  }

 /*----------------------------------------------------------------------*/

  FileSystemManager::CFilePointer FileSystemManager::openFileC(const std::string & name,
                                                                 const FileOperation & operation) const
  {
        Assert(operation != READ || existsFile(name), INVALID_NAME_ERROR, "Application::openFileC()");

        char mode[2] = "r";

        switch (operation)
        {
         case READ:
                strcpy(mode, "r");
                break;
         case WRITE:
                strcpy(mode, "w");
                break;
         case APPEND:
                strcpy(mode, "a");
                break;
        }

        FILE *fp = fopen(name.c_str(), mode);

        // Operation is not allowed
        Assert(fp, INVALID_OPERATION_ERROR, "Application::openFileC()");

        return FileSystemManager::CFilePointer(fp);
  }

 /*----------------------------------------------------------------------*/

  FileSystemManager::CFilePointer FileSystemManager::openAppFileC(const std::string & name,
                                                                 const FileOperation & operation) const
  {
        return openFileC(mAppDirectory + name, operation);
  }

 /*----------------------------------------------------------------------*/

  FileSystemManager::CFilePointer FileSystemManager::openDataFileC(const std::string & name,
                                                                  const FileOperation & operation) const
  {
        return openFileC(mDataDirectory + name, operation);
  }

 /*----------------------------------------------------------------------*/

  FileSystemManager::CppFilePointer FileSystemManager::openFileCpp(const std::string & name,
                                                                  const FileOperation & operation) const
  {
        //Assert(operation != READ || existsFile(name), INVALID_NAME_ERROR, "Application::openFileCpp()");
        if(operation == READ && !existsFile(name))
         Except(INVALID_NAME_ERROR, "Application::openFileCpp()", "Unable to open `" + name + "' for reading.");

        std::_Ios_Openmode mode = std::ios::in;

        switch (operation)
        {
         case READ:
                mode = std::ios::in;
                break;
         case WRITE:
                mode = std::ios::out;
                break;
         case APPEND:
                mode = std::ios::app;
                break;
        }

        std::fstream * fstr = new std::fstream(name.c_str(), mode);

        return FileSystemManager::CppFilePointer(fstr);
  }

 /*----------------------------------------------------------------------*/

  FileSystemManager::CppFilePointer FileSystemManager::openAppFileCpp(const std::string & name,
                                                                        const FileOperation & operation)
        const
  {
        return openFileCpp(mAppDirectory + name, operation);
  }

 /*----------------------------------------------------------------------*/

  FileSystemManager::CppFilePointer FileSystemManager::openDataFileCpp(const std::string & name,
                                                                         const FileOperation & operation)
        const
  {
        return openFileCpp(mDataDirectory + name, operation);
  }

 /*----------------------------------------------------------------------*/

  std::string FileSystemManager::getPathDataFile(const std::string & name) const
  {
        return mDataDirectory + name;
  }

 /*----------------------------------------------------------------------*/

  std::string FileSystemManager::readTextFile(const std::string & name) const
  {
        CppFilePointer fp(openFileCpp(name, FileSystemManager::READ));

        const u32 lineBufSize = 1024;
        char lineBuf[lineBufSize];

        std::ostringstream osstr;

        while(!fp->eof())
        {
         fp->getline(lineBuf, lineBufSize);
         osstr << lineBuf << std::endl;
        }

        FileSystemManager::getInstance()->closeFile(fp);
        return osstr.str();
  }

 /*----------------------------------------------------------------------*/

  std::string FileSystemManager::readAppTextFile(const std::string & name) const
  {
        return readTextFile(mAppDirectory + name);
  }

 /*----------------------------------------------------------------------*/

  std::string FileSystemManager::readDataTextFile(const std::string & name) const
  {
        return readTextFile(mDataDirectory + name);
  }

 /*----------------------------------------------------------------------*/

  void FileSystemManager::_findHomeDirectory()
  {
        mHomeDirectory = Application::getInstance()->getEnvironmentVariable("HOME") + "/";
  }

 /*----------------------------------------------------------------------*/

  std::string FileSystemManager::_replaceHomeChar(const std::string & path) const
  {
        std::string _path = path;
        /*
         * int pos = _path.find("~/");
         * 
         * if(pos != std::string::npos)
         * _path.replace(pos, 2, mHomeDirectory);
         */
        StringConverter::trim(_path);
        if(_path.substr(0, 2) == "~/")
         _path = mHomeDirectory + _path.substr(2);

        return _path;
  }

 /*----------------------------------------------------------------------*/

  std::string FileSystemManager::_translateToAbsolutePath(const std::string & path) const
  {
        // Create relative path by replacing '~' to home directory
        std::string relpath = _replaceHomeChar(path);

        // Jump out if the path is already absolute path
        if(relpath.substr(0, 1) == PATH_SEPARATOR)
         return relpath;

        bool directory = relpath.substr(relpath.length() - 1) == PATH_SEPARATOR;

        typedef std::queue < char *>QueuePtrChar;
        typedef std::stack < char *>StackPtrChar;

        char _abspath[MAX_PATH];

        std::string acTmpCurrDir = mCurrentDirectory;
        std::string acTmpRelPath = relpath;

        QueuePtrChar tmpQueueRelPath;
        StackPtrChar tmpStackCurrPath;
        StackPtrChar tmpStackOutPath;

        char *sTmp = strtok((char *) acTmpRelPath.c_str(), PATH_SEPARATOR.c_str());

        while(sTmp)
        {
         tmpQueueRelPath.push(sTmp);
         sTmp = strtok(0, PATH_SEPARATOR.c_str());
        }

        sTmp = strtok((char *) acTmpCurrDir.c_str(), PATH_SEPARATOR.c_str());
        while(sTmp)
        {
         tmpStackCurrPath.push(sTmp);
         sTmp = strtok(0, PATH_SEPARATOR.c_str());
        }

        while(tmpQueueRelPath.size() > 0)
        {
         char *pcTmp = tmpQueueRelPath.front();

         if(strcmp(pcTmp, "..") == 0)
                tmpStackCurrPath.pop();
         else
                tmpStackCurrPath.push(pcTmp);
         tmpQueueRelPath.pop();
        }
        while(tmpStackCurrPath.size() > 0)
        {
         tmpStackOutPath.push(tmpStackCurrPath.top());
         tmpStackCurrPath.pop();
        }

        sTmp = _abspath;
#if defined(__GNUC__)
        *sTmp++ = PATH_SEPARATOR.c_str()[0];
#endif
        while(tmpStackOutPath.size() > 0)
        {
         char *pcTmp = tmpStackOutPath.top();

         while(*pcTmp != '\0')
                *sTmp++ = *pcTmp++;
         tmpStackOutPath.pop();
         *sTmp++ = PATH_SEPARATOR.c_str()[0];
        }
        *(--sTmp) = '\0';

        return std::string(_abspath) + (directory ? PATH_SEPARATOR : "");
  }

 /*----------------------------------------------------------------------*/

  void FileSystemManager::_createAppDirectory()
  {
        // Creating application directory
        createDirectory(mAppDirectory);
  }

 /*----------------------------------------------------------------------*/

}

© Copyright - 2006 (IT)² ParCompMark Dev. Team