ObjMapMgr Class Reference

#include <ObjMapMgr.h>

Public Member Functions
	ObjMapMgr ()
	~ObjMapMgr ()
int	Initialize (int Size, unsigned int BlockSize, int MaxReplications, int UseReplications, DiskMgr *DiskMgr, ostream *LogStream)
int	Start ()
int	Stop ()
int	Open (char *Name, RioAccess Access, RioObject **Object)
void	CleanUpDelete ()
int	GetObjectInfo (char *Name, ObjectInfo *ObjectInfo)
int	createobject (char *name)
Static Public Attributes
static const int	OBJHDRSIZE = 64
Private Attributes
int	m_used
int	m_n
unsigned int	m_BlockSize
int	m_MaxReplications
int	m_UseReplications
DiskMgr *	m_DiskMgr
pthread_mutex_t	m_mutexmeta
pthread_mutex_t	m_mutexfast
ostream *	m_log
Friends
class	RioObject

---

Detailed Description

Definition at line 174 of file ObjMapMgr.h.

---

Constructor & Destructor Documentation

ObjMapMgr::ObjMapMgr

(

)

Definition at line 63 of file ObjMapMgr.cpp.

{
    m_used            = 0;
    m_n               = 0;
    m_BlockSize       = 0;
    m_MaxReplications = 0;
    m_UseReplications = 0;
    m_DiskMgr         = NULL;
    m_log             = NULL;
    pthread_mutex_init( &m_mutexmeta, NULL );
    pthread_mutex_init( &m_mutexfast, NULL );
}

ObjMapMgr::~ObjMapMgr

(

)

Definition at line 77 of file ObjMapMgr.cpp.

{
    pthread_mutex_destroy(&m_mutexmeta);
    pthread_mutex_destroy(&m_mutexfast);
}

---

Member Function Documentation

void ObjMapMgr::CleanUpDelete

(

)

int ObjMapMgr::createobject

(

char *

name

)

Definition at line 131 of file ObjMapMgr.cpp.

{
    int handle, nbytes, rc, error = 0;
    ObjectHeader header;

    pthread_mutex_lock(&m_mutexmeta);

    handle = open( name, O_RDWR | O_CREAT | O_EXCL, 0700 );
    if( handle == -1 )
    {
        error = errno;
    }

    if( handle == -1 )
    {
        (*m_log) << "Create object failed " << strerror(errno) << endl;
        switch (error)
        {
            case EEXIST:
                rc = ERROR_OBJECTMANAGER + ERROR_OBJECT_EXISTS;
                goto unlockret;

            case EISDIR:
            case ENAMETOOLONG:
            case ENOENT:
            case ENOTDIR:
                rc = ERROR_OBJECTMANAGER + ERROR_INVALID_OBJECTNAME;
                goto unlockret;

            default:
                rc = ERROR_OBJECTMANAGER + ERROR_OBJECT_OPEN_FAILED;
                goto unlockret;
        }
    }

    memset(&header, 0, sizeof(header));
    memcpy(header.Signature, ObjectSignatureValue, sizeof(header.Signature));
    header.Type      = ObjectInfo::FILE_TYPE_DATA;
    header.nRep      = m_UseReplications;
    header.BlockSize = m_BlockSize;
    header.nBlocks   = 0;
    header.Size      = 0;

    header.nullmd5 = true;

    nbytes = write( handle, &header, sizeof( header ));
    if( nbytes != sizeof( header ) )
    {
        close( handle );
        rc = ERROR_OBJECTMANAGER + ERROR_OBJECT_METADATA_WRITE;
        goto unlockret;
    }
    close( handle );
    rc = S_OK;

    unlockret:
    pthread_mutex_unlock( &m_mutexmeta );

    return rc;
}

int ObjMapMgr::GetObjectInfo	(	char *	Name,
		ObjectInfo *	ObjectInfo
	)

Definition at line 1139 of file ObjMapMgr.cpp.

{
    struct stat mystat;

    if( stat( Name, &mystat ) )
        return ERROR_OBJECTMANAGER + ERROR_OBJECT_OPEN_FAILED;

    if( S_ISREG( mystat.st_mode ) )
    {
        ObjectInfo->setType( ObjectInfo::FILE_TYPE_DATA );
    }
    else if(S_ISDIR(mystat.st_mode))
    {
        ObjectInfo->setType( ObjectInfo::FILE_TYPE_DIRECTORY );
    }
    else return ERROR_OBJECTMANAGER + ERROR_UNEXPECTED;

    struct tm LastWrite;
    AccessTime LastModificationTime;

    // convert time_t to .. using thread safe localtime_r
    localtime_r(&mystat.st_ctime, &LastWrite);
    LastModificationTime.Year       = LastWrite.tm_year+1900;
    LastModificationTime.Month      = LastWrite.tm_mon+1;
    LastModificationTime.DayOfWeek  = LastWrite.tm_wday;
    LastModificationTime.Day        = LastWrite.tm_mday;
    LastModificationTime.Hour       = LastWrite.tm_hour;
    LastModificationTime.Minute     = LastWrite.tm_min;

    ObjectInfo->setTime( LastModificationTime );

    if( ObjectInfo->isDir() )
        ObjectInfo->setPermission( 0777 );// octal (allow all for now)
    else
        ObjectInfo->setPermission( 0666 );

    if( !ObjectInfo->isDir() )
    {
        int Handle;
        pthread_mutex_lock( &m_mutexmeta );

        Handle = open( Name, O_RDWR );
        if( Handle == -1 )
        {
            RioErr << "ObjMapMgr: [Warning] Could not open " << Name
                   << " with RDRW permissions. Trying to open it with "
                   << "RDONLY permission" << endl;
            Handle = open( Name, O_RDONLY );
            if( Handle == -1 )
            {
                pthread_mutex_unlock( &m_mutexmeta );
                if(errno == ENOENT)
                    return ERROR_OBJECTMANAGER + ERROR_INVALID_OBJECTNAME;
                return ERROR_OBJECTMANAGER + ERROR_OBJECT_OPEN_FAILED;
            }
        }

        ObjectHeader header;
        int nbytes;

        // Read object metadata and make sure it is a valid RIO object
        nbytes = read( Handle, &header, sizeof( header ));
        pthread_mutex_unlock( &m_mutexmeta );

        if( ( nbytes != sizeof( header )) || (header.BlockSize != m_BlockSize) ||
           ( memcmp( header.Signature, ObjectSignatureValue,
                     sizeof(ObjectSignatureValue))) )
        {
            close(Handle);
            (*m_log) << "ObjMapMgr.GetObjectInfo(): "
                     << "Object metadata is corrupted" << endl;
            return ERROR_OBJECTMANAGER + ERROR_OBJECT_METADATA_CORRUPTED;
        }

        // Close object
        close(Handle);

        // Update object size
        ObjectInfo->setSize( header.Size );

        // Fill MD5sum field
        if( header.nullmd5 )
            ObjectInfo->setMd5sum( NULL );
        else
        {
            char hexmd5sum[33];
            char hex[17] = "0123456789abcdef";
            for( int i = 0; i < 16; ++i ) 
            {
                hexmd5sum[2*i]     = hex[ ((unsigned char)header.md5sum[i]) >> 4 ];
                hexmd5sum[2*i + 1] = hex[ ((unsigned char)header.md5sum[i]) & 15 ];
            }
            hexmd5sum[32] = '\0';
            ObjectInfo->setMd5sum( hexmd5sum );
        }

        // Preenche o campo VideoRate de ObjectInfo com a informacao obtida do
        // objeto (usado pelo controle de fluxo) [um arquivo].
        if( header.VideoRate == 0 ) // Metadados antigo -> usamos o valor 
                                    // default.
            ObjectInfo->setVideoRate( DEFAULTVIDEORATE );                         
        else                            
            ObjectInfo->setVideoRate( header.VideoRate );
       
    }
    else
    {
        ObjectInfo->setSize( 0 );

        ObjectInfo->setMd5sum( NULL );

        // Preenche o campo VideoRate de ObjectInfo com a informacao obtida do
        // objeto (usado pelo controle de fluxo) [um diretorio].
        ObjectInfo->setVideoRate( 0 );
    }

    // Fill in User and Group owner with Invalid value for now
    ObjectInfo->setOwner( "NoUser" );
    ObjectInfo->setGroup( "NoGroup" );
    
    return S_OK;
}

int ObjMapMgr::Initialize	(	int	Size,
		unsigned int	BlockSize,
		int	MaxReplications,
		int	UseReplications,
		DiskMgr *	DiskMgr,
		ostream *	LogStream
	)

Definition at line 84 of file ObjMapMgr.cpp.

{
    if( sizeof( ObjectHeader ) != OBJHDRSIZE )
    {
        (*LogStream) << "ObjMapMgr.Initialize sizeof(ObjectHeader) "
                     << sizeof(ObjectHeader) << " not " << OBJHDRSIZE << " \n";
        return -1;
    }

    m_BlockSize = BlockSize;

    // MaxReplications aren't really used yet
    // code contains hard coded value of 2 everywhere (DiskMgr.cpp)
    // need to add replications used for object to each metadata file
    // as it determines number of disk addresses for each logical block
    m_MaxReplications = MaxReplications;
    m_UseReplications = UseReplications;

    m_DiskMgr = DiskMgr;
    m_log     = LogStream;

    // update table size and number of used entries
    m_n       = Size;
    m_used    = 0;

    return S_OK;
}

int ObjMapMgr::Open	(	char *	Name,
		RioAccess	Access,
		RioObject **	Object
	)

Definition at line 199 of file ObjMapMgr.cpp.

{
    int rc, nBytes = 0;
    off_t offset = 0;
    off_t readl = 0;

    RioObject *op = new RioObject( this );

    char *namep = new char[ strlen( Name ) + 1 ];

    if( ( op == 0 ) || ( namep == 0 ) )
    {
        delete op;
        delete [] namep;
        return ERROR_OBJECTMANAGER + ERROR_MEMORY;
    }

    strcpy(namep, Name);
    op->o_Name = namep;

    pthread_mutex_lock( &m_mutexmeta );

    m_used++;

    rc = open( op->o_Name, O_RDWR );
    if( rc == -1 )
    {
        #ifdef RIO_DEBUG2
        RioErr << "ObjMapMgr: [Warning] Could not open " << op->o_Name
               << " with RDRW permissions. Trying to open it with RDONLY "
               << "permission" << endl;
        #endif

        rc = open( op->o_Name, O_RDONLY );
        if( rc == -1 ){
            int error = errno;
            delete op;
            pthread_mutex_unlock(&m_mutexmeta);
            switch( error )
            {
                case EISDIR:
                case EACCES:
                case ENAMETOOLONG:
                case ENOENT:
                case ENOTDIR:
                    return ERROR_OBJECTMANAGER + ERROR_INVALID_OBJECTNAME;

                default:
                    return ERROR_OBJECTMANAGER + ERROR_OBJECT_OPEN_FAILED;
            }
        }
    }

    char *info = myInfo();
    (*m_log) << info << " Object Manager: opening object " << Name
             << ". active objs " << m_used << endl;
    free( info );


    op->o_FileHandle = rc;

    // Read object metadata and make sure it is a valid RIO object
    int nbytes = read( op->o_FileHandle, &op->o_Hdr, sizeof( op->o_Hdr ));

    if( nbytes != sizeof( op->o_Hdr ) )
    {
        rc = 1;
        goto err;
    }
    if( op->o_Hdr.BlockSize != m_BlockSize )
    {
        rc = 2;
        goto err;
    }
    if( memcmp( op->o_Hdr.Signature, ObjectSignatureValue,
                sizeof( ObjectSignatureValue )))
    {
        rc = 3;
        goto err;
    }
    op->o_HdrValid = 1;

    offset = lseek( op->o_FileHandle, 0, SEEK_END );
    if( offset == (off_t) -1 )
    {
        rc = 4;
        goto err;
    }
    if( ( unsigned ) offset != ( sizeof( op->o_Hdr )
            + op->o_Hdr.nBlocks * op->o_Hdr.nRep * sizeof( RioDiskBlock ) ) )
    {
        rc = 5;
        goto err;
    }
    if( ( (op->o_Hdr.Size + m_BlockSize - 1) / m_BlockSize ) !=
        op->o_Hdr.nBlocks
      )
    {
        rc = 6;
        // goto err;

        // copy operation was interrupted before finished
        // must check if this change is ok!
        RioErr << "ObjMapMgr.Open: metadata corrupt for " << op->o_Name;
        RioErr << ".Changing number of blocks from " << op->o_Hdr.nBlocks;

        op->o_Hdr.nBlocks = ( op->o_Hdr.Size + m_BlockSize - 1 ) / m_BlockSize;

        RioErr << " to " << op->o_Hdr.nBlocks  << endl;

        op->SaveObject();
        // --------------------------------------------------------------------
    }

    op->o_Map = new RioDiskBlock[ op->o_Hdr.nBlocks * op->o_Hdr.nRep ];
    if( op->o_Map == 0 )
    {
        rc = 7;
        goto err;
    }
    op->o_nMapBlocks = op->o_Hdr.nBlocks;

    offset = lseek( op->o_FileHandle, sizeof( op->o_Hdr ), SEEK_SET );
    if( offset == (off_t) -1 )
    {
        rc = 8;
        goto err;
    }

    readl = op->o_Hdr.nBlocks * op->o_Hdr.nRep * sizeof( RioDiskBlock );
    nBytes = read( op->o_FileHandle, op->o_Map, readl );
    if( nBytes != readl )
    {
        rc = 9;
        goto err;
    }
    op->o_MapValid = 1;

    pthread_mutex_lock( &m_mutexfast );
    op->o_Locked = 0;
    pthread_mutex_unlock( &m_mutexfast );

    // return ptr to RioObject
    *Object = op;
    
    // Imprime a taxa de transferencia
    
    unsigned int VideoRate, VideoRateHeader;
    VideoRateHeader = op->o_Hdr.VideoRate;
    
    pthread_mutex_unlock( &m_mutexmeta );
    
    op->GetVideoRate( &VideoRate ); 
    
    #ifdef RIO_DEBUG2
    RioErr << "ObjMapMgr.Open taxa de transferencia do objeto " 
           << Name << ": lida = " << VideoRateHeader  
           << ", alterada = " << VideoRate << endl;
    #endif

    return S_OK;

err:
    RioErr << "ObjMapMgr.Open: metadata corrupt code " << rc
           << " for "    << op->o_Name << endl;
    RioErr << " offset " << offset << " readl "  << readl
           << " nBytes " << nBytes << endl;
    op->PrintHdr();
    delete op;
    pthread_mutex_unlock(&m_mutexmeta);
    return ERROR_OBJECTMANAGER + ERROR_OBJECT_METADATA_CORRUPTED;
}

int ObjMapMgr::Start

(

void

)

Definition at line 117 of file ObjMapMgr.cpp.

{
    return S_OK;
}

int ObjMapMgr::Stop

(

void

)

Definition at line 123 of file ObjMapMgr.cpp.

{
    // Can only stop if table is not being used
    return S_OK;
}

---

Friends And Related Function Documentation

friend class RioObject [friend]

Definition at line 194 of file ObjMapMgr.h.

---

Field Documentation

unsigned int ObjMapMgr::m_BlockSize [private]

Definition at line 179 of file ObjMapMgr.h.

DiskMgr* ObjMapMgr::m_DiskMgr [private]

Definition at line 182 of file ObjMapMgr.h.

ostream* ObjMapMgr::m_log [private]

Definition at line 192 of file ObjMapMgr.h.

int ObjMapMgr::m_MaxReplications [private]

Definition at line 180 of file ObjMapMgr.h.

pthread_mutex_t ObjMapMgr::m_mutexfast [private]

Definition at line 190 of file ObjMapMgr.h.

pthread_mutex_t ObjMapMgr::m_mutexmeta [private]

Definition at line 186 of file ObjMapMgr.h.

int ObjMapMgr::m_n [private]

Definition at line 178 of file ObjMapMgr.h.

int ObjMapMgr::m_used [private]

Definition at line 177 of file ObjMapMgr.h.

int ObjMapMgr::m_UseReplications [private]

Definition at line 181 of file ObjMapMgr.h.

const int ObjMapMgr::OBJHDRSIZE = 64 [static]

Definition at line 216 of file ObjMapMgr.h.

---

The documentation for this class was generated from the following files:

• ObjMapMgr.h
• ObjMapMgr.cpp