i_ResourceManager_i Class Reference
[Resource Manager]

#include <i_rm_impl.h>

Inheritance diagram for i_ResourceManager_i:

[legend]

Collaboration diagram for i_ResourceManager_i:

[legend]

List of all members.

Detailed Description

Definition at line 26 of file i_rm_impl.h.


Public Member Functions
	i_ResourceManager_i ()
virtual	~i_ResourceManager_i ()
void	GetResources (i_Job_ptr a_job, const i_JobParams &a_jobParams, const i_ResourceList_t &a_resources)
void	ExchangeResources (i_Job_ptr a_job, const i_JobParams &a_jobParams, const i_ResourceList_t &a_resources)
i_Index_t	GetBestCopy (const i_CopiesPos_v_t &a_mediaTable)
i_DriveHost_t *	GetHost (i_DBKey_t a_driveKey)
i_MigID_t	GetNewMigId (const char *a_partName)
i_MediaInfoSeq_t *	GetMediaInfo (const char *a_partName)
void	GetRecallResources (i_Job_ptr a_job, const i_JobParams &a_jobParams, const i_Resource_t &a_resources)
void	ExchangeRecallResources (i_Job_ptr a_job, const i_JobParams &a_jobParams, const i_Resource_t &a_relResources, const i_Resource_t &a_getResources)
void	ReleaseResource (const i_JobParams &a_jobParams, const i_ResourceList_t &a_resources)
void	CancelGetResource (i_JobID_t a_jobId)
void	UseNewResource ()
i_FileSize_t	GetMaxDiskBufferSize (const char *a_partName)
char *	ReserveDiskBuffer (i_JobID_t a_jobID, i_FileSize_t a_minJobSize, i_FileSize_t a_maxJobSize, i_FileSize_t &a_allocatedJobSize, i_JobType_t a_jobType)
void	ReleaseDiskBuffer (i_JobID_t a_jobID)
void	MediumLoaded (const char a_libName, const char a_medBarcode, const char *a_driveAddr)
void	MediumUnLoaded (const char a_libName, const char a_medBarcode, const char *a_slotAddr, i_Type_t a_slotType)
void	VolumeFull (const char *a_medVolId)
void	VolumeEmpty (const char *a_medVolId)
void	VolumeUsage (const char *a_medVolId, CORBA::Long a_percentage, i_VolSize_t a_totalData)
void	VolumeError (const char *a_medVolId)
void	MediumUnreliable (i_DBKey_t a_mediaKey)
void	MediumUnusable (i_DBKey_t a_mediaKey)
void	MediumStatusSet (const char *a_barcode, i_Status_t a_status)
void	MediumStatusClear (const char *a_barcode, i_Status_t a_status)
void	DriveStatusSet (const char *a_drvName, i_Status_t a_status)
void	DriveStatusClear (const char *a_drvName, i_Status_t a_status)
void	DriveError (i_DBKey_t a_driveKey)
void	MedVolStatusSet (const char *a_medVoId, i_Status_t a_status)
void	MedVolStatusClear (const char *a_medVoId, i_Status_t a_status)
void	VolumeListStatusSet (CORBA::ULong a_medKey, const i_ULongList_t &a_volumes, CORBA::ULong a_status)
void	EmergencyInventory (i_Time_t a_resAssignTime)
void	InventoryUpdate (const char *a_libName, const i_UpdateList_t &a_elemStatus)
void	LibraryStatusSet (const char *a_libName, i_Status_t a_status)
void	LibraryStatusClear (const char *a_libName, i_Status_t a_status)
char *	AddPartition (const i_Partition_t &a_part)
void	RemovePartition (const char *a_partName)
void	UpdatePartition (const char *a_partName)
i_Partition_t *	SelectPartition (const char *a_partName)
i_Partition_t *	SelectPartitionByUUID (const char *a_partUuid)
void	DisablePartition (const char *a_partName)
void	EnablePartition (const char *a_partName)
i_PartSeq_t *	SelectAllPartition ()
char *	RegisterPartition (const char *a_partName)
void	UnRegisterPartition (const char *a_partName)
void	SetPartitionStatus (i_BitFlag_t a_flag, const char *a_partName)
void	ClearPartitionStatus (i_BitFlag_t a_flag, const char *a_partName)
i_JobID_t	GetNewJobID ()
void	AddColMediaVol (const i_ColMediaVol_t &a_colMediaVol, CORBA::ULong a_flags)
void	AddMajorCol (const i_MajorCol_t &a_majorCol)
void	AddLibrary (i_Library_t &a_library)
void	AddDrive (i_Drive_t &a_drive)
void	AddDriveHost (i_DriveHost_t &a_driveHost)
void	AddDiskSubsys (i_DiskSubsys_t &a_dss)
void	AddSlot (i_Slot_t &a_slot)
void	AddMediaPool (i_MediaPool_t &a_mediaPool)
void	AddMedium (i_Medium_t &a_medium)
void	AddMediumVol (i_MediumVol_t &a_mediumVol)
void	RemoveLibrary (const char *a_libraryName)
void	RemoveDrive (const char *a_driveName)
void	RemoveDriveHost (const char a_driveName, const char a_host)
void	RemoveDSS (const char *a_dssName)
void	RemoveSlot (const char a_slotAddr, const char a_libraryName, i_Type_t a_slotType)
void	RemoveMediaPool (const char *a_mediaPoolName)
void	RemoveMedium (const char *a_mediumBarcode)
void	RemoveMediumVol (const char *a_mediumBarcode, i_Index_t a_mediaVolNr)
void	RemoveColIDs (const char *a_partUUID)
void	UpdateLibrary (const i_Library_t &a_library)
void	UpdateDrive (const i_Drive_t &a_drive)
void	UpdateDriveHost (const i_DriveHost_t &a_driveHost)
void	UpdateDiskSubsys (const i_DiskSubsys_t &a_dss)
void	UpdateSlot (const i_Slot_t &a_slot)
void	UpdateMediaPool (const i_MediaPool_t &a_mediaPool)
void	UpdateMedium (const i_Medium_t &a_medium)
void	UpdateMediumVol (const i_MediumVol_t &a_mediumVol)
void	UpdateMajorCol (const i_MajorCol_t &a_majorCol)
void	UpdateDataSize (i_DBKey_t a_mediumKey, i_DBKey_t a_medvolNum, i_VolSize_t a_totalSize, i_VolSize_t a_reorgSize)
i_Library_t *	SelectLibrary (const char *a_libraryName)
i_LibrarySeq_t *	SelectAllLibraries ()
i_Drive_t *	SelectDrive (const char *a_driveName)
i_Drive_t *	SelectDriveByKey (i_DBKey_t a_driveKey)
i_DriveSeq_t *	SelectAllDrives ()
i_DriveHost_t *	SelectDriveHost (const char a_driveName, const char a_host)
i_DriveHostSeq_t *	SelectAllDriveHosts ()
i_DiskSubsys_t *	SelectDSS (const char *a_dssName)
i_DssSeq_t *	SelectAllDSS ()
i_Slot_t *	SelectSlot (const char a_slotAddr, const char a_libraryName, i_Type_t a_slotType)
i_SlotSeq_t *	SelectAllSlots ()
i_MajorColSeq_t *	SelectAllMajorCol ()
i_MinorColSeq_t *	SelectAllMinorColByMajCol (i_ColID_t a_majColId)
i_MediaPool_t *	SelectMediaPool (const char *a_mediaPoolName)
i_MediaPool_t *	SelectMediaPoolbyUUID (const char *a_mediaPoolUUID)
i_MediaPoolSeq_t *	SelectAllMediaPools ()
i_Medium_t *	SelectMedium (const char *a_mediumBarcode)
i_Medium_t *	SelectMediumByKey (i_DBKey_t a_mediumKey)
i_Medium_t *	SelectMediumByDrive (const char *a_driveName)
i_MediumSeq_t *	SelectAllMedia ()
i_MediumVol_t *	SelectMediumVol (const char *a_mediumBarcode, i_Index_t a_mediumVolNr)
i_MediumVol_t *	SelectMediumVolByKey (i_DBKey_t a_mediumKey, i_Index_t a_mediumVolNr)
i_MediumVol_t *	SelectMediumVolByUUID (const char *a_medVolUUID)
i_MediumVolSeq_t *	SelectAllMediumVol ()
i_ColMediaVolSeq_t *	SelectAllColVolumes ()
i_MinorColSeq_t *	SelectAllMinorCol ()
i_MediumVolSeq_t *	SelectAllMediumVolByBarcode (const char *a_mediumBarcode)
i_MediumSeqByVol_t *	SelectAllMediumVolByPart (const char *a_partName)
i_MediumSeq_t *	SelectAllMediaByPart (const char *a_partName)
CORBA::Boolean	IsSomeVolumeUsed (const char *a_partName)
i_MediumSeqByVol_t *	SelectAllUnrecoveredMedVol (const char *a_partName)
i_MinorCol_t	SelectMinorCol (i_ColID_t a_minColId)
void	AddMinorCol (const i_MinorCol_t &a_minorCol)
void	SetRecoveryFlag (const char *a_medVolId)
void	ClearRecoveryFlag (const char *a_medVolId)
i_JobParamsSeq_t *	GetAllJobs ()
i_JobParamsSeq_t *	GetJob (i_JobID_t a_jobID)
i_ResourceList_t *	GetJobResources (i_JobID_t a_jobID)
void	StartLA (const char *a_libName)
void	StopLA (const char *a_libName)
void	ReconfigureLibrary (const char *a_libName)
void	SetPriorityModifier (i_JobID_t a_jobID, CORBA::Long a_modifier)
void	SetPhase (i_JobID_t a_jobID, i_Index_t a_phase)
i_PoolInfoSeq_t *	PoolInfo (const char *a_partName)
void	SetReorgScan (const char *a_partName)
void	ClearReorgScan (const char *a_partName)
i_Status_t	Suspend ()
	i_ResourceManager_i::Suspend() : Implements suspend database operation interface.
i_Status_t	Resume ()
	i_ResourceManager_i::Resume() : Implements resume database operation interface.
void	Remove ()
void	ReleaseRecallResources (const i_Resource_t &a_resources)
void	StartAllLA ()
void	StopAllLA ()
void	ExecStartLA (string a_libName, string a_host, ivd_LibraryType_e a_lType)
void	ExecStopLA (string a_libName, string a_host)
void	ParsePMConfig (cfg_PMCfg &a_cfgFile, const char *a_partName)
void	SetRMPartStatus (cfg_PMCfg &a_pmCfg)
Public Attributes
rm_Queue	m_queue
rm_JobIdGen	m_jobIdGen
rm_DBThread *	m_DBThread
bool	m_started
cmn_Mutex	m_diskBuf_x
rm_DiskBufAllocator	m_diskBufAllocator
	log_CLASSID_m

Constructor & Destructor Documentation

i_ResourceManager_i::i_ResourceManager_i ( )

Definition at line 42 of file i_rm_impl.cpp.

References CFG_LINK_LATEST, ivd_Directories::cfgSys, cmn_CleanDir(), dbg_LOW, cmn_Global::dirs, rm_DiskBufAllocator::DumpState(), rm_DBOperation::Execute(), g_cmn, rm_SysState::Init(), rm_Queue::Init(), ipc_EXEC_m, iRM, log_DBG_m, log_ERR_m, log_FUNC_m, m_DBThread, m_diskBufAllocator, m_jobIdGen, m_queue, m_started, rm_Queue::m_SysState, pf_File::Parse(), cfg_Server::phaseFactor, ipc_Corba::RegisterRM(), cfg_Server::resourceAllocationThreshold, cmn_Thread::Start(), StartAllLA(), cfg_Server::systemAdminPriority, cfg_Server::systemBackupPriority, cfg_Server::systemMaxNumDrivesAdmin, cfg_Server::systemMaxNumDrivesMaint, cfg_Server::systemMaxNumDrivesMigration, cfg_Server::systemMaxNumDrivesRecall, cfg_Server::systemMaxNumDrivesRecovery, cfg_Server::timeStep, and ivd_Directories::tmp.

00042                                          :
00043             m_started(true){
00044 
00045     log_FUNC_m(i_ResourceManager_i);
00046     // add extra constructor code here
00047     // init DB
00048     // m_database.Connect();
00049 
00050     pf_File serverCfg;
00051 
00052     try {
00053         cmn_Path cfgFile;
00054         cfgFile = g_cmn.dirs.cfgSys + string(CFG_LINK_LATEST);
00055         serverCfg.Parse(cfgFile);
00056 
00057         m_DBThread = new rm_DBThread;
00058         m_DBThread->Start();
00059     } catch (ivd_Exception &e) {
00060         log_ERR_m(e);
00061         m_started = false;
00062         return;
00063     }
00064 
00065     cfg_Server ivdServer(serverCfg);
00066     try {
00067         dbo_InitAllResource initAll(*m_DBThread);
00068         initAll.Execute();
00069     } catch (ivd_Exception& e) {
00070         // if (e.GetError() != 100) throw;
00071         // ignore all
00072         log_DBG_m(dbg_LOW, e);
00073 
00074     }
00075 
00076     StartAllLA();
00077 
00078     // init Queue
00079     m_queue.Init(
00080         this,
00081         ivdServer.resourceAllocationThreshold,
00082         ivdServer.timeStep,
00083         ivdServer.phaseFactor
00084         );
00085     log_DBG_m(dbg_LOW,  "ivdServer.resourceAllocationThreshold"
00086                         << ivdServer.resourceAllocationThreshold << endl
00087                         << "ivdServer.timeStep"
00088                         << ivdServer.timeStep << endl
00089                         << "ivdServer.phaseFactor"
00090                         << ivdServer.phaseFactor << endl);
00091 
00092 
00093     // init SysState
00094     m_queue.m_SysState.Init(
00095         ivdServer.systemMaxNumDrivesRecall,
00096         ivdServer.systemMaxNumDrivesMigration,
00097         ivdServer.systemMaxNumDrivesAdmin,
00098         ivdServer.systemMaxNumDrivesAdmin,
00099         ivdServer.systemMaxNumDrivesRecovery,
00100         ivdServer.systemMaxNumDrivesMaint,
00101         ivdServer.systemAdminPriority,
00102         ivdServer.systemBackupPriority );
00103 
00104     dbo_InitJobIdGen jobIdGen(m_jobIdGen, *m_DBThread);
00105     jobIdGen.Execute();
00106 
00107     ipc_EXEC_m(
00108         log_DBG_m(dbg_LOW, "Registering RM to NamingService.")
00109         i_ResourceManager_var iRM = this->_this();
00110 
00111         ipc_Corba::RegisterRM(iRM);
00112     );
00113 
00114 
00115     try {
00116         log_DBG_m(dbg_LOW, "Cleaning tmp/fri directory.");
00117         cmn_CleanDir(g_cmn.dirs.tmp + string("fri"));
00118     }
00119     catch (...) {
00120     }
00121     log_DBG_m(dbg_LOW, m_diskBufAllocator.DumpState());
00122 }

Here is the call graph for this function:

i_ResourceManager_i::~i_ResourceManager_i ( ) [virtual]

Definition at line 125 of file i_rm_impl.cpp.

References cmn_Condition::Broadcast(), dbg_DETAIL, log_DBG_m, log_FUNC_m, m_DBThread, rm_DBThread::m_reqInput_c, rm_DBThread::m_shutdown, NULL, and ipc_Corba::Shutdown().

00125                                           {
00126     log_FUNC_m(~i_ResourceManager_i);
00127 
00128     if (m_DBThread != NULL) {
00129         log_DBG_m(dbg_DETAIL, "Shutting down database thread.");
00130         m_DBThread->m_shutdown = true;
00131         m_DBThread->m_reqInput_c.Broadcast();
00132     };
00133 
00134     // wait for Database Thread to Finish
00135     // NO GOOOOOD while (m_DBThread->m_active) ivd_Sleep(1);
00136 
00137     ipc_Corba::Shutdown();
00138 }

Here is the call graph for this function:

Member Function Documentation

void i_ResourceManager_i::GetResources	(	i_Job_ptr	a_job,
		const i_JobParams &	a_jobParams,
		const i_ResourceList_t &	a_resources
	)

Definition at line 141 of file i_rm_impl.cpp.

References rm_Queue::Activate(), i_JobParams::bufId, rm_JobParams::bufId, i_JobParams::bufType, rm_JobParams::bufType, dbg_LOW, rm_SysState::GetAdminPriority(), rm_SysState::GetBackupPriority(), ie_INVALID_TBL_SIZE, rm_JobParams::iJob, rm_Queue::Insert(), ipc_CATCH_IVD_THROW_CORBA_m, ivd_Error, rm_JobParams::jobID, i_JobParams::jobID, i_JobParams::jobPriority, rm_JobParams::jobPriority, i_JobParams::jobType, rm_JobParams::jobType, jt_ADMIN, jt_BACKUP, log_DBG_m, log_FUNC_m, ipc_Log::LogJobParams(), ipc_Log::LogResources(), rm_JobParams::m_jobInformed, m_queue, rm_JobParams::m_resources, rm_Queue::m_SysState, i_JobParams::partName, rm_JobParams::partName, i_JobParams::partUUID, rm_JobParams::partUUID, i_JobParams::phase, rm_JobParams::phase, i_JobParams::priorityModifier, rm_JobParams::priorityModifier, i_JobParams::startTime, and rm_JobParams::startTime.

00143                                                                              {
00144     log_FUNC_m(GetResources);
00145 
00146     try {
00147         log_DBG_m(dbg_LOW,  "RM GetResources invoked for Job:" <<
00148                         a_jobParams.jobID << endl <<
00149                         ipc_Log::LogJobParams(a_jobParams) << endl <<
00150                         ipc_Log::LogResources(a_resources));
00151 
00152         rm_JobParams rmJobParams;
00153 
00154         rmJobParams.iJob            = i_Job::_duplicate(a_job);  // copy reference to Job
00155 
00156         rmJobParams.partName        = a_jobParams.partName;
00157         rmJobParams.partUUID        = a_jobParams.partUUID;
00158         rmJobParams.jobID           = a_jobParams.jobID;
00159         rmJobParams.jobPriority     = a_jobParams.jobPriority;
00160         rmJobParams.priorityModifier     = a_jobParams.priorityModifier;
00161         if (rmJobParams.jobType == jt_ADMIN) {
00162             rmJobParams.jobPriority = m_queue.m_SysState.GetAdminPriority();
00163         }
00164 
00165         if (rmJobParams.jobType == jt_BACKUP) {
00166             rmJobParams.jobPriority = m_queue.m_SysState.GetBackupPriority();
00167         }
00168 
00169         rmJobParams.jobType         = static_cast<ivd_JobType_e>(a_jobParams.jobType);
00170         rmJobParams.phase           = a_jobParams.phase;
00171         rmJobParams.startTime       = a_jobParams.startTime;
00172         rmJobParams.bufType         = a_jobParams.bufType;
00173         rmJobParams.bufId           = a_jobParams.bufId;
00174 
00175         // converstion from CORBA::sequence to vector
00176         if (a_resources.length() == 0) {
00177             throw ivd_Error(ie_INVALID_TBL_SIZE, "Resource table empty");
00178         }
00179 
00180         // copy resources from i_ResourceList to rm_ResourceTable
00181         for (UInt32_t i = 0; i < a_resources.length(); i++) {
00182             rm_Resource_t resource;
00183             resource = a_resources[i];
00184             rmJobParams.m_resources.push_back(resource);
00185         };
00186 
00187         rmJobParams.m_jobInformed = false;
00188 
00189         {
00190             m_queue.Insert(rmJobParams);
00191             m_queue.Activate();
00192         }
00193 
00194     } ipc_CATCH_IVD_THROW_CORBA_m;
00195 }

Here is the call graph for this function:

void i_ResourceManager_i::ExchangeResources	(	i_Job_ptr	a_job,
		const i_JobParams &	a_jobParams,
		const i_ResourceList_t &	a_resources
	)

Definition at line 198 of file i_rm_impl.cpp.

References rm_Resource_t::barcode, i_JobParams::bufId, rm_JobParams::bufId, i_JobParams::bufType, rm_JobParams::bufType, dbg_LOW, rm_Resource_t::driveCtrlDevice, rm_Resource_t::driveIndex, rm_Resource_t::driveKey, rm_SysState::GetAdminPriority(), rm_SysState::GetBackupPriority(), ie_INVALID_TBL_SIZE, rm_JobParams::iJob, rm_Queue::Insert(), ipc_CATCH_IVD_THROW_CORBA_m, ivd_Error, rm_JobParams::jobID, i_JobParams::jobID, i_JobParams::jobPriority, rm_JobParams::jobPriority, i_JobParams::jobType, rm_JobParams::jobType, jt_ADMIN, jt_BACKUP, rm_Resource_t::loadSlotAddr, log_DBG_m, log_FUNC_m, ipc_Log::LogJobParams(), ipc_Log::LogResources(), m_queue, rm_JobParams::m_resources, rm_Queue::m_SysState, rm_Resource_t::mediumKey, i_JobParams::partName, rm_JobParams::partName, i_JobParams::partUUID, rm_JobParams::partUUID, i_JobParams::phase, rm_JobParams::phase, i_JobParams::priorityModifier, rm_JobParams::priorityModifier, ReleaseResource(), i_JobParams::startTime, rm_JobParams::startTime, rm_Resource_t::unloadBarcode, and rm_Resource_t::unloadSlotAddr.

00200                                                                              {
00201     log_FUNC_m(ExchangeResources);
00202 
00203     try {
00204         log_DBG_m(dbg_LOW,  "RM ExchangeResources invoked for Job:" <<
00205                         a_jobParams.jobID << endl <<
00206                         ipc_Log::LogJobParams(a_jobParams) << endl <<
00207                         ipc_Log::LogResources(a_resources));
00208 
00209         rm_JobParams rmJobParams;
00210 
00211         rmJobParams.iJob            = i_Job::_duplicate(a_job);  // copy reference to Job
00212 
00213         rmJobParams.partName        = a_jobParams.partName;
00214         rmJobParams.partUUID        = a_jobParams.partUUID;
00215         rmJobParams.jobID           = a_jobParams.jobID;
00216         rmJobParams.jobPriority     = a_jobParams.jobPriority;
00217         rmJobParams.priorityModifier= a_jobParams.priorityModifier;
00218         if (rmJobParams.jobType == jt_ADMIN) {
00219             rmJobParams.jobPriority = m_queue.m_SysState.GetAdminPriority();
00220         }
00221 
00222         if (rmJobParams.jobType == jt_BACKUP) {
00223             rmJobParams.jobPriority = m_queue.m_SysState.GetBackupPriority();
00224         }
00225         rmJobParams.jobType         = static_cast<ivd_JobType_e>(a_jobParams.jobType);
00226         rmJobParams.phase           = a_jobParams.phase;
00227         rmJobParams.startTime       = a_jobParams.startTime;
00228         rmJobParams.bufType         = a_jobParams.bufType;
00229         rmJobParams.bufId           = a_jobParams.bufId;
00230 
00231         // converstion from CORBA::sequence to vector
00232         if (a_resources.length() == 0) {
00233             throw ivd_Error(ie_INVALID_TBL_SIZE, "Resource table empty");
00234         }
00235 
00236         // copy resources from i_ResourceList to rm_ResourceTable
00237         for (UInt32_t i = 0; i < a_resources.length(); i++) {
00238             rm_Resource_t resource;
00239             resource = a_resources[i];
00240             resource.driveKey = 0;
00241             resource.mediumKey = 0;
00242             resource.driveCtrlDevice = "";
00243             resource.driveIndex = "";
00244             resource.barcode = "";
00245             resource.loadSlotAddr = "";
00246             resource.unloadSlotAddr = "";
00247             resource.unloadBarcode = "";
00248             rmJobParams.m_resources.push_back(resource);
00249         };
00250 
00251         {
00252             m_queue.Insert(rmJobParams);
00253             ReleaseResource(a_jobParams, a_resources);
00254         }
00255 
00256     } ipc_CATCH_IVD_THROW_CORBA_m;
00257 }

Here is the call graph for this function:

i_Index_t i_ResourceManager_i::GetBestCopy ( const i_CopiesPos_v_t & a_mediaTable )

Definition at line 260 of file i_rm_impl.cpp.

References rm_MediumPos_t::blockOffset, dbg_DETAIL, dbg_NORM, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogCopiesPosition(), m_DBThread, rm_MediumPos_t::mediumKey, rm_CopyPos_t::mediumPos, rm_MediumPos_t::medVolNr, rm_CopyPos_t::rowNum, rm_MediumPos_t::splitOffset, and rm_MediumPos_t::splitSize.

00260                                                                              {
00261     log_FUNC_m(GetBestCopy);
00262     // convert from i_CopiesPos_v_t to rm_CopiesPos_v_t
00263 
00264     log_DBG_m(dbg_NORM, endl <<
00265             "GetBestCopy got CopiesPos " << endl <<
00266             ipc_Log::LogCopiesPosition(a_copiesPos) );
00267     try {
00268 
00269         log_DBG_m(dbg_DETAIL,"Copiing from i_CopiesPos_v_t to rm_CopiesPos_v_t");
00270 
00271         rm_CopyPos_t rmMedPosVec;
00272         rm_MediumPos_t rmMedPos;
00273         rm_CopiesPos_v_t rmCopyPosVec;
00274 
00275         for (UInt32_t i = 0; i < a_copiesPos.length(); i++ ) { // for each set of splits
00276             rmMedPosVec.rowNum = i;
00277             for (UInt32_t j = 0; j < a_copiesPos[i].length(); j++) { // for each split
00278                 rmMedPos.blockOffset    = a_copiesPos[i][j].blockOffset;
00279                 rmMedPos.mediumKey       = a_copiesPos[i][j].mediumKey;
00280                 rmMedPos.medVolNr       = a_copiesPos[i][j].medVolNum;
00281                 rmMedPos.splitOffset    = a_copiesPos[i][j].splitOffset;
00282                 rmMedPos.blockOffset    = a_copiesPos[i][j].blockOffset;
00283                 rmMedPos.splitSize      = a_copiesPos[i][j].splitSize;
00284                 rmMedPosVec.mediumPos.push_back(rmMedPos);
00285             }
00286             rmCopyPosVec.push_back(rmMedPosVec);
00287             rmMedPosVec.mediumPos.clear();
00288         }
00289         log_DBG_m(dbg_DETAIL,"Coping finished");
00290 
00291         UInt32_t bestIdx;
00292 
00293         dbo_GetBestCopy best(rmCopyPosVec, bestIdx, *m_DBThread );
00294         best.Execute();
00295 
00296         log_DBG_m(dbg_DETAIL,"Will Return " << bestIdx);
00297 
00298         return  bestIdx;
00299 
00300 
00301     } ipc_CATCH_IVD_THROW_CORBA_m;
00302 
00303 }

Here is the call graph for this function:

i_DriveHost_t * i_ResourceManager_i::GetHost ( i_DBKey_t a_driveKey )

Definition at line 306 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

00306                                                                 {
00307     log_FUNC_m(GetHost);
00308     try {
00309         i_DriveHost_t * dh = new i_DriveHost_t;
00310         dbo_GetHost host(a_driveKey, *dh, *m_DBThread);
00311         host.Execute();
00312         return dh;
00313     } ipc_CATCH_IVD_THROW_CORBA_m;
00314 }

Here is the call graph for this function:

i_MigID_t i_ResourceManager_i::GetNewMigId ( const char * a_partName )

Definition at line 1173 of file i_rm_impl.cpp.

References rm_SysState::GetNewMigID(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_queue, and rm_Queue::m_SysState.

01173                                                                  {
01174     log_FUNC_m(GetNewMigId);
01175 
01176     try {
01177         string partName(a_partName);
01178         return m_queue.m_SysState.GetNewMigID(partName);
01179 
01180     } ipc_CATCH_IVD_THROW_CORBA_m;
01181 
01182 }

Here is the call graph for this function:

i_MediaInfoSeq_t * i_ResourceManager_i::GetMediaInfo ( const char * a_partName )

Definition at line 778 of file i_rm_impl.cpp.

References dbg_LOW, dbg_NORM, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

00778                                                                           {
00779     log_FUNC_m(GetMediaInfo);
00780     try {
00781         log_DBG_m(dbg_LOW, "Getting media info.");
00782 
00783         i_MediaInfoSeq_t_var i_medInfoSeq(new i_MediaInfoSeq_t);
00784         string partName(a_partName);
00785 
00786         dbo_GetMediaInfo mediaInfo(partName, i_medInfoSeq, *m_DBThread);
00787         mediaInfo.Execute();
00788 
00789         log_DBG_m(dbg_NORM, "Length: " << i_medInfoSeq->length());
00790 
00791         return i_medInfoSeq._retn();
00792     } ipc_CATCH_IVD_THROW_CORBA_m;
00793 }

Here is the call graph for this function:

void i_ResourceManager_i::GetRecallResources	(	i_Job_ptr	a_job,
		const i_JobParams &	a_jobParams,
		const i_Resource_t &	a_resources
	)

Definition at line 317 of file i_rm_impl.cpp.

References rm_Queue::Activate(), i_JobParams::bufId, rm_JobParams::bufId, i_JobParams::bufType, rm_JobParams::bufType, dbg_LOW, rm_JobParams::iJob, rm_Queue::Insert(), ipc_CATCH_IVD_THROW_CORBA_m, rm_JobParams::jobID, i_JobParams::jobID, i_JobParams::jobPriority, rm_JobParams::jobPriority, i_JobParams::jobType, rm_JobParams::jobType, log_DBG_m, log_FUNC_m, ipc_Log::LogJobParams(), ipc_Log::LogResources(), m_queue, rm_JobParams::m_resources, i_JobParams::partName, rm_JobParams::partName, i_JobParams::partUUID, rm_JobParams::partUUID, i_JobParams::phase, rm_JobParams::phase, i_JobParams::priorityModifier, rm_JobParams::priorityModifier, i_JobParams::startTime, and rm_JobParams::startTime.

00320                                                              {
00321 
00322     log_FUNC_m(GetRecallResources);
00323     log_DBG_m(dbg_LOW,  "RM GetRecallResources invoked for Job:" <<
00324                         a_jobParams.jobID << endl <<
00325                         ipc_Log::LogJobParams(a_jobParams) << endl <<
00326                         ipc_Log::LogResources(a_resources));
00327 
00328     try {
00329         rm_JobParams rmJobParams;
00330         rmJobParams.iJob            = i_Job::_duplicate(a_job);  // copy reference to Job
00331 
00332         rmJobParams.partName       = a_jobParams.partName;
00333         rmJobParams.jobID          = a_jobParams.jobID;
00334         rmJobParams.jobPriority    = a_jobParams.jobPriority;
00335         rmJobParams.priorityModifier= a_jobParams.priorityModifier;
00336         rmJobParams.jobType        = static_cast<ivd_JobType_e>(a_jobParams.jobType);
00337         rmJobParams.phase          = a_jobParams.phase;
00338         rmJobParams.startTime      = a_jobParams.startTime;
00339         rmJobParams.partUUID       = a_jobParams.partUUID;
00340         rmJobParams.bufType        = a_jobParams.bufType ;
00341         rmJobParams.bufId          = a_jobParams.bufId   ;
00342 
00343 
00344         rm_Resource_t resource;
00345         resource = a_resources;
00346         rmJobParams.m_resources.push_back(resource);
00347         {
00348             m_queue.Insert(rmJobParams);
00349             m_queue.Activate();
00350         }
00351     } ipc_CATCH_IVD_THROW_CORBA_m;
00352 
00353 }

Here is the call graph for this function:

void i_ResourceManager_i::ExchangeRecallResources	(	i_Job_ptr	a_job,
		const i_JobParams &	a_jobParams,
		const i_Resource_t &	a_relResources,
		const i_Resource_t &	a_getResources
	)

Definition at line 356 of file i_rm_impl.cpp.

References rm_Resource_t::barcode, i_JobParams::bufId, rm_JobParams::bufId, i_JobParams::bufType, rm_JobParams::bufType, dbg_LOW, rm_Resource_t::driveCtrlDevice, rm_Resource_t::driveIndex, rm_Resource_t::driveKey, rm_JobParams::iJob, rm_Queue::Insert(), ipc_CATCH_IVD_THROW_CORBA_m, rm_JobParams::jobID, i_JobParams::jobID, i_JobParams::jobPriority, rm_JobParams::jobPriority, i_JobParams::jobType, rm_JobParams::jobType, rm_Resource_t::load, rm_Resource_t::loadSlotAddr, log_DBG_m, log_FUNC_m, ipc_Log::LogJobParams(), ipc_Log::LogResources(), m_queue, rm_JobParams::m_resources, i_JobParams::partName, rm_JobParams::partName, i_JobParams::partUUID, rm_JobParams::partUUID, i_JobParams::phase, rm_JobParams::phase, i_JobParams::priorityModifier, rm_JobParams::priorityModifier, ReleaseResource(), i_JobParams::startTime, rm_JobParams::startTime, rm_Resource_t::unloadBarcode, and rm_Resource_t::unloadSlotAddr.

00360                                                                 {
00361     log_FUNC_m(ExchangeRecallResources);
00362     log_DBG_m(dbg_LOW,  "RM ExchangeRecallResources invoked for Job:" <<
00363                         a_jobParams.jobID << endl <<
00364                         ipc_Log::LogJobParams(a_jobParams) << endl <<
00365                         ipc_Log::LogResources(a_relResources) << endl <<
00366                         ipc_Log::LogResources(a_getResources));
00367 
00368     try {
00369         rm_JobParams rmJobParams;
00370         rmJobParams.iJob            = i_Job::_duplicate(a_job);  // copy reference to Job
00371 
00372         rmJobParams.partName       = a_jobParams.partName;
00373         rmJobParams.jobID          = a_jobParams.jobID;
00374         rmJobParams.jobPriority    = a_jobParams.jobPriority;
00375         rmJobParams.priorityModifier= a_jobParams.priorityModifier;
00376         rmJobParams.jobType        = static_cast<ivd_JobType_e>(a_jobParams.jobType);
00377         rmJobParams.phase          = a_jobParams.phase;
00378         rmJobParams.startTime      = a_jobParams.startTime;
00379         rmJobParams.partUUID       = a_jobParams.partUUID;
00380         rmJobParams.bufType        = a_jobParams.bufType ;
00381         rmJobParams.bufId          = a_jobParams.bufId   ;
00382 
00383         rm_Resource_t resource;
00384         resource = a_getResources;
00385         resource.driveKey = 0;
00386         resource.driveCtrlDevice = "";
00387         resource.driveIndex = "";
00388         resource.barcode = "";
00389         resource.load = false;
00390         resource.loadSlotAddr = "";
00391         resource.unloadSlotAddr = "";
00392         resource.unloadBarcode = "";
00393         rmJobParams.m_resources.push_back(resource);
00394         {
00395             m_queue.Insert(rmJobParams);
00396             i_ResourceList_t resList;
00397             resList.length(1);
00398             resList[0] = a_relResources;
00399             ReleaseResource(a_jobParams, resList);
00400         }
00401     } ipc_CATCH_IVD_THROW_CORBA_m;
00402 }

Here is the call graph for this function:

void i_ResourceManager_i::ReleaseResource	(	const i_JobParams &	a_jobParams,
		const i_ResourceList_t &	a_resources
	)

Definition at line 405 of file i_rm_impl.cpp.

References rm_Queue::Activate(), dbg_DETAIL, dbg_LOW, rm_DBOperation::Execute(), ivd_BaseException::GetError(), ie_PARTSTATNF, rm_Queue::IncReleasedCount(), ipc_CATCH_IVD_THROW_CORBA_m, i_JobParams::jobID, i_JobParams::jobType, jt_ADMIN, jt_BACKUP, jt_MAINT, jt_RECALL, jt_REORG, log_DBG_m, log_FUNC_m, log_WRN_m, ipc_Log::LogJobParams(), ipc_Log::LogResources(), m_DBThread, m_queue, rm_Queue::m_SysState, mf_DISK, i_JobParams::partName, and rm_SysState::Release().

Referenced by rm_Queue::Allocate(), ExchangeRecallResources(), and ExchangeResources().

00406                                                                              {
00407     log_FUNC_m(ReleaseResource);
00408 
00409     try {
00410 
00411         log_DBG_m(dbg_LOW,  "RM ReleaseResources invoked for Job:" <<
00412                         a_jobParams.jobID << endl <<
00413                         ipc_Log::LogJobParams(a_jobParams) << endl <<
00414                         ipc_Log::LogResources(a_resources));
00415 
00416         try {
00417             if ((a_jobParams.jobType != jt_ADMIN) && (a_jobParams.jobType != jt_BACKUP)) {
00418                 string pId(a_jobParams.partName);
00419                 m_queue.m_SysState.Release(
00420                         pId,
00421                         static_cast<ivd_JobType_e>(a_jobParams.jobType),
00422                         a_resources.length() );
00423             } else {
00424                 m_queue.m_SysState.Release(
00425                     static_cast<ivd_JobType_e>(a_jobParams.jobType),
00426                     a_resources.length() );
00427             }
00428         } catch (ivd_Exception& e) {
00429             if (e.GetError() == ie_PARTSTATNF) {
00430                 log_WRN_m (e);
00431             }
00432             else throw;
00433         }
00434 
00435         // Increase released count to make the queue start from beginning
00436         m_queue.IncReleasedCount();
00437 
00438         if ((a_jobParams.jobType == jt_RECALL) &&
00439             (a_resources[0].mediumFamily == mf_DISK) ) {
00440             // do not release the resources for disk medium
00441             log_DBG_m(dbg_DETAIL, "Recall job does not release resources");
00442         } else if ( (a_jobParams.jobType == jt_REORG) &&
00443                     (a_resources[0].resNum == 0) &&
00444                     (a_resources[0].mediumFamily == mf_DISK) ) {
00445             // first medium of reorg is also like recall
00446             log_DBG_m(dbg_DETAIL, "Reorg job (0) does not release resources");
00447         } else if ( (a_jobParams.jobType == jt_MAINT) &&
00448                     (a_resources[0].resNum == 0) &&
00449                     (a_resources[0].mediumFamily == mf_DISK) ) {
00450             // first medium of redundant copy is also like recall
00451             log_DBG_m(dbg_DETAIL, "Redundant job (0) does not release resources");
00452 
00453         // todo Update AccessNr. for disk media volume
00454         } else {
00455             dbo_ReleaseResources relRes(a_resources,
00456                                         static_cast<ivd_JobType_e>(a_jobParams.jobType),
00457                                         *m_DBThread);
00458             relRes.Execute();
00459         };
00460         m_queue.Activate();
00461 
00462     } ipc_CATCH_IVD_THROW_CORBA_m;
00463 }

Here is the call graph for this function:

Here is the caller graph for this function:

void i_ResourceManager_i::CancelGetResource ( i_JobID_t a_jobId )

Definition at line 475 of file i_rm_impl.cpp.

References rm_Queue::Activate(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_queue, and rm_Queue::Remove().

00475                                                              {
00476     log_FUNC_m(CancelGetResource);
00477 
00478     try {
00479         m_queue.Remove(a_jobId);
00480         m_queue.Activate();
00481     } ipc_CATCH_IVD_THROW_CORBA_m;
00482 }

Here is the call graph for this function:

void i_ResourceManager_i::UseNewResource ( )

Definition at line 485 of file i_rm_impl.cpp.

References rm_Queue::Activate(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_queue.

Referenced by DriveError(), DriveStatusClear(), LibraryStatusClear(), MediumStatusClear(), and UpdateMajorCol().

00485                                          {
00486     log_FUNC_m(UseNewResource);
00487     try {
00488         m_queue.Activate();
00489     } ipc_CATCH_IVD_THROW_CORBA_m;
00490 }

Here is the call graph for this function:

Here is the caller graph for this function:

i_FileSize_t i_ResourceManager_i::GetMaxDiskBufferSize ( const char * a_partName )

Definition at line 493 of file i_rm_impl.cpp.

References dbg_LOW, rm_DiskBufAllocator::GetMaxDiskBufferSize(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, m_diskBuf_x, and m_diskBufAllocator.

00493                                                                              {
00494     log_FUNC_m(GetMaxDiskBufferSize);
00495     try {
00496         log_DBG_m(dbg_LOW, "GetMaxDiskBufferSize does not regard partition.");
00497         cmn_MutexLock l(m_diskBuf_x);
00498         return m_diskBufAllocator.GetMaxDiskBufferSize();
00499     } ipc_CATCH_IVD_THROW_CORBA_m;
00500 }

Here is the call graph for this function:

char * i_ResourceManager_i::ReserveDiskBuffer	(	i_JobID_t	a_jobID,
		i_FileSize_t	a_minJobSize,
		i_FileSize_t	a_maxJobSize,
		i_FileSize_t &	a_allocatedJobSize,
		i_JobType_t	a_jobType
	)

Definition at line 503 of file i_rm_impl.cpp.

References dbg_LOW, ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, m_diskBuf_x, m_diskBufAllocator, and rm_DiskBufAllocator::ReserveDiskBuffer().

00508                                                               {
00509     log_FUNC_m(ReserveDiskBuffer);
00510     log_DBG_m(dbg_LOW, "a_jobID:" << a_jobID <<
00511         " ,a_minJobSize:" << a_minJobSize <<
00512         " ,a_maxJobSize:" << a_maxJobSize <<
00513         ", a_jobType:" << a_jobType);
00514     cmn_MutexLock l(m_diskBuf_x);
00515     try {
00516         string filesystem;
00517         filesystem = m_diskBufAllocator.ReserveDiskBuffer(  a_jobID,
00518                                                             a_minJobSize,
00519                                                             a_maxJobSize,
00520                                                             a_allocatedJobSize,
00521                                                             a_jobType);
00522         log_DBG_m(dbg_LOW, "Reserved. Diskbuferfs:" << filesystem <<
00523             " space:" << a_allocatedJobSize);
00524         return CORBA::string_dup(filesystem.c_str());
00525     } ipc_CATCH_IVD_THROW_CORBA_m;
00526 }

Here is the call graph for this function:

void i_ResourceManager_i::ReleaseDiskBuffer ( i_JobID_t a_jobID )

Definition at line 529 of file i_rm_impl.cpp.

References dbg_LOW, ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, m_diskBuf_x, m_diskBufAllocator, and rm_DiskBufAllocator::ReleaseDiskBuffer().

00529                                                             {
00530     log_FUNC_m(ReleaseDiskBuffer);
00531     log_DBG_m(dbg_LOW, "a_jobID:" << a_jobID);
00532     try {
00533         cmn_MutexLock l(m_diskBuf_x);
00534         m_diskBufAllocator.ReleaseDiskBuffer(a_jobID);
00535     } ipc_CATCH_IVD_THROW_CORBA_m;
00536 }

Here is the call graph for this function:

void i_ResourceManager_i::MediumLoaded	(	const char *	a_libName,
		const char *	a_medBarcode,
		const char *	a_driveAddr
	)

Definition at line 539 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

00539                                                                                                                {
00540     log_FUNC_m(MediumLoaded);
00541     try {
00542         dbo_MediumLoaded ml(a_libName, a_medBarcode, a_driveAddr, *m_DBThread);
00543         ml.Execute();
00544 
00545     } ipc_CATCH_IVD_THROW_CORBA_m;
00546 }

Here is the call graph for this function:

void i_ResourceManager_i::MediumUnLoaded	(	const char *	a_libName,
		const char *	a_medBarcode,
		const char *	a_slotAddr,
		i_Type_t	a_slotType
	)

Definition at line 549 of file i_rm_impl.cpp.

References rm_Queue::Activate(), rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, and m_queue.

00553                                                             {
00554     log_FUNC_m(MediumUnLoaded);
00555     try {
00556         dbo_MediumUnloaded mu(a_libName, a_medBarcode, a_slotAddr, a_slotType, *m_DBThread);
00557         mu.Execute();
00558         m_queue.Activate();
00559     } ipc_CATCH_IVD_THROW_CORBA_m;
00560 }

Here is the call graph for this function:

void i_ResourceManager_i::VolumeFull ( const char * a_medVolId )

Definition at line 563 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

00563                                                            {
00564     log_FUNC_m(VolumeFull);
00565     try {
00566         dbo_VolumeFull vf(a_medVolId, *m_DBThread);
00567         vf.Execute();
00568 
00569     } ipc_CATCH_IVD_THROW_CORBA_m;
00570 }

Here is the call graph for this function:

void i_ResourceManager_i::VolumeEmpty ( const char * a_medVolId )

Definition at line 573 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

00573                                                             {
00574     log_FUNC_m(VolumeEmpty);
00575     try {
00576 
00577         dbo_VolumeEmpty ve(a_medVolId, *m_DBThread);
00578         ve.Execute();
00579 
00580     } ipc_CATCH_IVD_THROW_CORBA_m;
00581 }

Here is the call graph for this function:

void i_ResourceManager_i::VolumeUsage	(	const char *	a_medVolId,
		CORBA::Long	a_percentage,
		i_VolSize_t	a_totalData
	)

Definition at line 584 of file i_rm_impl.cpp.

References dbg_NORM, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

00587                              {
00588 
00589     log_FUNC_m(VolumeUsage);
00590     try {
00591 
00592         log_DBG_m(dbg_NORM, "Setting Vol: " << a_medVolId <<
00593                             " usage to " << a_percentage << "%" <<
00594                             " Total: " << a_totalData << " MB");
00595 
00596         dbo_VolumeUsage mv(a_medVolId, a_percentage, a_totalData, *m_DBThread);
00597         mv.Execute();
00598 
00599     } ipc_CATCH_IVD_THROW_CORBA_m;
00600 
00601 }

Here is the call graph for this function:

void i_ResourceManager_i::VolumeError ( const char * a_medVolId )

Definition at line 604 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

00604                                                             {
00605     log_FUNC_m(VolumeError);
00606     try {
00607 
00608         dbo_VolumeError mv(a_medVolId, *m_DBThread);
00609         mv.Execute();
00610 
00611     } ipc_CATCH_IVD_THROW_CORBA_m;
00612 
00613 }

Here is the call graph for this function:

void i_ResourceManager_i::MediumUnreliable ( i_DBKey_t a_mediaKey )

Definition at line 616 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

00616                                                                 {
00617     log_FUNC_m(MediumUnreliable);
00618     try {
00619         UInt32_t medKey = a_mediumKey;
00620         dbo_MediumUnreliable mur(medKey, *m_DBThread);
00621         mur.Execute();
00622 
00623     } ipc_CATCH_IVD_THROW_CORBA_m;
00624 }

Here is the call graph for this function:

void i_ResourceManager_i::MediumUnusable ( i_DBKey_t a_mediaKey )

Definition at line 627 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

00627                                                               {
00628     log_FUNC_m(MediumUnusable);
00629     try {
00630         UInt32_t medKey = a_mediumKey;
00631         dbo_MediumUnusable mus(medKey, *m_DBThread);
00632         mus.Execute();
00633 
00634     } ipc_CATCH_IVD_THROW_CORBA_m;
00635 }

Here is the call graph for this function:

void i_ResourceManager_i::MediumStatusSet	(	const char *	a_barcode,
		i_Status_t	a_status
	)

Definition at line 638 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

00638                                                                                     {
00639     log_FUNC_m(MediumStatusSet);
00640     try {
00641         string barcode(a_barcode);
00642         dbo_MediumStatusSet mss(barcode, a_status, *m_DBThread);
00643         mss.Execute();
00644 
00645     } ipc_CATCH_IVD_THROW_CORBA_m;
00646 }

Here is the call graph for this function:

void i_ResourceManager_i::MediumStatusClear	(	const char *	a_barcode,
		i_Status_t	a_status
	)

Definition at line 649 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, and UseNewResource().

00649                                                                                       {
00650     log_FUNC_m(MediumStatusClear);
00651     try {
00652         string barcode(a_barcode);
00653         dbo_MediumStatusClear msc(barcode, a_status, *m_DBThread);
00654         msc.Execute();
00655         UseNewResource();
00656 
00657     } ipc_CATCH_IVD_THROW_CORBA_m;
00658 }

Here is the call graph for this function:

void i_ResourceManager_i::DriveStatusSet	(	const char *	a_drvName,
		i_Status_t	a_status
	)

Definition at line 661 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

00661                                                                                    {
00662     log_FUNC_m(DriveStatusSet);
00663     try {
00664         string drvName(a_drvName);
00665         dbo_DriveStatusSet dss(drvName, a_status, *m_DBThread);
00666         dss.Execute();
00667 
00668     } ipc_CATCH_IVD_THROW_CORBA_m;
00669 }

Here is the call graph for this function:

void i_ResourceManager_i::DriveStatusClear	(	const char *	a_drvName,
		i_Status_t	a_status
	)

Definition at line 672 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, and UseNewResource().

00672                                                                                      {
00673     log_FUNC_m(DriveStatusClear);
00674     try {
00675         string drvName(a_drvName);
00676         dbo_DriveStatusClear dsc(drvName, a_status, *m_DBThread);
00677         dsc.Execute();
00678         UseNewResource();
00679 
00680     } ipc_CATCH_IVD_THROW_CORBA_m;
00681 }

Here is the call graph for this function:

void i_ResourceManager_i::DriveError ( i_DBKey_t a_driveKey )

Definition at line 684 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, and UseNewResource().

00684                                                          {
00685     log_FUNC_m(DriveError);
00686     try {
00687         UInt32_t drvKey = a_driveKey;
00688         dbo_DriveError de(drvKey, *m_DBThread);
00689         de.Execute();
00690         UseNewResource();
00691     } ipc_CATCH_IVD_THROW_CORBA_m;
00692 }

Here is the call graph for this function:

void i_ResourceManager_i::MedVolStatusSet	(	const char *	a_medVoId,
		i_Status_t	a_status
	)

Definition at line 695 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_A_m, and m_DBThread.

00696                                                                  {
00697     log_FUNC_A_m(MedVolStatusSet, "a_medVoId:" << a_medVoId <<
00698                                   ", a_status:" << hex << a_status);
00699     try {
00700         string medVoId(a_medVoId);
00701         dbo_MedVolStatusSet mss(medVoId, a_status, *m_DBThread);
00702         mss.Execute();
00703     } ipc_CATCH_IVD_THROW_CORBA_m;
00704 }

Here is the call graph for this function:

void i_ResourceManager_i::MedVolStatusClear	(	const char *	a_medVoId,
		i_Status_t	a_status
	)

Definition at line 707 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

00708                                                                  {
00709     log_FUNC_m(MedVolStatusClear);
00710     try {
00711         string medVoId(a_medVoId);
00712         dbo_MedVolStatusClear mss(medVoId, a_status, *m_DBThread);
00713         mss.Execute();
00714     } ipc_CATCH_IVD_THROW_CORBA_m;
00715 }

Here is the call graph for this function:

void i_ResourceManager_i::VolumeListStatusSet	(	CORBA::ULong	a_medKey,
		const i_ULongList_t &	a_volumes,
		CORBA::ULong	a_status
	)

Definition at line 718 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

00720                                                                     {
00721    log_FUNC_m(VolumeListStatusSet);
00722    try {
00723        dbo_VolumeListStatusSet vlss(a_medKey, a_volumes, a_status, *m_DBThread);
00724        vlss.Execute();
00725    } ipc_CATCH_IVD_THROW_CORBA_m;
00726 }

Here is the call graph for this function:

void i_ResourceManager_i::EmergencyInventory ( i_Time_t a_resAssignTime )

void i_ResourceManager_i::InventoryUpdate	(	const char *	a_libName,
		const i_UpdateList_t &	a_elemStatus
	)

Definition at line 738 of file i_rm_impl.cpp.

References rm_Queue::Activate(), rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_A_m, m_DBThread, and m_queue.

00740                                         {
00741 
00742     log_FUNC_A_m(InventoryUpdate, "lib: " << a_libName);
00743 
00744     try {
00745 
00746         dbo_InventoryUpdate iu(a_libName, a_elemStatus, *m_DBThread);
00747         iu.Execute();
00748         m_queue.Activate();
00749 
00750     } ipc_CATCH_IVD_THROW_CORBA_m;
00751 }

Here is the call graph for this function:

void i_ResourceManager_i::LibraryStatusSet	(	const char *	a_libName,
		i_Status_t	a_status
	)

Definition at line 754 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

00754                                                                                      {
00755     log_FUNC_m(LibraryStatusSet);
00756     try {
00757         string libName(a_libName);
00758         dbo_LibraryStatusSet dss(libName, a_status, *m_DBThread);
00759         dss.Execute();
00760 
00761     } ipc_CATCH_IVD_THROW_CORBA_m;
00762 }

Here is the call graph for this function:

void i_ResourceManager_i::LibraryStatusClear	(	const char *	a_libName,
		i_Status_t	a_status
	)

Definition at line 765 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, and UseNewResource().

00765                                                                                        {
00766     log_FUNC_m(LibraryStatusClear);
00767     try {
00768         string libName(a_libName);
00769         dbo_LibraryStatusClear dsc(libName, a_status, *m_DBThread);
00770         dsc.Execute();
00771         UseNewResource();
00772 
00773     } ipc_CATCH_IVD_THROW_CORBA_m;
00774 }

Here is the call graph for this function:

char * i_ResourceManager_i::AddPartition ( const i_Partition_t & a_part )

Definition at line 856 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), i_Partition_t::fsHost, rm_Partition::fsHost, i_Partition_t::fsID, rm_Partition::fsID, i_Partition_t::fsMountpoint, rm_Partition::fsMountpoint, ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, rm_Partition::migIdCount, rm_Partition::migIdTime, i_Partition_t::options, rm_Partition::options, i_Partition_t::partitionName, rm_Partition::partitionName, rm_Partition::partitionUUIDString, rm_Partition::partUUID, i_Partition_t::status, rm_Partition::status, and cmn_UUID_t::ToString().

00856                                                                    {
00857 
00858     log_FUNC_m(AddPartition);
00859     time_t tTime;
00860     time(&tTime);
00861 
00862     rm_Partition part;
00863     try {
00864         part.migIdCount = 0;
00865         part.migIdTime = tTime;
00866         part.partitionName = a_part.partitionName;
00867         part.partitionUUIDString = part.partUUID.ToString();
00868         part.status = a_part.status;
00869         part.fsHost = a_part.fsHost;
00870         part.fsMountpoint = a_part.fsMountpoint;
00871         part.fsID = a_part.fsID;
00872         part.options = a_part.options;
00873 
00874         dbo_InsertPartition insPart(part, *m_DBThread);
00875         insPart.Execute();
00876 
00877     } ipc_CATCH_IVD_THROW_CORBA_m;
00878     return CORBA::string_dup(part.partitionUUIDString.c_str() );
00879 }

Here is the call graph for this function:

void i_ResourceManager_i::RemovePartition ( const char * a_partName )

Definition at line 882 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, and rm_Partition::partitionName.

00882                                                                 {
00883     log_FUNC_m(RemovePartition);
00884     try {
00885 
00886         rm_Partition part;
00887         part.partitionName = a_partName;
00888 
00889         dbo_RemovePartition rmvPart(part, *m_DBThread);
00890         rmvPart.Execute();
00891 
00892     } ipc_CATCH_IVD_THROW_CORBA_m;
00893 }

Here is the call graph for this function:

void i_ResourceManager_i::UpdatePartition ( const char * a_partName )

Definition at line 1104 of file i_rm_impl.cpp.

References cfg_PMCfg::clients, dbg_NORM, rm_DBOperation::Execute(), rm_Partition::fsHost, rm_Partition::fsID, rm_Partition::fsMountpoint, ie_NOT_SUPPORTED, ipc_CATCH_IVD_THROW_CORBA_m, ivd_FSTypeToText(), log_DBG_m, log_FUNC_m, log_NOTE_m, m_DBThread, cfg_PMCfg::name, rm_Partition::options, ParsePMConfig(), SetFSType(), and SetRMPartStatus().

01104                                                                 {
01105     log_FUNC_m(UpdatePartition);
01106     try {
01107         cfg_PMCfg pmCfg;
01108         ParsePMConfig(pmCfg, a_partName);
01109         SetRMPartStatus(pmCfg);
01110 
01111         if (pmCfg.clients.size() != 1) {
01112             throw ivd_InternalError(ie_NOT_SUPPORTED,
01113                 "only one client supported in 3.1");
01114         }
01115 
01116         rm_Partition rmPart;
01117         dbo_SelectPartition selPart(pmCfg.name, rmPart, *m_DBThread);
01118         selPart.Execute();
01119         // i_Part UUID & MigIDTime & MgID Count can not be changed!!!
01120         // Note: only one client supported today
01121 
01122         rmPart.fsHost       = CORBA::string_dup(pmCfg.clients[0].name.c_str());
01123         rmPart.fsMountpoint = CORBA::string_dup("NYI");
01124         rmPart.fsID         = CORBA::string_dup(pmCfg.clients[0].fileSystemId.c_str());
01125 
01126         log_DBG_m(dbg_NORM, "pmCfg.clients[0].operationMode:" <<
01127                                         pmCfg.clients[0].operationMode);
01128 
01129         if (pmCfg.clients[0].operationMode != rmPart.options) {
01130             SetFSType(pmCfg.clients[0].operationMode, rmPart.options);
01131             ostringstream msg;
01132             msg << "Operation mode set to " << ivd_FSTypeToText(pmCfg.clients[0].operationMode);
01133             log_NOTE_m(msg.str());
01134 
01135         } else {
01136             log_DBG_m(dbg_NORM, "Operation mode did not change.");
01137         }
01138 
01139         // update record in rmdb
01140         log_DBG_m(dbg_NORM, "rmPart.options:" << rmPart.options);
01141 
01142         dbo_UpdatePartition updatePart(rmPart, *m_DBThread);
01143         updatePart.Execute();
01144     } ipc_CATCH_IVD_THROW_CORBA_m;
01145 }

Here is the call graph for this function:

i_Partition_t * i_ResourceManager_i::SelectPartition ( const char * a_partName )

Definition at line 896 of file i_rm_impl.cpp.

References rm_String::cvalue_p, dbg_NORM, rm_DBOperation::Execute(), rm_Partition::fsHost, i_Partition_t::fsHost, rm_Partition::fsID, i_Partition_t::fsID, rm_Partition::fsMountpoint, i_Partition_t::fsMountpoint, ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, m_DBThread, rm_Partition::migIdCount, i_Partition_t::migIdCount, rm_Partition::migIdTime, i_Partition_t::migIdTime, rm_Partition::options, i_Partition_t::options, rm_Partition::partitionName, i_Partition_t::partitionName, rm_Partition::partitionUUIDString, i_Partition_t::partitionUUIDString, rm_Partition::status, and i_Partition_t::status.

00896                                                                           {
00897     log_FUNC_m(SelectPartition);
00898 
00899     log_DBG_m(dbg_NORM, "a_partName: " << a_partName);
00900 
00901     try {
00902         rm_Partition part;
00903 
00904         i_Partition_t * iPart = new i_Partition_t;
00905         dbo_SelectPartition selPart(a_partName, part, *m_DBThread);
00906         selPart.Execute();
00907         iPart->partitionName = CORBA::string_dup(part.partitionName.cvalue_p);
00908         iPart->partitionUUIDString = CORBA::string_dup(part.partitionUUIDString.cvalue_p);
00909         iPart->migIdTime = part.migIdTime;
00910         iPart->migIdCount = part.migIdCount;
00911         iPart->status = part.status;
00912         iPart->options = part.options;
00913         iPart->fsHost = CORBA::string_dup(part.fsHost.cvalue_p);
00914         iPart->fsMountpoint = CORBA::string_dup(part.fsMountpoint.cvalue_p);
00915         iPart->fsID = CORBA::string_dup(part.fsID.cvalue_p);
00916 
00917 
00918         return iPart;
00919 
00920     } ipc_CATCH_IVD_THROW_CORBA_m;
00921 }

Here is the call graph for this function:

i_Partition_t * i_ResourceManager_i::SelectPartitionByUUID ( const char * a_partUuid )

Definition at line 924 of file i_rm_impl.cpp.

References rm_String::cvalue_p, rm_DBOperation::Execute(), rm_Partition::fsHost, i_Partition_t::fsHost, rm_Partition::fsID, i_Partition_t::fsID, rm_Partition::fsMountpoint, i_Partition_t::fsMountpoint, ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, rm_Partition::migIdCount, i_Partition_t::migIdCount, rm_Partition::migIdTime, i_Partition_t::migIdTime, rm_Partition::partitionName, i_Partition_t::partitionName, rm_Partition::partitionUUIDString, i_Partition_t::partitionUUIDString, rm_Partition::status, and i_Partition_t::status.

00924                                                                                 {
00925     log_FUNC_m(SelectPartitionByUUID);
00926     rm_Partition part;
00927     try {
00928         i_Partition_t * iPart = new i_Partition_t;
00929         dbo_SelectPartitionByUuid selPart(a_partUuid, part, *m_DBThread);
00930         selPart.Execute();
00931         iPart->partitionName = CORBA::string_dup(part.partitionName.cvalue_p);
00932         iPart->partitionUUIDString = CORBA::string_dup(part.partitionUUIDString.cvalue_p);
00933         iPart->migIdTime = part.migIdTime;
00934         iPart->migIdCount = part.migIdCount;
00935         iPart->status = part.status;
00936         iPart->fsHost = CORBA::string_dup(part.fsHost.cvalue_p);
00937         iPart->fsMountpoint = CORBA::string_dup(part.fsMountpoint.cvalue_p);
00938         iPart->fsID = CORBA::string_dup(part.fsID.cvalue_p);
00939         return iPart;
00940 
00941     } ipc_CATCH_IVD_THROW_CORBA_m;
00942 
00943 }

Here is the call graph for this function:

void i_ResourceManager_i::DisablePartition ( const char * a_partName )

Definition at line 946 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, and rmdb_MAX_PARTITIONNAME.

00946                                                                    {
00947     log_FUNC_m(DisablePartition);
00948     try {
00949         rm_String partName(rmdb_MAX_PARTITIONNAME);
00950         partName = a_partName;
00951         dbo_DisablePartition part(partName, *m_DBThread);
00952         part.Execute();
00953     } ipc_CATCH_IVD_THROW_CORBA_m;
00954 }

Here is the call graph for this function:

void i_ResourceManager_i::EnablePartition ( const char * a_partName )

Definition at line 957 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, and rmdb_MAX_PARTITIONNAME.

00957                                                                   {
00958     log_FUNC_m(EnablePartition);
00959     try {
00960         rm_String partName(rmdb_MAX_PARTITIONNAME);
00961         partName = a_partName;
00962         dbo_EnablePartition part(partName, *m_DBThread);
00963         part.Execute();
00964     } ipc_CATCH_IVD_THROW_CORBA_m;
00965 
00966 }

Here is the call graph for this function:

i_PartSeq_t * i_ResourceManager_i::SelectAllPartition ( )

Definition at line 995 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

00995                                                      {
00996     log_FUNC_m(SelectAllPartition);
00997     try {
00998         i_PartSeq_t* iPartSeq = new i_PartSeq_t;
00999         log_DBG_m(dbg_LOW,"Select All Partition");
01000 
01001         dbo_SelectAllPartition part(*iPartSeq, *m_DBThread);
01002         part.Execute();
01003 
01004         return iPartSeq;
01005     } ipc_CATCH_IVD_THROW_CORBA_m;
01006 
01007 }

Here is the call graph for this function:

char * i_ResourceManager_i::RegisterPartition ( const char * a_partName )

Definition at line 1070 of file i_rm_impl.cpp.

References cfg_PMCfg::clients, rm_DBOperation::Execute(), ie_NOT_SUPPORTED, ipc_CATCH_IVD_THROW_CORBA_m, ivd_FSTypeToText(), log_FUNC_m, log_NOTE_m, m_DBThread, cfg_PMCfg::name, rm_Partition::options, ParsePMConfig(), rm_Partition::partUUID, rmdb_PARTITION_OPTION_NOT_SET, SetFSType(), SetRMPartStatus(), and cmn_UUID_t::ToString().

01070                                                                    {
01071     log_FUNC_m(RegisterPartition);
01072     try {
01073         cfg_PMCfg pmCfg;
01074         ParsePMConfig(pmCfg, a_partName);
01075         SetRMPartStatus(pmCfg);
01076 
01077         rm_Partition rmPart;
01078         dbo_SelectPartition selPart(pmCfg.name, rmPart, *m_DBThread);
01079         selPart.Execute();
01080 
01081         if (pmCfg.clients.size() != 1) {
01082             throw ivd_InternalError(ie_NOT_SUPPORTED,
01083                                     "only one client supported in 3.1");
01084         }
01085 
01086         if (rmPart.options == rmdb_PARTITION_OPTION_NOT_SET) {
01087             // ver 3.1 patch 2 sets option value for regular and WORM functionality
01088 
01089             SetFSType(pmCfg.clients[0].operationMode, rmPart.options);
01090             ostringstream msg;
01091             msg << "Operation mode set to " << ivd_FSTypeToText(pmCfg.clients[0].operationMode);
01092             log_NOTE_m(msg.str());
01093             // update record in rmdb
01094             rmPart.options = pmCfg.clients[0].operationMode;
01095             dbo_UpdatePartition updatePart(rmPart, *m_DBThread);
01096             updatePart.Execute();
01097         }
01098 
01099         return CORBA::string_dup(rmPart.partUUID.ToString().c_str());
01100     } ipc_CATCH_IVD_THROW_CORBA_m;
01101 }

Here is the call graph for this function:

void i_ResourceManager_i::UnRegisterPartition ( const char * a_partName )

Definition at line 1148 of file i_rm_impl.cpp.

References ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_queue, rm_Queue::m_SysState, and rm_SysState::UnRegisterPM().

01148                                                                     {
01149     log_FUNC_m(UnRegisterPartition);
01150     string pmID(a_partName);
01151     try {
01152         m_queue.m_SysState.UnRegisterPM(pmID);
01153     } ipc_CATCH_IVD_THROW_CORBA_m;
01154 }

Here is the call graph for this function:

void i_ResourceManager_i::SetPartitionStatus	(	i_BitFlag_t	a_flag,
		const char *	a_partName
	)

Definition at line 969 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, and rmdb_MAX_PARTITIONNAME.

00970                                                                      {
00971     log_FUNC_m(SetPartitionStatus);
00972     try {
00973         rm_String partName(rmdb_MAX_PARTITIONNAME);
00974         partName = a_partName;
00975         UInt32_t flag(a_flag);
00976         dbo_SetPartitionStatus part(flag, partName, *m_DBThread);
00977         part.Execute();
00978     } ipc_CATCH_IVD_THROW_CORBA_m;
00979 }

Here is the call graph for this function:

void i_ResourceManager_i::ClearPartitionStatus	(	i_BitFlag_t	a_flag,
		const char *	a_partName
	)

Definition at line 982 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, and rmdb_MAX_PARTITIONNAME.

00983                                                                        {
00984     log_FUNC_m(ClearPartitionStatus);
00985     try {
00986         rm_String partName(rmdb_MAX_PARTITIONNAME);
00987         partName = a_partName;
00988         UInt32_t flag(a_flag);
00989         dbo_ClearPartitionStatus part(flag, partName, *m_DBThread);
00990         part.Execute();
00991     } ipc_CATCH_IVD_THROW_CORBA_m;
00992 }

Here is the call graph for this function:

i_JobID_t i_ResourceManager_i::GetNewJobID ( )

Definition at line 1157 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, and m_jobIdGen.

01157                                            {
01158     log_FUNC_m(GetNewJobID);
01159 
01160     try {
01161         UInt64_t newJobId;
01162         dbo_NewJobIdGen idGen(m_jobIdGen, newJobId, *m_DBThread);
01163         idGen.Execute();
01164         return newJobId;
01165     } ipc_CATCH_IVD_THROW_CORBA_m;
01166 
01167 }

Here is the call graph for this function:

void i_ResourceManager_i::AddColMediaVol	(	const i_ColMediaVol_t &	a_colMediaVol,
		CORBA::ULong	a_flags
	)

Definition at line 795 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_A_m, m_DBThread, i_ColMediaVol_t::mediaKey, i_ColMediaVol_t::medVolNr, and i_ColMediaVol_t::minColId.

00795                                                                                                  {
00796     log_FUNC_A_m(AddColMediaVol, "minColId: " << a_colMediaVol.minColId
00797                            << " medium key: " << a_colMediaVol.mediaKey
00798                            << " volume: " << a_colMediaVol.medVolNr
00799                            << " flags: " << a_flags);
00800     try {
00801         dbo_CheckAndAddColMediaVol mc(a_colMediaVol, a_flags, *m_DBThread);
00802         mc.Execute();
00803     } ipc_CATCH_IVD_THROW_CORBA_m;
00804 }

Here is the call graph for this function:

void i_ResourceManager_i::AddMajorCol ( const i_MajorCol_t & a_majorCol )

Definition at line 806 of file i_rm_impl.cpp.

References cmn_Num2Str(), rm_DBOperation::Execute(), i_MajorCol_t::flags, ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_A_m, log_WriteEvent(), m_DBThread, i_MajorCol_t::majColId, i_MajorCol_t::majColSize, and i_MajorCol_t::partUUID.

00806                                                                     {
00807     log_FUNC_A_m(AddMajorCol, "majColId: " << a_majorCol.majColId
00808                            << " size: " << a_majorCol.majColSize
00809                            << " partUUID: " << a_majorCol.partUUID
00810                            << " flags: " << a_majorCol.flags);
00811     try {
00812         dbo_AddMajorCol mc(a_majorCol, *m_DBThread);
00813         mc.Execute();
00814         ostringstream sstr;
00815         sstr << "Collocation group added. Max size: " << a_majorCol.majColSize << "MB.";
00816         log_WriteEvent(sstr.str(), "", 0, cmn_Num2Str(a_majorCol.majColId));
00817     } ipc_CATCH_IVD_THROW_CORBA_m;
00818 }

Here is the call graph for this function:

void i_ResourceManager_i::AddLibrary ( i_Library_t & a_library )

Definition at line 1185 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogLibrary(), and m_DBThread.

01185                                                            {
01186     log_FUNC_m(AddLibrary);
01187 
01188     try {
01189         log_DBG_m(dbg_LOW,"Adding Library" << endl << ipc_Log::LogLibrary(a_library));
01190 
01191         dbo_AddLibrary lib(a_library, *m_DBThread);
01192         lib.Execute();
01193 
01194     } ipc_CATCH_IVD_THROW_CORBA_m;
01195 }

Here is the call graph for this function:

void i_ResourceManager_i::AddDrive ( i_Drive_t & a_drive )

Definition at line 1198 of file i_rm_impl.cpp.

References dbg_DETAIL, dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, ipc_EXEC_m, i_Drive_t::libraryName, log_DBG_m, log_ERR_m, log_FUNC_m, ipc_Log::LogDrive(), m_DBThread, and ipc_Corba::ResolveLA().

01198                                                      {
01199     log_FUNC_m(AddDrive);
01200 
01201     try {
01202         log_DBG_m(dbg_LOW,"Adding Drive" << endl << ipc_Log::LogDrive(a_drive));
01203 
01204         dbo_AddDrive drv(a_drive, *m_DBThread);
01205         drv.Execute();
01206 
01207         // call LA for this drive for Inventory
01208         string libName(a_drive.libraryName);
01209         if ( libName.size() != 0 ) {
01210             i_Library_t_var iL(new i_Library_t);
01211             dbo_SelectLibrary sl(libName, iL, *m_DBThread);
01212             sl.Execute();
01213 
01214             try {
01215                 string lHost(iL->host);
01216 
01217                 ipc_EXEC_m (
01218                     CORBA::Object_var obj = ipc_Corba::ResolveLA(lHost, libName, false);
01219                     i_LibraryAgent_var la = i_LibraryAgent::_narrow(obj);
01220 
01221                     log_DBG_m(dbg_DETAIL,"Calling Inventory on LA:" << libName);
01222 
01223                     la->Inventory(false);
01224                 );
01225             }
01226             catch (ivd_Error ) {
01227                 log_ERR_m("Could not start Inventory on LA:" << libName);
01228             }
01229         }
01230 
01231     } ipc_CATCH_IVD_THROW_CORBA_m;
01232 }

Here is the call graph for this function:

void i_ResourceManager_i::AddDriveHost ( i_DriveHost_t & a_driveHost )

Definition at line 1235 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogDriveHost(), and m_DBThread.

01235                                                                  {
01236     log_FUNC_m(AddDriveHost);
01237     try {
01238         log_DBG_m(dbg_LOW,"Adding DriveHost" << endl << ipc_Log::LogDriveHost(a_driveHost));
01239 
01240         dbo_AddDriveHost dh(a_driveHost, *m_DBThread);
01241         dh.Execute();
01242 
01243     } ipc_CATCH_IVD_THROW_CORBA_m;
01244 }

Here is the call graph for this function:

void i_ResourceManager_i::AddDiskSubsys ( i_DiskSubsys_t & a_dss )

Definition at line 1247 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogDSS(), and m_DBThread.

01247                                                              {
01248     log_FUNC_m(AddDiskSubsys);
01249     try {
01250         log_DBG_m(dbg_LOW,"Adding DiskSubSystem" << endl << ipc_Log::LogDSS(a_dss));
01251 
01252         dbo_AddDiskSubsys dss(a_dss, *m_DBThread);
01253         dss.Execute();
01254 
01255     } ipc_CATCH_IVD_THROW_CORBA_m;
01256 }

Here is the call graph for this function:

void i_ResourceManager_i::AddSlot ( i_Slot_t & a_slot )

Definition at line 1259 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogSlot(), and m_DBThread.

01259                                                   {
01260     log_FUNC_m(AddSlot);
01261     try {
01262         log_DBG_m(dbg_LOW,"Adding Slot" << endl << ipc_Log::LogSlot(a_slot));
01263 
01264         dbo_AddSlot slot(a_slot, *m_DBThread);
01265         slot.Execute();
01266 
01267     } ipc_CATCH_IVD_THROW_CORBA_m;
01268 }

Here is the call graph for this function:

void i_ResourceManager_i::AddMediaPool ( i_MediaPool_t & a_mediaPool )

Definition at line 1271 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogMediaPool(), and m_DBThread.

01271                                                                  {
01272     log_FUNC_m(AddMediaPool);
01273     try {
01274         log_DBG_m(dbg_LOW,"Adding MediaPool" << endl << ipc_Log::LogMediaPool(a_mediaPool));
01275 
01276         dbo_AddMediaPool mp(a_mediaPool, *m_DBThread);
01277         mp.Execute();
01278 
01279     } ipc_CATCH_IVD_THROW_CORBA_m;
01280 }

Here is the call graph for this function:

void i_ResourceManager_i::AddMedium ( i_Medium_t & a_medium )

Definition at line 1283 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogMedium(), and m_DBThread.

01283                                                         {
01284     log_FUNC_m(AddMedium);
01285     try {
01286         log_DBG_m(dbg_LOW,"Adding Medium" << endl << ipc_Log::LogMedium(a_medium));
01287 
01288         dbo_AddMedium medium(a_medium, *m_DBThread);
01289         medium.Execute();
01290 
01291     } ipc_CATCH_IVD_THROW_CORBA_m;
01292 }

Here is the call graph for this function:

void i_ResourceManager_i::AddMediumVol ( i_MediumVol_t & a_mediumVol )

Definition at line 1295 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogMediumVol(), and m_DBThread.

01295                                                                  {
01296     log_FUNC_m(AddMediumVol);
01297     try {
01298         log_DBG_m(dbg_LOW,"Adding MediumVolume" << endl << ipc_Log::LogMediumVol(a_mediumVol));
01299 
01300         dbo_AddMediumVol mv(a_mediumVol, *m_DBThread);
01301         mv.Execute();
01302 
01303     } ipc_CATCH_IVD_THROW_CORBA_m;
01304 }

Here is the call graph for this function:

void i_ResourceManager_i::RemoveLibrary ( const char * a_libraryName )

Definition at line 1307 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

01307                                                                  {
01308     log_FUNC_m(RemoveLibrary);
01309     try {
01310 
01311         dbo_RemoveLibrary lib(a_libraryName, *m_DBThread);
01312         lib.Execute();
01313 
01314     } ipc_CATCH_IVD_THROW_CORBA_m;
01315 }

Here is the call graph for this function:

void i_ResourceManager_i::RemoveDrive ( const char * a_driveName )

Definition at line 1318 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

01318                                                              {
01319     log_FUNC_m(RemoveDrive);
01320     try {
01321 
01322         dbo_RemoveDrive drv(a_driveName, *m_DBThread);
01323         drv.Execute();
01324 
01325     } ipc_CATCH_IVD_THROW_CORBA_m;
01326 }

Here is the call graph for this function:

void i_ResourceManager_i::RemoveDriveHost	(	const char *	a_driveName,
		const char *	a_host
	)

Definition at line 1329 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

01330                                                                 {
01331     log_FUNC_m(RemoveDriveHost);
01332     try {
01333 
01334         dbo_RemoveDriveHost dh(a_driveName, a_host, *m_DBThread);
01335         dh.Execute();
01336 
01337     } ipc_CATCH_IVD_THROW_CORBA_m;
01338 }

Here is the call graph for this function:

void i_ResourceManager_i::RemoveDSS ( const char * a_dssName )

Definition at line 1341 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01341                                                          {
01342     log_FUNC_m(RemoveDSS);
01343     try {
01344         log_DBG_m(dbg_LOW,"Removing DSS: " << a_dssName);
01345 
01346         dbo_RemoveDiskSubsys dss(a_dssName, *m_DBThread);
01347         dss.Execute();
01348 
01349     } ipc_CATCH_IVD_THROW_CORBA_m;
01350 }

Here is the call graph for this function:

void i_ResourceManager_i::RemoveSlot	(	const char *	a_slotAddr,
		const char *	a_libraryName,
		i_Type_t	a_slotType
	)

Definition at line 1353 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01355                                                                 {
01356     log_FUNC_m(RemoveSlot);
01357     try {
01358         log_DBG_m(dbg_LOW,  "Removing Slot:slotAddr " << a_slotAddr <<
01359                             " LibraryName" << a_libraryName );
01360 
01361         dbo_RemoveSlot slot(a_slotAddr, a_libraryName, a_slotType, *m_DBThread);
01362         slot.Execute();
01363 
01364     } ipc_CATCH_IVD_THROW_CORBA_m;
01365 }

Here is the call graph for this function:

void i_ResourceManager_i::RemoveMediaPool ( const char * a_mediaPoolName )

Definition at line 1368 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01368                                                                      {
01369     log_FUNC_m(RemoveMediaPool);
01370     try {
01371         log_DBG_m(dbg_LOW,"Removing MediaPool: " << a_mediaPoolName);
01372 
01373         dbo_RemoveMediaPool mp(a_mediaPoolName, *m_DBThread);
01374         mp.Execute();
01375 
01376     } ipc_CATCH_IVD_THROW_CORBA_m;
01377 }

Here is the call graph for this function:

void i_ResourceManager_i::RemoveMedium ( const char * a_mediumBarcode )

Definition at line 1380 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01380                                                                   {
01381     log_FUNC_m(RemoveMedium);
01382     try {
01383         log_DBG_m(dbg_LOW,"Removing Medium: " << a_mediumBarcode);
01384 
01385         dbo_RemoveMedium medium(a_mediumBarcode, *m_DBThread);
01386         medium.Execute();
01387 
01388     } ipc_CATCH_IVD_THROW_CORBA_m;
01389 }

Here is the call graph for this function:

void i_ResourceManager_i::RemoveMediumVol	(	const char *	a_mediumBarcode,
		i_Index_t	a_mediaVolNr
	)

Definition at line 1392 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01393                                                                   {
01394     log_FUNC_m(RemoveMediumVol);
01395     try {
01396         log_DBG_m(dbg_LOW,  "Removing MediumVol: " << a_mediumVolNr <<
01397                             " of medium:" << a_mediumBarcode );
01398 
01399         dbo_RemoveMediumVol mv(a_mediumBarcode, a_mediumVolNr, *m_DBThread);
01400         mv.Execute();
01401 
01402     } ipc_CATCH_IVD_THROW_CORBA_m;
01403 }

Here is the call graph for this function:

void i_ResourceManager_i::RemoveColIDs ( const char * a_partUUID )

Definition at line 1405 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01405                                                              {
01406     log_FUNC_m(RemoveColIDs);
01407     try {
01408         log_DBG_m(dbg_LOW,  "Removing ColIDs of partition: " << a_partUUID);
01409         dbo_RemoveColIDs rcd(a_partUUID, *m_DBThread);
01410         rcd.Execute();
01411     } ipc_CATCH_IVD_THROW_CORBA_m;
01412 }

Here is the call graph for this function:

void i_ResourceManager_i::UpdateLibrary ( const i_Library_t & a_library )

Definition at line 1414 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogLibrary(), and m_DBThread.

01414                                                                     {
01415     log_FUNC_m(UpdateLibrary);
01416     log_DBG_m(dbg_LOW,"Updating Library" << endl << ipc_Log::LogLibrary(a_library));
01417     try {
01418 
01419         dbo_UpdateLibrary lib(a_library, *m_DBThread);
01420         lib.Execute();
01421 
01422     } ipc_CATCH_IVD_THROW_CORBA_m;
01423 }

Here is the call graph for this function:

void i_ResourceManager_i::UpdateDrive ( const i_Drive_t & a_drive )

Definition at line 1426 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogDrive(), and m_DBThread.

01426                                                               {
01427     log_FUNC_m(UpdateDrive);
01428     log_DBG_m(dbg_LOW,"Updating Drive" << endl << ipc_Log::LogDrive(a_drive));
01429     try {
01430 
01431         dbo_UpdateDrive drv(a_drive, *m_DBThread);
01432         drv.Execute();
01433 
01434     } ipc_CATCH_IVD_THROW_CORBA_m;
01435 }

Here is the call graph for this function:

void i_ResourceManager_i::UpdateDriveHost ( const i_DriveHost_t & a_driveHost )

Definition at line 1438 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogDriveHost(), and m_DBThread.

01438                                                                           {
01439     log_FUNC_m(UpdateDriveHost);
01440     try {
01441         log_DBG_m(dbg_LOW,"Updating DriveHost" << endl << ipc_Log::LogDriveHost(a_driveHost));
01442 
01443         dbo_UpdateDriveHost dh(a_driveHost, *m_DBThread);
01444         dh.Execute();
01445 
01446     } ipc_CATCH_IVD_THROW_CORBA_m;
01447 }

Here is the call graph for this function:

void i_ResourceManager_i::UpdateDiskSubsys ( const i_DiskSubsys_t & a_dss )

Definition at line 1450 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogDSS(), and m_DBThread.

01450                                                                       {
01451     log_FUNC_m(UpdateDiskSubsys);
01452     try {
01453         log_DBG_m(dbg_LOW,"Updating DiskSubSystem" << endl << ipc_Log::LogDSS(a_dss));
01454 
01455         dbo_UpdateDiskSubsys dss(a_dss, *m_DBThread);
01456         dss.Execute();
01457     } ipc_CATCH_IVD_THROW_CORBA_m;
01458 }

Here is the call graph for this function:

void i_ResourceManager_i::UpdateSlot ( const i_Slot_t & a_slot )

Definition at line 1461 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogSlot(), and m_DBThread.

01461                                                            {
01462     log_FUNC_m(UpdateSlot);
01463     try {
01464         log_DBG_m(dbg_LOW,"Updating Slot" << endl << ipc_Log::LogSlot(a_slot));
01465 
01466         dbo_UpdateSlot slot(a_slot, *m_DBThread);
01467         slot.Execute();
01468     } ipc_CATCH_IVD_THROW_CORBA_m;
01469 }

Here is the call graph for this function:

void i_ResourceManager_i::UpdateMediaPool ( const i_MediaPool_t & a_mediaPool )

Definition at line 1472 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogMediaPool(), and m_DBThread.

01472                                                                           {
01473     log_FUNC_m(UpdateMediaPool);
01474     try {
01475         log_DBG_m(dbg_LOW,"Update MediaPool" << endl << ipc_Log::LogMediaPool(a_mediaPool));
01476 
01477         dbo_UpdateMediaPool mp(a_mediaPool, *m_DBThread);
01478         mp.Execute();
01479 
01480     } ipc_CATCH_IVD_THROW_CORBA_m;
01481 }

Here is the call graph for this function:

void i_ResourceManager_i::UpdateMedium ( const i_Medium_t & a_medium )

Definition at line 1484 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogMedium(), and m_DBThread.

01484                                                                  {
01485     log_FUNC_m(UpdateMedium);
01486     try {
01487         log_DBG_m(dbg_LOW,"Update Medium" << endl << ipc_Log::LogMedium(a_medium));
01488 
01489         dbo_UpdateMedium medium(a_medium, *m_DBThread);
01490         medium.Execute();
01491 
01492     } ipc_CATCH_IVD_THROW_CORBA_m;
01493 }

Here is the call graph for this function:

void i_ResourceManager_i::UpdateMediumVol ( const i_MediumVol_t & a_mediumVol )

Definition at line 1496 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogMediumVol(), m_DBThread, i_MediumVol_t::mediumBarcode, i_MediumVol_t::medVolNr, rmdb_MEDVOL_EMPTY, and i_MediumVol_t::status.

01496                                                                           {
01497     log_FUNC_m(UpdateMediumVol);
01498     try {
01499         log_DBG_m(dbg_LOW,"Update MediumVolume" << endl << ipc_Log::LogMediumVol(a_mediumVol));
01500 
01501         dbo_UpdateMediumVol mv(a_mediumVol, *m_DBThread);
01502         mv.Execute();
01503 
01504         if (a_mediumVol.status == rmdb_MEDVOL_EMPTY) {
01505             log_DBG_m(dbg_LOW, "Removing medium " << a_mediumVol.mediumBarcode
01506                 << ", volume " << a_mediumVol.medVolNr
01507                 << " from ColMediaVol.");
01508             dbo_RemoveColMediaVol cmv(string(a_mediumVol.mediumBarcode), a_mediumVol.medVolNr, *m_DBThread);
01509             cmv.Execute();
01510         }
01511 
01512     } ipc_CATCH_IVD_THROW_CORBA_m;
01513 }

Here is the call graph for this function:

void i_ResourceManager_i::UpdateMajorCol ( const i_MajorCol_t & a_majorCol )

Definition at line 842 of file i_rm_impl.cpp.

References cmn_Num2Str(), dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, log_WriteEvent(), m_DBThread, i_MajorCol_t::majColId, i_MajorCol_t::majColSize, and UseNewResource().

00842                                                                        {
00843     log_FUNC_m(UpdateMajorCol);
00844     try {
00845         log_DBG_m(dbg_LOW, "Updating MajorCol: " << a_majorCol.majColId << endl);
00846         dbo_UpdateMajorCol mc(a_majorCol, *m_DBThread);
00847         mc.Execute();
00848         ostringstream sstr;
00849         sstr << "Collocation group size updated: " << a_majorCol.majColSize << "MB.";
00850         log_WriteEvent(sstr.str(), "", 0, cmn_Num2Str(a_majorCol.majColId));
00851         UseNewResource();
00852     } ipc_CATCH_IVD_THROW_CORBA_m;
00853 }

Here is the call graph for this function:

void i_ResourceManager_i::UpdateDataSize	(	i_DBKey_t	a_mediumKey,
		i_DBKey_t	a_medvolNum,
		i_VolSize_t	a_totalSize,
		i_VolSize_t	a_reorgSize
	)

Definition at line 1516 of file i_rm_impl.cpp.

References dbg_NORM, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01519                                                                     {
01520     log_FUNC_m(UpdateDataSize);
01521     try {
01522         log_DBG_m(dbg_NORM, "a_mediumKey" << a_mediumKey <<
01523                             ", a_medVolNum" << a_medVolNum <<
01524                             ", a_totalSize" << a_totalSize <<
01525                             ", a_validSize" << a_validSize);
01526         dbo_UpdateDataSize ds(  a_mediumKey,
01527                                 a_medVolNum,
01528                                 a_totalSize,
01529                                 a_validSize,
01530                                 *m_DBThread);
01531         ds.Execute();
01532 
01533     } ipc_CATCH_IVD_THROW_CORBA_m;
01534 }

Here is the call graph for this function:

i_Library_t * i_ResourceManager_i::SelectLibrary ( const char * a_libraryName )

Definition at line 1537 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01537                                                                          {
01538     log_FUNC_m(SelectLibrary);
01539     try {
01540         log_DBG_m(dbg_LOW,"Select Library:  " << a_libraryName);
01541         i_Library_t* i_lib = new i_Library_t;
01542 
01543         dbo_SelectLibrary lib(a_libraryName, *i_lib, *m_DBThread);
01544         lib.Execute();
01545         return i_lib;
01546 
01547     } ipc_CATCH_IVD_THROW_CORBA_m;
01548 }

Here is the call graph for this function:

i_LibrarySeq_t * i_ResourceManager_i::SelectAllLibraries ( )

Definition at line 1551 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01551                                                         {
01552     log_FUNC_m(SelectAllLibraries);
01553 
01554     try {
01555         log_DBG_m(dbg_LOW,"Select ALL Library ");
01556         i_LibrarySeq_t* iLibSeq = new i_LibrarySeq_t;
01557         dbo_SelectAllLibraries lib(*iLibSeq, *m_DBThread);
01558         lib.Execute();
01559         return iLibSeq;
01560 
01561     } ipc_CATCH_IVD_THROW_CORBA_m;
01562 }

Here is the call graph for this function:

i_Drive_t * i_ResourceManager_i::SelectDrive ( const char * a_driveName )

Definition at line 1580 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01580                                                                    {
01581     log_FUNC_m(SelectDrive);
01582 
01583     try {
01584         log_DBG_m(dbg_LOW,"Select Drive: " << a_driveName);
01585         i_Drive_t* i_drv = new i_Drive_t;
01586 
01587         dbo_SelectDrive drv(a_driveName, *i_drv, *m_DBThread);
01588         drv.Execute();
01589         return i_drv;
01590 
01591     } ipc_CATCH_IVD_THROW_CORBA_m;
01592 }

Here is the call graph for this function:

i_Drive_t * i_ResourceManager_i::SelectDriveByKey ( i_DBKey_t a_driveKey )

Definition at line 1565 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01565                                                                      {
01566     log_FUNC_m(SelectDriveByKey);
01567 
01568     try {
01569         log_DBG_m(dbg_LOW,"Select Drive: " << a_driveKey);
01570         i_Drive_t* i_drv = new i_Drive_t;
01571 
01572         dbo_SelectDriveByKey drv(a_driveKey, *i_drv, *m_DBThread);
01573         drv.Execute();
01574         return i_drv;
01575 
01576     } ipc_CATCH_IVD_THROW_CORBA_m;
01577 }

Here is the call graph for this function:

i_DriveSeq_t * i_ResourceManager_i::SelectAllDrives ( )

Definition at line 1595 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01595                                                    {
01596     log_FUNC_m(SelectAllDrive);
01597     try {
01598         i_DriveSeq_t* i_drvSeq = new i_DriveSeq_t;
01599         log_DBG_m(dbg_LOW,"Select AllDrive");
01600 
01601         dbo_SelectAllDrives drv(*i_drvSeq, *m_DBThread);
01602         drv.Execute();
01603 
01604         return i_drvSeq;
01605     } ipc_CATCH_IVD_THROW_CORBA_m;
01606 }

Here is the call graph for this function:

i_DriveHost_t * i_ResourceManager_i::SelectDriveHost	(	const char *	a_driveName,
		const char *	a_host
	)

Definition at line 1609 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01609                                                                                                {
01610     log_FUNC_m(SelectDriveHost);
01611 
01612     try {
01613         log_DBG_m(dbg_LOW,"Select DriveHost  " << a_driveName << "  " << a_host);
01614         i_DriveHost_t* i_dH = new i_DriveHost_t;
01615 
01616         dbo_SelectDriveHost dh(a_driveName, a_host, *i_dH, *m_DBThread);
01617         dh.Execute();
01618 
01619         return i_dH;
01620 
01621     } ipc_CATCH_IVD_THROW_CORBA_m;
01622 }

Here is the call graph for this function:

i_DriveHostSeq_t * i_ResourceManager_i::SelectAllDriveHosts ( )

Definition at line 1625 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01625                                                            {
01626     log_FUNC_m(SelectAllDriveHosts);
01627     try {
01628         i_DriveHostSeq_t* i_dhSeq = new i_DriveHostSeq_t;
01629         log_DBG_m(dbg_LOW,"Select AllDriveHosts");
01630 
01631         dbo_SelectAllDriveHosts dh(*i_dhSeq, *m_DBThread);
01632         dh.Execute();
01633 
01634         return i_dhSeq;
01635     } ipc_CATCH_IVD_THROW_CORBA_m;
01636 }

Here is the call graph for this function:

i_DiskSubsys_t * i_ResourceManager_i::SelectDSS ( const char * a_dssName )

Definition at line 1639 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01639                                                                     {
01640     log_FUNC_m(SelectDSS);
01641 
01642     try {
01643         log_DBG_m(dbg_LOW,"Select DiskSubSystem  " << a_dssName );
01644         i_DiskSubsys_t* i_dss = new i_DiskSubsys_t;
01645 
01646         dbo_SelectDiskSubsys dss(a_dssName, *i_dss, *m_DBThread);
01647         dss.Execute();
01648 
01649         return i_dss;
01650 
01651     } ipc_CATCH_IVD_THROW_CORBA_m;
01652 }

Here is the call graph for this function:

i_DssSeq_t * i_ResourceManager_i::SelectAllDSS ( )

Definition at line 1655 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01655                                               {
01656     log_FUNC_m(SelectAllDSS);
01657     try {
01658         i_DssSeq_t* iDssSeq = new i_DssSeq_t;
01659         log_DBG_m(dbg_LOW,"Select AllDss");
01660 
01661         dbo_SelectAllDiskSubsys dss(*iDssSeq, *m_DBThread);
01662         dss.Execute();
01663 
01664         return iDssSeq;
01665     } ipc_CATCH_IVD_THROW_CORBA_m;
01666 }

Here is the call graph for this function:

i_Slot_t * i_ResourceManager_i::SelectSlot	(	const char *	a_slotAddr,
		const char *	a_libraryName,
		i_Type_t	a_slotType
	)

Definition at line 1669 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01669                                                                                                                 {
01670     log_FUNC_m(SelectSlot);
01671 
01672     try {
01673         log_DBG_m(dbg_LOW,"Select Slot  " << a_slotAddr << " " << a_libraryName << " " << a_slotType);
01674         i_Slot_t* i_s = new i_Slot_t;
01675 
01676         dbo_SelectSlot slot(a_slotAddr, a_libraryName, a_slotType, *i_s, *m_DBThread);
01677         slot.Execute();
01678 
01679         return i_s;
01680 
01681     } ipc_CATCH_IVD_THROW_CORBA_m;
01682 }

Here is the call graph for this function:

i_SlotSeq_t * i_ResourceManager_i::SelectAllSlots ( )

Definition at line 1685 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01685                                                  {
01686     log_FUNC_m(SelectAllSlots);
01687 
01688     try {
01689         i_SlotSeq_t* iSlotSeq = new i_SlotSeq_t;
01690         log_DBG_m(dbg_LOW,"Select All Slots");
01691 
01692         dbo_SelectAllSlots slot(*iSlotSeq, *m_DBThread);
01693         slot.Execute();
01694 
01695         return iSlotSeq;
01696     } ipc_CATCH_IVD_THROW_CORBA_m;
01697 }

Here is the call graph for this function:

i_MajorColSeq_t * i_ResourceManager_i::SelectAllMajorCol ( )

Definition at line 820 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

00820                                                         {
00821     log_FUNC_m(SelectAllMajorCol);
00822     try {
00823         i_MajorColSeq_t* majorColList = new i_MajorColSeq_t;
00824         dbo_SelectAllMajorCol mcl (*majorColList, *m_DBThread);
00825         mcl.Execute();
00826         return majorColList;
00827     } ipc_CATCH_IVD_THROW_CORBA_m;
00828 }

Here is the call graph for this function:

i_MinorColSeq_t * i_ResourceManager_i::SelectAllMinorColByMajCol ( i_ColID_t a_majColId )

Definition at line 1988 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01988                                                                                     {
01989     log_FUNC_m(SelectAllMinorColbyMajCol);
01990 
01991     try {
01992         i_MinorColSeq_t* iMcSeq = new i_MinorColSeq_t;
01993         log_DBG_m(dbg_LOW,"Select All Minor collocations by majColId: " << a_majColId);
01994 
01995         dbo_SelectMinColByMajCol mc(a_majColId, *iMcSeq, *m_DBThread);
01996         mc.Execute();
01997         log_DBG_m(dbg_LOW,"length: " << iMcSeq->length());
01998         for (UInt32_t i(0); i < iMcSeq->length(); i++) {
01999             log_DBG_m(dbg_LOW,"iMcSeq: " << (*iMcSeq)[i].minColId
02000                                          << (*iMcSeq)[i].flags);
02001         }
02002         return iMcSeq;
02003     }ipc_CATCH_IVD_THROW_CORBA_m;
02004 }

Here is the call graph for this function:

i_MediaPool_t * i_ResourceManager_i::SelectMediaPool ( const char * a_mediaPoolName )

Definition at line 1700 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

Referenced by SelectMediaPoolbyUUID().

01700                                                                                {
01701     log_FUNC_m(SelectMediaPool);
01702 
01703     try {
01704         log_DBG_m(dbg_LOW,"Select MediaPool  " << a_mediaPoolName );
01705         i_MediaPool_t* i_mp = new i_MediaPool_t;
01706 
01707         dbo_SelectMediaPool mp(a_mediaPoolName, *i_mp, *m_DBThread);
01708         mp.Execute();
01709         return i_mp;
01710 
01711     } ipc_CATCH_IVD_THROW_CORBA_m;
01712 }

Here is the call graph for this function:

Here is the caller graph for this function:

i_MediaPool_t * i_ResourceManager_i::SelectMediaPoolbyUUID ( const char * a_mediaPoolUUID )

Definition at line 1715 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, m_DBThread, and SelectMediaPool().

01715                                                                                      {
01716     log_FUNC_m(SelectMediaPool);
01717 
01718     try {
01719         log_DBG_m(dbg_LOW,"Select MediaPool  " << a_mediaPoolUUID );
01720         i_MediaPool_t* i_mp = new i_MediaPool_t;
01721 
01722         dbo_SelectMediaPoolbyUUID mp(a_mediaPoolUUID, *i_mp, *m_DBThread);
01723         mp.Execute();
01724         return i_mp;
01725 
01726     } ipc_CATCH_IVD_THROW_CORBA_m;
01727 }

Here is the call graph for this function:

i_MediaPoolSeq_t * i_ResourceManager_i::SelectAllMediaPools ( )

Definition at line 1730 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01730                                                            {
01731     log_FUNC_m(SelectAllMediaPools);
01732 
01733     try {
01734         i_MediaPoolSeq_t* iMediaPoolSeq = new i_MediaPoolSeq_t;
01735         log_DBG_m(dbg_LOW,"Select All MediaPools");
01736 
01737         dbo_SelectAllMediaPool mp(*iMediaPoolSeq, *m_DBThread);
01738         mp.Execute();
01739 
01740         return iMediaPoolSeq;
01741     } ipc_CATCH_IVD_THROW_CORBA_m;
01742 }

Here is the call graph for this function:

i_Medium_t * i_ResourceManager_i::SelectMedium ( const char * a_mediumBarcode )

Definition at line 1745 of file i_rm_impl.cpp.

References dbg_DETAIL, dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogMedium(), and m_DBThread.

Referenced by SelectMediumByDrive().

01745                                                                          {
01746     log_FUNC_m(SelectMedium);
01747 
01748     try {
01749         log_DBG_m(dbg_LOW,"Select Medium  " << a_mediumBarcode );
01750         i_Medium_t* i_m = new i_Medium_t;
01751         dbo_SelectMedium medium(a_mediumBarcode, *i_m, *m_DBThread);
01752         medium.Execute();
01753 
01754         log_DBG_m(dbg_DETAIL,"Selected Medium:" << endl <<
01755                                 ipc_Log::LogMedium(*i_m) );
01756         return i_m;
01757 
01758     } ipc_CATCH_IVD_THROW_CORBA_m;
01759 }

Here is the call graph for this function:

Here is the caller graph for this function:

i_Medium_t * i_ResourceManager_i::SelectMediumByKey ( i_DBKey_t a_mediumKey )

Definition at line 1761 of file i_rm_impl.cpp.

References dbg_DETAIL, dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogMedium(), and m_DBThread.

01761                                                                         {
01762     log_FUNC_m(SelectMediumByKey);
01763 
01764     try {
01765         log_DBG_m(dbg_LOW,"Select Medium  " << a_mediumKey );
01766         i_Medium_t* i_m = new i_Medium_t;
01767         dbo_SelectMediumByKey medium(a_mediumKey, *i_m, *m_DBThread);
01768         medium.Execute();
01769 
01770         log_DBG_m(dbg_DETAIL,"Selected Medium:" << endl <<
01771                                 ipc_Log::LogMedium(*i_m) );
01772         return i_m;
01773 
01774     } ipc_CATCH_IVD_THROW_CORBA_m;
01775 }

Here is the call graph for this function:

i_Medium_t * i_ResourceManager_i::SelectMediumByDrive ( const char * a_driveName )

Definition at line 1778 of file i_rm_impl.cpp.

References dbg_DETAIL, dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, ipc_Log::LogMedium(), m_DBThread, and SelectMedium().

01778                                                                             {
01779     log_FUNC_m(SelectMedium);
01780 
01781     try {
01782         log_DBG_m(dbg_LOW,"Select Medium by Drive " << a_driveName );
01783         i_Medium_t* i_m = new i_Medium_t;
01784         dbo_SelectMediumByDrive medium(a_driveName, *i_m, *m_DBThread);
01785         medium.Execute();
01786 
01787         log_DBG_m(dbg_DETAIL,"Selected Medium:" << endl <<
01788                                 ipc_Log::LogMedium(*i_m) );
01789         return i_m;
01790 
01791     } ipc_CATCH_IVD_THROW_CORBA_m;
01792 }

Here is the call graph for this function:

i_MediumSeq_t * i_ResourceManager_i::SelectAllMedia ( )

Definition at line 1795 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01795                                                    {
01796     log_FUNC_m(SelectAllMedia);
01797 
01798     try {
01799         i_MediumSeq_t* iMediumSeq = new i_MediumSeq_t;
01800         log_DBG_m(dbg_LOW,"Select All Mediums");
01801 
01802         dbo_SelectAllMedium medium(*iMediumSeq, *m_DBThread);
01803         medium.Execute();
01804 
01805         return iMediumSeq;
01806     } ipc_CATCH_IVD_THROW_CORBA_m;
01807 }

Here is the call graph for this function:

i_MediumVol_t * i_ResourceManager_i::SelectMediumVol	(	const char *	a_mediumBarcode,
		i_Index_t	a_mediumVolNr
	)

Definition at line 1810 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01810                                                                                                         {
01811     log_FUNC_m(SelectMediumVol);
01812 
01813     try {
01814         log_DBG_m(dbg_LOW,"Select MediumVolume:  " << a_mediumBarcode << " " << a_mediumVolNr);
01815         i_MediumVol_t* i_mv = new i_MediumVol_t;
01816 
01817         dbo_SelectMediumVol mv(a_mediumBarcode, a_mediumVolNr, *i_mv, *m_DBThread);
01818         mv.Execute();
01819         return i_mv;
01820 
01821     } ipc_CATCH_IVD_THROW_CORBA_m;
01822 }

Here is the call graph for this function:

i_MediumVol_t * i_ResourceManager_i::SelectMediumVolByKey	(	i_DBKey_t	a_mediumKey,
		i_Index_t	a_mediumVolNr
	)

Definition at line 1825 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01825                                                                                                        {
01826     log_FUNC_m(SelectMediumVolByKey);
01827 
01828     try {
01829         log_DBG_m(dbg_LOW,"Select MediumVolume:  " << a_mediumKey << " " << a_mediumVolNr);
01830         i_MediumVol_t* i_mv = new i_MediumVol_t;
01831 
01832         dbo_SelectMediumVolByKey mv(a_mediumKey, a_mediumVolNr, *i_mv, *m_DBThread);
01833         mv.Execute();
01834         return i_mv;
01835 
01836     } ipc_CATCH_IVD_THROW_CORBA_m;
01837 }

Here is the call graph for this function:

i_MediumVol_t * i_ResourceManager_i::SelectMediumVolByUUID ( const char * a_medVolUUID )

Definition at line 1840 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01840                                                                                   {
01841     log_FUNC_m(SelectMediumVolByUUID);
01842 
01843     try {
01844         log_DBG_m(dbg_LOW,"Select MediumVolume:  " << a_medVolUUID);
01845         i_MediumVol_t* i_mv = new i_MediumVol_t;
01846 
01847         dbo_SelectMediumVolByUUID mv(a_medVolUUID, *i_mv, *m_DBThread);
01848         mv.Execute();
01849         return i_mv;
01850 
01851     } ipc_CATCH_IVD_THROW_CORBA_m;
01852 }

Here is the call graph for this function:

i_MediumVolSeq_t * i_ResourceManager_i::SelectAllMediumVol ( )

Definition at line 1855 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

Referenced by SelectAllMediumVolByBarcode().

01855                                                           {
01856     log_FUNC_m(SelectAllMediumVol);
01857 
01858     try {
01859         i_MediumVolSeq_t* iMvSeq = new i_MediumVolSeq_t;
01860         log_DBG_m(dbg_LOW,"Select All MediumVol");
01861 
01862         dbo_SelectAllMediumVol mv(*iMvSeq, *m_DBThread);
01863         mv.Execute();
01864 
01865         return iMvSeq;
01866 
01867     } ipc_CATCH_IVD_THROW_CORBA_m;
01868 }

Here is the call graph for this function:

Here is the caller graph for this function:

i_ColMediaVolSeq_t * i_ResourceManager_i::SelectAllColVolumes ( )

Definition at line 1870 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

Referenced by SelectAllMinorCol().

01870                                                              {
01871     log_FUNC_m(SelectAllColVolumes);
01872 
01873     try {
01874         i_ColMediaVolSeq_t* iCmvSeq = new i_ColMediaVolSeq_t;
01875         log_DBG_m(dbg_LOW,"Select all collocation media volumes");
01876 
01877         dbo_SelectAllColVolumes cmv(*iCmvSeq, *m_DBThread);
01878         cmv.Execute();
01879 
01880         return iCmvSeq;
01881 
01882     } ipc_CATCH_IVD_THROW_CORBA_m;
01883 }

Here is the call graph for this function:

Here is the caller graph for this function:

i_MinorColSeq_t * i_ResourceManager_i::SelectAllMinorCol ( )

Definition at line 1885 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, m_DBThread, and SelectAllColVolumes().

01885                                                         {
01886     log_FUNC_m(SelectAllColVolumes);
01887 
01888     try {
01889         i_MinorColSeq_t* iMcsSeq = new i_MinorColSeq_t;
01890         log_DBG_m(dbg_LOW,"Select all minor collocation IDs");
01891 
01892         dbo_SelectAllMinorCol mc(*iMcsSeq, *m_DBThread);
01893         mc.Execute();
01894 
01895         return iMcsSeq;
01896 
01897     } ipc_CATCH_IVD_THROW_CORBA_m;
01898 }

Here is the call graph for this function:

i_MediumVolSeq_t * i_ResourceManager_i::SelectAllMediumVolByBarcode ( const char * a_mediumBarcode )

Definition at line 1901 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, m_DBThread, and SelectAllMediumVol().

01901                                                                                               {
01902     log_FUNC_m(SelectAllMediumVol);
01903 
01904     try {
01905         i_MediumVolSeq_t* iMvSeq = new i_MediumVolSeq_t;
01906         log_DBG_m(dbg_LOW,"Select All MediumVol by Barcode");
01907         string barcode(a_mediumBarcode);
01908         dbo_SelectAllMediumVolByBarcode mv(barcode, *iMvSeq, *m_DBThread);
01909         mv.Execute();
01910 
01911         return iMvSeq;
01912 
01913     } ipc_CATCH_IVD_THROW_CORBA_m;
01914 }

Here is the call graph for this function:

i_MediumSeqByVol_t * i_ResourceManager_i::SelectAllMediumVolByPart ( const char * a_partName )

Definition at line 1917 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01917                                                                                         {
01918 
01919     log_FUNC_m(SelectAllMediumVolByPart);
01920 
01921     try {
01922         string partName(a_partName);
01923         i_MediumSeqByVol_t* iMvSeq = new i_MediumSeqByVol_t;
01924         log_DBG_m(dbg_LOW,"Select All MediumVols By Partiton:" << partName);
01925 
01926         dbo_SelectAllMediumVolByPart mv(partName, false, *iMvSeq, *m_DBThread);
01927         mv.Execute();
01928 
01929         return iMvSeq;
01930 
01931     } ipc_CATCH_IVD_THROW_CORBA_m;
01932 }

Here is the call graph for this function:

i_MediumSeq_t * i_ResourceManager_i::SelectAllMediaByPart ( const char * a_partName )

Definition at line 1935 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01935                                                                               {
01936 
01937     log_FUNC_m(SelectAllMediaByPart);
01938 
01939     try {
01940         string partName(a_partName);
01941         i_MediumSeq_t* i_MediumSeq = new i_MediumSeq_t;
01942         log_DBG_m(dbg_LOW,"Select All Media By Partiton:" << partName);
01943 
01944         dbo_SelectAllMediaByPart medium(partName, *i_MediumSeq, *m_DBThread);
01945         medium.Execute();
01946 
01947         return i_MediumSeq;
01948 
01949     } ipc_CATCH_IVD_THROW_CORBA_m;
01950 }

Here is the call graph for this function:

CORBA::Boolean i_ResourceManager_i::IsSomeVolumeUsed ( const char * a_partName )

Definition at line 1953 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01953                                                                          {
01954         log_FUNC_m(IsSomeVolumeUsed);
01955 
01956     try {
01957         string partName(a_partName);
01958         bool isUsed(false);
01959 
01960         log_DBG_m(dbg_LOW,"Is some volume used for Partiton:" << partName);
01961 
01962         dbo_IsSomeVolumeUsed isvu(partName, isUsed, *m_DBThread);
01963         isvu.Execute();
01964 
01965         return isUsed;
01966 
01967     } ipc_CATCH_IVD_THROW_CORBA_m;
01968 }

Here is the call graph for this function:

i_MediumSeqByVol_t * i_ResourceManager_i::SelectAllUnrecoveredMedVol ( const char * a_partName )

Definition at line 1971 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

01971                                                                                           {
01972 
01973     log_FUNC_m(SelectAllUnrecoveredMedVol);
01974 
01975     try {
01976         string partName(a_partName);
01977         i_MediumSeqByVol_t* iMvSeq = new i_MediumSeqByVol_t;
01978         log_DBG_m(dbg_LOW,"Select All Unrecovered MediumVols By Partiton:" << partName);
01979 
01980         dbo_SelectAllMediumVolByPart mv(partName, true, *iMvSeq, *m_DBThread);
01981         mv.Execute();
01982 
01983         return iMvSeq;
01984 
01985     } ipc_CATCH_IVD_THROW_CORBA_m;
01986 }

Here is the call graph for this function:

i_MinorCol_t i_ResourceManager_i::SelectMinorCol ( i_ColID_t a_minColId )

Definition at line 2006 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

02006                                                                     {
02007     log_FUNC_m(SelectMinorCol);
02008 
02009     try {
02010         i_MinorCol_t minCol;
02011         dbo_SelectMinorCol mc(a_minColId, minCol, *m_DBThread);
02012         mc.Execute();
02013         return minCol;
02014     } ipc_CATCH_IVD_THROW_CORBA_m;
02015 }

Here is the call graph for this function:

void i_ResourceManager_i::AddMinorCol ( const i_MinorCol_t & a_minorCol )

Definition at line 831 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), i_MinorCol_t::flags, ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_A_m, m_DBThread, i_MinorCol_t::majColId, and i_MinorCol_t::minColId.

00831                                                                     {
00832     log_FUNC_A_m(AddMinorCol, "minColId: " << a_minorCol.minColId <<
00833                               ", majColId: " << a_minorCol.majColId <<
00834                               " flags: " << a_minorCol.flags);
00835     try {
00836         dbo_AddMinorCol mc(a_minorCol, *m_DBThread);
00837         mc.Execute();
00838 
00839     } ipc_CATCH_IVD_THROW_CORBA_m;
00840 }

Here is the call graph for this function:

void i_ResourceManager_i::SetRecoveryFlag ( const char * a_medVolId )

Definition at line 2017 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

02017                                                                 {
02018     log_FUNC_m(SetRecoveryFlag);
02019     try {
02020         string medVolId(a_medVolId);
02021         dbo_SetRecoveryFlag mv(medVolId, *m_DBThread);
02022         mv.Execute();
02023     } ipc_CATCH_IVD_THROW_CORBA_m;
02024 }

Here is the call graph for this function:

void i_ResourceManager_i::ClearRecoveryFlag ( const char * a_medVolId )

Definition at line 2027 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

02027                                                                   {
02028 
02029     log_FUNC_m(ClearRecoveryFlag);
02030     try {
02031         string medVolId(a_medVolId);
02032         dbo_ClearRecoveryFlag mv(medVolId, *m_DBThread);
02033         mv.Execute();
02034     } ipc_CATCH_IVD_THROW_CORBA_m;
02035 }

Here is the call graph for this function:

i_JobParamsSeq_t * i_ResourceManager_i::GetAllJobs ( )

Definition at line 2038 of file i_rm_impl.cpp.

References dbg_DETAIL, rm_Queue::GetAllJobs(), ipc_CATCH_IVD_THROW_CORBA_m, ipc_Init::JobParamsInit(), log_DBG_m, log_FUNC_m, and m_queue.

02038                                                   {
02039     log_FUNC_m(GetAllJobs);
02040 
02041     try {
02042 
02043         vector<rm_JobParams> rmJPVec;
02044         rmJPVec = m_queue.GetAllJobs();
02045 
02046         i_JobParamsSeq_t* iJPSeq = new i_JobParamsSeq_t;
02047 
02048         iJPSeq->length(rmJPVec.size());
02049         for (UInt32_t i = 0; i < rmJPVec.size(); i++) {
02050             ipc_Init::JobParamsInit((*iJPSeq)[i]);
02051             (*iJPSeq)[i].jobID          = rmJPVec[i].jobID;
02052             log_DBG_m(dbg_DETAIL,"" << endl <<
02053                 "(*iJPSeq)[i].jobPriority " <<   (*iJPSeq)[i].jobPriority    <<
02054                 "rmJPVec[i].jobPriority;=" << rmJPVec[i].jobPriority );
02055 
02056             (*iJPSeq)[i].jobPriority    = rmJPVec[i].jobPriority;
02057             (*iJPSeq)[i].priorityModifier = rmJPVec[i].priorityModifier;
02058             (*iJPSeq)[i].partName   = CORBA::string_dup(rmJPVec[i].partName.c_str());
02059             (*iJPSeq)[i].partUUID   = CORBA::string_dup(rmJPVec[i].partUUID.c_str());
02060             (*iJPSeq)[i].jobType    = rmJPVec[i].jobType;
02061             (*iJPSeq)[i].bufType    = rmJPVec[i].bufType;
02062             (*iJPSeq)[i].bufId      = rmJPVec[i].bufId;
02063             (*iJPSeq)[i].startTime  = rmJPVec[i].startTime;
02064             (*iJPSeq)[i].phase      = rmJPVec[i].phase;
02065         }
02066         return iJPSeq;
02067 
02068     } ipc_CATCH_IVD_THROW_CORBA_m;
02069 }

Here is the call graph for this function:

i_JobParamsSeq_t * i_ResourceManager_i::GetJob ( i_JobID_t a_jobID )

Definition at line 2072 of file i_rm_impl.cpp.

References dbg_DETAIL, rm_Queue::GetJob(), ie_JOBNOTFOUND, ipc_CATCH_IVD_THROW_CORBA_m, ivd_Error, ipc_Init::JobParamsInit(), log_DBG_m, log_FUNC_m, ipc_Log::LogJobParams(), and m_queue.

02072                                                                {
02073     log_FUNC_m(GetJob);
02074     try {
02075 
02076         vector<rm_JobParams> rmJPVec;
02077         rmJPVec = m_queue.GetJob(a_jobID);
02078 
02079         i_JobParamsSeq_t_var iJPSeq(new i_JobParamsSeq_t);
02080 
02081         if (rmJPVec.empty()) {
02082             log_DBG_m(dbg_DETAIL,"No Jobs with ID " << a_jobID << " in RM queue");
02083             throw ivd_Error(ie_JOBNOTFOUND,"No such job in Queue");
02084             iJPSeq->length(0);
02085             return iJPSeq._retn();
02086         } else {
02087             log_DBG_m(dbg_DETAIL,"Found " << rmJPVec.size() << " jobs in rm->queue");
02088             iJPSeq->length(rmJPVec.size());
02089             for (UInt32_t i = 0; i < rmJPVec.size(); i++) {
02090                 ipc_Init::JobParamsInit(iJPSeq[i]);
02091                 iJPSeq[i].jobID          = rmJPVec[i].jobID;
02092                 iJPSeq[i].jobPriority    = rmJPVec[i].jobPriority;
02093                 iJPSeq[i].priorityModifier    = rmJPVec[i].priorityModifier;
02094                 iJPSeq[i].partName   = CORBA::string_dup(rmJPVec[i].partName.c_str());
02095                 iJPSeq[i].partUUID   = CORBA::string_dup(rmJPVec[i].partUUID.c_str());
02096                 iJPSeq[i].jobType    = rmJPVec[i].jobType;
02097                 iJPSeq[i].bufType    = rmJPVec[i].bufType;
02098                 iJPSeq[i].bufId      = rmJPVec[i].bufId;
02099                 iJPSeq[i].startTime  = rmJPVec[i].startTime;
02100                 iJPSeq[i].phase      = rmJPVec[i].phase;
02101                 log_DBG_m(dbg_DETAIL, "JobParams:" << endl
02102                         << ipc_Log::LogJobParams(iJPSeq[i]));
02103             }
02104         }
02105         return iJPSeq._retn();
02106     } ipc_CATCH_IVD_THROW_CORBA_m;
02107 }

Here is the call graph for this function:

i_ResourceList_t * i_ResourceManager_i::GetJobResources ( i_JobID_t a_jobID )

Definition at line 2109 of file i_rm_impl.cpp.

References dbg_DETAIL, rm_Queue::GetJob(), ie_JOBNOTFOUND, ipc_CATCH_IVD_THROW_CORBA_m, ivd_Error, log_DBG_m, log_FUNC_m, ipc_Log::LogResources(), and m_queue.

02109                                                                         {
02110     log_FUNC_m(GetJobResources);
02111     try {
02112 
02113         vector<rm_JobParams> rmJPVec;
02114         rmJPVec = m_queue.GetJob(a_jobID);
02115 
02116         i_ResourceList_t_var iResourcesSeq(new i_ResourceList_t);
02117 
02118         if (rmJPVec.empty()) {
02119             log_DBG_m(dbg_DETAIL,"No Jobs with ID " << a_jobID << " in RM queue");
02120             throw ivd_Error(ie_JOBNOTFOUND,"No such job in Queue");
02121             iResourcesSeq->length(0);
02122             return iResourcesSeq._retn();
02123         } else {
02124             log_DBG_m(dbg_DETAIL,"Found " << rmJPVec.size() << " jobs in rm->queue");
02125 
02126             for (UInt32_t i = 0; i < rmJPVec.size(); i++) {
02127                 for (UInt32_t j = 0; j < rmJPVec[i].m_resources.size();j++) {
02128                     UInt32_t pos = iResourcesSeq->length();
02129                     iResourcesSeq->length(pos+1);
02130                     iResourcesSeq[pos] = rmJPVec[i].m_resources[j].Convert2Corba();
02131 
02132                     log_DBG_m(dbg_DETAIL, "JobResources:" << endl
02133                         << ipc_Log::LogResources(iResourcesSeq[pos]));
02134 
02135                 }
02136             }
02137         }
02138         return iResourcesSeq._retn();
02139     } ipc_CATCH_IVD_THROW_CORBA_m;
02140 }

Here is the call graph for this function:

void i_ResourceManager_i::StartLA ( const char * a_libName )

Definition at line 2143 of file i_rm_impl.cpp.

References ExecStartLA(), rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

02143                                                        {
02144     log_FUNC_m(StartLA);
02145 
02146     try{
02147         i_Library_t_var iLib(new i_Library_t);
02148         dbo_SelectLibrary sl(a_libName, iLib, *m_DBThread );
02149         sl.Execute();
02150         string lHost(iLib->host);
02151         ivd_LibraryType_e lType;
02152         lType = static_cast<ivd_LibraryType_e>(iLib->libraryType);
02153 
02154         ExecStartLA(a_libName, lHost, lType);
02155     }
02156     ipc_CATCH_IVD_THROW_CORBA_m;
02157 }

Here is the call graph for this function:

void i_ResourceManager_i::StopLA ( const char * a_libName )

Definition at line 2193 of file i_rm_impl.cpp.

References ExecStopLA(), rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, and m_DBThread.

02193                                                       {
02194     log_FUNC_m(StopLA);
02195     try {
02196 
02197         i_Library_t_var iLib(new i_Library_t);
02198         dbo_SelectLibrary sl(a_libName, iLib, *m_DBThread );
02199         sl.Execute();
02200 
02201         string lHost(iLib->host);
02202         ExecStopLA(a_libName, lHost);
02203 
02204     } ipc_CATCH_IVD_THROW_CORBA_m;
02205 }

Here is the call graph for this function:

void i_ResourceManager_i::ReconfigureLibrary ( const char * a_libName )

Definition at line 2224 of file i_rm_impl.cpp.

References dbg_DETAIL, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, m_DBThread, and ipc_Corba::ResolveLA().

02224                                                                   {
02225     log_FUNC_m(ReconfigureLibrary);
02226 
02227     try {
02228         i_Library_t_var iLib(new i_Library_t);
02229         dbo_SelectLibrary sl(a_libName, iLib, *m_DBThread );
02230         sl.Execute();
02231 
02232         string lHost;
02233         lHost = iLib->host;
02234 
02235         CORBA::Object_var obj = ipc_Corba::ResolveLA(lHost, a_libName);
02236         i_LibraryAgent_var la = i_LibraryAgent::_narrow(obj);
02237 
02238         log_DBG_m(dbg_DETAIL,"Reconfiguring LA: " << a_libName);
02239         la->Reconfigure(iLib);
02240 
02241     } ipc_CATCH_IVD_THROW_CORBA_m;
02242 }

Here is the call graph for this function:

void i_ResourceManager_i::SetPriorityModifier	(	i_JobID_t	a_jobID,
		CORBA::Long	a_modifier
	)

Definition at line 2317 of file i_rm_impl.cpp.

References rm_Queue::Activate(), dbg_DETAIL, ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, m_queue, and rm_Queue::ModifyPriority().

02317                                                                                      {
02318     log_FUNC_m(SetPriorityModifier);
02319     try {
02320 
02321         log_DBG_m(dbg_DETAIL,"Setting Priority mofifier for Job " << a_jobID << " to " << a_modifier);
02322 
02323         m_queue.ModifyPriority(a_jobID, a_modifier);
02324         m_queue.Activate();
02325 
02326     } ipc_CATCH_IVD_THROW_CORBA_m;
02327 
02328 }

Here is the call graph for this function:

void i_ResourceManager_i::SetPhase	(	i_JobID_t	a_jobID,
		i_Index_t	a_phase
	)

Definition at line 2331 of file i_rm_impl.cpp.

References ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_queue, and rm_Queue::SetPhase().

02331                                                                        {
02332     log_FUNC_m(SetPhase);
02333     try {
02334 
02335         m_queue.SetPhase(a_jobID, a_phase);
02336 
02337     } ipc_CATCH_IVD_THROW_CORBA_m;
02338 
02339 }

Here is the call graph for this function:

i_PoolInfoSeq_t * i_ResourceManager_i::PoolInfo ( const char * a_partName )

Definition at line 2342 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

02342                                                                      {
02343     log_FUNC_m(PoolInfo);
02344     try {
02345         log_DBG_m(dbg_LOW,"PoolInfo " << a_partName);
02346         string partName(a_partName);
02347         i_PoolInfoSeq_t_var i_pis(new i_PoolInfoSeq_t);
02348         dbo_PoolInfo pis(partName, i_pis, *m_DBThread);
02349         pis.Execute();
02350 
02351         return i_pis._retn();
02352     } ipc_CATCH_IVD_THROW_CORBA_m;
02353 }

Here is the call graph for this function:

void i_ResourceManager_i::SetReorgScan ( const char * a_partName )

Definition at line 2356 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

02356                                                              {
02357     log_FUNC_m(SetReorgScan);
02358     try {
02359         log_DBG_m(dbg_LOW,"a_partName " << a_partName);
02360         string partName(a_partName);
02361 
02362         dbo_SetReorgScan srs(partName, *m_DBThread);
02363         srs.Execute();
02364 
02365 
02366     } ipc_CATCH_IVD_THROW_CORBA_m;
02367 }

Here is the call graph for this function:

void i_ResourceManager_i::ClearReorgScan ( const char * a_partName )

Definition at line 2370 of file i_rm_impl.cpp.

References dbg_LOW, rm_DBOperation::Execute(), ipc_CATCH_IVD_THROW_CORBA_m, log_DBG_m, log_FUNC_m, and m_DBThread.

02370                                                                {
02371     log_FUNC_m(ClearReorgScan);
02372     try {
02373         log_DBG_m(dbg_LOW,"a_partName " << a_partName);
02374         string partName(a_partName);
02375 
02376         dbo_ClearReorgScan srs(partName, *m_DBThread);
02377         srs.Execute();
02378 
02379 
02380     } ipc_CATCH_IVD_THROW_CORBA_m;
02381 }

Here is the call graph for this function:

i_Status_t i_ResourceManager_i::Suspend ( void )

i_ResourceManager_i::Suspend() : Implements suspend database operation interface.

A RMDB suspend causes the IVD System to freeze until a Resume occures. All jobs remain in their current state, no new jobs are added. IVD commands that are database related are blocked. ivdjob -l will be blocked if there are pending jobs (not having a thread yet ).

Definition at line 2392 of file i_rm_impl.cpp.

References ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, and rm_DBThread::Suspend().

02392                                        {
02393     log_FUNC_m(Suspend);
02394     try {
02395         return (i_Status_t) m_DBThread->Suspend();
02396     } ipc_CATCH_IVD_THROW_CORBA_m;
02397 }

Here is the call graph for this function:

i_Status_t i_ResourceManager_i::Resume ( void )

i_ResourceManager_i::Resume() : Implements resume database operation interface.

Definition at line 2403 of file i_rm_impl.cpp.

References ipc_CATCH_IVD_THROW_CORBA_m, log_FUNC_m, m_DBThread, and rm_DBThread::Resume().

02403                                       {
02404     log_FUNC_m(Resume);
02405     try {
02406         return (i_Status_t) m_DBThread->Resume();
02407     } ipc_CATCH_IVD_THROW_CORBA_m;
02408 }

Here is the call graph for this function:

void i_ResourceManager_i::Remove ( ) [virtual]

Reimplemented from i_Component_i.

Definition at line 2302 of file i_rm_impl.cpp.

References ipc_EXEC_m, log_FUNC_m, i_Component_i::Remove(), and StopAllLA().

02302                                  {
02303     log_FUNC_m(Remove);
02304 
02305     // TODO: Do any cleanup necessary
02306     // Notify PMs...
02307 
02308     // Stop all Library agents
02309     StopAllLA();
02310 
02311     ipc_EXEC_m(
02312         i_Component_i::Remove();
02313     );
02314 }

Here is the call graph for this function:

void i_ResourceManager_i::ReleaseRecallResources ( const i_Resource_t & a_resources )

Definition at line 466 of file i_rm_impl.cpp.

References rm_DBOperation::Execute(), jt_RECALL, and m_DBThread.

Referenced by rm_Queue::AllocateRec().

00466                                                                                 {
00467     i_ResourceList_t resources;
00468     resources.length(1);
00469     resources[0] = a_resources;
00470     dbo_ReleaseResources relRes(resources, jt_RECALL, *m_DBThread);
00471     relRes.Execute();
00472 }

Here is the call graph for this function:

Here is the caller graph for this function:

void i_ResourceManager_i::StartAllLA ( )

Definition at line 2245 of file i_rm_impl.cpp.

References dbg_DETAIL, ExecStartLA(), rm_DBOperation::Execute(), ie_FATAL_ERROR, log_DBG_m, log_ERR_m, log_FUNC_m, lt_MANUAL, lt_SCSI, lt_UNKNOWN, and m_DBThread.

Referenced by i_ResourceManager_i().

02245                                      {
02246     log_FUNC_m(StartAllLA);
02247 
02248     i_LibrarySeq_t_var iLS(new i_LibrarySeq_t);
02249     dbo_SelectAllLibraries sAll(iLS, *m_DBThread);
02250     sAll.Execute();
02251 
02252     for (UInt32_t i = 0; i < iLS->length(); i++) {
02253         try {
02254             string lName(iLS[i].libraryName);
02255             string lHost(iLS[i].host);
02256 
02257             ivd_LibraryType_e lType;
02258             switch (iLS[i].libraryType) {
02259                 case(0):
02260                     lType = lt_UNKNOWN;
02261                     break;
02262                 case(1):
02263                     lType = lt_SCSI;
02264                     break;
02265                 case(2):
02266                     lType = lt_MANUAL;
02267                     break;
02268                 default:
02269                     throw ivd_InternalError(ie_FATAL_ERROR, "Conversion to ivd_LibraryType_e for unknown int");
02270             }
02271             log_DBG_m(dbg_DETAIL,"lHost:" << lHost);
02272 
02273             ExecStartLA(lName, lHost, lType);
02274         }
02275         catch (ivd_Error) {
02276             log_ERR_m("Could not start LA:" << iLS[i].libraryName);
02277         }
02278     }
02279 }

Here is the call graph for this function:

Here is the caller graph for this function:

void i_ResourceManager_i::StopAllLA ( )

Definition at line 2282 of file i_rm_impl.cpp.

References ExecStopLA(), rm_DBOperation::Execute(), log_ERR_m, log_FUNC_m, and m_DBThread.

Referenced by Remove().

02282                                     {
02283     log_FUNC_m(StopAllLA);
02284 
02285     i_LibrarySeq_t_var iLS(new i_LibrarySeq_t);
02286     dbo_SelectAllLibraries sAll(iLS, *m_DBThread);
02287     sAll.Execute();
02288 
02289     for (UInt32_t i = 0; i < iLS->length(); i++) {
02290         try {
02291             string lName(iLS[i].libraryName);
02292             string lHost(iLS[i].host);
02293             ExecStopLA(lName, lHost);
02294         }
02295         catch (ivd_Error) {
02296             log_ERR_m("Could not stop LA:" << iLS[i].libraryName);
02297         }
02298     }
02299 }

Here is the call graph for this function:

Here is the caller graph for this function:

void i_ResourceManager_i::ExecStartLA	(	string	a_libName,
		string	a_host,
		ivd_LibraryType_e	a_lType
	)

Definition at line 2160 of file i_rm_impl.cpp.

References dbg_DETAIL, dbg_LOW, i_IVDLAM, i_IVDLAS, ipc_EXEC_m, log_DBG_m, log_ERR_m, log_FUNC_m, lt_MANUAL, lt_SCSI, and ipc_Corba::ResolveSvc().

Referenced by StartAllLA(), and StartLA().

02161                                    {
02162     log_FUNC_m(ExecStartLA);
02163 
02164     log_DBG_m(dbg_LOW,"Starting LA:" << a_libName << " on:" << a_host);
02165 
02166     i_StringList_t argSeq;
02167     argSeq.length(1);
02168     argSeq[0] = CORBA::string_dup(a_libName.c_str());
02169 
02170     i_Service_var svc;
02171 
02172     ipc_EXEC_m (
02173         CORBA::Object_var obj = ipc_Corba::ResolveSvc(a_host, true);
02174         svc = i_Service::_narrow(obj);
02175     );
02176 
02177     switch (a_lType) {
02178         case lt_SCSI:
02179             log_DBG_m(dbg_DETAIL,"Starting LA-S: " << a_libName);
02180             ipc_EXEC_m( svc->Execute(i_IVDLAS, argSeq); );
02181             break;
02182         case lt_MANUAL:
02183             log_DBG_m(dbg_DETAIL,"Starting LA-M: " << a_libName);
02184             ipc_EXEC_m( svc->Execute(i_IVDLAM, argSeq); );
02185             break;
02186         default:
02187             log_ERR_m("Invalid LA type: " << a_lType);
02188     }
02189 
02190 }

Here is the call graph for this function:

Here is the caller graph for this function:

void i_ResourceManager_i::ExecStopLA	(	string	a_libName,
		string	a_host
	)

Definition at line 2209 of file i_rm_impl.cpp.

References dbg_DETAIL, ipc_EXEC_m, log_DBG_m, log_FUNC_A_m, and ipc_Corba::ResolveLA().

Referenced by StopAllLA(), and StopLA().

02209                                                                     {
02210     log_FUNC_A_m(ExecStopLA, "lib: " << a_libName << " host: " << a_host);
02211 
02212     ipc_EXEC_m(
02213 
02214         CORBA::Object_var obj = ipc_Corba::ResolveLA(a_host, a_libName, false);
02215         i_LibraryAgent_var la = i_LibraryAgent::_narrow(obj);
02216 
02217         log_DBG_m(dbg_DETAIL,"Stopping LA: " << a_libName);
02218         la->Remove();
02219     );
02220 
02221 }

Here is the call graph for this function:

Here is the caller graph for this function:

void i_ResourceManager_i::ParsePMConfig	(	cfg_PMCfg &	a_cfgFile,
		const char *	a_partName
	)

Definition at line 1010 of file i_rm_impl.cpp.

References CFG_LINK_LATEST, ivd_Directories::cfgPart, dbg_DETAIL, cmn_Global::dirs, g_cmn, log_DBG_m, log_ERR_m, log_FUNC_m, pf_File::Parse(), and cfg_PMCfg::Refresh().

Referenced by RegisterPartition(), and UpdatePartition().

01010                                                                                     {
01011     log_FUNC_m(ParsePMConfig);
01012 
01013     cmn_Path cfgFilePath;
01014     cfgFilePath = g_cmn.dirs.cfgPart + string(a_partName) + string(CFG_LINK_LATEST);
01015 
01016     pf_File pmFile;
01017 
01018     try {
01019         pmFile.Parse(cfgFilePath);
01020         log_DBG_m(dbg_DETAIL, "File name: " << cfgFilePath);
01021         a_cfgFile.Refresh(pmFile);
01022     } catch (ivd_Exception& e) {
01023         log_ERR_m(e);
01024         throw;
01025     }
01026 }

Here is the call graph for this function:

Here is the caller graph for this function:

void i_ResourceManager_i::SetRMPartStatus ( cfg_PMCfg & a_pmCfg )

Definition at line 1029 of file i_rm_impl.cpp.

References dbg_NORM, rm_PartitionStatus::GetPartName(), rm_PartitionStatus::GetPartUUID(), log_DBG_m, log_FUNC_m, log_WRN_m, rm_PartitionStatus::LogCurrentState(), m_queue, rm_Queue::m_SysState, cfg_PMCfg::maintPriority, cfg_PMCfg::maxNumDrives, cfg_PMCfg::maxNumDrivesMaint, cfg_PMCfg::maxNumDrivesMigration, cfg_PMCfg::maxNumDrivesRecall, cfg_PMCfg::maxNumDrivesRecovery, cfg_PMCfg::maxNumDrivesReorg, cfg_PMCfg::migrationPriority, cfg_PMCfg::name, cfg_PMCfg::partitionPriority, cfg_PMCfg::recallPriority, cfg_PMCfg::recoveryPriority, cfg_PMCfg::reorgPriority, cfg_PMCfg::reserveNumDrives, cfg_PMCfg::reserveNumDrivesMaint, cfg_PMCfg::reserveNumDrivesMigration, cfg_PMCfg::reserveNumDrivesRecall, cfg_PMCfg::reserveNumDrivesRecovery, cfg_PMCfg::reserveNumDrivesReorg, cmn_UUID_t::ToString(), and rm_SysState::UpdatePM().

Referenced by RegisterPartition(), and UpdatePartition().

01029                                                             {
01030     log_FUNC_m(SetRMPartStatus);
01031     try {
01032         rm_PartitionStatus rmPartStat(  a_pmCfg.name,
01033                                         a_pmCfg.maxNumDrives,
01034                                         a_pmCfg.maxNumDrivesRecall,
01035                                         a_pmCfg.maxNumDrivesMigration,
01036                                         a_pmCfg.maxNumDrivesReorg,
01037                                         a_pmCfg.maxNumDrivesRecovery,
01038                                         a_pmCfg.maxNumDrivesMaint,
01039                                         a_pmCfg.reserveNumDrives,
01040                                         a_pmCfg.reserveNumDrivesRecall,
01041                                         a_pmCfg.reserveNumDrivesMigration,
01042                                         a_pmCfg.reserveNumDrivesReorg,
01043                                         a_pmCfg.reserveNumDrivesRecovery,
01044                                         a_pmCfg.reserveNumDrivesMaint,
01045                                         a_pmCfg.partitionPriority,
01046                                         a_pmCfg.migrationPriority,
01047                                         a_pmCfg.recallPriority,
01048                                         a_pmCfg.reorgPriority,
01049                                         a_pmCfg.recoveryPriority,
01050                                         a_pmCfg.maintPriority,
01051                                         this);
01052 
01053         log_DBG_m(dbg_NORM, " Found Partition with Name: " <<
01054             rmPartStat.GetPartName() <<
01055             " and UUID: " << rmPartStat.GetPartUUID().ToString());
01056 
01057         m_queue.m_SysState.UpdatePM(rmPartStat);
01058 
01059         log_DBG_m(dbg_NORM,
01060             " added partition: " << rmPartStat.GetPartName() <<
01061             " to systemstate"
01062             );
01063         rmPartStat.LogCurrentState();
01064     } catch (ivd_Error& e) {
01065         log_WRN_m(e);
01066     }
01067 }