root/ossie/trunk/ossie/framework/LoadableDevice_impl.cpp @ 3646

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

Copyright 2004, 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

LOADABLEDEVICE_IMPL.CPP
Functions for class LoadableDevice_impl. Provides a mechanism to load and unload
software on the device.

Craig Neely, Carlos Aguayo, 12 December 2003

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

#include <fstream>
#include <string>
#include <iostream>

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

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

namespace fs = boost::filesystem;

LoadableDevice_impl::LoadableDevice_impl (char *id, char *lbl, char *sftwrPrfl) : Device_impl (id, lbl, sftwrPrfl)
{

    init();
}


LoadableDevice_impl::LoadableDevice_impl (char *id, char *lbl, char *sftwrPrfl, CF::Properties capacities) : Device_impl (id, lbl, sftwrPrfl, capacities)
{

    init();
}


LoadableDevice_impl::~LoadableDevice_impl ()
{
}

void LoadableDevice_impl::init()
{

    localFileRoot = "/sdr";
    localFileRoot /= label();
    fs::create_directory(localFileRoot);

    // Assumption: all executable files named as /bin/exec_name
    fs::path binDir = localFileRoot / "bin";
    fs::create_directory(binDir);
}

void LoadableDevice_impl::load (CF::FileSystem_ptr fs, const char *fileName, CF::LoadableDevice::LoadType loadKind)
throw (CORBA::SystemException, CF::Device::InvalidState,
CF::LoadableDevice::InvalidLoadKind, CF::InvalidFileName,
CF::LoadableDevice::LoadFail)
{

    //CF::File_ptr fileToLoad;                      // file pointer
    bool readOnly = true;                         // read only flag
    
    // verify that the device is in a valid state for loading
    if (!isUnlocked () || isDisabled ()) {
        throw (CF::Device::InvalidState("Cannot load. System is either LOCKED, SHUTTING DOWN or DISABLED."));
    }
    
    // verify that the loadKind is supported (only executable is supported by this version)
    if (loadKind != CF::LoadableDevice::EXECUTABLE) {
        throw CF::LoadableDevice::InvalidLoadKind ();
    }
    
    // verify the file name exists in the file system and get a pointer to it
    
    if (!fs->exists ((char *) fileName))
        throw (CF::InvalidFileName (CF::CFENOENT, "Cannot load. File name is invalid."));
    
    if (incrementFile (fileName) == 1) { // First use of file update local cache
        CF::File_var execFile = fs->open(fileName, true);
        unsigned long remoteFileSize = execFile->sizeOf();
        unsigned long localFileSize;
        if (exists(localFileRoot / fileName))
            localFileSize = fs::file_size(localFileRoot / fileName);
        else
            localFileSize = 0;

        ///\todo Make a better check for identical files
        if (remoteFileSize != localFileSize) { // Update local cache
            fs::path filePath = localFileRoot / fileName;

            std::fstream f;
            std::ios_base::openmode mode(std::ios::in|std::ios::out|std::ios::trunc);
            f.open(filePath.string().c_str(), mode);
            
            if (!f.is_open()) {
                DEBUG(3, LoadableDevice, "File " << filePath.string() << " did not open succesfully.");
                return;
            }
            
            bool done(false);
            do {
                CF::OctetSequence_var data;
                execFile->read(data, 8192);
                f.write((const char *)data->get_buffer(), data->length());

                done = (data->length() != 0);
            } while (done);
            f.close();
        }

        execFile->close();
       
    }
}


int LoadableDevice_impl::incrementFile (const char *fileName)
{
    for (unsigned int i = 0; i < loadedFiles.size (); i++) {
        if (loadedFiles[i].fileId == fileName) {
            loadedFiles[i].counter++;
            return loadedFiles[i].counter++;
        }
    }
    //If the file is not loaded yet, then add a new element to loadedFiles
    fileCount tempNode;
    tempNode.fileId = fileName;
    tempNode.counter = 1;
    loadedFiles.push_back (tempNode);
    return 1;
}


void LoadableDevice_impl::unload (const char *fileName)
throw (CORBA::SystemException, CF::Device::InvalidState, CF::InvalidFileName)
{
    
    // verify that the device is in a valid state for loading
    if (isLocked () || isDisabled ()) {
        throw (CF::Device::InvalidState("Cannot unload. System is either LOCKED or DISABLED."));
    }
    
    // decrement the list entry counter for this file
    decrementFile (fileName);
    
}


int LoadableDevice_impl::decrementFile (const char *fileName)
{
    for (unsigned int i = 0; i < loadedFiles.size (); i++) {
        if (loadedFiles[i].fileId == fileName) {
            if (--loadedFiles[i].counter == 0) {
                
                // unload fileName using API (device specific, not currently implemented)
                
                loadedFiles.erase (loadedFiles.begin () + i);
            }
            return loadedFiles[i].counter;
        }
    }
    
    //If it gets to this point the file was not loaded previously
    throw (CF::InvalidFileName (CF::CFENOENT, "Cannot unload. File was not already loaded."));
}


bool LoadableDevice_impl::isFileLoaded (const char *fileName)
{
    for (unsigned int i = 0; i < loadedFiles.size (); i++) {
        if (loadedFiles[i].fileId == fileName) {
            return true;
        }
    }
    return false;
}


void LoadableDevice_impl ::configure (const CF::Properties & capacities)
throw (CF::PropertySet::PartialConfiguration, CF::PropertySet::
InvalidConfiguration, CORBA::SystemException)
{
    Device_impl::configure(capacities);
}


#ifdef AUTOMATIC_TEST

/* displayLoadedFiles *****************************************************************************
    - prints the list of loaded files to the console (not currently implemented)
************************************************************************************************ */
void LoadableDevice_impl::displayLoadedFiles()
{
    printf("\nDisplaying Loaded Files\n\n");
    for(int i = 0; i<loadedFiles.size();i++)
    {
        printf("%s has been loaded %d time(s)\n",loadedFiles[i].fileId,loadedFiles[i].counter);
    }

}
#endif