root/ossie/branches/philip-work/framework/FileSystem_impl.cpp @ 3269

/****************************************************************************

Copyright 2004, 2007, Virginia Polytechnic Institute and State University

This file is part of the OSSIE Core Framework.

OSSIE Core Framework is free software; you can redistribute it and/or modify
it under the terms of the Lesser GNU General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

OSSIE Core Framework 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
Lesser GNU General Public License for more details.

You should have received a copy of the Lesser GNU General Public License
along with OSSIE Core Framework; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

****************************************************************************/

/* SCA */

#include <iostream>
#include <string>

#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>

#include "ossie/FileSystem_impl.h"
#include "ossie/debug.h"

FileSystem_impl::FileSystem_impl ()
{
    DEBUG(6, FileSystem, "In constructor.");

    if (boost::filesystem::path::default_name_check_writable())
        boost::filesystem::path::default_name_check(boost::filesystem::portable_posix_name);

    root = boost::filesystem::initial_path();

    init ();
}


FileSystem_impl::FileSystem_impl (char *_root)
{
    DEBUG(6, FileSystem, "In constructor with " << _root);

    root = _root;

    init ();
}


void
FileSystem_impl::init ()
{
    DEBUG(6, FileSystem, "In init()");
}

FileSystem_impl::~FileSystem_impl ()
{
    DEBUG(6, FileSystem, "In destructor.");
}

void FileSystem_impl::remove (const char *fileName) throw (CORBA::SystemException, CF::FileException, CF::InvalidFileName)
{
    DEBUG(6, FileSystem, "In remove with " << fileName);

    if (!ossieSupport::isValidFileName(fileName)) {
        DEBUG(7, FileSystem, "remove passed bad filename, throwing exception.");
        throw CF::InvalidFileName (CF::CFEINVAL, "[FileSystem::remove] Invalid file name");
    }

    boost::filesystem::path fname(root / fileName);

    DEBUG(6, FileSystem, "About to remove file " << fname.string());
    bool exists = boost::filesystem::remove(fname);

    if (!exists) {
        DEBUG(6, FileSystem, "Attempt to remove non-existant file.");
        throw (CF::FileException (CF::CFEEXIST, "[FileSystem_impl::remove] Error removing file from file system"));
    }
}

void FileSystem_impl::copy (const char *sourceFileName, const char *destinationFileName) throw (CORBA::SystemException, CF::InvalidFileName, CF::FileException)
{
    DEBUG(6, FileSystem, "In copy from " << sourceFileName << " to " << destinationFileName);

    if (!ossieSupport::isValidFileName(sourceFileName) || !ossieSupport::isValidFileName(destinationFileName)) {
        DEBUG(7, FileSystem, "copy passed bad filename, throwing exception.");
        throw CF::InvalidFileName (CF::CFEINVAL, "[FileSystem::copy] Invalid file name");
    }


    boost::filesystem::path sFile(root / sourceFileName);
    boost::filesystem::path dFile(root / destinationFileName);

    ///\todo Add proper exception handling

    boost::filesystem::copy_file(sFile, dFile);
}

CORBA::Boolean FileSystem_impl::exists (const char *fileName)
throw (CORBA::SystemException, CF::InvalidFileName)
{
    DEBUG(6, FileSystem, "In exists with " << fileName);

    if (!ossieSupport::isValidFileName(fileName)) {
        DEBUG(7, FileSystem, "exists passed bad filename, throwing exception.");
        throw CF::InvalidFileName (CF::CFEINVAL, "[FileSystem::exists] Invalid file name");
    }

    boost::filesystem::path fname(root / fileName);

    return(boost::filesystem::exists(fname));
}


/// \todo: modify to search the pattern as a regular expression
CF::FileSystem::FileInformationSequence* FileSystem_impl::list (const char *pattern) throw (CORBA::SystemException, CF::FileException, CF::InvalidFileName)
{
    DEBUG(6, FileSystem, "In list with " << pattern);
    
    boost::filesystem::path filePath(pattern);
    std::string searchName(filePath.leaf());
    boost::filesystem::path dirPath(root / filePath.branch_path());

    CF::FileSystem::FileInformationSequence_var result;
    unsigned int idx(0);

    boost::filesystem::directory_iterator end_itr; // past the end
    for (boost::filesystem::directory_iterator itr(dirPath); itr != end_itr; ++itr) {
        if (itr->leaf().find(searchName) == std::string::npos) {
            result->length(idx + 1);
            boost::filesystem::path foundPath(filePath.branch_path() / itr->leaf());
            result[idx].name = CORBA::string_dup(foundPath.root_directory().c_str());
            if (boost::filesystem::is_directory(*itr))
                result[idx].kind = CF::FileSystem::DIRECTORY;
            else
                result[idx].kind = CF::FileSystem::PLAIN;

            result[idx].size = boost::filesystem::file_size(*itr);

            /// \todo fix file creation time and last access time
            CF::Properties prop;
            prop.length(3);
            prop[0].id = CORBA::string_dup(CF::FileSystem::CREATED_TIME_ID);
            prop[0].value <<= boost::filesystem::last_write_time(*itr);
            prop[1].id = CORBA::string_dup(CF::FileSystem::MODIFIED_TIME_ID);
            prop[1].value <<= boost::filesystem::last_write_time(*itr);
            prop[2].id = CORBA::string_dup(CF::FileSystem::LAST_ACCESS_TIME_ID);
            prop[2].value <<= boost::filesystem::last_write_time(*itr);

            result[idx].fileProperties = prop;
            ++idx;
        }
    }
    return result._retn();
}


CF::File_ptr FileSystem_impl::create (const char *fileName) throw (CORBA::SystemException, CF::InvalidFileName, CF::FileException)
{
    DEBUG(6, FileSystem, "In create with " << fileName);

    if (!ossieSupport::isValidFileName(fileName)) {
        DEBUG(7, FileSystem, "create passed bad filename, throwing exception.");
        throw CF::InvalidFileName (CF::CFEINVAL, "[FileSystem::create] Invalid file name");
    }

    if (exists(fileName)) {
        DEBUG(6, FileSystem, "FileName exists in create, throwing exception.");
        throw CF::FileException(CF::CFEEXIST, "File exists.");
    }

    File_impl *file = new File_impl (fileName, root, false, true);
    CF::File_var fileServant = file->_this();

    fileInfo newFile;
    newFile.fileName = fileName;
    newFile.servant = fileServant;
    files.push_back(newFile);

    return fileServant._retn();
}

CF::File_ptr FileSystem_impl::open (const char *fileName, CORBA::Boolean read_Only) throw (CORBA::SystemException, CF::InvalidFileName, CF::FileException)
{
    DEBUG(6, FileSystem, "In open with " << fileName);

    if (!ossieSupport::isValidFileName(fileName)) {
        DEBUG(7, FileSystem, "open passed bad filename, throwing exception.");
        throw CF::InvalidFileName (CF::CFEINVAL, "[FileSystem::open] Invalid file name");
    }

    boost::filesystem::path filePath(root / fileName);

    File_impl *file = new File_impl (fileName, root, read_Only, false);
    CF::File_var fileServant = file->_this();

    fileInfo newFile;
    newFile.fileName = fileName;
    newFile.servant = fileServant;
    files.push_back(newFile);

    return fileServant._retn();
}


void FileSystem_impl::mkdir (const char *directoryName) throw (CORBA::SystemException, CF::FileException, CF::InvalidFileName)
{
    DEBUG(6, FileSystem, "In mkdir with " << directoryName);

    if (!ossieSupport::isValidFileName(directoryName)) {
        DEBUG(7, FileSystem, "mkdir passed bad filename, throwing exception.");
        throw CF::InvalidFileName (CF::CFEINVAL, "[FileSystem::mkdir] Invalid file name");
    }

    boost::filesystem::path dirPath(root / directoryName);

    boost::filesystem::path::iterator walkPath(dirPath.begin());
    boost::filesystem::path currentPath;
    while (walkPath != dirPath.end()) {
        DEBUG(9, FileSystem, "Walking path to create directories, current path " << currentPath.string());
        currentPath /= *walkPath;
        if (!boost::filesystem::exists(currentPath)) {
            DEBUG(9, FileSystem, "Creating directory " << currentPath.string());
            try {
                boost::filesystem::create_directory(currentPath);
            } catch (...) {
                throw CF::FileException (CF::CFENFILE, "[FileSystem::mkdir] Failed to create directory");
            }
        }
        ++walkPath;
    }
}

void FileSystem_impl::rmdir (const char *directoryName) throw (CORBA::SystemException, CF::FileException, CF::InvalidFileName)
{
    DEBUG(6, FileSystem, "In rmdir with " << directoryName);

    if (!ossieSupport::isValidFileName(directoryName)) {
        DEBUG(7, FileSystem, "rmdir passed bad directory name, throwing exception.");
        throw CF::InvalidFileName (CF::CFEINVAL, "[FileSystem::rmdir] Invalid directory name");
    }

    boost::filesystem::path dirPath(root / directoryName);

    ///\todo Fix case where directory contains only other empty directories
    try {
        boost::filesystem::remove(dirPath);
    } catch (...) {
    }
}


void FileSystem_impl::query (CF::Properties & fileSysProperties) throw (CORBA::SystemException, CF::FileSystem::UnknownFileSystemProperties)
{
    DEBUG(6, FileSystem, "In query");
#if 0  ///\todo Implement query operations
    bool check;

    for (unsigned int i = 0; i < fileSysProperties.length (); i++)
    {
        check = false;
        if (strcmp (fileSysProperties[i].id, CF::FileSystem::SIZE) == 0)
        {
            struct stat fileStat;
            stat (root, &fileStat);
//          fileSysProperties[i].value <<= fileStat.st_size;  /// \bug FIXME
            check = true;
        }
        if (strcmp (fileSysProperties[i].id,
            CF::FileSystem::AVAILABLE_SIZE) == 0)
        {
//to complete
        }
        if (!check)
            throw CF::FileSystem::UnknownFileSystemProperties ();
    }
#endif
}

///\todo Implement File object reference clean up.