mumulib.h

Go to the documentation of this file.

/**
 * @file   mumulib.h
 * @author Sergey Satskiy
 * @brief  C++ template library for mumufs.
 *
 * Copyright (C) 2007 - 2009 Sergey Satskiy.
 *
 * This file is released under the GPL.
 */



#ifndef MUMULIB_H
#define MUMULIB_H

#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/time.h>

#include <string>
#include <stdexcept>


    /**
     * @brief The library namespace
     */
namespace mumu
{
        /**
         * @brief The way to open a file
         */
    enum RWMode
    {
        ReadOnly  = O_RDONLY,
        WriteOnly = O_WRONLY,
        ReadWrite = O_RDWR
    };

        /**
         * @brief The template represents a single file on mumufs
         */
    template <typename  Type>
    class Entry
    {
        private:
            int     fd;     //!< File descritor
            RWMode  mode;   //!< How the file was opened

        public:
                /**
                 * @brief Constructs a single entry. Creates the corresponding
                 *        file if it does not exist
                 * @param path Path to a file on mumufs.
                 * @param openMode How to open a file. Default is ReadWrite.
                 * @param isBlocking file opening mode. Default is blocking.
                 * @exception std::runtime_error in case of problems
                 *
                 * The blocking mode matters for read(...) calls only
                 */
            explicit Entry( const std::string &  path,
                            RWMode               openMode = ReadWrite,
                            bool                 isBlocking = true ) : fd( -1 ), mode( openMode )
            {
                int     flags( openMode | O_CREAT );
                if ( !isBlocking )  flags |= O_NONBLOCK;

                fd = open( path.c_str(), flags, S_IRUSR | S_IWUSR |
                                                S_IRGRP | S_IWGRP |
                                                S_IROTH | S_IWOTH );
                if ( fd < 0 )       throw std::runtime_error( "Cannot open the given entry." );
            }

                /**
                 * @brief Closes the file
                 */
            ~Entry()
            {
                close( fd );
            }

                /**
                 * @brief Constructs a copy of entry
                 * @param rhs Pattern
                 * @exception std::runtime_error in case of errors
                 */
            Entry( const Entry &  rhs ) : fd( dup( rhs.fd ) )
            {
                if ( fd < 0 )       throw std::runtime_error( "Cannot duplicate file descriptor." );
            }

        private:
                /* No way for assigning */
            Entry &  operator= ( const Entry &  rhs );

        protected:

                /**
                 * @brief Utility function to add two timeval values
                 * @param Left First timeval
                 * @param Right Second timeval
                 * @return Addition result
                 */
            struct timeval AddTimeval( const struct timeval &  Left,
                                       const struct timeval &  Right ) const
            {
                struct timeval      Result;

                Result.tv_sec = Left.tv_sec + Right.tv_sec;
                Result.tv_usec = Left.tv_usec + Right.tv_usec;
                while ( Result.tv_usec >= 1000000 )
                {
                    ++Result.tv_sec;
                    Result.tv_usec -= 1000000;
                }
                return Result;
            }

                /**
                 * @brief Utility function to subtract two timeval values
                 * @param Left First timeval
                 * @param Right Second timeval
                 * @return Subtraction result
                 */
            struct timeval SubTimeval( const struct timeval &  Left,
                                       const struct timeval &  Right ) const
            {
                struct timeval      Result;

                Result.tv_sec = Left.tv_sec - Right.tv_sec;
                Result.tv_usec = Left.tv_usec - Right.tv_usec;
                while ( Result.tv_usec < 0 )
                {
                    --Result.tv_sec;
                    Result.tv_usec += 1000000;
                }
                return Result;
            }

                /**
                 * @brief Utility function to compare two timeval values
                 * @param Left First timeval
                 * @param Right Second timeval
                 * @return First < Second
                 */
            bool LessTimeval( const struct timeval &  Left,
                              const struct timeval &  Right ) const
            {
                if ( Left.tv_sec < Right.tv_sec )   return true;
                if ( Left.tv_sec > Right.tv_sec )   return false;
                return Left.tv_usec < Right.tv_usec;
            }

                /**
                 * @brief Retrieves file size in bytes
                 * @return File size in bytes
                 * @exception Throws std::runtime_error in case of fstat() call
                 * errors
                 */
            off_t GetFileSize( void ) const
            {
                struct stat     fileInfo;

                if ( fstat( fd, &fileInfo ) != 0 )
                {
                    throw std::runtime_error( "Cannot get fstat" );
                }
                return fileInfo.st_size;
            }

        public:

                /**
                 * @brief select(...) for the file on mumufs
                 * @param inTimeout select timeout. It could be NULL. If NULL then waits forever.
                 * @return true if Entry is ready for reading without blocking.
                 * @exception if the open mode is WriteOnly
                 */
            bool Select( struct timeval *  inTimeout )
            {
                if ( mode == WriteOnly ) throw std::runtime_error( "Select for WriteOnly mode is not supported" );

                fd_set             Set;
                struct timeval     AbsoluteEnd;
                struct timeval     Timeout;
                struct timeval *   Argument( NULL );

                if ( inTimeout != NULL )
                {
                    Timeout = *inTimeout;
                    Argument = &Timeout;
                    gettimeofday( &AbsoluteEnd, NULL );
                    AbsoluteEnd = AddTimeval( AbsoluteEnd, Timeout );
                }


                FD_ZERO( &Set );
                FD_SET( fd, &Set );

                int         RetVal;

                for ( ; ; )
                {
                    RetVal = select( fd + 1, &Set, NULL, NULL, Argument );

                        // We have exactly 1 fd so this check is enough for this specific case
                    if ( RetVal >= 1 ) return true;
                    if ( RetVal == 0 ) return false;

                        // The last case is RetVal < 0 => error
                    if ( errno == EINTR )
                    {
                        // It is the timeout exceeded, we need to call select again
                        // We can reach this point only if we had !NULL timeout
                        FD_ZERO( &Set );
                        FD_SET( fd, &Set );

                        struct timeval  Current;
                        gettimeofday( &Current, NULL );

                        if ( LessTimeval( AbsoluteEnd, Current ) )    return false;

                        Timeout = SubTimeval( AbsoluteEnd, Current );
                        continue;
                    }

                    throw std::runtime_error( "Select call error." );
                }
            }

                /**
                 * @brief Write a raw buffer to the entry
                 * @param Buffer Pointer to the buffer
                 * @param BufferSize Size of the buffer
                 * @exception std::runtime_error in case of problems
                 */
            void Write( const unsigned char *  Buffer, size_t  BufferSize )
            {
                if ( mode == ReadOnly ) throw std::runtime_error( "Cannot write into ReadOnly entry" );

                for ( ; ; )
                {
                    int     Bytes( write( fd, Buffer, BufferSize ) );
                    if ( Bytes == static_cast<int>(BufferSize) ) return;

                    if ( Bytes == -1 && errno == EINTR ) continue;

                    throw std::runtime_error( "Error writing to file descriptor." );
                }
            }

                /**
                 * @brief Write the given object to the entry.
                 *        Be carefull, this is the generic implementation which
                 *        supposes that the data occupies a consequent memory
                 *        address space.
                 * @param T Object to be written
                 * @exception std::runtime_error in case of problems
                 */
            void  Write( const Type &  T )
            {
                this->Write( reinterpret_cast<const unsigned char *>(&T), sizeof( T ) );
            }


                /**
                 * @brief Reads raw data into the given buffer
                 * @param Buffer Pointer to the buffer
                 * @param BufferSize Size of the provided buffer
                 * @return Number of bytes that were actually read or -1 if the
                 *         buffer is not big enough
                 *         0 if no data is available
                 * @exception std::runtime_error in case of errors
                 */
            int  Read( unsigned char *  Buffer, size_t  BufferSize )
            {
                if ( mode == WriteOnly ) throw std::runtime_error( "Cannot read from WriteOnly entry" );

                for ( ; ; )
                {
                    int     Bytes( read( fd, Buffer, BufferSize ) );
                    if ( Bytes > 0 ) return Bytes;
                    if ( Bytes == -1 && errno == EINTR ) continue;
                    if ( Bytes == -1 && errno == EAGAIN ) return 0;
                    if ( Bytes == -1 && errno == EINVAL ) return -1;

                    throw std::runtime_error( "Error reading from file descriptor." );
                }
            }

                /**
                 * @brief reading of entry. It suits for blocking mode.
                 * @return A constructed object
                 */
            Type  Read( void )
            {
                Type    T;
                Read( T );
                return T;
            }

                /**
                 * @brief reading of entry. It suits for non-blocking mode.
                 * @param T A reference to the object to be filled
                 * @exception std::runtime_error in case of errors
                 * @return 0 - no new data available, positive value - # of bytes read
                 */
            int  Read( Type &  T )
            {
                if ( mode == WriteOnly ) throw std::runtime_error( "Cannot read from WriteOnly entry" );
                for ( ; ; )
                {
                    int     Bytes( read( fd, &T, sizeof( T ) ) );
                    if ( Bytes == sizeof( T ) ) return Bytes;

                    if ( Bytes == -1 && errno == EINTR ) continue;
                    if ( Bytes == -1 && errno == EAGAIN ) return 0;

                    throw std::runtime_error( "Error reading from file descriptor" );
                }
            }
    };


        /**
         * @brief Write specialisation for std::string.
         * @param T Object to be written
         * @exception std::runtime_error in case of problems
         */
    template <>
    void  Entry< std::string >::Write( const std::string &  T )
    {
        if ( mode == ReadOnly ) throw std::runtime_error( "Cannot write into ReadOnly entry" );

        size_t      size( T.size() + 1 );   // +1 is for trailing \0
        for ( ; ; )
        {
            int  Bytes( write( fd, T.c_str(), size ) );
            if ( Bytes == static_cast< int >( size ) ) return;

            if ( Bytes == -1 && errno == EINTR ) continue;

            throw std::runtime_error( "Error writing to file descriptor" );
        }
    }

        /**
         * @brief reading specilisation for std::string. It suits for non-blocking mode.
         * @param S A reference to the object to be filled
         * @exception std::runtime_error in case of errors
         * @return 0 - no new data available, positive value - # of bytes read
         */
    template <>
    int  Entry< std::string >::Read( std::string &  S )
    {
        if ( mode == WriteOnly ) throw std::runtime_error( "Cannot read from WriteOnly entry" );

        off_t           BufferSize( GetFileSize() + 1 );
        char *          Buffer( new char[ BufferSize ] );

        for ( ; ; )
        {
            int     Bytes( read( fd, Buffer, BufferSize ) );

            if ( Bytes > 0 && Bytes < static_cast<int>( BufferSize ) )
            {
                if ( Buffer[ Bytes - 1 ] == '\0' )  S = std::string( Buffer, Bytes - 1 );
                else                                S = std::string( Buffer, Bytes );
                delete [] Buffer;
                return Bytes;
            }

            if ( Bytes == -1 && errno == EAGAIN ) { delete [] Buffer; return 0; }   // Blocking IO
            if ( Bytes == -1 && errno == EINTR ) continue;
            if ( Bytes == -1 && errno == EINVAL )
            {
                delete [] Buffer;
                BufferSize = GetFileSize() + 1;
                Buffer = new char[ BufferSize ];
                continue;
            }

            delete [] Buffer;
            throw std::runtime_error( "Error reading from file descriptor" );
        }
    }


        /**
         * @brief reading specialisation for std::string. It suits for non-blocking mode.
         * @exception std::runtime_error in case of errors
         * @return 0 - no new data available, positive value - # of bytes read
         */
    template <>
    std::string  Entry< std::string >::Read( void )
    {
        std::string     S;
        Read( S );
        return S;
    }

}   // End of mumu namespace


#endif