CSystemManager Class Reference

#include <SystemManager.h>

Public Member Functions
	CSystemManager ()
	~CSystemManager ()
int	Run (int DebugFlag, int FormatFlag, char *PrefixDirectory)
void	PostITEvent (MonitorEvent *event)
int	GetMonitorTable (vector< ClientData > &clientTable, vector< StorageData > &storageTable)
void	InvalidateStorageNatMappings (int StorageId)
	Funcao para invalidar todos os mapeamentos dos clientes conectados para um servidor de armazenamento identificado pela ID passada como parametro.
void	SetNumberOfDisks (unsigned int NumberOfDisks)
	Funcao para alterar o valor do numero de discos do servidor.
int	Stop ()
	Funcao que para todos os modulos do servidor RIO.
Private Member Functions
int	Format ()
int	ReadConfiguration ()
int	CheckConfiguration ()
int	CheckString (const char *name, const char *x)
void	printSystemConfiguration ()
int	Start ()
int	StartDiskMgr (int formatflag)
int	StartObjectManager ()
int	StartRouter ()
int	StartStreamManager ()
int	StartSessionManager ()
int	StartConnectionManager ()
int	StartUserManager ()
int	FreeMembers ()
Static Private Member Functions
static void *	MonitorTableTrigger (void *)
Private Attributes
int	m_BlockSize
int	m_MaxDisks
int	m_MaxReplications
int	m_UseReplications
int	m_MaxDataRequests
int	m_MaxPendingRequests
char *	m_FileRoot
char *	m_MetaRoot
char *	m_UserRoot
int	m_MaxSessions
int	m_MaxStreams
int	m_MaxOpenObjects
double	m_MaxRate
double	m_NRTReservedRate
int	m_NumberOfBuffersForEachClient
int	m_BurstSizeOfEachClient
int	m_MaxNumberAtDiskQueueToEachClient
char *	m_CollectMeasures
char *	m_UseServerSideBuffers
char *	m_UseNewCAC
double	m_NetworkRate
double	m_EstimatedTimeParameter
double	m_MaxIntervalEmpty
int	m_NumberOfEmptyTimes
int	m_GenerateLogs
DiskMgr *	m_DiskMgr
CObjectManager *	m_objectManager
CRouter *	m_Router
CStreamManager *	m_StreamManager
CSessionManager *	m_SessionManager
CConnectionManager *	m_ConnectionManager
CUserManager *	m_UserManager
bool	m_initialized
bool	m_started
char *	m_ConfigsDirectory
char *	m_LogsDirectory
int	m_MaxAttempts
int	m_TimeBetweenAttempts
int	m_ClientsTimeOut
unsigned int	m_MaxLogFileSize
unsigned long long int	m_MaxCombinedLogFilesSize
char *	m_SaveLogs
MonitorTable	m_MonitorTable

---

Detailed Description

Definition at line 40 of file SystemManager.h.

---

Constructor & Destructor Documentation

CSystemManager::CSystemManager

(

)

Definition at line 67 of file SystemManager.cpp.

{
    m_BlockSize          = 0;
    m_MaxDisks           = 0;
    m_MaxReplications    = 0;
    m_UseReplications    = 0;
    m_MaxDataRequests    = 0;
    m_MaxPendingRequests = 0;
    m_FileRoot           = NULL;
    m_MetaRoot           = NULL;
    m_UserRoot           = NULL;
    m_MaxSessions        = 0;
    m_MaxStreams         = 0;
    m_MaxOpenObjects     = 0;
    m_MaxRate            = 0.0;
    m_NRTReservedRate    = 0.0;

    // to support buffers and new CAC
    m_NumberOfBuffersForEachClient     = 0;
    m_BurstSizeOfEachClient            = 0;
    m_MaxNumberAtDiskQueueToEachClient = 0;
    m_CollectMeasures                  = NULL;
    m_UseServerSideBuffers             = NULL;
    m_UseNewCAC                        = NULL;
    m_NetworkRate                      = 0.0;
    m_EstimatedTimeParameter           = 0.0;
    m_MaxIntervalEmpty                 = 0.0;
    m_NumberOfEmptyTimes               = 0;
    // ------------------------------------------------------------------------

    m_GenerateLogs   = 0;
    m_DiskMgr        = NULL;
    m_objectManager  = NULL;
    m_Router         = NULL;
    m_StreamManager  = NULL;
    m_SessionManager = NULL;
    m_UserManager    = NULL;

    m_initialized    = false;
    m_started        = false;
    
    // Inicializacao das novas variaveis com o nome do diretorio com os
    // arquivos de configuracao e de senhas, e com o nome do diretorio onde
    // os logs serao salvos.
    m_ConfigsDirectory = NULL;
    m_LogsDirectory = NULL;
    
    // Inicializacao das novas variaveis usadas para tentar a conexao com cada
    // servidor de armazenamento por mais de uma vez antes de abortar a 
    // execucao do servidor de despacho.
    m_MaxAttempts = 20; // Numero de tentativas.
    m_TimeBetweenAttempts = 2; // Tempo entre as tentativas.
    // Inicializacao do novo parametro usado para indicar o tempo maximo que o 
    // servidor espera por uma requisicao de um cliente.
    m_ClientsTimeOut = 0; // Nao usa o timeout, isto e, igual ao que ocorria
                          // anteriormente.
                          
    // Inicializacao dos novos parametros usados pela classe de gerenciamento
    // dos logs.
    m_MaxLogFileSize = MAXLOGFILESIZE;
    m_MaxCombinedLogFilesSize = MAXCOMBINEDLOGSFILESIZE;    
    // Inicializacao da nova variavel usada para indicar se devemos salvar os
    // logs. Por default (NULL), supomos que os logs devem ser salvos.
    m_SaveLogs = NULL;                   
}

CSystemManager::~CSystemManager

(

)

Definition at line 134 of file SystemManager.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "[CSystemManager] Destructor Start" << endl;
    #endif
    
    if( m_FileRoot != 0 )
    {
        delete[] m_FileRoot;
    }
    if( m_MetaRoot != 0 )
    {
        delete[] m_MetaRoot;
    }
    if( m_UserRoot != 0 )
    {
        delete[] m_UserRoot;
    }

    // Remocao das novas variaveis com o nome do diretorio com os arquivos de
    // configuracao e de senhas, e com o nome do diretorio onde os logs serao
    // salvos.
    if( m_ConfigsDirectory != NULL )
        delete[] m_ConfigsDirectory;
        
    if( m_LogsDirectory != NULL )
        delete[] m_LogsDirectory;

    // Remove as strings usadas ao ler a configuracao.
    if( m_UseServerSideBuffers != NULL )
        delete[] m_UseServerSideBuffers;
    if( m_UseNewCAC != NULL )
        delete[] m_UseNewCAC;
    if( m_CollectMeasures != NULL )
        delete[] m_CollectMeasures;
    if( m_SaveLogs != NULL )
        delete[] m_SaveLogs;
        
    #ifdef RIO_DEBUG1
    RioErr << "[CSystemManager] Destructor End" << endl;
    #endif
}

---

Member Function Documentation

int CSystemManager::CheckConfiguration

(

)

[private]

Definition at line 641 of file SystemManager.cpp.

{
    // check BlockSize
    if( ( m_BlockSize < 512 ) || ( m_BlockSize % 512 != 0 ) )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << " - Invalid block size " << m_BlockSize
               << " (must be multiple of physical sector) " << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_BLOCKSIZE;
    }

    // check MaxDisks
    if( ( m_MaxDisks < 1 ) || ( m_MaxDisks > (int) ( MAXNUMSTORAGES * 
                                                     MAXSTORAGEDISKSARRAY ) ) )
    {
        RioErr << "SystemManager::CheckConfiguration "
               << "MaxDisks: " << m_MaxDisks
               << " invalid (range 1-" << MAXNUMSTORAGES * MAXSTORAGEDISKSARRAY
               << ")" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    if( m_MaxSessions < 1 )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "MaxSessions: " << m_MaxSessions
               << " invalid (must be > 1)" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    if( m_MaxStreams < 1 )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "MaxStreams: " << m_MaxStreams
               << " invalid (must be > 1)" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    if( m_MaxOpenObjects < 1 )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "MaxOpenObjects: " << m_MaxOpenObjects
               << " invalid (must be > 1)" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    // check replication values
    if( ( m_UseReplications < 1 ) || ( m_UseReplications > 8 ) )
    {
        RioErr << "SystemManager.CheckConfiguration "
                  "UseReplications must be between 1 and 8" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }
    if( ( m_MaxReplications < 1 ) || ( m_MaxReplications > 8 ) )
    {
        RioErr << "SystemManager.CheckConfiguration "
                  "MaxReplications must be between 1 and 8" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    if( m_UseReplications > m_MaxReplications )
    {
        RioErr << "SystemManager.CheckConfiguration "
                  "UseReplications > MaxReplications " << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    if( ( m_UseReplications > 1 ) && ( m_MaxDisks < MAXSTORAGEDISKSARRAY ) )
    {
        RioErr << "SystemManager.CheckConfiguration warning: "
                  "using replication > 1 with few disks or nodes may not work "
            << endl;
    }

    if( m_BurstSizeOfEachClient < 0 )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "BurstSizeOfEachClient: " << m_BurstSizeOfEachClient
            << " invalid (must be > 0)" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    if( ( m_NumberOfBuffersForEachClient < 0 ) ||
       ( m_NumberOfBuffersForEachClient > 20 ))
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "NumberOfBuffersForEachClient: "
               << m_NumberOfBuffersForEachClient
               << " invalid (must be between 0 and 20)" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    if( m_NetworkRate < 0 )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "NetworkRate: " << m_NetworkRate
               << " invalid (must be > 0)" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }
    else
    {
        m_NetworkRate = (m_NetworkRate * 1024.0 * 1024.0) / 8; //in bytes/sec
    }

    if( ( m_EstimatedTimeParameter < 0 ) || ( m_EstimatedTimeParameter > 1 ) )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "EstimatedTimeParameter: " << m_EstimatedTimeParameter
               << " invalid (must be between 0 and 1)" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    if( ( strcasecmp( m_UseServerSideBuffers, "on" ) != 0 ) &&
       ( strcasecmp( m_UseServerSideBuffers, "off" ) != 0 ))
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "UseServerSideBuffers: " << m_UseServerSideBuffers
               << " invalid (must be 'on' or 'off')" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }
    if( ( strcasecmp( m_UseNewCAC, "on" ) != 0 ) &&
       ( strcasecmp( m_UseNewCAC, "off" ) != 0 ))
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "UseNewCAC: " << m_UseNewCAC
               << " invalid (must be 'on' or 'off')" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }
    if( ( strcasecmp( m_CollectMeasures, "on" ) != 0 ) &&
       ( strcasecmp( m_CollectMeasures, "off" ) != 0 ))
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "CollectMeasures: " << m_CollectMeasures
               << " invalid (must be 'on' or 'off')" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    if( ( m_GenerateLogs != 0 ) && ( m_GenerateLogs != 1 ) )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "GenerateLogs: " << m_GenerateLogs
               << " invalid (must be '0' or '1')" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    if( strcasecmp( m_UseNewCAC, "on" ) == 0 )
    {
        strcpy( m_UseNewCAC, "on" );
        strcpy( m_UseServerSideBuffers, "on" );
        strcpy( m_CollectMeasures, "on" );
    }

    if( m_NumberOfEmptyTimes < 0 )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "NumberOfEmptyTimes: " << m_NumberOfEmptyTimes
               << " invalid (must be >= 0)" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }
    if( m_MaxIntervalEmpty < 0 )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "MaxIntervalEmpty: " << m_MaxIntervalEmpty
               << " invalid (must be >= 0)" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    RioErr << "UseNewCAC " << m_UseNewCAC << endl;
    RioErr << "UseServerSideBuffers " << m_UseServerSideBuffers << endl;
    RioErr << "CollectMeasures " << m_CollectMeasures << endl;
    // ------------------------------------------------------------------------

    // check Roots
    if( CheckString( "FileRoot", m_FileRoot ) )
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    if( CheckString( "MetaRoot", m_MetaRoot ) )
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    if( CheckString( "UserRoot", m_UserRoot ) )
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;

   // Duas novas opcoes para permitir que o servidor tente se conectar mais de 
   // uma vez a cada um dos servidores de armazenamento, antes de abortar com 
   // erro. A opcao MaxAttempts define o numero de tentativas e a 
   // TimeBetweenAttempts define o tempo (em segundos entre duas tentativas 
   // consecutivas).    

    if( m_MaxAttempts < 0 )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "MaxAttempts: " << m_MaxAttempts
               << " invalid (must be >= 0)" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    if( m_TimeBetweenAttempts < 0 )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "TimeBetweenAttempts: " << m_TimeBetweenAttempts
               << " invalid (must be >= 0)" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    // Nova opcao usada para indicar o tempo maximo que o servidor espera por 
    // uma requisicao de um cliente. Se a opcao nao for usada, ou se o seu valor 
    // for 0, entao nao teremos um tempo maximo (como ocorria antes).

    if( m_ClientsTimeOut < 0 )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "ClientsTimeOut: " << m_ClientsTimeOut
               << " invalid (must be >= 0)" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    // Novas opcoes usadas pelo gerenciamento dos logs para limitar o tamanho
    // do arquivo de log nao compactado e o tamanho total combinado de todos
    // os logs (compactados ou nao).
    
    if( m_MaxLogFileSize <= 0 )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "MaxLogFileSize: " << m_MaxLogFileSize
               << " invalid (must be > 0)" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    if( m_MaxCombinedLogFilesSize <= 0 )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "MaxCombinedLogFilesSize: " << m_MaxCombinedLogFilesSize
               << " invalid (must be > 0)" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    // Nova opcao para definir se os logs devem ou nao ser salvos, ou seja, se 
    // devemos ou nao somente executar buscas nestes logs.
    if( ( m_SaveLogs != NULL ) && ( strcasecmp( m_SaveLogs, "on" ) != 0 ) &&
        ( strcasecmp( m_SaveLogs, "off" ) != 0 ) )
    {
        RioErr << "SystemManager.CheckConfiguration "
               << "LogRotation: " << m_SaveLogs
               << " invalid (must be 'on' or 'off')" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }

    printSystemConfiguration();

    return 0;
}

int CSystemManager::CheckString	(	const char *	name,
		const char *	x
	)			[private]

Definition at line 892 of file SystemManager.cpp.

{
    if( ( x == 0 ) || ( strlen( x ) < 1 ) )
    {
        RioErr << "SystemManager::CheckConfiguration "
               << name << " not specified or null string" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_INVALID_PARAM;
    }
    return 0;
}

int CSystemManager::Format

(

)

[private]

Definition at line 321 of file SystemManager.cpp.

{
    int rc = 0;

    if( mkdir( m_FileRoot, 0700 ) )
    {
        RioErr << "SystemManager.Format - mkdir failed for "
               << m_FileRoot << " (m_FileRoot) "
               << strerror(errno) << endl;
        rc = 1;
    }

    if( mkdir( m_MetaRoot, 0700 ) )
    {
        RioErr << "SystemManager.Format - mkdir failed for "
               << m_MetaRoot << " (m_MetaRoot) "
               << strerror(errno) << endl;
        rc = 1;
    }

    if( mkdir( m_UserRoot, 0700 ) ) {
        RioErr << "SystemManager.Format - mkdir failed for "
               << m_UserRoot << " (m_UserRoot) "
               << strerror(errno) << endl;
        // allow failing to mkdir UserRoot to continue;
        // perhaps it has useful info in it...
        if( !rc )
            RioErr << "\t\t...continuing anyway... " << endl;
    }

    if( rc )
    {
        RioErr << "fatal format error above, exiting.." << endl;
        return 1;
    }

    // Initialize EventManager
    // Initialize allocates space for each type of event
    // The number of events of each type can not exceed the maximum
    // set at Initialization. Attempting to do so will block
    // the asking thread until one event of that type is freed by
    // other thread. If these values are too small system performance
    // may be degraded, since threads will be blocked waiting
    // for event entries
    EventManager.Initialize( EventTypeStorageRequest, 2*m_MaxDisks );
    EventManager.Initialize( EventTypeStorageReply, 2*m_MaxDisks );
    EventManager.Initialize( EventTypeAddDisk, m_MaxDisks );
    
    // Inicializa os novos eventos para tratar da queda/reinicio dos servidores 
    // de armazenamento.
    EventManager.Initialize( EventTypeStorageDown, MAXNUMSTORAGES );
    EventManager.Initialize( EventTypeStorageUp, MAXNUMSTORAGES );
    
    // Inicializa os novos eventos para tratar do termino das threads que usem 
    // uma fila.
    EventManager.Initialize( EventTypeFinalizeThread, 1 );

    // Initialize DiskMgr (finds nodes)
    if( StartDiskMgr(1) )
        return 1;

    //### kludge wait to allow time for DiskMgr to contact storage nodes
    sleep(5);

    //now build empty metadata for storage space etc.
    return m_DiskMgr->Format();
}

int CSystemManager::FreeMembers

(

)

[private]

Definition at line 1378 of file SystemManager.cpp.

{
    int result = S_OK;
    int result2;

    if( m_UserManager != 0 )
    {
        delete m_UserManager;
        m_UserManager = 0;
    }
    
    if( m_SessionManager != 0 )
    {
        delete m_SessionManager;
        m_SessionManager = 0;
    }

    if( m_StreamManager != 0 )
    {
        delete m_StreamManager;
        m_StreamManager = 0;
    }

    if( m_Router != 0 )
    {
        result2 = m_Router->Stop();
        if( ( ( unsigned int ) result2 !=
              ( ERROR_ROUTER + ERROR_NOT_STARTED )
            ) &&
            ( FAILED ( result2 ) )
          )
        {
            RioErr << "FreeMembers(): Failed to stop Router" << endl;
            result = result2;
        }
        delete m_Router;
        m_Router = 0;
    }

    if( m_objectManager != 0 )
    {
        result2 = m_objectManager->Stop();
        if( FAILED( result2 ) )
        {
            RioErr << "FreeMembers(): Failed to stop Object Manager" << endl;
            result = result2;
        }
        delete m_objectManager;
        m_objectManager = 0;
    }

    //### have DiskMgr stop all storage nodes here...
    if( m_DiskMgr != 0 )
        delete m_DiskMgr;

    // Finaliza a thread de monitoramento.   
    m_MonitorTable.Stop();    
        
    return result;
}

int CSystemManager::GetMonitorTable	(	vector< ClientData > &	clientTable,
		vector< StorageData > &	storageTable
	)

Definition at line 1519 of file SystemManager.cpp.

{
    m_MonitorTable.getData( clientTable, storageTable );
    return 0;
}

void CSystemManager::InvalidateStorageNatMappings

(

int

StorageId

)

Funcao para invalidar todos os mapeamentos dos clientes conectados para um servidor de armazenamento identificado pela ID passada como parametro.

Parameters:

StorageId

Identificador do servidor de armazenamento.

Definition at line 1530 of file SystemManager.cpp.

{
    // Somente devemos executar este metodo se a classe ja foi criada e 
    // inicializada.
    if( m_SessionManager != NULL )
        m_SessionManager->InvalidateStorageNatMappings( StorageId );
    else
        RioErr << "CSystemManager::InvalidateStorageNatMappings aviso a funcao "
               << "foi chamada antes da criacao e inicializacao do objecto da "
               << "classe CSessionManager" << endl;
            
}

void * CSystemManager::MonitorTableTrigger

(

void *

param

)

[static, private]

Definition at line 1506 of file SystemManager.cpp.

{
    ((CSystemManager *)param)->m_MonitorTable.Monitor();
    return NULL;
}

void CSystemManager::PostITEvent

(

MonitorEvent *

event

)

Definition at line 1513 of file SystemManager.cpp.

{
    m_MonitorTable.putMonitorEvent( event );
}

void CSystemManager::printSystemConfiguration

(

)

[private]

Definition at line 1440 of file SystemManager.cpp.

{
    cout << "---------------------------------------------------" << endl;
    cout << "                 RIO Configuration                 " << endl;
    cout << "---------------------------------------------------" << endl;
    cout << "RIO System Block Size \t\t" << m_BlockSize << " Bytes" << endl;
    cout << "Maximum Number of disks \t" << m_MaxDisks << endl;
    cout << "Maximum Number of sessions \t" << m_MaxSessions << endl;
    cout << "Maximum Number of streams \t" << m_MaxStreams << endl;
    cout << "Maximum Number of open objects \t" << m_MaxOpenObjects << endl;

    cout << "MaxReplications \t\t" << m_MaxReplications << endl;
    cout << "UseReplications \t\t" << m_UseReplications << endl;

    cout << "MaxDataRequests \t\t" << m_MaxDataRequests << endl;
    cout << "MaxPendingRequests \t\t" << m_MaxPendingRequests << endl;

    cout << "FileRoot \t\t\t" << m_FileRoot << endl;
    cout << "MetaRoot \t\t\t" << m_MetaRoot << endl;
    cout << "UserRoot \t\t\t" << m_UserRoot << endl;

    cout << "Buffers to each client \t\t" << m_NumberOfBuffersForEachClient << endl;
    cout << "Burst Size of each client \t" << m_BurstSizeOfEachClient << endl;

    //convert B/sec -> Mb/sec
    double networkrate = (m_NetworkRate * 8 )/1024.0/1024.0;
    cout << "NetworkRate \t\t\t" << networkrate <<" Mbps"<< endl;
    cout << "CollectMeasures \t\t" << m_CollectMeasures << endl;
    cout << "UseServerSideBuffers \t\t" << m_UseServerSideBuffers << endl;
    cout << "UseNewCAC \t\t\t" << m_UseNewCAC << endl;
    cout << "EstimatedTimeParameter \t\t" << m_EstimatedTimeParameter << endl;
    cout << "NumberOfEmptyTimes \t\t" << m_NumberOfEmptyTimes << endl;
    cout << "MaxIntervalEmpty \t\t" << m_MaxIntervalEmpty << " msec" << endl;
    // ------------------------------------------------------------------------
    cout << "GenerateLogs \t\t\t" << m_GenerateLogs << endl;
    // ------------------------------------------------------------------------
    // Novas opcoes para permitir que o servidor tente se conectar mais de uma
    // vez a cada um dos servidores de armazenamento, antes de abortar com
    // erro. A opcao MaxAttempts define o numero de tentativas e a
    // TimeBetweenAttempts define o tempo (em segundos entre duas tentativas
    // consecutivas).    
    cout << "MaxAttempts \t\t\t" << m_MaxAttempts << endl;
    cout << "TimeBetweenAttempts \t\t" << m_TimeBetweenAttempts << endl;
    // Nova opcao usada para indicar o tempo maximo que o servidor espera por 
    // uma requisicao de um cliente. Se a opcao nao for usada, ou se o seu valor 
    // for 0, entao nao teremos um tempo maximo (como ocorria antes).
    cout << "ClientsTimeOut \t\t\t" << m_ClientsTimeOut << endl;
    // Novas opcoes usadas pelo gerenciamento dos logs para limitar o tamanho
    // do arquivo de log nao compactado e o tamanho total combinado de todos
    // os logs (compactados ou nao).
    cout << "MaxLogFileSize \t\t\t" << m_MaxLogFileSize / 1024 << " Kbytes" 
         << endl;
    cout << "MaxCombinedLogFilesSize \t" << m_MaxCombinedLogFilesSize / 1024
         << " Kbytes" << endl;
    // Nova opcao para definir se os logs devem ou nao ser salvos, ou seja, se 
    // devemos ou nao somente executar buscas nestes logs.
    if( m_SaveLogs != NULL )
        cout << "LogRotation \t\t\t" << m_SaveLogs << endl;
    else
        cout << "LogRotation \t\t\tOn" << endl;

    cout << "---------------------------------------------------" << endl
         << endl;
}

int CSystemManager::ReadConfiguration

(

)

[private]

Definition at line 390 of file SystemManager.cpp.

{
    // Variavel usada para compor o nome do arquivo com a configuracao do
    // servidor RIO.
    char ConfigFileName[ MaxPathSize ];

    enum keys
    {
        BlockSize = 1, MaxDisks, MaxSessions, MaxStreams,
        MaxOpenObjects, MaxReplications, UseReplications,
        MaxDataRequests, MaxPendingRequests,
        FileRoot, MetaRoot, UserRoot, TotalRate, NRTReservedRate,
        NumberOfBuffersForEachClient, BurstSizeOfEachClient,
        NetworkRate, CollectMeasures,
        UseServerSideBuffers, UseNewCAC,
        EstimatedTimeParameter,
        NumberOfEmptyTimes, MaxIntervalEmpty,
        GenerateLogs, MaxAttempts, TimeBetweenAttempts,
        ClientsTimeOut, MaxLogFileSize, MaxCombinedLogFilesSize,
        LogRotation
    };

    static struct token_kw mykeys[] = {
        {"BlockSize", BlockSize},
        {"MaxDisks", MaxDisks},
        {"MaxSessions", MaxSessions},
        {"MaxStreams", MaxStreams},
        {"MaxOpenObjects", MaxOpenObjects},
        {"MaxReplications", MaxReplications},
        {"UseReplications", UseReplications},
        {"MaxDataRequests", MaxDataRequests},
        {"MaxPendingRequests", MaxPendingRequests},
        {"FileRoot",  FileRoot},
        {"MetaRoot",  MetaRoot},
        {"UserRoot",  UserRoot},
        {"TotalRate",  TotalRate},
        {"NRTReservedRate",  NRTReservedRate},
        {"NumberOfBuffersForEachClient",  NumberOfBuffersForEachClient},
        {"BurstSizeOfEachClient",  BurstSizeOfEachClient},
        {"NetworkRate", NetworkRate},
        {"CollectMeasures", CollectMeasures},
        {"UseServerSideBuffers", UseServerSideBuffers},
        {"UseNewCAC", UseNewCAC},
        {"EstimatedTimeParameter", EstimatedTimeParameter},
        {"NumberOfEmptyTimes", NumberOfEmptyTimes},
        {"MaxIntervalEmpty", MaxIntervalEmpty},
        {"GenerateLogs", GenerateLogs},
        // Duas novas opcoes para permitir que o servidor tente se conectar
        // mais de uma vez a cada um dos servidores de armazenamento,
        // antes de abortar com erro. A opcao MaxAttempts define o numero
        // de tentativas e a TimeBetweenAttempts define o tempo (em 
        // segundos entre duas tentativas consecutivas).    
        {"MaxAttempts", MaxAttempts},
        {"TimeBetweenAttempts", TimeBetweenAttempts},
        // Nova opcao usada para indicar o tempo maximo que o servidor espera 
        // por uma requisicao de um cliente. Se a opcao nao for usada, ou se o
        // seu valor for 0, entao nao teremos um tempo maximo (como ocorria
        // antes).
        {"ClientsTimeOut", ClientsTimeOut},
        // Novas opcoes usadas pelo gerenciamento dos logs para limitar o 
        // tamanho do arquivo de log nao compactado e o tamanho total combinado 
        // de todos os logs (compactados ou nao).
        {"MaxLogFileSize", MaxLogFileSize},
        {"MaxCombinedLogFilesSize", MaxCombinedLogFilesSize}, 
        // Nova opcao para definir se os logs devem ou nao ser salvos, ou seja,
        // se devemos ou nao somente executar buscas nestes logs.
        {"LogRotation", LogRotation},
        // Define o final das opcoes.
        {NULL, 0}
    };

    cout << endl;
    token tok;
    //tok.setcerr(&cout);

    // Alteracao para ler o arquivo de configuracao de um diretorio qualquer,
    // diferente de onde o servidor esta. Por default, o arquivo e lido do
    // diretorio em que esta o binario do servidor.
    // Compoe o nome do arquivo com a configuracao do servidor.
    strcpy( ConfigFileName, m_ConfigsDirectory );
    strcat( ConfigFileName, CONFIGNAME );

    if( tok.openfile( ConfigFileName ) )
        return 1;

    int word;
    int number;

    while( ( word = tok.parseline( mykeys )) != END_TOKEN )
    {
        switch( word )
        {
            case BlockSize:
                tok.getnumber(&m_BlockSize);
                break;

            case MaxDisks:
                tok.getnumber(&m_MaxDisks);
                break;

            case MaxSessions:
                tok.getnumber(&m_MaxSessions);
                break;

            case MaxStreams:
                tok.getnumber(&m_MaxStreams);
                break;

            case MaxOpenObjects:
                tok.getnumber(&m_MaxOpenObjects);
                break;

            case MaxReplications:
                tok.getnumber(&m_MaxReplications);
                break;

            case UseReplications:
                tok.getnumber(&m_UseReplications);
                break;

            case MaxDataRequests:
                tok.getnumber(&m_MaxDataRequests);
                break;

            case MaxPendingRequests:
                tok.getnumber(&m_MaxPendingRequests);
                break;

            case FileRoot:
                tok.getstrnew(&m_FileRoot);
                break;

            case MetaRoot:
                tok.getstrnew(&m_MetaRoot);
                break;

            case UserRoot:
                tok.getstrnew(&m_UserRoot);
                break;

            case TotalRate:
                tok.getnumber(&number);
                //convert Kbps to bytes/sec
                m_MaxRate = ((number * 1000) / 8);
                break;

            case NRTReservedRate:
                tok.getnumber(&number);
                //convert Kbps to bytes/sec
                m_NRTReservedRate = ((number * 1000) / 8);
                break;

            case NumberOfBuffersForEachClient:
                tok.getnumber(&m_NumberOfBuffersForEachClient);
                break;

            case BurstSizeOfEachClient:
                tok.getnumber(&m_BurstSizeOfEachClient);
                break;

            case NetworkRate:
                tok.getdouble(&m_NetworkRate);
                break;

            case EstimatedTimeParameter:
                tok.getdouble(&m_EstimatedTimeParameter);
                break;

            case UseServerSideBuffers:
                tok.getstrnew(&m_UseServerSideBuffers);
                break;

            case UseNewCAC:
                tok.getstrnew(&m_UseNewCAC);
                break;

            case CollectMeasures:
                tok.getstrnew(&m_CollectMeasures);
                break;

            case NumberOfEmptyTimes:
                tok.getnumber(&m_NumberOfEmptyTimes);
                break;

            case MaxIntervalEmpty:
                tok.getdouble(&m_MaxIntervalEmpty);
                break;
            // ----------------------------------------------------------------
            case GenerateLogs:
                tok.getnumber(&m_GenerateLogs);
                break;
            // Duas novas opcoes para permitir que o servidor tente se conectar
            // mais de uma vez a cada um dos servidores de armazenamento,
            // antes de abortar com erro. A opcao MaxAttempts define o numero
            // de tentativas e a TimeBetweenAttempts define o tempo (em 
            // segundos entre duas tentativas consecutivas).    
            case MaxAttempts:
                tok.getnumber(&m_MaxAttempts);
                break;
            case TimeBetweenAttempts:
                tok.getnumber(&m_TimeBetweenAttempts);
                break;
            // Nova opcao usada para indicar o tempo maximo que o servidor 
            // espera por uma requisicao de um cliente. Se a opcao nao for
            // usada, ou se o seu valor for 0, entao nao teremos um tempo maximo 
            // (como ocorria antes).
            case ClientsTimeOut:
                tok.getnumber( &m_ClientsTimeOut );
                break;
            // Novas opcoes usadas pelo gerenciamento dos logs para limitar o 
            // tamanho do arquivo de log nao compactado e o tamanho total 
            // combinado de todos os logs (compactados ou nao).
            case MaxLogFileSize:
                // Tamanho do log nao compactado e dado em KB.
                tok.getnumber( &number );
                m_MaxLogFileSize = number * 1024;
                break;
            case MaxCombinedLogFilesSize:
                tok.getnumber( &number );
                // Tamanho combinado dos logs e dado em KB.
                m_MaxCombinedLogFilesSize = ( ( unsigned long long int ) number ) * 
                                            1024;
                break;
            // Nova opcao para definir se os logs devem ou nao ser salvos, ou 
            // seja, se devemos ou nao somente executar buscas nestes logs.
            case LogRotation:
                tok.getstrnew( &m_SaveLogs );
                break;

            // Valor para uma opcao invalida.
            case ERROR_TOKEN:
                char *Aux;
                tok.getstrnew( &Aux );
                RioErr << "warning: invalid keyword " << Aux << " ignored!"
                       << endl;
                delete[] Aux;
                break;

            // Chave invalida.
            default:
                RioErr << "word " << word << endl;
                tok.emsg("{default} invalid word");
                continue;
        }
        tok.ckend();
    }
    tok.closefile();
    return CheckConfiguration();
}

int CSystemManager::Run	(	int	DebugFlag,
		int	FormatFlag,
		char *	PrefixDirectory
	)

Definition at line 184 of file SystemManager.cpp.

{
    // Inicializa as variaveis com o diretorio onde os arquivos de
    // configuracao do servidor e os arquivos com as senhas, e com o 
    // diretorio onde os logs serao armazenados.
    if( PrefixDirectory == NULL )
    {
        // Se um prefixo nao foi passado, entao inicializamos os dois
        // diretorios com uma string vazia, para que os arquivos sejam
        // lidos e salvos no diretorio em que o codigo binario do servidor
        // esta armazenado.
        m_ConfigsDirectory = new char[ 1 ];
        if( m_ConfigsDirectory == NULL )
        {
            RioErr << "CSystemManager::Run Erro ao alocar a memoria" << endl;
            return -1;
        }
        m_LogsDirectory = new char[ 1 ];
        if( m_LogsDirectory == NULL )
        {
            RioErr << "CSystemManager::Run Erro ao alocar a memoria" << endl;
            delete[] m_ConfigsDirectory;
            m_ConfigsDirectory = NULL;
            return -1;
        }
        m_ConfigsDirectory[ 0 ] = 0;
        m_LogsDirectory[ 0 ] = 0;
    }
    else
    {
        // Devemos agora verificar se o prefixo do nome do diretorio passado
        // como parametro possui, no final, uma "/".
        unsigned int PrefixDirectorySize, ConfigsDirectorySize, 
                     LogsDirectorySize;
        PrefixDirectorySize = strlen( PrefixDirectory );
        ConfigsDirectorySize = PrefixDirectorySize + strlen( CONFIGSSUBDIR ) +
                               1;
        LogsDirectorySize = PrefixDirectorySize + strlen( LOGSSUBDIR ) + 1;
        // Verifica se o prefixo do diretorio termina ou nao com uma '/'.
        if( PrefixDirectory[ PrefixDirectorySize - 1 ] != '/' ) 
        {
            // Como nao temos uma "/" deveremos coloca-la e, com isso, o 
            // tamanho de ambos os nomes de diretorio aumentarao em uma
            // unidade.
            ConfigsDirectorySize++;
            LogsDirectorySize++;
        } 
        m_ConfigsDirectory = new char[ ConfigsDirectorySize ];
        if( m_ConfigsDirectory == NULL )
        {
            RioErr << "CSystemManager::Run Erro ao alocar a memoria" << endl;
            return -1;
        }
        m_LogsDirectory = new char[ LogsDirectorySize ];
        if( m_LogsDirectory == NULL )
        {
            RioErr << "CSystemManager::Run Erro ao alocar a memoria" << endl;
            delete[] m_ConfigsDirectory;
            m_ConfigsDirectory = NULL;
            return -1;
        }
        strcpy( m_ConfigsDirectory, PrefixDirectory );
        strcpy( m_LogsDirectory, PrefixDirectory );
        if( PrefixDirectory[ PrefixDirectorySize - 1 ] != '/' )
        {
            // Como nao temos uma '/' deveremos coloca-la em ambos os nomes
            // de diretorio.
            strcat( m_ConfigsDirectory, "/" );
            strcat( m_LogsDirectory, "/" );
        }
        strcat( m_ConfigsDirectory, CONFIGSSUBDIR );
        strcat( m_LogsDirectory, LOGSSUBDIR );
    }
    
    //Initialize random number generator seed
    InitializeRandomNumber();

    // read and check configuration values
    // {does not check them against any previous values}
    if( ReadConfiguration() )
    {
        RioErr << "SystemManager::ReadConfiguration failed" << endl;
        RioErr << "Server not running. Check error messages!" << endl;
        return -1;
    }

    if( FormatFlag )
    {
        return Format();
    }

    //Start monitor table thread
    pthread_t monitor_table_thread;
    pthread_attr_t attr_monitor_table_thread; 
    pthread_attr_init( &attr_monitor_table_thread );
    pthread_attr_setstacksize( &attr_monitor_table_thread, 
                               2*PTHREAD_STACK_MIN );
    
    pthread_create( &monitor_table_thread, &attr_monitor_table_thread, 
                    CSystemManager::MonitorTableTrigger, (void *)this );

    int rc;
    rc = Start(); // start things up
    if( rc )
    {
        RioErr << "Server not running. Check error messages!" << endl;
        return -1;
    }
    else
    {
        // now let things run...
        cout << endl;
        cout << " LAND/COPPE - UFRJ" << endl<<endl;
        cout << " RIO Multimedia Storage Server" << endl;
        cout << " Running ..." << endl;
    }
    // ------------------------------------------------------------------------

    pthread_join( monitor_table_thread, NULL );

    //the following loop is probably unnecessary, since the thread above is
    //supposed to never quit
    /*while( 1 )
    {
        sleep( 10 );
    }*/

    return 0;
}

void CSystemManager::SetNumberOfDisks

(

unsigned int

NumberOfDisks

)

Funcao para alterar o valor do numero de discos do servidor.

Ela foi necessaria porque, quando os servidores de armazenamento inicializam apos o servidor.

Parameters:

NumberOfDisks

novo numero de discos.

Definition at line 1546 of file SystemManager.cpp.

{
    // Somente devemos executar este metodo se a classe CSessionManagerja foi 
    // criada e inicializada.
    if( m_SessionManager != NULL )
        m_SessionManager->SetNumberOfDisks( NumberOfDisks );
    else
        RioErr << "CSystemManager::SetNumberOfDisks aviso a funcao foi chamada "
               << "antes da criacao e inicializacao do objecto da classe "
               << "CSessionManager" << endl;
    // Somente devemos executar este metodo se a classe CStreamManager ja foi 
    // criada e inicializada.
    if( m_StreamManager != NULL )
        m_StreamManager->SetNumberOfDisks( NumberOfDisks );
    else
        RioErr << "CSystemManager::SetNumberOfDisks aviso a funcao foi chamada "
               << "antes da criacao e inicializacao do objecto da classe "
               << "CStreamManager" << endl;
}

int CSystemManager::Start

(

void

)

[private]

Definition at line 904 of file SystemManager.cpp.

{
    int hResult;

    #ifdef RIO_DEBUG1
    RioErr << "### [CSystemManager - Start] Start" << endl;
    #endif

    // Initialize EventManager
    // Initialize allocates space for each type of event
    // The number of events of each type can not exceed the maximum
    // set at Initialization. Attempting to do so will block
    // the asking thread until one event of that type is freed by
    // other thread. If these values are too small system performance
    // may be degraded, since threads will be blocked waiting
    // for event entries

    EventManager.Initialize(EventTypeStorageRequest, 2*m_MaxDisks);
    EventManager.Initialize(EventTypeStorageReply, 2*m_MaxDisks);
    EventManager.Initialize(EventTypeAddDisk, m_MaxDisks);

    // Inicializa os novos eventos para tratar da queda/reinicio dos servidores 
    // de armazenamento.
    EventManager.Initialize( EventTypeStorageDown, MAXNUMSTORAGES );
    EventManager.Initialize( EventTypeStorageUp, MAXNUMSTORAGES );

    // Inicializa os novos eventos para tratar do termino das threads que usem 
    // uma fila.
    EventManager.Initialize( EventTypeFinalizeThread, 1 );

    Timer.Initialize (NUMBER_OF_TIMERS);

    // Create,  initialize and start DiskMgr
    cout << "Starting Disk Manager ....... ";
    #ifdef RIO_DEBUG2
    RioErr << "Starting Disk Manager ....... " << endl;
    #endif
    hResult = StartDiskMgr(0);
    if( hResult )
    {
        cout << "failed "<<endl;
        RioErr << "Start Disk Manager failed" << endl;
        FreeMembers();
        return hResult;
    }

    // Create and start Object Manager
    cout << "Starting User Manager ..... ";
    #ifdef RIO_DEBUG2
    RioErr << "Starting User Manager ..... " << endl;
    #endif
    // Create and start User Manager
    hResult = StartUserManager();
    if( hResult )
    {
        cout << "failed "<<endl;
        RioErr << "Start User Manager failed" << endl;
        FreeMembers();
        return hResult;
    }
    cout << "OK "<<endl;

    // Create and start Object Manager
    cout << "Starting Object Manager ..... ";
    #ifdef RIO_DEBUG2
    RioErr << "Starting Object Manager ..... " << endl;
    #endif
    hResult = StartObjectManager();
    if( hResult )
    {
        cout << "failed "<<endl;
        RioErr << "Start Object Manager failed" << endl;
        FreeMembers();
        return hResult;
    }
    cout << "OK "<<endl;

    // Create and start Router
    cout << "Starting Router ............. ";
    #ifdef RIO_DEBUG2
    RioErr << "Starting Router ............. " << endl;
    #endif
    hResult = StartRouter();
    if( hResult )
    {
        cout << "failed "<<endl;
        RioErr << "Start Router failed" << endl;
        FreeMembers();
        return hResult;
    }
    cout << "OK "<<endl;

    // Create and start Stream Manager
    cout << "Starting Stream Manager ..... ";
    #ifdef RIO_DEBUG2
    RioErr << "Starting Stream Manager ..... " << endl;
    #endif
    hResult = StartStreamManager();
    if( hResult )
    {
        cout << "failed "<<endl;
        RioErr << "Start Stream Manager failed" << endl;
        FreeMembers();
        return hResult;
    }
    cout << "OK "<<endl;

    // Create and start Session Manager
    cout << "Starting Session Manager .... ";
    #ifdef RIO_DEBUG2
    RioErr << "Starting Session Manager .... " << endl;
    #endif
    hResult = StartSessionManager();
    if( hResult )
    {
        cout << "failed "<<endl;
        RioErr << "Start Session Manager failed" << endl;
        FreeMembers();
        return hResult;
    }
    cout << "OK "<<endl;

    m_started = true;

    #ifdef RIO_DEBUG1
    RioErr << "### [CSystemManager - Start] End" << endl;
    #endif

    return 0;
}

int CSystemManager::StartConnectionManager

(

)

[private]

int CSystemManager::StartDiskMgr

(

int

formatflag

)

[private]

Definition at line 1036 of file SystemManager.cpp.

{
    int hResult;

    // create Router first and Initialize but don't start
    m_Router = new CRouter;

    // must pass DiskMgr to router too so make it now (but don't init yet)
    m_DiskMgr = new DiskMgr;

    // Initialize Router Config data
    RouterConfig Config;
    Config.nDisks           = m_MaxDisks;
    Config.BlockSize        = m_BlockSize;
    Config.MaxDataRequests  = m_MaxDataRequests;
    Config.MaxPending       = m_MaxPendingRequests;
    Config.CollectMeasures  = (( strcasecmp( m_CollectMeasures, "on" ) == 0 )||
                          ( strcasecmp( m_UseNewCAC, "on" ) == 0 ))? true:false;
    Config.EstimatedTimeParameter = m_EstimatedTimeParameter;
    // O parametro m_DiskMgr agora esta na estrutura RouterConfig ao inves de
    // ser passado como parametro.
    Config.DiskManager = m_DiskMgr;
    Config.SystemManager = this;
    // Somente deveremos inicializar o campo LogdDirectory da estrutura 
    // RouterConfig, para passar o nome do diretorio usados para salvar os 
    // logs da classe, somente se a opcao __QUEUE_RESP_LOG estiver habilitada.
    #ifdef __QUEUE_RESP_LOG
    Config.LogsDirectory = m_LogsDirectory;
    #endif

    hResult = m_Router->Initialize( &Config );

    if( hResult )
    {
        RioErr << "Start(): Failed to initialize Router"
               << ". hresult=" << hResult << endl;
        delete m_Router;
        m_Router = 0;
        return hResult;
    }

    // Initialize DiskMgr Config data
    DiskMgrConfig ConfigDisk;
    ConfigDisk.BlockSize = m_BlockSize;
    ConfigDisk.MaxDisks = m_MaxDisks;
    ConfigDisk.MetaRoot = m_MetaRoot;
    ConfigDisk.router = m_Router;
    ConfigDisk.manager = this;
    ConfigDisk.GenerateLogs = m_GenerateLogs;
    ConfigDisk.MaxReps = m_UseReplications;
    ConfigDisk.ConfigsDirectory = m_ConfigsDirectory;
    ConfigDisk.LogsDirectory = m_LogsDirectory;
    ConfigDisk.MaxAttempts = m_MaxAttempts;
    ConfigDisk.TimeBetweenAttempts = m_TimeBetweenAttempts;
    // Inicializa a variavel booleana que indica se estamos formatando os discos
    // do RIO.
    ConfigDisk.IsFormatting = ( formatflag != 0 );    

    hResult = m_DiskMgr->Initialize( &ConfigDisk );

    if( hResult )
    {
        RioErr << "SystemManager.StartDiskMgr: DiskMgr.Initialize failed."
               << endl;
        return hResult;
    }

    // ### if formating don't start DiskMgr (which would try to load
    //     up old metadata, instead just return (and call DiskMgr.Format)
    if( formatflag )
        return 0;

    hResult = m_DiskMgr->Start();
    if( hResult )
    {
        RioErr << "SystemManager.StartDiskMgr: DiskMgr.Start failed." << endl;
        return hResult;
    }

    return 0;
}

int CSystemManager::StartObjectManager

(

)

[private]

Definition at line 1119 of file SystemManager.cpp.

{
    // create to object manager
    m_objectManager = new CObjectManager;

    // Initialize Object Manager Config data
    ObjectManagerConfig ObjectConfig;
    ObjectConfig.BlockSize       = m_BlockSize;
    ObjectConfig.FileRoot        = m_FileRoot;
    ObjectConfig.MaxNhandle      = m_MaxOpenObjects;
    ObjectConfig.MaxReplications = m_MaxReplications;
    ObjectConfig.UseReplications = m_UseReplications;
    ObjectConfig.c_DiskMgr       = m_DiskMgr;
    ObjectConfig.UserManager     = m_UserManager;
    // Iniciaiza os novos campos da estrutura ObjectManagerConfig, com os
    // valores de m_GenerateLogs (passado antes como parametro) e 
    // m_LogsDirectory (o novo parametro que define onde o log da classe devera
    // ser salvo).
    ObjectConfig.GenerateLogs = m_GenerateLogs;
    ObjectConfig.LogsDirectory = m_LogsDirectory;

    // Initialize object manager
    // Mudanca na passagem de parametro ao inicializar a classe ObjectManager,
    // pois agora o campo m_GenerateLogs esta dentro da estrutura
    // ObjectManagerConfig.  
    int hResult = m_objectManager->Initialize( &ObjectConfig );
    if( hResult )
    {
        RioErr << "Start(): Failed to initialize object manager"
               << ". hresult=" << hResult << endl;
        delete m_objectManager;
        m_objectManager = 0;
        return hResult;
    }

    hResult = m_objectManager->Start();
    if( hResult )
    {
        RioErr << "Start(): Failed to start object manager"
               << ". hresult=" << hResult << endl;
        delete m_objectManager;
        m_objectManager = 0;
        return hResult;
    }

    return 0;
}

int CSystemManager::StartRouter

(

)

[private]

Definition at line 1168 of file SystemManager.cpp.

{

    // already created & init -- just start
    int hResult = m_Router->Start();
    if( hResult )
    {
        RioErr << "Start(): Failed to initialize Router"
               << ". hresult=" << hResult << endl;
        delete m_Router;
        m_Router = 0;
        return hResult;
    }

    return 0;
}

int CSystemManager::StartSessionManager

(

)

[private]

Definition at line 1272 of file SystemManager.cpp.

{
    // create Session Manager
    m_SessionManager = new CSessionManager;

    // Initialize Session Manager Config data
    SessionManagerConfig Config;
    Config.MaxSessions      = m_MaxSessions;
    Config.BlockSize        = m_BlockSize;
    Config.StreamManager    = m_StreamManager;
    Config.ObjectManager    = m_objectManager;
    Config.UserManager      = m_UserManager;
    Config.Router           = m_Router;
    Config.SystemManager    = this;

    //added to support df command ----------------------------------
    Config.diskMgr            = m_DiskMgr;
    m_DiskMgr->GetNumberOfActiveDisks( &Config.NumberOfDisks );
    m_DiskMgr->GetNumberOfStorageNodes( &Config.NumberOfStorageNodes );
    // ------------------------------------------------------------------------

    Config.FileRoot         = m_FileRoot;
    // ------------------------------------------------------------------------
    // Iniciaiza os novos campos da estrutura ObjectManagerConfig, com os
    // valores de m_GenerateLogs (passado antes como parametro) e 
    // m_LogsDirectory (o novo parametro que define onde o log da classe devera
    // ser salvo).
    Config.GenerateLogs = m_GenerateLogs;
    Config.LogsDirectory = m_LogsDirectory;
    // Inicializa o novo campo usado para indicar o tempo maximo que o servidor 
    // espera por uma requisicao de um cliente. Se a opcao nao for usada, ou se 
    // o seu valor for 0, entao nao teremos um tempo maximo (como ocorria 
    // antes).
    Config.ClientsTimeOut = m_ClientsTimeOut;
    // Novos parametros usados pela classe de controle de logs para limitar o
    // tamanho do arquivo nao compactado e o tamanho maximo dos arquivos com
    // os logs.
    Config.MaxLogFileSize = m_MaxLogFileSize;
    Config.MaxCombinedLogFilesSize = m_MaxCombinedLogFilesSize;
    // Inicializa a nova variavel usada para indicar se o salvamento dos logs 
    // esta ou nao habilitado
    Config.SaveLogs = ( ( m_SaveLogs == NULL ) || 
                        ( strcasecmp( m_SaveLogs, "on" ) == 0 ) );

    // Initialize Session Manager
    // Mudanca na passagem de parametro ao inicializar a classe CSessionManager, para
    // passar nome do diretorio em que salvamos o log da classe. 
    int hResult = m_SessionManager->Initialize( &Config );
    if( hResult )
    {
        RioErr << "Start(): Failed to initialize Session Manager"
               << ". hresult=" << (int *)hResult << endl;
        delete m_SessionManager;
        m_SessionManager = 0;
        return hResult;
    }

    return 0;
}

int CSystemManager::StartStreamManager

(

)

[private]

Definition at line 1186 of file SystemManager.cpp.

{
    #ifdef RIO_DEBUG1
    RioErr << "### [CSystemManager - StartStreamManager] Start" << endl;
    #endif

    // create Stream Manager
    m_StreamManager = new CStreamManager;

    // Initialize Stream Manager Config data
    StreamManagerConfig Config;
    Config.BlockSize                    = m_BlockSize;
    Config.MaxStreams                   = m_MaxStreams;
    Config.TotalRate                    = m_MaxRate;
    Config.NRTReservedRate              = m_NRTReservedRate;
    Config.FileRoot                     = m_FileRoot;

    Config.MaxPending                   = m_MaxPendingRequests;
    Config.NumberOfBuffersForEachClient = m_NumberOfBuffersForEachClient;
    Config.BurstSizeOfEachClient        = m_BurstSizeOfEachClient;
    Config.NetworkRate                  = m_NetworkRate;
    Config.EstimatedTimeParameter       = m_EstimatedTimeParameter;
    Config.NumberOfEmptyTimes           = m_NumberOfEmptyTimes;
    Config.MaxIntervalEmpty             = m_MaxIntervalEmpty;
    if( strcasecmp( m_UseNewCAC, "on" ) == 0 )
    {
        Config.UseNewCAC                = true;
        Config.UseServerSideBuffers     = true;
        Config.CollectMeasures          = true;
    }
    else
    {
        Config.UseNewCAC                = false;
        Config.UseServerSideBuffers     = ( strcasecmp( m_UseServerSideBuffers, "on" ) == 0 )? true:false;
        Config.CollectMeasures          = ( strcasecmp( m_CollectMeasures, "on" ) == 0 )? true:false;
    }

    //Config.MaxDiskQueueSize           = 20;
    Config.MaxDiskQueueSize             = m_MaxDataRequests;
    Config.ExtraStreamRequests          = 3;
    //Config.nDisks                       = m_MaxDisks;
    unsigned int nDisks;
    //m_DiskMgr->GetNumberOfActiveDisks( &nDisks );
    m_DiskMgr->GetNumberOfNeededDisks( &nDisks );
    Config.nDisks = nDisks;
    #ifdef RIO_DEBUG2
    RioErr << "### [CSystemManager - StartStreamManager] Numero de discos " 
           << Config.nDisks << endl;
    #endif

    Config.ObjectManager                = m_objectManager;
    Config.Router                       = m_Router;
    Config.SystemManager                = this;

    // Iniciaiza os novos campos da estrutura ObjectManagerConfig, com os
    // valores de m_GenerateLogs (passado antes como parametro) e 
    // m_LogsDirectory (o novo parametro que define onde o log da classe devera
    // ser salvo).
    Config.GenerateLogs = m_GenerateLogs;
    Config.LogsDirectory = m_LogsDirectory;

    // Inicializa a noca variavel usada para armazenar o tempo maximo de 
    // inatividade de uma conexao TCP antes de ela ser fechada por timeout.
    Config.ClientsTimeOut = m_ClientsTimeOut;                    

    // Initialize Stream Manager
    // Mudanca na passagem de parametro ao inicializar a classe StreamManager,
    // para passar o nome do diretorio em que salvamos o log da classe. 
    int hResult = m_StreamManager->Initialize( &Config );
    if( hResult )
    {
        RioErr << "Start(): Failed to initialize Stream Manager"
               << ". hresult=" << (int *)hResult << endl;
        delete m_StreamManager;
        m_StreamManager = 0;
        return hResult;
    }

    #ifdef RIO_DEBUG1
    RioErr << "### [CSystemManager - StartStreamManager] End" << endl;
    #endif

    return 0;
}

int CSystemManager::StartUserManager

(

)

[private]

Definition at line 1333 of file SystemManager.cpp.

{
    // create Session Manager
    m_UserManager = new CUserManager;

    // Initialize CUserManager Config data
    UserManagerConfig Config;
    Config.UserRoot = m_UserRoot; 
    Config.FileRoot = m_FileRoot; 
    Config.GenerateLogs = m_GenerateLogs;  
    Config.ConfigsDirectory = m_ConfigsDirectory;
    Config.LogsDirectory = m_LogsDirectory; 
    
    // Initialize User Manager
    int hResult = m_UserManager->Initialize( &Config );
    if( hResult )
    {
        RioErr << "Start(): Failed to initialize User Manager"
               << ". hresult=" << (int *)hResult << endl;

        delete m_UserManager;

        m_UserManager = 0;
        return hResult;
    }

    return 0;
}

int CSystemManager::Stop

(

void

)

Funcao que para todos os modulos do servidor RIO.

Agora a funcao e publica porque precisamos parar estes modulos quando recebermos o sinal SIGTERM.

Definition at line 1363 of file SystemManager.cpp.

{
    // make sure we are started

    if( !m_started )
    {
        RioErr << "stop(): System Manager not started" << endl;
        return ERROR_SYSTEMMANAGER + ERROR_NOT_STARTED;
    }

    m_started = false;
    return FreeMembers();
}

---

Field Documentation

int CSystemManager::m_BlockSize [private]

Definition at line 44 of file SystemManager.h.

int CSystemManager::m_BurstSizeOfEachClient [private]

Definition at line 60 of file SystemManager.h.

int CSystemManager::m_ClientsTimeOut [private]

Definition at line 101 of file SystemManager.h.

char* CSystemManager::m_CollectMeasures [private]

Definition at line 62 of file SystemManager.h.

char* CSystemManager::m_ConfigsDirectory [private]

Definition at line 89 of file SystemManager.h.

CConnectionManager* CSystemManager::m_ConnectionManager [private]

Definition at line 80 of file SystemManager.h.

DiskMgr* CSystemManager::m_DiskMgr [private]

Definition at line 75 of file SystemManager.h.

double CSystemManager::m_EstimatedTimeParameter [private]

Definition at line 66 of file SystemManager.h.

char* CSystemManager::m_FileRoot [private]

Definition at line 50 of file SystemManager.h.

int CSystemManager::m_GenerateLogs [private]

Definition at line 72 of file SystemManager.h.

bool CSystemManager::m_initialized [private]

Definition at line 83 of file SystemManager.h.

char* CSystemManager::m_LogsDirectory [private]

Definition at line 92 of file SystemManager.h.

int CSystemManager::m_MaxAttempts [private]

Definition at line 96 of file SystemManager.h.

unsigned long long int CSystemManager::m_MaxCombinedLogFilesSize [private]

Definition at line 108 of file SystemManager.h.

int CSystemManager::m_MaxDataRequests [private]

Definition at line 48 of file SystemManager.h.

int CSystemManager::m_MaxDisks [private]

Definition at line 45 of file SystemManager.h.

double CSystemManager::m_MaxIntervalEmpty [private]

Definition at line 67 of file SystemManager.h.

unsigned int CSystemManager::m_MaxLogFileSize [private]

Definition at line 104 of file SystemManager.h.

int CSystemManager::m_MaxNumberAtDiskQueueToEachClient [private]

Definition at line 61 of file SystemManager.h.

int CSystemManager::m_MaxOpenObjects [private]

Definition at line 55 of file SystemManager.h.

int CSystemManager::m_MaxPendingRequests [private]

Definition at line 49 of file SystemManager.h.

double CSystemManager::m_MaxRate [private]

Definition at line 56 of file SystemManager.h.

int CSystemManager::m_MaxReplications [private]

Definition at line 46 of file SystemManager.h.

int CSystemManager::m_MaxSessions [private]

Definition at line 53 of file SystemManager.h.

int CSystemManager::m_MaxStreams [private]

Definition at line 54 of file SystemManager.h.

char* CSystemManager::m_MetaRoot [private]

Definition at line 51 of file SystemManager.h.

MonitorTable CSystemManager::m_MonitorTable [private]

Definition at line 131 of file SystemManager.h.

double CSystemManager::m_NetworkRate [private]

Definition at line 65 of file SystemManager.h.

double CSystemManager::m_NRTReservedRate [private]

Definition at line 57 of file SystemManager.h.

int CSystemManager::m_NumberOfBuffersForEachClient [private]

Definition at line 59 of file SystemManager.h.

int CSystemManager::m_NumberOfEmptyTimes [private]

Definition at line 68 of file SystemManager.h.

CObjectManager* CSystemManager::m_objectManager [private]

Definition at line 76 of file SystemManager.h.

CRouter* CSystemManager::m_Router [private]

Definition at line 77 of file SystemManager.h.

char* CSystemManager::m_SaveLogs [private]

Definition at line 111 of file SystemManager.h.

CSessionManager* CSystemManager::m_SessionManager [private]

Definition at line 79 of file SystemManager.h.

bool CSystemManager::m_started [private]

Definition at line 84 of file SystemManager.h.

CStreamManager* CSystemManager::m_StreamManager [private]

Definition at line 78 of file SystemManager.h.

int CSystemManager::m_TimeBetweenAttempts [private]

Definition at line 97 of file SystemManager.h.

char* CSystemManager::m_UseNewCAC [private]

Definition at line 64 of file SystemManager.h.

int CSystemManager::m_UseReplications [private]

Definition at line 47 of file SystemManager.h.

CUserManager* CSystemManager::m_UserManager [private]

Definition at line 81 of file SystemManager.h.

char* CSystemManager::m_UserRoot [private]

Definition at line 52 of file SystemManager.h.

char* CSystemManager::m_UseServerSideBuffers [private]

Definition at line 63 of file SystemManager.h.

---

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

• SystemManager.h
• SystemManager.cpp