FesaStream.cpp

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI

#include <fesa-core/Diagnostic/FesaStream.h>

#include <cmw-log/Logger.h>

#include <sys/stat.h>


namespace
{

CMW::Log::Logger& logger = CMW::Log::LoggerFactory::getLogger("FESA.FWK.fesa-core.Diagnostic.FesaStream");

} // namespace


namespace fesa
{

std::string
FesaStream::configHeader_ =
    "<?xml version= '1.0' encoding= 'UTF-8'?>\n<Fesa-class-configuration xmlns:xsi= \"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation =\"\" ";
std::string FesaStream::configFooter_ = "</fesa-class-configuration>";

std::string
FesaStream::stateHeader_ =
    "<?xml version= '1.0' encoding= 'UTF-8'?>\n<Fesa-class-state xmlns:xsi= \"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation =\"\">";
std::string FesaStream::stateFooter_ = "</fesa-class-state>";

std::map<std::string, FesaStream *> FesaStream::fileFactoryMap_;


FesaStream::FesaStream(const std::string streamName)
{
    /* The configuration file has the following name: "<class><Server|Rt>Config.xml"
     * /tmp will be used to store it (volatile).
     * This UNIX std. folder is created with rw access and T sticky-bit: force owner write access only.
     * umask() can be used to set initial permission at file creation.
     */
    fileName_ = "/tmp/" + streamName + ".xml";
}

/* -------------------------------------------------------------------------
 */
FesaStream* FesaStream::getFileStream(const std::string streamName)
{

    FesaStream* pFileStream;
    std::map<std::string, FesaStream *>::iterator itr = fileFactoryMap_.find(streamName);
    if (itr != fileFactoryMap_.end())
    {
        //This FesaStream has already been defined
        pFileStream = (FesaStream *) ((*itr).second);
    }
    else
    {
        pFileStream = new FesaStream(streamName);
        //register the new instance
        fileFactoryMap_[streamName] = pFileStream;
    }

    return pFileStream;
}

/* -------------------------------------------------------------------------
 */
bool FesaStream::update()
{

    // This method is used to create the file in one-shot process
    // open file, insert header, append with current string buffer and footer
    // close file
    // file is overwrited each time updateFile is called
    // true: means everything is ok
    // false: something is wrong: file does not exist ...
    bool ret;

    // /tmp will be used to store the configuration file (rw access with T sticky-bit: only owner write access)
    // create files and directories with rw public access: disable the sticky-bit protection
    int32_t oldUmask = umask(0);

    try
    {
        fileStream_.open(fileName_.c_str(), std::ios::out);
    }
    catch (...)
    { // Just because an open can throw an exception
    }

    if (fileStream_.fail())
    {
        std::ostringstream errorStrStream;
        errorStrStream << "Failed to opene file " << fileName_;
        LOG_ERROR_IF(logger, errorStrStream.str());
        // clear the state flags
        fileStream_.clear();
        ret = false;
    }
    else
    {
        // Start with Header
        fileStream_ << *fileHeader_;

        // Insert current string buffer
        fileStream_ << str();

        // End with Footer and close
        fileStream_ << *fileFooter_;
        fileStream_.close();
        ret = true;
    }

    umask(oldUmask); //Restore original umask
    return ret;
}

/* -------------------------------------------------------------------------
 */
bool FesaStream::read(std::string& text)
{

    // This method is used to read a file
    // Complete text is stored in the string parameter
    // true: means everything is ok
    // false: something is wrong: file does not exist ...
    std::ifstream infile(fileName_.c_str());

    if (infile.good())
    {
        std::string line;
        try
        {
            text.erase();
            infile.is_open();
            while (getline(infile, line))
            {
                text.append(line);
                line.erase();
                if (!infile.eof())
                    text.append("\n");
            }
            return true;
        }
        catch (...)
        {
            return false;
        }
    }
    return false;
}

//instantiate or just retrieve a config stream object (one FesaStream per independent Fesa project).
FesaStream* FesaStream::getConfigStream(const std::string streamName)
{
    FesaStream* pFileStream = getFileStream(streamName + "Config");
    pFileStream->fileHeader_ = &configHeader_;
    pFileStream->fileFooter_ = &configFooter_;
    return pFileStream;
}

FesaStream* FesaStream::getStateStream(const std::string streamName)
{
    FesaStream* pFileStream = getFileStream(streamName + "State");
    pFileStream->fileHeader_ = &stateHeader_;
    pFileStream->fileFooter_ = &stateFooter_;
    return pFileStream;
}

}