Public Member Functions | Public Attributes | Private Member Functions | Private Attributes | Friends

i_PartitionManager_i Class Reference
[Partition Manager]

CORBA servant for i_PartitionManager. More...

#include <i_pm_impl.h>

Inheritance diagram for i_PartitionManager_i:
Inheritance graph
[legend]
Collaboration diagram for i_PartitionManager_i:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 i_PartitionManager_i (string &a_partName)
void RefreshCfg ()
i_ClientConf_tRegisterHSM (i_HSM_ptr a_iHsm, CORBA::Char a_pathSeparator)
void UnRegisterHSM ()
void RegisterFSID (const char *a_majorMinor)
void UnRegisterFSID (const char *a_majorMinor)
i_HSM_ptr GetHSM ()
i_FSC_ptr GetFSC ()
i_ResourceManager_ptr GetRM ()
i_JobID_t Migrate (const i_JobRequestList_t &a_files, i_MigID_t a_migrationID, i_ColID_t a_majColId, i_ColID_t a_minColId, i_BitFlag_t a_flags)
i_JobID_t AllocateNewJobIDforEffRecall ()
i_JobID_t Recall (const i_Recall_t &a_file)
i_JobID_t EfficientRecall (const i_RecallList_t &a_files, i_JobID_t a_mainJobID)
i_JobID_t FSCRecovery (const i_StringList_t &a_volumes, i_UIMessageServer_ptr a_uims)
i_JobID_t IVDFSRecover (i_UIMessageServer_ptr a_uims)
i_JobID_t CheckFSCvsIVDFS (i_Count_t a_numFilesPerBatch, CORBA::Short a_sysLoadPct, i_UIMessageServer_ptr a_uims)
i_JobID_t CheckFSCvsMedia (const i_StringList_t &a_volumes, CORBA::Boolean a_autoCorrect, CORBA::Boolean a_removeMissingOnMedia, i_UIMessageServer_ptr a_uims)
i_JobID_t LimitedCheckFSCvsMedia (const i_StringList_t &a_barcodes, const i_VolNumList_t &a_volumes, CORBA::Boolean a_autoCorrect, CORBA::Boolean a_removeMissingOnMedia, i_UIMessageServer_ptr a_uims)
i_JobID_t ReorgScan (i_Time_t a_date, CORBA::Long a_numOfGenerations, i_UIMessageServer_ptr a_uims)
i_JobID_t Reorg (const char *a_barcode, const i_VolNumList_t &a_volumes, i_UIMessageServer_ptr a_uims)
i_JobIDList_tReorgByColId (CORBA::LongLong a_majColId, CORBA::LongLong a_minColId)
i_JobID_t CopyContents (const char *a_barcode, const i_VolNumList_t &a_volumes,::CORBA::Boolean a_best_effort, i_UIMessageServer_ptr a_uims)
i_JobID_t TrigDeletion (i_UIMessageServer_ptr a_uims)
i_Job_ptr GetJob (i_JobID_t a_jobId)
i_JobList_tGetAllJobs ()
i_JobParamsSeq_tGetAllJobsParam ()
i_Count_t GetJobCount ()
void AbortJob (i_JobID_t a_jobId)
void AbortAllJobs ()
i_Status_t GetJobStatus (i_JobID_t a_jobId)
virtual void Remove ()
void ReleaseVolEntries (CORBA::ULong a_mediumKey, CORBA::ULong a_volumeNr)
i_Time_t GetExpirationAge (const char *a_path)
fsc_FileExpirationGetExpirationTree ()
void FSCRecovery (const string &a_medVolIDstr, ivd_MedVolNum_t a_medVolNum, ivd_MediaKey_t a_mediaKey, UInt32_t a_blkSize, UInt32_t a_lastDataPosition)
CORBA::Boolean RecoveryMode ()
CORBA::Boolean RecoveryNeeded ()
i_BitFlag_t GetStatus (CORBA::String_out a_mountPoint, i_BitFlag_t &a_activity)
CORBA::Boolean ReplicationNeeded ()
i_PartitionManager_ptr GetReplicationPM ()
CORBA::Boolean RecallOnlyMode ()
CORBA::Boolean MigrateWithCollocation ()
void AddMajorCol (const i_MajorCol_t &a_majorCol)
void UpdateMajorCol (const i_MajorCol_t &a_majorCol)
void WriteCollocationInfo (const i_ColInfo_t &a_info)
i_ColInfoList_tReadCollocationInfo ()
void WriteHl7Info (const i_HL7Info_t &a_info)
i_HL7InfoList_tReadHl7Info ()
void SetReorgScan ()
void ClearReorgScan (bool a_succeded)
bool GetReorgScan ()
void StartReorgJob ()
void StopReorgJob ()
string GetName ()
char GetClientPathSeparator ()
void RecoveryModeSet ()
void RecoveryModeClear ()
void ClearRecoveryRunning ()
bool RecoveryOfIVDFSSet ()
void RecoveryOfIVDFSClear ()
bool IsRecoveryOfIVDFSRun ()
void GetPartitionRecord ()
void SetCheckAutoCorrectRunning ()
void ClearCheckAutoCorrectRunning ()
bool GetCheckAutoCorrectRunning ()
void SetCheckRunning ()
void ClearCheckRunning ()
bool GetCheckRunning ()
void GetAllMediaWithPools (fsc_MediumStatus_v &ms)

Public Attributes

cfg_PM m_config
bool m_externalClient
rm_Partition m_rmPart
UInt64_t m_maxDiskBuff
job_dbgDiskBuf_e m_dbgDiskBuff
i_ResourceManager_var m_iRM
i_PartitionManager_var m_iPM
i_FSC_var m_iFSC
i_HSM_var m_iHSM
i_FSC_im_iFSCi

Private Member Functions

virtual ~i_PartitionManager_i ()
void BuildExpirationTree ()
void ParseConfig ()
i_ClientConf_tFillClientCfg ()

Private Attributes

cmn_Mutex m_reorgScan_x
bool m_reorgScanRunning
UInt32_t m_reorgJobCounter
 log_CLASSID_m
string m_partName
bool m_iFSCisDown
pm_JobMgr m_jobMgr
cmn_Mutex m_startup_x
cmn_Mutex m_recoveryMode_x
bool m_recoveryNeeded
bool m_recoveryMode
cmn_Mutex m_checkAutoCorrectRunning_x
bool m_checkAutoCorrectRunning
cmn_Mutex m_checkRunning_x
bool m_checkRunning
bool m_recoveryOfIVDFS
cmn_Mutex m_recoveryOfIVDFS_x
fsc_FileExpiration m_expirationTree
char m_clientPathSeparator

Friends

class pm_JobMgr

Detailed Description

CORBA servant for i_PartitionManager.

Definition at line 64 of file i_pm_impl.h.


Constructor & Destructor Documentation

i_PartitionManager_i::~i_PartitionManager_i (  )  [private, virtual]

Definition at line 230 of file i_pm_impl.cpp.

References dbg_NORM, ipc_EXEC_m, ivd_Sleep, log_DBG_m, log_FUNC_m, m_iFSCisDown, m_iRM, m_partName, and ipc_Corba::Shutdown().

                                            {
    log_FUNC_m(~i_PartitionManager_i);

    try {
        ipc_EXEC_m(
            m_iRM->UnRegisterPartition(m_partName.c_str());
        );
    } catch (ivd_Exception& e) {
        // ignore if RM is down
        log_DBG_m(dbg_NORM,"UnRegisterPartition failed " << e);
    } catch (...) {
        // ignore if RM is down
        log_DBG_m(dbg_NORM,"UnRegisterPartition failed " );
    }

    log_DBG_m(dbg_NORM, "Waiting for FSC to go down.");
    do {
        ivd_Sleep(1);
    }
    while (!m_iFSCisDown);

    ipc_Corba::Shutdown();
}

Here is the call graph for this function:

i_PartitionManager_i::i_PartitionManager_i ( string &  a_partName  ) 

Definition at line 60 of file i_pm_impl.cpp.

References cfg_PMCfg::clients, cmn_GetEnvVariable(), pm_JobMgr::CreateFSCRecoveryJob(), dbg_DETAIL, dbg_LOW, dbg_NORM, ivd_BaseException::GetError(), GetPartitionRecord(), cfg_PMCfg::globalTreeOptions, ipc_EXEC_m, iPM, job_DBG_DISKBUFF(), job_DBG_DISKBUFF_ALL(), job_DBG_DISKBUFF_CORRUPT(), log_DBG_m, log_ERR_m, log_FUNC_m, log_WriteEvent(), m_config, m_dbgDiskBuff, m_iFSC, m_iFSCi, m_iFSCisDown, m_iPM, m_iRM, m_jobMgr, m_maxDiskBuff, m_partName, m_recoveryNeeded, m_rmPart, m_startup_x, cfg_PMCfg::name, ParseConfig(), rm_Partition::partitionUUIDString, cfg_PMTree::pools, RecoveryModeSet(), ipc_Corba::RegisterPMByDeviceName(), ipc_Corba::RegisterPMByPMID(), ipc_Corba::ResolveRM(), rmdb_PARTITION_RECOVERY_MODE, pm_JobMgr::SetPMi(), and rm_Partition::status.

    : m_reorgScanRunning(false),
      m_reorgJobCounter(0),
      m_externalClient(false),
      m_maxDiskBuff(0),
      m_partName(a_partName),
      m_iFSCisDown(true),
      m_recoveryNeeded(false),
      m_recoveryMode(false),
      m_checkAutoCorrectRunning(false),
      m_checkRunning(false),
      m_recoveryOfIVDFS(false),
      m_clientPathSeparator('?')
      { // must be set by HSM register

    log_FUNC_m(i_PartitionManager_i);

    cmn_MutexLock l(m_startup_x);

    string dbgDiskBuff = cmn_GetEnvVariable(job_DBG_DISKBUFF.c_str());

    log_DBG_m(dbg_DETAIL,"dbgDiskBuff: " << dbgDiskBuff);

    if (dbgDiskBuff == job_DBG_DISKBUFF_ALL){
        m_dbgDiskBuff = job_DISKBUFALL;
    }
    else if(dbgDiskBuff == job_DBG_DISKBUFF_CORRUPT) {
        m_dbgDiskBuff = job_DISKBUFCORRUPT;
    }
    else {
        m_dbgDiskBuff = job_DISKBUFNONE;
    }
    log_DBG_m(dbg_DETAIL,"DBG_DISKBUFF: " << m_dbgDiskBuff);


    ipc_EXEC_m(
        CORBA::Object_var obj = ipc_Corba::ResolveRM();
        m_iRM = i_ResourceManager::_narrow(obj);
    );


    m_iRM->RegisterPartition(a_partName.c_str());
    m_maxDiskBuff = m_iRM->GetMaxDiskBufferSize(a_partName.c_str());
    log_DBG_m(dbg_LOW, "m_maxDiskBuff" << m_maxDiskBuff);

    ParseConfig();
    GetPartitionRecord();

    //
    // NOTE:
    //
    // PM must register itself and therefore check if another PM is
    // already running *BEFORE* loading the FSC.
    // Otherwise the journal of the FSC can get *corrupted*.
    //
    ipc_EXEC_m(
        log_DBG_m(dbg_LOW, "Registering PM to NamingService.")
        i_PartitionManager_var iPM = this->_this();

        ipc_Corba::RegisterPMByPMID(iPM, m_config.name);

        for (unsigned int i = 0; i < m_config.clients.size(); i++) {
            ipc_Corba::RegisterPMByDeviceName(
                iPM,
                m_config.clients[i].name,
                m_config.clients[i].fileSystemId);
        }
        m_iPM = iPM;


        // --- End of PM registration

    );

    m_jobMgr.SetPMi(this);
    log_DBG_m(dbg_DETAIL, "PM:" << this);

    try {
        ipc_EXEC_m(
            log_DBG_m(dbg_NORM, "will run FSC now ....");
            log_DBG_m(dbg_LOW, "Partition UUID set to:" << m_rmPart.partitionUUIDString);
            log_DBG_m(dbg_NORM, "m_config.pool.size = " << m_config.globalTreeOptions.pools.size());

            m_iFSCi = new i_FSC_i(m_rmPart.partitionUUIDString, m_partName, m_iFSCisDown, m_config.globalTreeOptions.pools.size());
            m_iFSC = m_iFSCi->_this();

            // Decrease reference count on servant object to
            // make POA delete the object on deativate_object.
            // Default (initial) reference is 1 and is increased
            // by each activation (->_this() makes new activation).
            m_iFSCi->_remove_ref();

            log_DBG_m(dbg_NORM, "FSC running ....");
            UInt32_t numFileID = m_iFSCi->GetNumOfUsedFileID();
            bool volUsed;
            ipc_EXEC_m(
                volUsed = m_iRM->IsSomeVolumeUsed(a_partName.c_str());
            );

            log_DBG_m(dbg_LOW,"volUsed " << volUsed << endl <<
                                 "numFileID" << numFileID);

            ostringstream logStr;
            logStr << "FSC initialized. Partition UUID: "
                << m_rmPart.partitionUUIDString << ". Last fileID: "
                << numFileID;

            log_WriteEvent(logStr.str());


            if (volUsed && (numFileID == 0)) {
                m_recoveryNeeded = true;
                ostringstream sstr;

                sstr << "New FSC created, but some data exists on medium,"<<
                        " Run recovery to recreate FSC.";
                log_WriteEvent(sstr.str(), m_partName);
            };
        );
    }
    catch (ivd_Error &ie) {
        if (ie.GetError() == ie_IPC_ORB_EXCEPTION) {
            delete m_iFSCi;
        }   // insert Event Log about here
        log_DBG_m(dbg_DETAIL, ie );
        throw;
    }
    catch (...) {
        ostringstream sstr;
        sstr << "Corrupted DB or FSC creation error.";
        log_WriteEvent(sstr.str(), m_partName);
        throw;
    }

    if ( (m_rmPart.status & rmdb_PARTITION_RECOVERY_MODE) == rmdb_PARTITION_RECOVERY_MODE ){
        // recovery was started but did not finish
        // restarting recovery

        i_MediumSeqByVol_t_var medVolSeq;
        ipc_EXEC_m(
            medVolSeq = m_iRM->SelectAllUnrecoveredMedVol(m_partName.c_str());
        );

        log_DBG_m(dbg_DETAIL,"Select finished. "); // Selected " << medVolSeq->length() << " medium for recovery");

        i_StringList_t volumes;

        for (UInt32_t medIdx = 0; medIdx < medVolSeq->length(); medIdx++ ){
            for (UInt32_t volIdx = 0; volIdx < medVolSeq[medIdx].length(); volIdx++ ){
                volumes.length(volumes.length() + 1);
                log_DBG_m(dbg_DETAIL,"Inserting volume " << medVolSeq[medIdx][volIdx].medVolId);
                volumes[volumes.length()-1] = CORBA::string_dup(medVolSeq[medIdx][volIdx].medVolId);
            }
        }
        log_DBG_m(dbg_LOW,"Will invoke recovery");
        try {
            RecoveryModeSet();
            m_jobMgr.CreateFSCRecoveryJob(volumes, i_UIMessageServer::_nil());
        } catch (ivd_Exception& e) {
            log_ERR_m("Recovery Retry failed" << e);
            // ignore this error and continue
        }
    }
} // i_PartitionManager_i::i_PartitionManager_i()

Here is the call graph for this function:


Member Function Documentation

void i_PartitionManager_i::AbortAllJobs (  ) 

Definition at line 887 of file i_pm_impl.cpp.

References job_Manager::AbortAllJobs(), log_FUNC_m, and m_jobMgr.

                                        {
    log_FUNC_m(AbortAllJobs);
    try {
        m_jobMgr.AbortAllJobs();

    } ipc_CATCH_IVD_THROW_CORBA_m;
}

Here is the call graph for this function:

void i_PartitionManager_i::AbortJob ( i_JobID_t  a_jobId  ) 

Definition at line 874 of file i_pm_impl.cpp.

References job_Manager::AbortJob(), dbg_DETAIL, log_DBG_m, log_FUNC_m, and m_jobMgr.

                                                     {
    log_FUNC_m(AbortJob);
    try {
        UInt64_t jobId = a_jobId;

        log_DBG_m(dbg_DETAIL,"Removing job with id:" << a_jobId);
        m_jobMgr.AbortJob(jobId);


    } ipc_CATCH_IVD_THROW_CORBA_m;
}

Here is the call graph for this function:

void i_PartitionManager_i::AddMajorCol ( const i_MajorCol_t a_majorCol  ) 

Definition at line 1797 of file i_pm_impl.cpp.

References cfg_PMCfg::clients, dbg_NORM, i_MajorCol_t::flags, GetReplicationPM(), ipc_EXEC_m, log_DBG_m, log_FUNC_A_m, log_WriteErrorEvent, m_config, m_iRM, i_MajorCol_t::majColId, i_MajorCol_t::majColSize, i_MajorCol_t::partUUID, and ReplicationNeeded().

                                                                     {
    log_FUNC_A_m(AddMajorCol, "majColId: " << a_majorCol.majColId
                           << " size: " << a_majorCol.majColSize
                           << " partUUID: " << a_majorCol.partUUID
                           << " flags: " << a_majorCol.flags);

    i_PartitionManager_var replPM;
    bool doReplication(false);
    ipc_EXEC_m(
        doReplication = ReplicationNeeded();
        if (doReplication) {
            log_DBG_m(dbg_NORM, "Getting PM reference...");
            replPM = GetReplicationPM();
            log_DBG_m(dbg_NORM, "Got PM reference.");
        }
    );

    m_iRM->AddMajorCol(a_majorCol);

    if (doReplication) {
        log_DBG_m(dbg_NORM, "Adding major col on replication server "
        << m_config.clients[0].replTargHost << ", partition "
        << m_config.clients[0].replTargPart);
        if (!CORBA::is_nil(replPM)) {
            try {
                ipc_EXEC_m(
                    i_MajorCol_t tgtMajorCol(a_majorCol);
                    i_ResourceManager_var replRM = replPM->GetRM();
                    i_Partition_t_var partition = replRM->SelectPartition(m_config.clients[0].replTargPart.c_str());
                    tgtMajorCol.partUUID = CORBA::string_dup(partition->partitionUUIDString);
                    replPM->AddMajorCol(tgtMajorCol);
                );
            }
            catch (...) {
                log_DBG_m(dbg_NORM, "Adding major col on replication server failed.");
                throw;
            }
        }
        else {
            log_WriteErrorEvent( "Replication PM is in not available.");
        }
    }
}

Here is the call graph for this function:

i_JobID_t i_PartitionManager_i::AllocateNewJobIDforEffRecall (  ) 

Definition at line 342 of file i_pm_impl.cpp.

References log_FUNC_m, and m_iRM.

                                                             {
    log_FUNC_m(AllocateNewJobIDforEffRecall);

    return m_iRM->GetNewJobID();
}

void i_PartitionManager_i::BuildExpirationTree (  )  [private]

Definition at line 1686 of file i_pm_impl.cpp.

References fsc_FileExpiration::Clear(), dbg_DETAIL, dbg_NORM, fsc_FileExpiration::DbgDump(), cfg_PMCfg::deleteFile, g_cmn, cmn_Global::IsDbgActive(), log_DBG_m, log_FUNC_m, m_config, m_expirationTree, and fsc_FileExpiration::SetExpirationAge().

Referenced by ParseConfig().

                                               {
    log_FUNC_m(BuildExpirationTree);

    m_expirationTree.Clear();

    log_DBG_m(dbg_DETAIL, "m_config.deleteFile.size():" <<
                           m_config.deleteFile.size());

    for (UInt32_t item = 0; item < m_config.deleteFile.size(); item++) {
        vector<val_Element<string> >::iterator iter
                            = m_config.deleteFile[item].m_pathList.begin();
        while (iter != m_config.deleteFile[item].m_pathList.end()) {

            log_DBG_m(dbg_DETAIL, "(*iter).Val():" << (*iter).Val()<<
                " m_config.deleteFile[item].m_fileAge:" <<
                m_config.deleteFile[item].m_fileAge);

            m_expirationTree.SetExpirationAge(
                        (*iter).Val(), m_config.deleteFile[item].m_fileAge);
            iter++;
        }
    }
    if (g_cmn.IsDbgActive()) {
        ostringstream sstr;
        m_expirationTree.DbgDump(sstr);
        log_DBG_m(dbg_NORM, "Expiration tree:" << endl << sstr.str());
    }
} // i_PartitionManager_i::BuildExpirationTree()

Here is the call graph for this function:

Here is the caller graph for this function:

i_JobID_t i_PartitionManager_i::CheckFSCvsIVDFS ( i_Count_t  a_numFilesPerBatch,
CORBA::Short  a_sysLoadPct,
i_UIMessageServer_ptr  a_uims 
)

Definition at line 439 of file i_pm_impl.cpp.

References pm_JobMgr::CheckFSCvsIVDFS(), GetAllMediaWithPools(), log_FUNC_m, m_iFSCi, m_jobMgr, and i_FSC_i::SetMediumStatusMember().

                                      {

    log_FUNC_m(CheckFSCvsIVDFS);

    try {
        fsc_MediumStatus_v ms;
        GetAllMediaWithPools(ms);

        m_iFSCi->SetMediumStatusMember(ms);
        return m_jobMgr.CheckFSCvsIVDFS(a_numFilesPerBatch, a_sysLoadPct, a_uims);
    } ipc_CATCH_IVD_THROW_CORBA_m;
}

Here is the call graph for this function:

i_JobID_t i_PartitionManager_i::CheckFSCvsMedia ( const i_StringList_t a_volumes,
CORBA::Boolean  a_autoCorrect,
CORBA::Boolean  a_removeMissingOnMedia,
i_UIMessageServer_ptr  a_uims 
)

Definition at line 456 of file i_pm_impl.cpp.

References pm_JobMgr::CreateCheckFSCvsMediaJob(), dbg_LOW, GetCheckAutoCorrectRunning(), GetCheckRunning(), ie_PRECONDITION, ie_VOL_NOT_FOUND, ipc_EXEC_m, ivd_Error, log_DBG_m, log_FUNC_m, m_iRM, m_jobMgr, m_partName, m_reorgScan_x, m_reorgScanRunning, and RecoveryMode().

Referenced by LimitedCheckFSCvsMedia().

                                                                         {
    log_FUNC_m(CheckFSCvsMedia);

    try {

        // is check or recovery running
        if (GetCheckRunning() ||
            GetCheckAutoCorrectRunning() ){
            ostringstream msg;
            msg << "Check FSC vs. Media is already running.";
            throw ivd_Error(ie_PRECONDITION, msg.str());
        }
        else if (RecoveryMode()){
            ostringstream msg;
            msg << "Recovery of FSC is running. " <<
                "Wait for recovery to finish, then run check";
            throw ivd_Error(ie_PRECONDITION, msg.str());
        };


        //
        if (a_autoCorrect){
            // do not allow reorg scan
            cmn_MutexLock l(m_reorgScan_x);
            if (m_reorgScanRunning){
                ostringstream msg;
                msg << "Check FSC vs. Media with autocorrect is not allowed" <<
                       " when reorganization scan is running.";
                throw ivd_Error(ie_PRECONDITION, msg.str());
            }
            // clear all scanned statuses for volumes
            ipc_EXEC_m(
                m_iRM->ClearReorgScan(m_partName.c_str());
            );

        }

        i_MediumSeqByVol_t_var allMedVol;
        ipc_EXEC_m(
            allMedVol = m_iRM->SelectAllMediumVolByPart(
                                        CORBA::string_dup(m_partName.c_str()));
        )
        log_DBG_m(dbg_LOW,"Selected Medium for Partition: " << allMedVol->length() );


        i_MediumSeqByVol_t volSeqByMed;

        if (a_volumes.length() > 0) {
            i_MediumVolSeq_t tmpVolSeq;

            // recover just specified volumes

            bool found = false;
            tmpVolSeq.length( a_volumes.length() );

            // copy all required volumes to tmpVolSeq
            for (UInt32_t i = 0; i < a_volumes.length(); i++){

                for (UInt32_t j = 0; j < allMedVol->length(); j++){
                    for (UInt32_t k = 0; k < allMedVol[j].length(); k++){
                        if ( strcmp(    allMedVol[j][k].medVolId,
                                        a_volumes[i]
                                   ) == 0 ) {
                            tmpVolSeq[i] = allMedVol[j][k];
                            found = true;
                            break;
                        }
                    }
                }
                if (!found){
                    throw ivd_Error(    ie_VOL_NOT_FOUND,
                                        "Nonexistent Volume was specified.");
                }
                found = false;
            }

            // make new volSeqByMed out of tmpVolSeq

            for (UInt32_t i = 0; i < tmpVolSeq.length(); i++){


                for (UInt32_t j = 0; j < volSeqByMed.length(); j++){ // for each medium

                    if (volSeqByMed[j].length() > 0){ // is there a medium entry
                        if ( strcmp(    volSeqByMed[j][0].mediumBarcode,
                                        tmpVolSeq[i].mediumBarcode ) == 0 )
                        { // does the barcode match
                            volSeqByMed[j].length( volSeqByMed[j].length() + 1);
                            volSeqByMed[j][volSeqByMed[j].length() - 1] = tmpVolSeq[i];
                            found = true;
                            break;
                        }
                    }
                }
                if (!found){
                    // insert new medium
                    volSeqByMed.length(volSeqByMed.length() + 1);
                    // set length to 1
                    volSeqByMed[volSeqByMed.length() - 1].length(1);
                    // set first in sequence to vol
                    volSeqByMed[volSeqByMed.length() - 1][0] = tmpVolSeq[i];
                }
                found = false;
            }

            return m_jobMgr.CreateCheckFSCvsMediaJob(  volSeqByMed,
                                                a_autoCorrect,
                                                a_removeMissingOnMedia,
                                                a_uims);
        } else {
            // check all volumes
            return m_jobMgr.CreateCheckFSCvsMediaJob( *(allMedVol._retn()),
                                                a_autoCorrect,
                                                a_removeMissingOnMedia,
                                                a_uims);
        }

    } ipc_CATCH_IVD_THROW_CORBA_m;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void i_PartitionManager_i::ClearCheckAutoCorrectRunning (  ) 

Definition at line 1756 of file i_pm_impl.cpp.

References m_checkAutoCorrectRunning, and m_checkAutoCorrectRunning_x.

Referenced by i_MediumCheckJob_i::~i_MediumCheckJob_i().

Here is the caller graph for this function:

void i_PartitionManager_i::ClearCheckRunning (  ) 

Definition at line 1774 of file i_pm_impl.cpp.

References m_checkRunning, and m_checkRunning_x.

Referenced by i_MediumCheckJob_i::~i_MediumCheckJob_i().

Here is the caller graph for this function:

void i_PartitionManager_i::ClearRecoveryRunning (  ) 

Definition at line 1655 of file i_pm_impl.cpp.

References log_FUNC_m, m_recoveryMode, and m_recoveryMode_x.

Referenced by i_RecoveryJob_i::~i_RecoveryJob_i().

Here is the caller graph for this function:

void i_PartitionManager_i::ClearReorgScan ( bool  a_succeded  ) 

Definition at line 1261 of file i_pm_impl.cpp.

References GetReorgScan(), ie_PRECONDITION, ipc_EXEC_m, log_FUNC_m, m_iRM, m_partName, m_reorgScanRunning, and rmdb_PARTITION_REORG_SCAN_INPROG.

Referenced by i_ReorgScanJob_i::~i_ReorgScanJob_i().

                                                         {
    log_FUNC_m(ClearReorgScan);

    if (!GetReorgScan()){
        throw ivd_InternalError(ie_PRECONDITION,
            "Reorganization scan not running.");
    }
    if (a_succeded){
        // Clear status flag in RM
        ipc_EXEC_m(
            m_iRM->ClearPartitionStatus(rmdb_PARTITION_REORG_SCAN_INPROG, m_partName.c_str());
        );
    }
    m_reorgScanRunning = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

i_JobID_t i_PartitionManager_i::CopyContents ( const char *  a_barcode,
const i_VolNumList_t a_volumes,
::CORBA::Boolean  a_best_effort,
i_UIMessageServer_ptr  a_uims 
)

Definition at line 834 of file i_pm_impl.cpp.

References pm_JobMgr::CreateCopyContentsJob(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_jobMgr.

                                                                         {
    log_FUNC_m(CopyContents);
    try {
        string barcode(a_barcode);
        return m_jobMgr.CreateCopyContentsJob(barcode, a_volumes, a_best_effort, a_uims);
    } ipc_CATCH_IVD_THROW_CORBA_m

}

Here is the call graph for this function:

i_JobID_t i_PartitionManager_i::EfficientRecall ( const i_RecallList_t a_files,
i_JobID_t  a_mainJobID 
)

Definition at line 349 of file i_pm_impl.cpp.

References pm_JobMgr::CreateEfficientRecallJobs(), dbg_DETAIL, log_DBG_m, log_FUNC_m, and m_jobMgr.

Referenced by i_EfficientRecallJob_i::RecallRetry().

                                                                                                    {
    log_FUNC_m(EfficientRecall);

    log_DBG_m(dbg_DETAIL,"" << endl <<
        "**** EfficientRecall was called for "
        << a_files.length() << " of files."
    );

    try {
        a_mainJobID = m_jobMgr.CreateEfficientRecallJobs(a_files, a_mainJobID);
    } ipc_CATCH_IVD_THROW_CORBA_m;

    return a_mainJobID;
}

Here is the call graph for this function:

Here is the caller graph for this function:

i_ClientConf_t * i_PartitionManager_i::FillClientCfg (  )  [private]

Definition at line 1416 of file i_pm_impl.cpp.

References cfg_PMCfg::alternateDataPath, cfg_PMCfg::clients, cfg_PMCfg::criticalWaterMark, dbg_DETAIL, evt_WARNING, cfg_PMCfg::fileHeaderSize, fst_REGULAR, fst_WORM, GetPartitionRecord(), cfg_PMCfg::hashSize, cfg_PMCfg::highWaterMark, ie_NYI, ivd_Error, log_DBG_m, log_FUNC_m, log_WriteEvent(), log_WRN_m, cfg_PMCfg::lowWaterMark, m_config, m_maxDiskBuff, m_recoveryOfIVDFS, m_rmPart, cfg_PMCfg::maxMigSize, cfg_PMCfg::maxNumMigFiles, cfg_PMCfg::maxWaitTime, cfg_PMCfg::migRetentionTime, cfg_PMCfg::minFileAge, cfg_PMCfg::minFileSize, cfg_PMCfg::minMigSize, cfg_PMCfg::minNumMigFiles, cfg_PMCfg::minWaitTime, cfg_PMCfg::name, rm_Partition::partitionUUIDString, cfg_PMCfg::recallRetentionTime, cfg_PMCfg::recallTimeOut, cfg_PMCfg::releaseExcludeFile, and cfg_PMCfg::releaseInterval.

Referenced by RefreshCfg(), and RegisterHSM().

                                                    {
    log_FUNC_m(FillClientCfg);

    i_ClientConf_t_var cfgClient(new i_ClientConf_t);

    cfgClient->CfgFileHeaderSize     = m_config.fileHeaderSize;
    cfgClient->CfgHashSize           = m_config.hashSize;
    cfgClient->CfgMaxMigSize         = m_config.maxMigSize;
    cfgClient->CfgMinMigSize         = m_config.minMigSize;

    if (cfgClient->CfgMaxMigSize > m_maxDiskBuff/2) {
        ostringstream msg;
        msg << "MaxMigSize is larger than half of the biggest file system for disk buffer.";
        msg << " Reducing MaxMigSize to " << m_maxDiskBuff/2;
        log_WriteEvent(evt_WARNING, msg.str());
        cfgClient->CfgMaxMigSize = m_maxDiskBuff/2;
        if (cfgClient->CfgMinMigSize >= cfgClient->CfgMaxMigSize) {
            cfgClient->CfgMinMigSize = cfgClient->CfgMaxMigSize/2;
            msg.str("");
            msg << "MinMigSize is larger than MaxMigSize.";
            msg << " Reducing MinMigSize to " << cfgClient->CfgMinMigSize;
            log_WriteEvent(evt_WARNING, msg.str());
        }
    }


    cfgClient->CfgMaxNumFiles        = m_config.maxNumMigFiles;
    cfgClient->CfgMaxWaitTime        = m_config.maxWaitTime;
    cfgClient->CfgMFAge              = m_config.minFileAge;
    cfgClient->CfgMinNumFiles        = m_config.minNumMigFiles;
    cfgClient->CfgMinWaitTime        = m_config.minWaitTime;
    cfgClient->CfgHighWaterMark      = m_config.highWaterMark;
    cfgClient->CfgLowWaterMark       = m_config.lowWaterMark;
    cfgClient->CfgCriticalWaterMark  = m_config.criticalWaterMark;
    cfgClient->CfgReleaseInterval    = m_config.releaseInterval;
    cfgClient->CfgMigRetentionTime   = m_config.migRetentionTime;
    cfgClient->CfgRecallRetentionTime= m_config.recallRetentionTime;
    cfgClient->CfgMinFileSize        = m_config.minFileSize;
    cfgClient->CfgChunkSize          = 0;
    cfgClient->CfgPartitionName      = CORBA::string_dup( m_config.name.c_str() );
    cfgClient->CfgPartitionUUID      = CORBA::string_dup( m_rmPart.partitionUUIDString.c_str() );
    cfgClient->CfgRecallTimeOut      = m_config.recallTimeOut;
    cfgClient->CfgRecoveryOfIVDFS    = m_recoveryOfIVDFS;
    cfgClient->CfgAlternateDataPath  = CORBA::string_dup( m_config.alternateDataPath.c_str() );

    cfgClient->CfgExcludeFromRelease.length(m_config.releaseExcludeFile.size());
    for (UInt32_t item = 0; item < m_config.releaseExcludeFile.size(); item++) {
        cfgClient->CfgExcludeFromRelease[item]
            = CORBA::string_dup( m_config.releaseExcludeFile[item].Val().c_str() );
    }

    /*  ZJ - not needed/used by client
    cfgClient->CfgDelete.length(m_config.deleteFile.size());
    for (UInt32_t item = 0; item < m_config.deleteFile.size(); item++) {
        cfgClient->CfgDelete[item].fileAge = m_config.deleteFile[item].m_fileAge;
        cfgClient->CfgDelete[item].pathList.length(m_config.deleteFile[item].m_pathList.size());
        for (UInt32_t ui = 0; ui < m_config.deleteFile[item].m_pathList.size(); ui++) {
            cfgClient->CfgDelete[item].pathList[ui] =
                CORBA::string_dup( m_config.deleteFile[item].m_pathList[ui].Val().c_str() );
        }
    }
    */

    if (m_config.clients.size() != 1) {
        throw ivd_Error(ie_NYI,"Can handle only one client");
    }

    cfgClient->CfgWORMTimeout = m_config.clients[0].WORMTimeout;

    cfgClient->CfgRecallOnly = (m_config.clients[0].disableAutMig != 0);
    cfgClient->CfgMigrateWithCollocation = (m_config.clients[0].migrateWithCollocation != 0);
    cfgClient->CfgSendHL7Messages = (m_config.clients[0].sendHl7Messages != 0);

    cfgClient->CfgReplTargetHost = CORBA::string_dup(m_config.clients[0].replTargHost.c_str());
    cfgClient->CfgReplTargetPart = CORBA::string_dup(m_config.clients[0].replTargPart.c_str());

    log_DBG_m(dbg_DETAIL, "recallOnly:" << m_config.clients[0].disableAutMig <<
                          ", replTargHost:" << m_config.clients[0].replTargHost <<
                          ", replTargPart:" << m_config.clients[0].replTargPart);

    if (cfgClient->CfgRecallOnly) {
        log_DBG_m(dbg_DETAIL, "setting minFileAge to 1s");
        cfgClient->CfgMFAge = 1;
    }

    GetPartitionRecord();

    switch (m_config.clients[0].operationMode){
        case(fst_REGULAR):  cfgClient->CfgOperationMode = i_FST_REGULAR; break;
        case(fst_WORM):     cfgClient->CfgOperationMode = i_FST_WORM; break;
        default:            log_WRN_m(  "FileSystem Type not specified "
                                        "in configuration file properly "
                                        "FSType set to REGULAR!");
                            cfgClient->CfgOperationMode = i_FST_REGULAR;
    }

    cfgClient->CfgRecallOnOpen = (m_config.clients[0].recallOnOpen != 0);

    return cfgClient._retn();
} // i_PartitionManager_i::FillClientCfg()

Here is the call graph for this function:

Here is the caller graph for this function:

void i_PartitionManager_i::FSCRecovery ( const string &  a_medVolIDstr,
ivd_MedVolNum_t  a_medVolNum,
ivd_MediaKey_t  a_mediaKey,
UInt32_t  a_blkSize,
UInt32_t  a_lastDataPosition 
) [inline]

Definition at line 163 of file i_pm_impl.h.

References i_FSC_i::FSCRecovery(), and m_iFSCi.

                                                                {
        m_iFSCi->FSCRecovery(a_medVolIDstr, a_medVolNum, a_mediaKey, a_blkSize, a_lastDataPosition);
    };

Here is the call graph for this function:

i_JobID_t i_PartitionManager_i::FSCRecovery ( const i_StringList_t a_volumes,
i_UIMessageServer_ptr  a_uims 
)

Definition at line 284 of file i_pm_impl.cpp.

References pm_JobMgr::CreateFSCRecoveryJob(), GetCheckAutoCorrectRunning(), GetCheckRunning(), GetReorgScan(), ie_PRECONDITION, ivd_Error, log_FUNC_m, m_jobMgr, RecoveryMode(), and RecoveryModeSet().

Referenced by i_RecoveryJob_i::ProcessFRI().

                                                                     {
    log_FUNC_m(Recover);

    try {
        if (GetCheckRunning() ||
            GetCheckAutoCorrectRunning() ){
                ostringstream msg;
                msg << "Recovery can not be started. " <<
                    "Check FSC vs. Media is running.";
                throw ivd_Error(ie_PRECONDITION, msg.str());
            }
        else if (RecoveryMode()){
            ostringstream msg;
            msg << "Recovery can not be started. Recovery of FSC is already running. ";
            throw ivd_Error(ie_PRECONDITION, msg.str());
        }
        else if (GetReorgScan()){
            ostringstream msg;
            msg << "Recovery can not be started. Reorganization scan is running.";
            throw ivd_Error(ie_PRECONDITION, msg.str());
        };

        RecoveryModeSet();
        return m_jobMgr.CreateFSCRecoveryJob(a_volumes, a_uims);

    } ipc_CATCH_IVD_THROW_CORBA_m;
} // i_PartitionManager_i::FSCRecovery()

Here is the call graph for this function:

Here is the caller graph for this function:

i_JobList_t * i_PartitionManager_i::GetAllJobs (  ) 

Definition at line 856 of file i_pm_impl.cpp.

References job_Manager::GetAllJobs(), log_FUNC_m, and m_jobMgr.

Referenced by GetStatus().

                                              {
    log_FUNC_m(GetAllJobs);

    try {
        return m_jobMgr.GetAllJobs();
    } ipc_CATCH_IVD_THROW_CORBA_m;
}

Here is the call graph for this function:

Here is the caller graph for this function:

i_JobParamsSeq_t * i_PartitionManager_i::GetAllJobsParam (  ) 

Definition at line 865 of file i_pm_impl.cpp.

References job_Manager::GetAllJobParams(), log_FUNC_m, and m_jobMgr.

                                                        {
    log_FUNC_m(GetAllJobsParam);

    try{
        return m_jobMgr.GetAllJobParams();
    } ipc_CATCH_IVD_THROW_CORBA_m;
}

Here is the call graph for this function:

void i_PartitionManager_i::GetAllMediaWithPools ( fsc_MediumStatus_v ms  ) 

Definition at line 365 of file i_pm_impl.cpp.

References dbg_DETAIL, dbg_IsActive(), dbg_NORM, ie_FATAL_ERROR, log_DBG_m, log_FUNC_m, m_config, cfg_PM::m_globalTree, m_iRM, i_MediaPool_t::mediaPoolKey, i_Medium_t::mediaPoolName, i_MediaPool_t::mediaPoolName, i_Medium_t::mediumKey, i_Medium_t::mediumType, mt_DISK, cfg_Tree::pools, and i_Medium_t::status.

Referenced by CheckFSCvsIVDFS().

                                                                      {
    log_FUNC_m(GetAllMediaWithPools);

    i_MediumSeq_t_var medSeq;
    medSeq = m_iRM->SelectAllMedia();
    vector<i_MediaPool_t> &pools = m_config.m_globalTree.pools;

    UInt32_t maxMedKey(0);
    if (medSeq->length() == 0){
        ostringstream sstr;
        sstr << "No media found at all ???. ";
        throw ivd_InternalError(ie_FATAL_ERROR, sstr.str());
    } else {
        maxMedKey = medSeq[0].mediumKey;
    }

    for (UInt32_t i(1); i < medSeq->length(); ++i){
        if (medSeq[i].mediumKey > maxMedKey){
            maxMedKey = medSeq[i].mediumKey;
        }
    }

    // index is mediumKey
    // index 0 is redundant
    ms.resize(maxMedKey + 1);
    ostringstream msgBase;
    log_DBG_m(dbg_NORM, "" << msgBase << "ms resized to " << ms.size());

    log_DBG_m(dbg_DETAIL, "Num of pools " << pools.size());
    if (dbg_IsActive()) {
        for(UInt32_t j(0); j < pools.size(); ++j){
            i_MediaPool_t &pool = pools[j];
            log_DBG_m(dbg_DETAIL, j
                << ". pool key " << pool.mediaPoolKey
                << " mediaPoolName " << pool.mediaPoolName );
        }
    }

    for (UInt32_t i(0); i < medSeq->length(); ++i){
        i_Medium_t& med = medSeq[i];
        // get pool key
        UInt32_t poolKey(0);
        for(UInt32_t j(0); j < pools.size(); ++j){
            i_MediaPool_t &pool = pools[j];
            if (string(pool.mediaPoolName).compare(med.mediaPoolName) == 0){
                poolKey = pool.mediaPoolKey;
            }
        }
        log_DBG_m(dbg_DETAIL, " medKey " << setw(4) << med.mediumKey
            << ". poolKey " << poolKey
            << ", med.status " << med.status
            << ", med.mediumType " << med.mediumType
            << ", med.mediaPoolName " << med.mediaPoolName );

        if (med.mediumKey == 0){
            ostringstream sstr;
            sstr << "mediumKey is zero. " << med.mediumKey;
            throw ivd_InternalError(ie_FATAL_ERROR, sstr.str());
        }
        if (med.mediumKey >= ms.size()){
            ostringstream sstr;
            sstr << "mediumKey is bigger than vector size. "
                << med.mediumKey << " > " << ms.size();
            throw ivd_InternalError(ie_FATAL_ERROR, sstr.str());
        }
        log_DBG_m(dbg_DETAIL, "inserting  mediaKey:" << med.mediumKey);
        ms[med.mediumKey] = fsc_MediumStatus_t( poolKey,
            med.status,
            med.mediumType == mt_DISK ? 2:1);
        // Higher number better medium
    }
} // i_PartitionManager_i::GetAllMediaWithPools()

Here is the call graph for this function:

Here is the caller graph for this function:

bool i_PartitionManager_i::GetCheckAutoCorrectRunning (  ) 
bool i_PartitionManager_i::GetCheckRunning (  ) 

Definition at line 1780 of file i_pm_impl.cpp.

References m_checkRunning, and m_checkRunning_x.

Referenced by CheckFSCvsMedia(), FSCRecovery(), and LimitedCheckFSCvsMedia().

Here is the caller graph for this function:

char i_PartitionManager_i::GetClientPathSeparator (  )  [inline]

Definition at line 223 of file i_pm_impl.h.

Referenced by i_DelExpiredFilesJob_i::Execute().

{ return m_clientPathSeparator; };

Here is the caller graph for this function:

i_Time_t i_PartitionManager_i::GetExpirationAge ( const char *  a_path  )  [inline]

Definition at line 156 of file i_pm_impl.h.

References fsc_FileExpiration::GetExpirationAge(), and m_expirationTree.

                                                  {
        return m_expirationTree.GetExpirationAge(a_path);
    };

Here is the call graph for this function:

fsc_FileExpiration& i_PartitionManager_i::GetExpirationTree (  )  [inline]

Definition at line 160 of file i_pm_impl.h.

References m_expirationTree.

Referenced by i_DelExpiredFilesJob_i::Execute().

{ return m_expirationTree; };

Here is the caller graph for this function:

i_FSC_ptr i_PartitionManager_i::GetFSC ( void   ) 

Definition at line 964 of file i_pm_impl.cpp.

References log_FUNC_m, and m_iFSC.

Referenced by pm_JobMgr::EfficientRecallGetLocations(), i_RecallJob_i::Execute(), i_ReorgJob_i::GetFSC(), i_RedundantCopyJob_i::GetFSC(), i_RecallJob_i::GetFSC(), i_MigrationJob_i::GetFSC(), and i_EfficientRecallJob_i::GetFSC().

                                       {
    log_FUNC_m(GetFSC);
    try {
        i_FSC_ptr tmpFSC = i_FSC::_duplicate(m_iFSC);
        return tmpFSC;
    } ipc_CATCH_IVD_THROW_CORBA_m;
}

Here is the caller graph for this function:

i_HSM_ptr i_PartitionManager_i::GetHSM (  ) 

Definition at line 980 of file i_pm_impl.cpp.

References cfg_PMCfg::clients, dbg_NORM, ie_LOST_HSM, ipc_EXEC_m, ivd_Error, log_DBG_m, log_FUNC_m, log_WRN_m, m_config, m_iHSM, and m_partName.

Referenced by i_FSCCheckJob_i::AbortJob(), i_EfficientRecallJob_i::AbortRecallOnHsm(), i_RecallJob_i::CompleteJob(), i_MigrationJob_i::CompleteJob(), pm_JobMgr::CreateEfficientRecallJobs(), i_MigrationJob_i::Execute(), i_FSCCheckJob_i::Execute(), i_EfficientRecallJob_i::MediumOperationComplete(), and pm_RecallClientThread::Run().

                                       {
    log_FUNC_m(GetHSM);
    try {
        if (CORBA::is_nil(m_iHSM)){
            log_DBG_m(dbg_NORM, "HSM is_nil");
            return i_HSM::_nil();
        } else {
            log_DBG_m(dbg_NORM, "HSM is_NOT_nil");
            bool hsmIsExistant(false);
            try {
                ipc_EXEC_m(
                    if (!m_iHSM->_non_existent()){
                        log_DBG_m(dbg_NORM, "!m_iHSM->_non_existent()");
                        hsmIsExistant = true;
                    }
                )
            } catch (ivd_Error &e){
                log_WRN_m(e);
            }
            if (hsmIsExistant){
                i_HSM_ptr tmpHSM = i_HSM::_duplicate(m_iHSM);
                return tmpHSM;
            } else {
                ostringstream msg;
                msg << "Partition " << m_partName << " lost access to HSM on "
                    << m_config.clients[0].name;
                throw ivd_Error(ie_LOST_HSM, msg.str());
            }
        }
    } ipc_CATCH_IVD_THROW_CORBA_m;
} // i_PartitionManager_i::GetHSM()

Here is the caller graph for this function:

i_Job_ptr i_PartitionManager_i::GetJob ( i_JobID_t  a_jobId  ) 

Definition at line 847 of file i_pm_impl.cpp.

References job_Manager::FindJob(), i_Job_i::GetJob(), log_FUNC_m, and m_jobMgr.

                                                        {
    log_FUNC_m(GetJob);

    try {
        return m_jobMgr.FindJob(a_jobId)->GetJob();
    } ipc_CATCH_IVD_THROW_CORBA_m;
}

Here is the call graph for this function:

i_Count_t i_PartitionManager_i::GetJobCount (  ) 

Definition at line 896 of file i_pm_impl.cpp.

References job_Manager::GetJobCount(), log_FUNC_m, and m_jobMgr.

                                            {
    log_FUNC_m(GetJobCount);
    try {
        return m_jobMgr.GetJobCount();
    } ipc_CATCH_IVD_THROW_CORBA_m;
}

Here is the call graph for this function:

i_Status_t i_PartitionManager_i::GetJobStatus ( i_JobID_t  a_jobId  ) 

Definition at line 903 of file i_pm_impl.cpp.

References dbg_NORM, job_Manager::GetJobStatus(), GetReplicationPM(), ie_JOB_NOT_FOUND, ipc_EXEC_m, iPM, ivd_Error, log_DBG_m, log_FUNC_m, m_jobMgr, REPL_JOB_ID_PREFIX, and ReplicationNeeded().

                                                              {
    log_FUNC_m(GetJobStatus);
    try {
        if (a_jobId > REPL_JOB_ID_PREFIX) {
            // Send request to replication target
            if (ReplicationNeeded()) {
                ipc_EXEC_m(
                    i_PartitionManager_var iPM = GetReplicationPM();
                    log_DBG_m(dbg_NORM, "Got PM reference.");

                    return iPM->GetJobStatus(a_jobId - REPL_JOB_ID_PREFIX);
                );
            }
            else {
                throw ivd_Error(ie_JOB_NOT_FOUND, "Replication not configured.");
            }
        }
        else {
                return m_jobMgr.GetJobStatus(a_jobId);
        }
    } ipc_CATCH_IVD_THROW_CORBA_m;
}

Here is the call graph for this function:

string i_PartitionManager_i::GetName ( void   )  [inline]

Definition at line 221 of file i_pm_impl.h.

References m_partName.

Referenced by i_RecreatedIVDFSJob_i::Execute(), i_DelExpiredFilesJob_i::Execute(), i_MediumCheckJob_i::i_MediumCheckJob_i(), and i_RecoveryJob_i::i_RecoveryJob_i().

{return m_partName;};

Here is the caller graph for this function:

void i_PartitionManager_i::GetPartitionRecord (  ) 

Definition at line 1716 of file i_pm_impl.cpp.

References cfg_PMCfg::clients, dbg_LOW, GetFSType(), ipc_EXEC_m, ivd_FSTypeToText(), log_DBG_m, log_FUNC_m, log_NOTE_m, m_config, m_iRM, m_partName, m_rmPart, rm_Partition::migIdCount, rm_Partition::migIdTime, rm_Partition::options, rm_Partition::partitionName, rm_Partition::partitionUUIDString, rm_Partition::partUUID, and rm_Partition::status.

Referenced by FillClientCfg(), and i_PartitionManager_i().

                                              {
    log_FUNC_m(GetPartitionRecord);

    i_Partition_t_var part;
    ipc_EXEC_m(
        part = m_iRM->SelectPartition(m_partName.c_str());
    );
    m_rmPart.partitionName          = part->partitionName;
    m_rmPart.partitionUUIDString    = part->partitionUUIDString;
    m_rmPart.partUUID               = string(part->partitionUUIDString);
    m_rmPart.migIdCount             = part->migIdCount;
    m_rmPart.migIdTime              = part->migIdTime;
    m_rmPart.status                 = part->status;
    m_rmPart.options                = part->options;


    log_DBG_m(dbg_LOW, "part->options:" << part->options <<
                        ", m_rmPart.options:" << m_rmPart.options);

    if (GetFSType(m_rmPart.options) != m_config.clients[0].operationMode){
        ostringstream msg;
        msg << "Operation mode for partition: " << m_partName <<
            " is ";

        msg << ivd_FSTypeToText(GetFSType(m_rmPart.options)) <<
            " in rmdb, but ";

        msg << ivd_FSTypeToText(GetFSType(m_config.clients[0].operationMode)) <<
            " in configuration file!";
        log_NOTE_m(msg.str());
    }
} // i_PartitionManager_i::GetPartitionRecord()

Here is the call graph for this function:

Here is the caller graph for this function:

bool i_PartitionManager_i::GetReorgScan (  ) 

Definition at line 1253 of file i_pm_impl.cpp.

References log_FUNC_m, m_reorgScan_x, and m_reorgScanRunning.

Referenced by ClearReorgScan(), FSCRecovery(), StartReorgJob(), and StopReorgJob().

Here is the caller graph for this function:

i_PartitionManager_ptr i_PartitionManager_i::GetReplicationPM (  ) 

Definition at line 1609 of file i_pm_impl.cpp.

References cfg_PMCfg::clients, dbg_NORM, iPM, log_DBG_m, log_FUNC_m, m_config, ipc_Corba::ResolveTargetPM(), and ipc_Corba::Singleton().

Referenced by AddMajorCol(), GetJobStatus(), ReorgByColId(), and UpdateMajorCol().

                                                              {
    log_FUNC_m(GetReplicationPM);
    log_DBG_m(dbg_NORM, "Checking connectivity to replication server "
        << m_config.clients[0].replTargHost << ", partition "
        << m_config.clients[0].replTargPart);

    try {
        CORBA::Object_var obj = ipc_Corba::Singleton().ResolveTargetPM(
            m_config.clients[0].replTargHost,
            m_config.clients[0].replTargPart);

        i_PartitionManager_var iPM = i_PartitionManager::_narrow(obj);
        log_DBG_m(dbg_NORM, "Got PM reference.");

        return iPM._retn();
    }
    ipc_CATCH_IVD_THROW_CORBA_m;
}

Here is the call graph for this function:

Here is the caller graph for this function:

i_ResourceManager_ptr i_PartitionManager_i::GetRM (  ) 

Definition at line 972 of file i_pm_impl.cpp.

References log_FUNC_m, and m_iRM.

                                                  {
    log_FUNC_m(GetRM);
    try {
        i_ResourceManager_ptr tmpRM = i_ResourceManager::_duplicate(m_iRM);
        return tmpRM;
    } ipc_CATCH_IVD_THROW_CORBA_m;
}

i_BitFlag_t i_PartitionManager_i::GetStatus ( CORBA::String_out  a_mountPoint,
i_BitFlag_t a_activity 
)

Definition at line 1537 of file i_pm_impl.cpp.

References dbg_NORM, GetAllJobs(), ipc_EXEC_m, log_DBG_m, log_FUNC_m, m_iHSM, m_partName, m_recoveryMode, m_recoveryNeeded, m_rmPart, rmdb_PARTITION_REORG_SCAN_INPROG, and rm_Partition::status.

                                                                                                  {
    log_FUNC_m(GetStatus);

    i_BitFlag_t  status = ps_UNKNOWN;
    string mountPoint = "<not mounted>";
    a_activity = pa_UNKNOWN;


    // first check if it is mounted

    if (m_recoveryMode) {
        status = ps_RECOVERYMODE;
        a_activity = pa_RECOVERYINPROG;
    }
    else if (m_recoveryNeeded) {
        status = ps_RECOVERYMODE;
        a_activity = pa_RECOVERYPENDING;
    }


    if ( CORBA::is_nil(m_iHSM) ) {
        log_DBG_m(dbg_NORM, "PM: HSM for partition "
                    << m_partName << " not running.");

        status = ps_READY;

        if (m_rmPart.status & rmdb_PARTITION_REORG_SCAN_INPROG) {
            a_activity = pa_REORGSCANINPROG;
        }
        else {
            a_activity = pa_IDLE;
        }
    }
    else {
        i_HsmInfo_t_var hsmInfo;
        try {
            ipc_EXEC_m(m_iHSM->GetInfo(hsmInfo););

            status = ps_MOUNTED;
            mountPoint = hsmInfo->mountPoint;

            if (m_rmPart.status & rmdb_PARTITION_REORG_SCAN_INPROG) {
                a_activity = pa_REORGSCANINPROG;
            }
            else {
                i_JobList_t *jobs = GetAllJobs();
                if (jobs->length() == 0) {
                    a_activity = pa_IDLE;
                }
                else {
                    a_activity = pa_JOBSRUNNING;
                }
            }
        }
        catch (ivd_Error &e) {
            log_DBG_m(dbg_NORM, e);
            status = ps_READY;
            a_activity = pa_MOUNTINPROG;
            mountPoint = "n/a";
        }
    }

    a_mountPoint = CORBA::string_dup(mountPoint.c_str());
    return status;
}

Here is the call graph for this function:

bool i_PartitionManager_i::IsRecoveryOfIVDFSRun (  )  [inline]

Definition at line 248 of file i_pm_impl.h.

References m_recoveryOfIVDFS.

{ return m_recoveryOfIVDFS; };

i_JobID_t i_PartitionManager_i::IVDFSRecover ( i_UIMessageServer_ptr  a_uims  ) 

Definition at line 314 of file i_pm_impl.cpp.

References pm_JobMgr::CreateIVDFSRecoveryJob(), log_FUNC_m, and m_jobMgr.

                                                                         {
    log_FUNC_m(IVDFSRecover);

    try {
        return m_jobMgr.CreateIVDFSRecoveryJob(a_uims);
    } ipc_CATCH_IVD_THROW_CORBA_m;
}

Here is the call graph for this function:

i_JobID_t i_PartitionManager_i::LimitedCheckFSCvsMedia ( const i_StringList_t a_barcodes,
const i_VolNumList_t a_volumes,
CORBA::Boolean  a_autoCorrect,
CORBA::Boolean  a_removeMissingOnMedia,
i_UIMessageServer_ptr  a_uims 
)

Definition at line 580 of file i_pm_impl.cpp.

References CheckFSCvsMedia(), pm_JobMgr::CreateCheckFSCvsMediaJob(), dbg_DETAIL, dbg_LOW, GetCheckAutoCorrectRunning(), GetCheckRunning(), ie_INVALID_ARG, ie_PRECONDITION, ipc_EXEC_m, ivd_Error, log_DBG_m, log_FUNC_m, m_iRM, m_jobMgr, m_partName, m_reorgScan_x, m_reorgScanRunning, and RecoveryMode().

                                          {
    log_FUNC_m(CheckFSCvsMedia);

    try {

        // is Check or recovery running
        if (GetCheckRunning() ||
            GetCheckAutoCorrectRunning() ){
            ostringstream msg;
            msg << "Check FSC vs. Media is already running.";
            throw ivd_Error(ie_PRECONDITION, msg.str());
        }
        else if (RecoveryMode()){
            ostringstream msg;
            msg << "Recovery of FSC is running. " <<
                "Wait for recovery to finish, then run check";
            throw ivd_Error(ie_PRECONDITION, msg.str());
        };


        //
        if (a_autoCorrect){
            // do not allow reorg scan
            cmn_MutexLock l(m_reorgScan_x);
            if (m_reorgScanRunning){
                ostringstream msg;
                msg << "Check FSC vs. Media with autocorrect is not allowed" <<
                       " when reorganization scan is running.";
                throw ivd_Error(ie_PRECONDITION, msg.str());
            }
            // clear all scanned statuses for volumes
            ipc_EXEC_m(
                m_iRM->ClearReorgScan(m_partName.c_str());
            );
        }

        CORBA::ULong numVolumes = a_volumes.length();

        i_MediumSeqByVol_t volSeqByMed;
        volSeqByMed.length(a_barcodes.length());
        UInt32_t numberOfAllVolumes = 0;
        for (UInt32_t i = 0; i < a_barcodes.length(); i++) {
            i_MediumVolSeq_t_var mediumVol;

            ipc_EXEC_m(
                mediumVol = m_iRM->SelectAllMediumVolByBarcode(
                                            CORBA::string_dup(a_barcodes[i]));
            );
            log_DBG_m(dbg_DETAIL,"Check medium: " << a_barcodes[i] );
            if (numVolumes > 0) {  // check if volume is specified
                i_MediumVolSeq_t &destMediumVol = volSeqByMed[i];
                destMediumVol.length(numVolumes);
                UInt32_t destIdx = 0;
                log_DBG_m(dbg_DETAIL,"Number of specified volumes: " << numVolumes
                                << ", number of medium voumes: " << mediumVol->length());
                for (UInt32_t srcIdx = 0; srcIdx < mediumVol->length(); srcIdx++) {
                    Int32_t volNum = mediumVol[srcIdx].medVolNr;
                    log_DBG_m(dbg_DETAIL,"Check volume num: " << volNum);
                    for (UInt32_t volIdx = 0; volIdx < numVolumes; volIdx++) {
                        log_DBG_m(dbg_DETAIL,"by: " << a_volumes[volIdx]);
                        if (volNum == a_volumes[volIdx]) { // volume is specified
                            destMediumVol[destIdx] = mediumVol[srcIdx];
                            destIdx++;
                            mediumVol[srcIdx].medVolNr = 0; //
                            numberOfAllVolumes++;
                            break;
                        }
                    }
                }
                // cut out non used array elements
                if (destIdx < destMediumVol.length()) {
                    destMediumVol.length(destIdx);
                }
            }
            else {
                numberOfAllVolumes += mediumVol->length();
                volSeqByMed[i] = mediumVol;
            }
        }

        log_DBG_m(dbg_LOW,"Selected Medium for Partition: " << volSeqByMed.length() );
        log_DBG_m(dbg_LOW,"Number of all selected volumes: " << numberOfAllVolumes );
        ipc_EXEC_m(
            if (numberOfAllVolumes == 0) {
                ostringstream sstr;
                sstr << "None of specified media/volumes are used and reliable.";
                throw ivd_Error(ie_INVALID_ARG, sstr.str());
            }
            else {
                return m_jobMgr.CreateCheckFSCvsMediaJob(  volSeqByMed,
                                                a_autoCorrect,
                                                a_removeMissingOnMedia,
                                                a_uims);
            }
        );
    } ipc_CATCH_IVD_THROW_CORBA_m;
}

Here is the call graph for this function:

i_JobID_t i_PartitionManager_i::Migrate ( const i_JobRequestList_t a_files,
i_MigID_t  a_migrationID,
i_ColID_t  a_majColId,
i_ColID_t  a_minColId,
i_BitFlag_t  a_flags 
)

Definition at line 255 of file i_pm_impl.cpp.

References dbg_LOW, ie_INVALID_ARG, log_DBG_m, log_FUNC_m, m_iHSM, m_jobMgr, and pm_JobMgr::Migrate().

Referenced by i_MigrationJob_i::CompleteJob().

                                             {

    log_FUNC_m(Migrate);

    i_JobID_t jobID(0);

    try {
        if (CORBA::is_nil(m_iHSM)) {
            log_DBG_m(dbg_LOW, "m_iHSM is nil");
            throw ivd_InternalError(
                ie_INVALID_ARG,
                "PM does not have reference to HSM. Who requested migration?");
        };
        pm_FileList files(a_files);

        // Split files to smaller lists, based on policies
        jobID = m_jobMgr.Migrate(files, a_migrationID, a_majColId, a_minColId, a_flags);

    } ipc_CATCH_IVD_THROW_CORBA_m;

    return jobID;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CORBA::Boolean i_PartitionManager_i::MigrateWithCollocation (  ) 

Definition at line 1791 of file i_pm_impl.cpp.

References cfg_PMCfg::clients, log_FUNC_m, and m_config.

                                                          {
    log_FUNC_m(MigrateWithCollocation);

    return (m_config.clients[0].migrateWithCollocation != 0);
}

void i_PartitionManager_i::ParseConfig (  )  [private]

Definition at line 1315 of file i_pm_impl.cpp.

References BuildExpirationTree(), CFG_LINK_LATEST, ivd_Directories::cfgPart, cfg_PMCfg::clients, dbg_DETAIL, dbg_LOW, cmn_Global::dirs, g_cmn, cfg_PMCfg::globalTreeOptions, ie_DATA_CORRUPTION, ie_NYI, ipc_EXEC_m, log_DBG_m, log_ERR_m, log_FUNC_m, log_WRN_m, m_config, m_externalClient, cfg_PM::m_globalTree, cmn_SysInfo::m_hostName, m_iRM, m_jobMgr, m_partName, cfg_PMCfg::maxNumDrives, cfg_PMCfg::maxNumDrivesMigration, cfg_PMCfg::maxNumDrivesRecall, cfg_PMCfg::maxNumDrivesReorg, cfg_PMCfg::migrationPriority, cfg_PMTree::name, cfg_Tree::name, pf_File::Parse(), cfg_PMCfg::partitionPriority, cfg_PMTree::pools, cfg_Tree::pools, cfg_PMCfg::recallPriority, cfg_PMCfg::Refresh(), cfg_PMCfg::reserveNumDrives, cfg_PMCfg::reserveNumDrivesMigration, cfg_PMCfg::reserveNumDrivesRecall, cfg_PMCfg::reserveNumDrivesReorg, job_Manager::SetMaxRunningJobs(), and cmn_Global::si.

Referenced by i_PartitionManager_i(), and RefreshCfg().

                                       {
    log_FUNC_m(ParseConfig);

    cmn_Path cfgFile = g_cmn.dirs.cfgPart + m_partName + string(CFG_LINK_LATEST);

    // Reread configuration file
    {
        pf_File pmPF;
        pmPF.Parse(cfgFile);

        log_DBG_m(dbg_DETAIL,"got PM Job Manager configuration" );

        m_config.Refresh(pmPF);
    }
    log_DBG_m(dbg_DETAIL,"migration job priority in pmjobmgr is: " << m_config.migrationPriority);

    if (m_config.clients.size() < 1) {
        log_ERR_m("No clients configured.");
    }
    else if (m_config.clients.size() > 1) {
        log_WRN_m("Multiple clients configured! Unsupported configuration.");
    }
    else {
        string& cltHost = m_config.clients.at(0).name;

        if (g_cmn.si.m_hostName != cltHost) {
            log_DBG_m(dbg_LOW, "Client " << cltHost << " is EXTERNAL.");
            m_externalClient = true;
        }
        else {
            log_DBG_m(dbg_LOW, "Client " << cltHost << " is LOCAL.");
            m_externalClient = false;
        }
    }

    log_DBG_m(dbg_DETAIL, "recallOnly:" << m_config.clients[0].disableAutMig << endl
                       << "migrateWithCollocation: " << m_config.clients[0].migrateWithCollocation << endl
                       << "sendHl7Messages: " << m_config.clients[0].sendHl7Messages);

    m_config.m_globalTree.pools.clear();
    log_DBG_m(dbg_DETAIL,"Cleared old pools");
    m_config.m_globalTree.name          = m_config.globalTreeOptions.name;

    for (UInt32_t i = 0; i < m_config.globalTreeOptions.pools.size(); i++){
        if (m_config.globalTreeOptions.pools[i].Type() == el_Simple ){
            string pName;
            pName = m_config.globalTreeOptions.pools[i].Val();
            i_MediaPool_t_var iMp;
            ipc_EXEC_m(
                log_DBG_m(dbg_DETAIL,"will select pool with name : " << pName);

                iMp = m_iRM->SelectMediaPool(pName.c_str());
                // mp.SelectByName(pName);

            );
            m_config.m_globalTree.pools.push_back(iMp);

        } else if (m_config.globalTreeOptions.pools[i].Type() == el_Range){

            throw ivd_InternalError(
                ie_NYI, "Range of MediaPools is not yet implmented");

        } else {
            throw ivd_InternalError(
                ie_DATA_CORRUPTION, "no element type for pool in cfgPM config type");
        }
    };
    BuildExpirationTree();

    log_DBG_m(dbg_DETAIL,"" << endl <<
        "Partition running with following parameters:" << endl <<
        "   globalTreeOptions.pools.size()" << m_config.globalTreeOptions.pools.size() << endl <<
        "   maxNumDrives                " << m_config.maxNumDrives              << endl <<
        "   maxNumDrivesMigration       " << m_config.maxNumDrivesMigration     << endl <<
        "   maxNumDrivesRecall          " << m_config.maxNumDrivesRecall        << endl <<
        "   maxNumDrivesReorg           " << m_config.maxNumDrivesReorg         << endl <<
        "   migrationPriority           " << m_config.migrationPriority         << endl <<
        "   partitionPriority           " << m_config.partitionPriority         << endl <<
        "   recallPriority              " << m_config.recallPriority            << endl <<
        "   reserveNumDrives            " << m_config.reserveNumDrives          << endl <<
        "   reserveNumDrivesMigration   " << m_config.reserveNumDrivesMigration << endl <<
        "   reserveNumDrivesRecall      " << m_config.reserveNumDrivesRecall    << endl <<
        "   reserveNumDrivesReorg       " << m_config.reserveNumDrivesReorg     << endl
        );

    UInt32_t jobLimit(m_config.maxNumDrives * 3 / 2);

    m_jobMgr.SetMaxRunningJobs(jobLimit);
} // i_PartitionManager_i::ParseConfig()

Here is the call graph for this function:

Here is the caller graph for this function:

i_ColInfoList_t * i_PartitionManager_i::ReadCollocationInfo (  ) 

Definition at line 1896 of file i_pm_impl.cpp.

References c_collocationFile(), cmn_Global::dirs, file, g_cmn, ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, cfg_CollocationInfo::m_dirColInfo_v, m_partName, and ivd_Directories::part.

                                                           {
    log_FUNC_m(ReadCollocationInfo);
    try {
        cmn_Path colInfoFilePath = g_cmn.dirs.part + m_partName + c_collocationDir;
        cmn_File file(colInfoFilePath + c_collocationFile);
        cfg_CollocationInfo colInfo;
        cfg_CollocationInfo::ReadCollocationInfo(file, colInfo);

        i_ColInfoList_t_var colInfoList = new i_ColInfoList_t;
        colInfoList->length(colInfo.m_dirColInfo_v.size());
        for (UInt32_t i(0); i < colInfoList->length(); i++) {
            colInfoList[i].m_path = CORBA::string_dup(colInfo.m_dirColInfo_v[i].m_directoryPath.c_str());
            colInfoList[i].m_colId = colInfo.m_dirColInfo_v[i].m_colId;
        }
        return colInfoList._retn();
    }
    ipc_CATCH_IVD_THROW_CORBA_m
}

Here is the call graph for this function:

i_HL7InfoList_t * i_PartitionManager_i::ReadHl7Info (  ) 

Definition at line 1928 of file i_pm_impl.cpp.

References c_hl7Dir(), cmn_Num2Str(), cmn_Global::dirs, file, g_cmn, ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, cfg_HL7Info::m_dirHL7Info_v, m_partName, ivd_Directories::part, and cfg_HL7Info::ReadHL7Info().

                                                   {
    log_FUNC_m(ReadHl7Info);
    try {
        cmn_Path hl7InfoFileName = g_cmn.dirs.part + m_partName + c_hl7Dir + c_hl7File;
        cmn_File file(hl7InfoFileName);
        cfg_HL7Info hl7Info;
        cfg_HL7Info::ReadHL7Info(file, hl7Info);

        i_HL7InfoList_t_var hl7InfoList = new i_HL7InfoList_t;
        hl7InfoList->length(hl7Info.m_dirHL7Info_v.size());
        for (UInt32_t i(0); i < hl7InfoList->length(); i++) {
            hl7InfoList[i].m_hostname = CORBA::string_dup(hl7Info.m_dirHL7Info_v[i].m_hostname.c_str());
            hl7InfoList[i].m_port = CORBA::string_dup(cmn_Num2Str(hl7Info.m_dirHL7Info_v[i].m_port).c_str());
            hl7InfoList[i].m_path = CORBA::string_dup(hl7Info.m_dirHL7Info_v[i].m_directoryPath.c_str());
        }

        return hl7InfoList._retn();
    }
    ipc_CATCH_IVD_THROW_CORBA_m
}

Here is the call graph for this function:

i_JobID_t i_PartitionManager_i::Recall ( const i_Recall_t a_file  ) 

Definition at line 323 of file i_pm_impl.cpp.

References pm_JobMgr::CreateRecallJob(), dbg_DETAIL, i_Recall_t::fileID, i_Recall_t::fileIdx, log_DBG_m, log_FUNC_m, and m_jobMgr.

                                                               {
    log_FUNC_m(Recall);

    i_JobID_t jobID (0);

    log_DBG_m(dbg_DETAIL,"" << endl <<
        "**** Recall was called with i_Recall_t param:" << endl <<
        " fileID:" << a_file.fileID << endl <<
        " fileIdx:" << a_file.fileIdx << endl
    );

    try {
        jobID = m_jobMgr.CreateRecallJob(a_file);
    } ipc_CATCH_IVD_THROW_CORBA_m;

    return jobID;
}

Here is the call graph for this function:

CORBA::Boolean i_PartitionManager_i::RecallOnlyMode (  ) 

Definition at line 1785 of file i_pm_impl.cpp.

References cfg_PMCfg::clients, log_FUNC_m, and m_config.

                                                  {
    log_FUNC_m(RecallOnlyMode);

    return (m_config.clients[0].disableAutMig != 0);
}

CORBA::Boolean i_PartitionManager_i::RecoveryMode (  ) 

Definition at line 1518 of file i_pm_impl.cpp.

References dbg_DETAIL, log_DBG_m, log_FUNC_m, m_recoveryMode, and m_recoveryMode_x.

Referenced by CheckFSCvsMedia(), FSCRecovery(), LimitedCheckFSCvsMedia(), RegisterHSM(), Reorg(), ReorgByColId(), and ReorgScan().

Here is the caller graph for this function:

void i_PartitionManager_i::RecoveryModeClear (  ) 

Definition at line 1641 of file i_pm_impl.cpp.

References ipc_EXEC_m, log_FUNC_m, log_WriteEvent(), m_iRM, m_partName, m_recoveryMode, m_recoveryMode_x, m_recoveryNeeded, and rmdb_PARTITION_RECOVERY_MODE.

Referenced by i_RecoveryJob_i::~i_RecoveryJob_i().

Here is the call graph for this function:

Here is the caller graph for this function:

void i_PartitionManager_i::RecoveryModeSet (  ) 

Definition at line 1628 of file i_pm_impl.cpp.

References ipc_EXEC_m, log_FUNC_m, log_WriteEvent(), m_iRM, m_partName, m_recoveryMode, m_recoveryMode_x, and rmdb_PARTITION_RECOVERY_MODE.

Referenced by FSCRecovery(), and i_PartitionManager_i().

Here is the call graph for this function:

Here is the caller graph for this function:

CORBA::Boolean i_PartitionManager_i::RecoveryNeeded (  ) 
void i_PartitionManager_i::RecoveryOfIVDFSClear (  ) 

Definition at line 1677 of file i_pm_impl.cpp.

References log_FUNC_m, m_recoveryOfIVDFS, and m_recoveryOfIVDFS_x.

Referenced by i_RecreatedIVDFSJob_i::Execute().

Here is the caller graph for this function:

bool i_PartitionManager_i::RecoveryOfIVDFSSet (  ) 

Definition at line 1664 of file i_pm_impl.cpp.

References log_FUNC_m, m_recoveryOfIVDFS, and m_recoveryOfIVDFS_x.

Referenced by i_RecreatedIVDFSJob_i::Execute().

Here is the caller graph for this function:

void i_PartitionManager_i::RefreshCfg (  ) 

Definition at line 927 of file i_pm_impl.cpp.

References cfg_PMCfg::clients, dbg_NORM, FillClientCfg(), ie_NYI, iPM, log_DBG_m, log_FUNC_m, m_config, m_iHSM, ParseConfig(), and ipc_Corba::RegisterPMByDeviceName().

                                      {
    log_FUNC_m(RefreshCfg);
    try {
        if (m_config.clients.size() > 1) {
            throw ivd_InternalError(ie_NYI, "More than one client configured.");
        }

        string oldFSID;
        log_DBG_m(dbg_NORM, "oldFSID:" <<
                            m_config.clients[0].fileSystemId);
        oldFSID = m_config.clients[0].fileSystemId;

        m_config.clients.clear();
        ParseConfig();

        i_PartitionManager_var iPM = this->_this();

        if ( (oldFSID.compare(m_config.clients[0].fileSystemId) != 0  )) {
            log_DBG_m(dbg_NORM, " registering client name:" << m_config.clients[0].name <<
                " fileSystemId:" << m_config.clients[0].fileSystemId);
            ipc_Corba::RegisterPMByDeviceName(
                iPM,
                m_config.clients[0].name,
                m_config.clients[0].fileSystemId);
        }

        log_DBG_m(dbg_NORM, "Will fill client cfg.");
        i_ClientConf_t_var clientCfg = FillClientCfg();

        if (!CORBA::is_nil(m_iHSM) && !m_iHSM->_non_existent()) {
            log_DBG_m(dbg_NORM, "Will send cfg to hsm.");
            m_iHSM->Reconfigure(clientCfg);
        }
    } ipc_CATCH_IVD_THROW_CORBA_m;
} // i_PartitionManager_i::RefreshCfg()

Here is the call graph for this function:

void i_PartitionManager_i::RegisterFSID ( const char *  a_majorMinor  ) 

Definition at line 1168 of file i_pm_impl.cpp.

References cfg_PMCfg::clients, dbg_LOW, ivd_BaseException::GetError(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, m_config, m_iPM, ipc_Corba::RegisterPMByFSID(), and UnRegisterFSID().

                                                                {
    log_FUNC_m(RegisterFSID);

    try {
        try {
            log_DBG_m(dbg_LOW, "Registering PM to NamingService using FSID.");

            ipc_Corba::RegisterPMByFSID(
                m_iPM,
                m_config.clients[0].name, // Note: only one client is supported
                a_majorMinor);
        }
        catch (ivd_Error &e) {
            if (e.GetError() == ie_IPC_OBJ_ACTIVE) {
                UnRegisterFSID(a_majorMinor);
                RegisterFSID(a_majorMinor);
            }
            else {
                throw;
            }
        }
    }
    ipc_CATCH_IVD_THROW_CORBA_m
}

Here is the call graph for this function:

i_ClientConf_t * i_PartitionManager_i::RegisterHSM ( i_HSM_ptr  a_iHsm,
CORBA::Char  a_pathSeparator 
)

Definition at line 1013 of file i_pm_impl.cpp.

References dbg_DETAIL, dbg_LOW, dbg_NORM, evt_ERROR, evt_WARNING, FillClientCfg(), i_Component_i::GetVersion(), ie_ARGUMENT_MISSING, ie_CONNECTIVITY, ie_IPC_OBJ_ACTIVE, ie_REGISTER_NOT_ALLOWED, ivd_Error, log_DBG_m, log_FUNC_m, log_WriteEvent(), log_WRN_m, m_clientPathSeparator, m_iHSM, m_partName, m_recoveryNeeded, m_startup_x, and RecoveryMode().

                                                                                             {
    log_FUNC_m(RegisterHSM);

    // wait for PM to finish starting bug 4212
    cmn_MutexLock l(m_startup_x);

    try {
        /*Re-coding because of bug 5392 "two HSM processes access HSMDB at same time"
         * 1. check if HSM argument is passed properly
         * 2. check if old HSM still running
         * 3. check if new HSM is accessible
         * 4. check if new HSM has proper version
         * 5. check if PM is in recovery mode
         * 6. register HSM
         */

/***** check if HSM argument is not null ********/
        if (CORBA::is_nil(a_ihsm)) {
            throw ivd_Error(ie_ARGUMENT_MISSING, "i_HSM_ptr a_ihsm is not set.");
        }

/***** check if old HSM still running ********/
        bool hsmRunning(false);
        //
        // Check if previously registered HSM is still
        // active. Prevent registration in that case.
        // Mount will fail until previously registered HSM
        // successfully writes data to HSMDB. HSMDB Data corruption
        // may occur otherwise.
        //
        if (!CORBA::is_nil(m_iHSM)) { // some HSM is stil registered
            try {
                if (!m_iHSM->_non_existent()) { // check if is available
                    log_WRN_m(
                        "Partition: " << m_partName << " : " <<
                        "HSM still active on mount attempt. Aborting registration.");
                    hsmRunning = true;
                }
                else {
                    log_WRN_m(
                        "Partition: " << m_partName << " : " <<
                        "HSM still active on mount attempt. Check if it is accesible.");
                }
            }
            catch (...) { //
                log_DBG_m(dbg_NORM,
                    "HSM on saved reference is non existent. That's OK.");
            };
        }

        if (hsmRunning) {
            // Prevent next HSM from starting
            throw ivd_Error(ie_IPC_OBJ_ACTIVE, "HSM still active.");
        }

/***** check if new HSM is accesible ********/
        log_DBG_m(dbg_DETAIL,"Client " << a_ihsm  << " contacted PM."
                << " Its path separator is '" << m_clientPathSeparator << "'.");

        bool hsmAccessible(false);
        try {
            if (!a_ihsm->_non_existent()) {
                hsmAccessible = true;
            }
        }
        catch(...) {
        }

        if (hsmAccessible) {
            log_DBG_m(dbg_NORM, "HSM is accesible.");
        }
        else {
            log_DBG_m(dbg_NORM, "HSM is not accesible.");
            ostringstream sstr;
            sstr
                << "Can't contact HSM that has contacted PM. "
                << "Please verify network connectivity.";
            log_WriteEvent(evt_ERROR, sstr.str(), m_partName);

            throw ivd_Error(ie_CONNECTIVITY, sstr.str());
        }

/***** check if new HSM and PM are same version ********/
        bool hsmSupportsVer(true);
        i_Version_var hsmVer;
        try {
             hsmVer = a_ihsm->GetVersion();
             log_DBG_m(dbg_LOW,
                "HSM OS/version: "
                << hsmVer->osType << ", "
                << hsmVer->major << "."
                << hsmVer->minor << "."
                << hsmVer->smr << "-"
                << hsmVer->build << " "
                << hsmVer->label);
        }
        catch(CORBA::MARSHAL) {
            // Implementation differs from IDL definition which is used
            // by the caller (PM): HSM has old interface.
            log_DBG_m(dbg_LOW, "Client returned CORBA::MARSHAL");
            hsmSupportsVer = false;
        }
        catch(CORBA::NO_IMPLEMENT) {
            // Servant doesn't have this interface implemeneted.
            log_DBG_m(dbg_LOW, "Client returned CORBA::NO_IMPLEMENT");
            hsmSupportsVer = false;
        }
        // other exceptions cause the registration to fail.

        i_Version_var pmVer = GetVersion();

        if (   !hsmSupportsVer
            || hsmVer->major != pmVer->major
            || hsmVer->minor != pmVer->minor) {

            throw ivd_Error(ie_REGISTER_NOT_ALLOWED,
                "Client and server have incompatible versions.");
        }

        if (hsmVer->smr != pmVer->smr) {
            log_WriteEvent(evt_WARNING,
            "Client and server have different service maintenance release version.",
            m_partName);
        }

/***** Check if PM is in recovery mode ********/
        // TODO: client path separator can be determined from i_Version (osType)
        m_clientPathSeparator = a_pathSeparator;
        if (RecoveryMode() ) {
            throw ivd_Error(
            ie_REGISTER_NOT_ALLOWED,
            "HSM wants to register. Can not serve HSM when in Recovery Mode");
        };

        if (m_recoveryNeeded) {
            throw ivd_Error(
                ie_REGISTER_NOT_ALLOWED,
                "HSM wants to register. Recovery is needed");
        };

/***** Now it is time to register HSM ********/
        m_iHSM = i_HSM::_duplicate(a_ihsm);

        log_DBG_m(dbg_DETAIL,"i_HSM_var m_iHSM: " << m_iHSM);

        i_ClientConf_t_var clientCfg = FillClientCfg();
        return clientCfg._retn();
    } ipc_CATCH_IVD_THROW_CORBA_m;
} // i_PartitionManager_i::RegisterHSM()

Here is the call graph for this function:

void i_PartitionManager_i::ReleaseVolEntries ( CORBA::ULong  a_mediumKey,
CORBA::ULong  a_volumeNr 
)

Definition at line 1217 of file i_pm_impl.cpp.

References ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_A_m, m_iFSCi, and i_FSC_i::ReleaseVolEntries().

                                                                       {

    log_FUNC_A_m(ReleaseVolEntries, "a_mediumKey: " << a_mediumKey <<
                                    ", a_volumeNr:" << a_volumeNr);
    try {
        m_iFSCi->ReleaseVolEntries(a_mediumKey, a_volumeNr);
    } ipc_CATCH_IVD_THROW_CORBA_m
}

Here is the call graph for this function:

void i_PartitionManager_i::Remove (  )  [virtual]

Reimplemented from i_Component_i.

Definition at line 1207 of file i_pm_impl.cpp.

References ipc_CATCH_IVD_THROW_CORBA_m, ipc_EXEC_m, log_FUNC_m, m_iFSCi, and i_Component_i::Remove().

Here is the call graph for this function:

i_JobID_t i_PartitionManager_i::Reorg ( const char *  a_barcode,
const i_VolNumList_t a_volumes,
i_UIMessageServer_ptr  a_uims 
)

Definition at line 705 of file i_pm_impl.cpp.

References pm_JobMgr::CreateReorgJob(), GetCheckAutoCorrectRunning(), ie_PRECONDITION, ipc_CATCH_IVD_THROW_CORBA_m, ivd_Error, log_FUNC_m, m_jobMgr, and RecoveryMode().

                                                                        {
    log_FUNC_m(Reorg);
    try {
        if (RecoveryMode()){
            throw ivd_Error(ie_PRECONDITION,
                "Recovery of FSC in progress. Reorganization is not allowed.");
        }
        if (GetCheckAutoCorrectRunning()){
            throw ivd_Error(ie_PRECONDITION,
                "FSC vs. Media check in progress. Reorganization is not allowed.");
        }

        string barcode(a_barcode);
        vector<UInt32_t> volumes;
        for (UInt32_t i(0); i < a_volumes.length(); i++){
            volumes.push_back(a_volumes[i]);
        }

        return m_jobMgr.CreateReorgJob(barcode,
                                volumes,
                                a_uims);
    } ipc_CATCH_IVD_THROW_CORBA_m
}

Here is the call graph for this function:

i_JobIDList_t * i_PartitionManager_i::ReorgByColId ( CORBA::LongLong  a_majColId,
CORBA::LongLong  a_minColId 
)

Definition at line 731 of file i_pm_impl.cpp.

References cfg_PMCfg::clients, pm_JobMgr::CreateReorgJob(), dbg_DETAIL, dbg_NORM, GetCheckAutoCorrectRunning(), GetReplicationPM(), ie_PRECONDITION, ipc_CATCH_IVD_THROW_CORBA_m, ipc_EXEC_m, ivd_Error, log_DBG_m, log_FUNC_m, log_WriteErrorEvent, m_config, m_iRM, m_jobMgr, RecoveryMode(), REPL_JOB_ID_PREFIX, and ReplicationNeeded().

                                  {
    log_FUNC_m(ReorgByColId);
    try {
        if (RecoveryMode()){
            throw ivd_Error(ie_PRECONDITION,
                "Recovery of FSC in progress. Reorganization is not allowed.");
        }
        if (GetCheckAutoCorrectRunning()){
            throw ivd_Error(ie_PRECONDITION,
                "FSC vs. Media check in progress. Reorganization is not allowed.");
        }

        i_PartitionManager_var replPM;
        bool doReplication(false);
        ipc_EXEC_m(
            doReplication = ReplicationNeeded();
            if (doReplication) {
                log_DBG_m(dbg_NORM, "Getting PM reference...");
                replPM = GetReplicationPM();
                log_DBG_m(dbg_NORM, "Got PM reference.");
            }
        );

        vector<i_JobID_t> jobList;
        i_ColMediaVolSeq_t_var cmv = m_iRM->SelectAllColVolumes();
        UInt32_t i(0);
        for (i = 0; i < cmv->length(); i++) {
            log_DBG_m(dbg_DETAIL, "medKey: " << cmv[i].mediaKey <<
                                    " medVolNr: " << cmv[i].medVolNr);
            if (cmv[i].minColId == UInt64_t(a_minColId)) {
                log_DBG_m(dbg_DETAIL, "Starting reorg for MediaKey: " << cmv[i].mediaKey <<
                                                        " vol: " << cmv[i].medVolNr);
                i_Medium_t_var med = m_iRM->SelectMediumByKey(cmv[i].mediaKey);
                string barcode(med->barcode);
                vector<UInt32_t> volumes;
                volumes.push_back(cmv[i].medVolNr);
                i_JobID_t jobID = m_jobMgr.CreateReorgJob(barcode, volumes, i_UIMessageServer::_nil());
                jobList.push_back(jobID);
            }
        }
        UInt32_t jobListSize(jobList.size());

        i_JobIDList_t_var replJobs;
        if (doReplication) {
            log_DBG_m(dbg_NORM, "Invoking reorg on replication server "
            << m_config.clients[0].replTargHost << ", partition "
            << m_config.clients[0].replTargPart);
            if (!CORBA::is_nil(replPM)) {
                try {
                    ipc_EXEC_m(
                        replJobs = replPM->ReorgByColId(a_majColId, a_minColId);
                    );
                    log_DBG_m(dbg_NORM, "Replication jobs: " << replJobs->length());
                    jobListSize += replJobs->length();
                }
                catch (...) {
                    log_DBG_m(dbg_NORM, "Reorg on replication server failed.");
                    throw;
                }
            }
            else {
                log_WriteErrorEvent( "Replication PM is in not available.");
                doReplication = false; // to prevent adding jobs to list
            }
        }

        i_JobIDList_t_var jobIDs(new i_JobIDList_t());
        jobIDs->length(jobListSize);

        log_DBG_m(dbg_NORM, "Started jobs: " << jobList.size());
        for (i = 0; i < jobList.size(); i++) {
            jobIDs[i] = jobList[i];
            log_DBG_m(dbg_NORM, " * " << jobList[i]);
        }

        for (i = 0; i < jobList.size(); i++) {
            jobIDs[i] = jobList[i];
            log_DBG_m(dbg_NORM, "Started jobs:" << jobList[i]);
        }

        if (doReplication) {
            for (i = 0; i < replJobs->length(); i++) {
                log_DBG_m(dbg_NORM, " * " << (replJobs[i] + REPL_JOB_ID_PREFIX));
                jobIDs[(jobList.size() + i)] = (replJobs[i] + REPL_JOB_ID_PREFIX);
            }
        }

        return jobIDs._retn();
    } ipc_CATCH_IVD_THROW_CORBA_m
}

Here is the call graph for this function:

i_JobID_t i_PartitionManager_i::ReorgScan ( i_Time_t  a_date,
CORBA::Long  a_numOfGenerations,
i_UIMessageServer_ptr  a_uims 
)

Definition at line 684 of file i_pm_impl.cpp.

References pm_JobMgr::CreateReorgScanJob(), GetCheckAutoCorrectRunning(), ie_PRECONDITION, ipc_CATCH_IVD_THROW_CORBA_m, ivd_Error, log_FUNC_m, m_jobMgr, and RecoveryMode().

                                                                {
    log_FUNC_m(ReorgScan);
    try {
        if (RecoveryMode()){
            throw ivd_Error(ie_PRECONDITION,
                "Recovery of FSC in progress. Reorganization scan is not allowed.");
        }
        if (GetCheckAutoCorrectRunning()){
            throw ivd_Error(ie_PRECONDITION,
                "FSC vs. Media check in progress. Reorganization scan is not allowed.");
        }
        return m_jobMgr.CreateReorgScanJob( a_date,
                                            a_numOfGenerations,
                                            a_uims);
    } ipc_CATCH_IVD_THROW_CORBA_m
}

Here is the call graph for this function:

CORBA::Boolean i_PartitionManager_i::ReplicationNeeded (  ) 

Definition at line 1603 of file i_pm_impl.cpp.

References cfg_PMCfg::clients, log_FUNC_m, and m_config.

Referenced by AddMajorCol(), GetJobStatus(), ReorgByColId(), and UpdateMajorCol().

                                                     {
    log_FUNC_m(ReplicationNeeded);
    return (!m_config.clients[0].replTargHost.empty())
        && (!m_config.clients[0].replTargPart.empty());
}

Here is the caller graph for this function:

void i_PartitionManager_i::SetCheckAutoCorrectRunning (  ) 

Definition at line 1750 of file i_pm_impl.cpp.

References m_checkAutoCorrectRunning, and m_checkAutoCorrectRunning_x.

Referenced by i_MediumCheckJob_i::i_MediumCheckJob_i().

Here is the caller graph for this function:

void i_PartitionManager_i::SetCheckRunning (  ) 

Definition at line 1768 of file i_pm_impl.cpp.

References m_checkRunning, and m_checkRunning_x.

Referenced by i_MediumCheckJob_i::i_MediumCheckJob_i().

Here is the caller graph for this function:

void i_PartitionManager_i::SetReorgScan (  ) 

Definition at line 1232 of file i_pm_impl.cpp.

References ie_PRECONDITION, ipc_EXEC_m, ivd_Error, log_FUNC_m, m_iRM, m_partName, m_reorgJobCounter, m_reorgScan_x, m_reorgScanRunning, and rmdb_PARTITION_REORG_SCAN_INPROG.

Referenced by i_ReorgScanJob_i::i_ReorgScanJob_i().

                                        {
    log_FUNC_m(SetReorgScan);

    cmn_MutexLock l(m_reorgScan_x);
    if (m_reorgScanRunning){
        throw ivd_Error(ie_PRECONDITION,
            "Reorganization scan is already running.");
    }
    if (m_reorgJobCounter > 0){
        throw ivd_Error(ie_PRECONDITION,
            "Reorganization job(s) in progress. Reorganization scan not allowed.");
    }

    // set status flag in RM
    ipc_EXEC_m(
        m_iRM->SetPartitionStatus(rmdb_PARTITION_REORG_SCAN_INPROG, m_partName.c_str());
    );
    m_reorgScanRunning = true;
}

Here is the caller graph for this function:

void i_PartitionManager_i::StartReorgJob (  ) 

Definition at line 1278 of file i_pm_impl.cpp.

References GetReorgScan(), ie_PRECONDITION, ipc_EXEC_m, ivd_Error, log_FUNC_m, m_iRM, m_partName, m_reorgJobCounter, and rmdb_PARTITION_REORG_SCAN_INPROG.

Referenced by i_ReorgJob_i::i_ReorgJob_i().

                                         {
    log_FUNC_m(StartReorgJob);

    // Check status flag in RM
    i_Partition_t_var part;
    ipc_EXEC_m(
        part = m_iRM->SelectPartition(m_partName.c_str());
    );
    if (GetReorgScan()){
        throw ivd_Error(ie_PRECONDITION,
            "Reorganization scan is running.");
    } else if (part->status & rmdb_PARTITION_REORG_SCAN_INPROG){
        throw ivd_Error(ie_PRECONDITION,
            "Reorganization can't be started because there are no valid reorg scan results.");
    }

    m_reorgJobCounter++;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void i_PartitionManager_i::StopReorgJob (  ) 

Definition at line 1298 of file i_pm_impl.cpp.

References GetReorgScan(), ie_FATAL_ERROR, m_reorgJobCounter, and m_reorgScan_x.

Referenced by i_ReorgJob_i::i_ReorgJob_i(), and i_ReorgJob_i::~i_ReorgJob_i().

                                        {

    if (GetReorgScan()){
        throw ivd_InternalError(ie_FATAL_ERROR,
            "Reorganization scan & job running in parallel!");
    }

    cmn_MutexLock l(m_reorgScan_x);
    if (m_reorgJobCounter == 0){
        throw ivd_InternalError(ie_FATAL_ERROR ,
                                "Counter for reorg jobs already 0.");
    }

    m_reorgJobCounter--;
}

Here is the call graph for this function:

Here is the caller graph for this function:

i_JobID_t i_PartitionManager_i::TrigDeletion ( i_UIMessageServer_ptr  a_uims  ) 

Definition at line 825 of file i_pm_impl.cpp.

References pm_JobMgr::CreateDelExpiredFilesJob(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_jobMgr.

Here is the call graph for this function:

void i_PartitionManager_i::UnRegisterFSID ( const char *  a_majorMinor  ) 

Definition at line 1193 of file i_pm_impl.cpp.

References cfg_PMCfg::clients, dbg_LOW, ipc_CATCH_IVD_THROW_CORBA_m, ipc_EXEC_m, log_DBG_m, log_FUNC_m, m_config, and ipc_Corba::RegisterPMByFSID().

Referenced by RegisterFSID().

                                                                  {
    log_FUNC_m(UnRegisterFSID);
    try {
        ipc_EXEC_m(
            log_DBG_m(dbg_LOW, "Unregistering PM from NamingService using FSID.");

            ipc_Corba::RegisterPMByFSID(
                i_PartitionManager::_nil(),
                m_config.clients[0].name, // Note: only one client is supported
                a_majorMinor);
        );
    } ipc_CATCH_IVD_THROW_CORBA_m
}

Here is the call graph for this function:

Here is the caller graph for this function:

void i_PartitionManager_i::UnRegisterHSM (  ) 

Definition at line 1163 of file i_pm_impl.cpp.

References log_FUNC_m, and m_iHSM.

                                         {
    log_FUNC_m(UnRegisterHSM);
    m_iHSM = i_HSM::_nil();
}

void i_PartitionManager_i::UpdateMajorCol ( const i_MajorCol_t a_majorCol  ) 

Definition at line 1841 of file i_pm_impl.cpp.

References cfg_PMCfg::clients, dbg_NORM, i_MajorCol_t::flags, GetReplicationPM(), ipc_EXEC_m, log_DBG_m, log_FUNC_A_m, log_WriteErrorEvent, m_config, m_iRM, i_MajorCol_t::majColId, i_MajorCol_t::majColSize, i_MajorCol_t::partUUID, and ReplicationNeeded().

                                                                        {
    log_FUNC_A_m(UpdateMajorCol, "majColId: " << a_majorCol.majColId
                           << " size: " << a_majorCol.majColSize
                           << " partUUID: " << a_majorCol.partUUID
                           << " flags: " << a_majorCol.flags);

    i_PartitionManager_var replPM;
    bool doReplication(false);
    ipc_EXEC_m(
        doReplication = ReplicationNeeded();
        if (doReplication) {
            log_DBG_m(dbg_NORM, "Getting PM reference...");
            replPM = GetReplicationPM();
            log_DBG_m(dbg_NORM, "Got PM reference.");
        }
    );

    m_iRM->UpdateMajorCol(a_majorCol);

    if (doReplication) {
        log_DBG_m(dbg_NORM, "Updating major col on replication server "
        << m_config.clients[0].replTargHost << ", partition "
        << m_config.clients[0].replTargPart);
        if (!CORBA::is_nil(replPM)) {
            try {
                ipc_EXEC_m(
                    i_MajorCol_t tgtMajorCol(a_majorCol);
                    i_ResourceManager_var replRM = replPM->GetRM();
                    i_Partition_t_var partition = replRM->SelectPartition(m_config.clients[0].replTargPart.c_str());
                    tgtMajorCol.partUUID = CORBA::string_dup(partition->partitionUUIDString);
                    replPM->UpdateMajorCol(tgtMajorCol);
                );
            }
            catch (...) {
                log_DBG_m(dbg_NORM, "Updating major col on replication server failed.");
                throw;
            }
        }
        else {
            log_WriteErrorEvent( "Replication PM is in not available.");
        }
    }
}

Here is the call graph for this function:

void i_PartitionManager_i::WriteCollocationInfo ( const i_ColInfo_t a_info  ) 
void i_PartitionManager_i::WriteHl7Info ( const i_HL7Info_t a_info  ) 

Friends And Related Function Documentation

friend class pm_JobMgr [friend]

Definition at line 73 of file i_pm_impl.h.


Member Data Documentation

Reimplemented from i_Component_i.

Definition at line 263 of file i_pm_impl.h.

Definition at line 296 of file i_pm_impl.h.

Referenced by ClearCheckRunning(), GetCheckRunning(), and SetCheckRunning().

Definition at line 295 of file i_pm_impl.h.

Referenced by ClearCheckRunning(), GetCheckRunning(), and SetCheckRunning().

Definition at line 302 of file i_pm_impl.h.

Referenced by RegisterHSM().

Definition at line 233 of file i_pm_impl.h.

Referenced by i_PartitionManager_i().

Definition at line 300 of file i_pm_impl.h.

Referenced by BuildExpirationTree(), GetExpirationAge(), and GetExpirationTree().

Definition at line 273 of file i_pm_impl.h.

Referenced by GetFSC(), and i_PartitionManager_i().

Definition at line 279 of file i_pm_impl.h.

Referenced by i_PartitionManager_i(), and ~i_PartitionManager_i().

i_PartitionManager_var i_PartitionManager_i::m_iPM

Definition at line 272 of file i_pm_impl.h.

Referenced by i_PartitionManager_i(), and RegisterFSID().

i_ResourceManager_var i_PartitionManager_i::m_iRM

Definition at line 299 of file i_pm_impl.h.

Referenced by RecoveryOfIVDFSClear(), and RecoveryOfIVDFSSet().

Definition at line 218 of file i_pm_impl.h.

Referenced by SetReorgScan(), StartReorgJob(), and StopReorgJob().

Definition at line 283 of file i_pm_impl.h.

Referenced by i_PartitionManager_i(), and RegisterHSM().


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