836 lines
30 KiB
C++
836 lines
30 KiB
C++
/*++
|
|
|
|
Copyright (c) 2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
cliadmin.cpp
|
|
|
|
Abstract:
|
|
|
|
Implements CLI ADMIN sub-interface
|
|
|
|
Author:
|
|
|
|
Ran Kalach [rankala] 3-March-2000
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
#include "HsmConn.h"
|
|
#include "engine.h"
|
|
#include "rsstrdef.h"
|
|
#include "mstask.h"
|
|
|
|
static GUID g_nullGuid = GUID_NULL;
|
|
|
|
// Internal utilities and classes for VOLUME interface
|
|
HRESULT DisplayServiceStatus(void);
|
|
HRESULT IsHsmInitialized(IN IHsmServer *pHsm);
|
|
|
|
HRESULT
|
|
AdminSet(
|
|
IN DWORD RecallLimit,
|
|
IN DWORD AdminExempt,
|
|
IN DWORD MediaCopies,
|
|
IN DWORD Concurrency,
|
|
IN PVOID Schedule
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sets Remote Storage general parameters
|
|
|
|
Arguments:
|
|
|
|
RecallLimit - The runaway recall limit to set
|
|
AdminExempt - Whether to set administrators exempt for the recall limit
|
|
MediaCopies - Number of media copy sets
|
|
Concurrency - How many migrate jobs/recalls can be executed concurrently
|
|
Schedule - The schedule for the global migration ("Manage") job of all managed volumes
|
|
|
|
Return Value:
|
|
|
|
S_OK - If all the parameters are set successfully
|
|
|
|
Notes:
|
|
The scheduling implementation of HSM (in the Engine) allows only one scheduling
|
|
for the global Manage job. The scheduling given here overrides any former scheduling.
|
|
However, the user can add another scheduling to the same task using the Task Scheduler UI.
|
|
Enabling that via HSM, requires changing the CHsmServer::CreateTaskEx implementation
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("AdminSet"), OLESTR(""));
|
|
|
|
try {
|
|
CWsbStringPtr param;
|
|
|
|
// Verify that input parameters are valid
|
|
WsbAffirmHr(ValidateLimitsArg(RecallLimit, IDS_RECALL_LIMIT, HSMADMIN_MIN_RECALL_LIMIT, INVALID_DWORD_ARG));
|
|
WsbAffirmHr(ValidateLimitsArg(MediaCopies, IDS_MEDIA_COPIES_PRM, HSMADMIN_MIN_COPY_SETS, HSMADMIN_MAX_COPY_SETS));
|
|
WsbAffirmHr(ValidateLimitsArg(Concurrency, IDS_CONCURRENCY_PRM, HSMADMIN_MIN_CONCURRENT_TASKS, INVALID_DWORD_ARG));
|
|
|
|
// Set parameters, if an error occurs we abort
|
|
if ((INVALID_DWORD_ARG != RecallLimit) || (INVALID_DWORD_ARG != AdminExempt)) {
|
|
// Need Fsa server and Fsa filter here
|
|
CComPtr<IFsaServer> pFsa;
|
|
CComPtr<IFsaFilter> pFsaFilter;
|
|
|
|
WsbAffirmHr(HsmConnectFromId(HSMCONN_TYPE_FSA, g_nullGuid, IID_IFsaServer, (void**)&pFsa));
|
|
WsbAffirmHr(pFsa->GetFilter( &pFsaFilter));
|
|
|
|
// Recall limit
|
|
if (INVALID_DWORD_ARG != RecallLimit) {
|
|
WsbAffirmHr(pFsaFilter->SetMaxRecalls(RecallLimit));
|
|
}
|
|
|
|
// Admin exempt
|
|
if (INVALID_DWORD_ARG != AdminExempt) {
|
|
BOOL bAdminExempt = (0 == AdminExempt) ? FALSE : TRUE;
|
|
WsbAffirmHr(pFsaFilter->SetAdminExemption(bAdminExempt));
|
|
}
|
|
}
|
|
|
|
if ( (INVALID_DWORD_ARG != MediaCopies) || (INVALID_DWORD_ARG != Concurrency) ||
|
|
(INVALID_POINTER_ARG != Schedule) ) {
|
|
// Need Hsm server
|
|
CComPtr<IHsmServer> pHsm;
|
|
|
|
WsbAffirmHr(HsmConnectFromId(HSMCONN_TYPE_HSM, g_nullGuid, IID_IHsmServer, (void**)&pHsm));
|
|
|
|
// Concurrency
|
|
if (INVALID_DWORD_ARG != Concurrency) {
|
|
WsbAffirmHr(pHsm->SetCopyFilesUserLimit(Concurrency));
|
|
}
|
|
|
|
// Media copies
|
|
if (INVALID_DWORD_ARG != MediaCopies) {
|
|
CComPtr<IHsmStoragePool> pStoragePool;
|
|
CComPtr<IWsbIndexedCollection> pCollection;
|
|
ULONG count;
|
|
|
|
// Get the storage pools collection. There should only be one member.
|
|
WsbAffirmHr(pHsm->GetStoragePools(&pCollection));
|
|
WsbAffirmHr(pCollection->GetEntries(&count));
|
|
WsbAffirm(1 == count, E_FAIL);
|
|
WsbAffirmHr(pCollection->At(0, IID_IHsmStoragePool, (void **)&pStoragePool));
|
|
|
|
WsbAffirmHr(pStoragePool->SetNumMediaCopies((USHORT)MediaCopies));
|
|
}
|
|
|
|
// Scheduling
|
|
if (INVALID_POINTER_ARG != Schedule) {
|
|
CWsbStringPtr taskName, taskComment;
|
|
TASK_TRIGGER_TYPE taskType;
|
|
PHSM_JOB_SCHEDULE pSchedule = (PHSM_JOB_SCHEDULE)Schedule;
|
|
SYSTEMTIME runTime;
|
|
DWORD runOccurrence;
|
|
|
|
// Set default valuess
|
|
GetSystemTime(&runTime);
|
|
runOccurrence = 0;
|
|
|
|
// Set input
|
|
switch (pSchedule->Frequency) {
|
|
case Daily:
|
|
taskType = TASK_TIME_TRIGGER_DAILY;
|
|
runTime = pSchedule->Parameters.Daily.Time;
|
|
runOccurrence = pSchedule->Parameters.Daily.Occurrence;
|
|
break;
|
|
|
|
case Weekly:
|
|
taskType = TASK_TIME_TRIGGER_WEEKLY;
|
|
runTime = pSchedule->Parameters.Weekly.Time;
|
|
runOccurrence = pSchedule->Parameters.Weekly.Occurrence;
|
|
break;
|
|
|
|
case Monthly:
|
|
taskType = TASK_TIME_TRIGGER_MONTHLYDATE;
|
|
runTime = pSchedule->Parameters.Monthly.Time;
|
|
break;
|
|
|
|
case Once:
|
|
taskType = TASK_TIME_TRIGGER_ONCE;
|
|
runTime = pSchedule->Parameters.Once.Time;
|
|
break;
|
|
|
|
case WhenIdle:
|
|
taskType = TASK_EVENT_TRIGGER_ON_IDLE;
|
|
runOccurrence = pSchedule->Parameters.WhenIdle.Occurrence;
|
|
break;
|
|
|
|
case SystemStartup:
|
|
taskType = TASK_EVENT_TRIGGER_AT_SYSTEMSTART;
|
|
break;
|
|
|
|
case Login:
|
|
taskType = TASK_EVENT_TRIGGER_AT_LOGON;
|
|
break;
|
|
|
|
default:
|
|
WsbThrow(E_INVALIDARG);
|
|
}
|
|
|
|
// Create the task with the new scheduling
|
|
// Note: Task parameters should not be localized - this is a parameter for RsLaunch.exe
|
|
WsbAffirmHr(WsbGetResourceString(IDS_HSM_SCHED_TASK_TITLE, &taskName));
|
|
WsbAffirmHr(WsbGetResourceString(IDS_HSM_SCHED_COMMENT, &taskComment));
|
|
WsbAffirmHr(pHsm->CreateTaskEx(taskName, L"run manage", taskComment,
|
|
taskType, runTime, runOccurrence, TRUE));
|
|
}
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("AdminSet"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
// Local structure for AdminShow
|
|
typedef struct _FSA_VOLUME_DATA {
|
|
WCHAR *Name;
|
|
BOOL Managed;
|
|
} FSA_VOLUME_DATA, *PFSA_VOLUME_DATA;
|
|
|
|
#define DATA_ALLOC_SIZE 10
|
|
|
|
HRESULT
|
|
AdminShow(
|
|
IN BOOL RecallLimit,
|
|
IN BOOL AdminExempt,
|
|
IN BOOL MediaCopies,
|
|
IN BOOL Concurrency,
|
|
IN BOOL Schedule,
|
|
IN BOOL General,
|
|
IN BOOL Manageables,
|
|
IN BOOL Managed,
|
|
IN BOOL Media
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Shows (prints to stdout) Remote Storage general parameters
|
|
|
|
Arguments:
|
|
|
|
RecallLimit - The runaway recall limit
|
|
AdminExempt - Whether administrators are exempt from the recall limit
|
|
MediaCopies - Number of media copy sets
|
|
Concurrency - How many migrate jobs/recalls can be executed concurrently
|
|
Schedule - The schedule for the global migration ("Manage") job of all managed volumes
|
|
General - General information: version, status, number of volumes managed,
|
|
number of tape cartridges used, data in remote storage
|
|
Manageables - List of volumes that may be managed by HSM
|
|
Managed - List of volumes that are managed by HSM
|
|
Media - List of medias that are allocated to HSM
|
|
|
|
Return Value:
|
|
|
|
S_OK - If all the required parameters are printed successfully
|
|
|
|
Notes:
|
|
The schedule is printed in a form of a list (like the volume list), not like a single parameter.
|
|
The reason is that a user can specify several schedules for the global Manage job.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// Volume saved data
|
|
PFSA_VOLUME_DATA pVolumesData = NULL;
|
|
ULONG volDataSize = 0;
|
|
|
|
// Media save data
|
|
BSTR* pMediasData = NULL;
|
|
ULONG mediaDataSize = 0;
|
|
CComPtr<IWsbDb> pDb;
|
|
CComPtr<IWsbDbSession> pDbSession;
|
|
|
|
WsbTraceIn(OLESTR("AdminShow"), OLESTR(""));
|
|
|
|
try {
|
|
CComPtr<IFsaServer> pFsa;
|
|
CComPtr<IHsmServer> pHsm;
|
|
CWsbStringPtr param;
|
|
CWsbStringPtr data;
|
|
WCHAR longData[100];
|
|
LPVOID pTemp;
|
|
|
|
// Volume data
|
|
LONGLONG dataInStorage = 0;
|
|
ULONG manageableCount = 0;
|
|
ULONG managedCount = 0;
|
|
|
|
// Media data
|
|
ULONG mediaAllocated = 0;
|
|
|
|
// Get required HSM servers
|
|
if (RecallLimit || AdminExempt || Manageables || Managed || General) {
|
|
// Need Fsa server
|
|
hr = HsmConnectFromId(HSMCONN_TYPE_FSA, g_nullGuid, IID_IFsaServer, (void**)&pFsa);
|
|
if (S_OK != hr) {
|
|
// Just print status before aborting
|
|
if (General) {
|
|
DisplayServiceStatus();
|
|
}
|
|
}
|
|
WsbAffirmHr(hr);
|
|
}
|
|
if (MediaCopies || Concurrency || General || Media) {
|
|
// Need Hsm (Engine) server
|
|
hr = HsmConnectFromId(HSMCONN_TYPE_HSM, g_nullGuid, IID_IHsmServer, (void**)&pHsm);
|
|
if (S_OK != hr) {
|
|
// Just print status before aborting
|
|
if (General) {
|
|
DisplayServiceStatus();
|
|
}
|
|
}
|
|
WsbAffirmHr(hr);
|
|
}
|
|
|
|
//
|
|
// Get basic information required according to the input settings
|
|
//
|
|
|
|
// Volumes data
|
|
if (General || Manageables || Managed) {
|
|
// Need to collect volumes information
|
|
CComPtr<IWsbEnum> pEnum;
|
|
CComPtr<IFsaResource> pResource;
|
|
HRESULT hrEnum;
|
|
BOOL bManaged;
|
|
|
|
LONGLONG totalSpace = 0;
|
|
LONGLONG freeSpace = 0;
|
|
LONGLONG premigrated = 0;
|
|
LONGLONG truncated = 0;
|
|
LONGLONG totalPremigrated = 0;
|
|
LONGLONG totalTruncated = 0;
|
|
|
|
|
|
WsbAffirmHr(pFsa->EnumResources(&pEnum));
|
|
hrEnum = pEnum->First(IID_IFsaResource, (void**)&pResource);
|
|
WsbAffirm((S_OK == hrEnum) || (WSB_E_NOTFOUND == hrEnum), hrEnum);
|
|
|
|
if (Manageables || Managed) {
|
|
volDataSize = DATA_ALLOC_SIZE;
|
|
pVolumesData = (PFSA_VOLUME_DATA)WsbAlloc(volDataSize * sizeof(FSA_VOLUME_DATA));
|
|
WsbAffirm(0 != pVolumesData, E_OUTOFMEMORY);
|
|
}
|
|
|
|
while(S_OK == hrEnum) {
|
|
// Don't count or display unavailable volumes
|
|
if (S_OK != pResource->IsAvailable()) {
|
|
goto skip_volume;
|
|
}
|
|
|
|
bManaged = (pResource->IsManaged() == S_OK);
|
|
|
|
if (Manageables) {
|
|
if (volDataSize == manageableCount) {
|
|
volDataSize += DATA_ALLOC_SIZE;
|
|
pTemp = WsbRealloc(pVolumesData, volDataSize * sizeof(FSA_VOLUME_DATA));
|
|
WsbAffirm(0 != pTemp, E_OUTOFMEMORY);
|
|
pVolumesData = (PFSA_VOLUME_DATA)pTemp;
|
|
}
|
|
pVolumesData[manageableCount].Name = NULL;
|
|
WsbAffirmHr(CliGetVolumeDisplayName(pResource, &(pVolumesData[manageableCount].Name)));
|
|
pVolumesData[manageableCount].Managed = bManaged;
|
|
}
|
|
|
|
manageableCount++;
|
|
|
|
if(bManaged) {
|
|
if (General) {
|
|
WsbAffirmHr(pResource->GetSizes(&totalSpace, &freeSpace, &premigrated, &truncated));
|
|
totalPremigrated += premigrated;
|
|
totalTruncated += truncated;
|
|
}
|
|
|
|
if (Managed && (!Manageables)) {
|
|
// Collect data only for managed volumes
|
|
if (volDataSize == managedCount) {
|
|
volDataSize += DATA_ALLOC_SIZE;
|
|
pTemp = WsbRealloc(pVolumesData, volDataSize * sizeof(FSA_VOLUME_DATA));
|
|
WsbAffirm(0 != pTemp, E_OUTOFMEMORY);
|
|
pVolumesData = (PFSA_VOLUME_DATA)pTemp;
|
|
}
|
|
|
|
pVolumesData[managedCount].Name = NULL;
|
|
WsbAffirmHr(CliGetVolumeDisplayName(pResource, &(pVolumesData[managedCount].Name)));
|
|
pVolumesData[managedCount].Managed = TRUE;
|
|
}
|
|
|
|
managedCount++;
|
|
}
|
|
|
|
skip_volume:
|
|
// Prepare for next iteration
|
|
pResource = 0;
|
|
hrEnum = pEnum->Next( IID_IFsaResource, (void**)&pResource );
|
|
}
|
|
if (Manageables) {
|
|
volDataSize = manageableCount;
|
|
} else if (Managed) {
|
|
volDataSize = managedCount;
|
|
}
|
|
|
|
if (General) {
|
|
dataInStorage = totalPremigrated + totalTruncated;
|
|
}
|
|
}
|
|
|
|
// Medias data
|
|
if (General || Media) {
|
|
CComPtr<IMediaInfo> pMediaInfo;
|
|
GUID mediaSubsystemId;
|
|
CComPtr<IRmsServer> pRms;
|
|
CComPtr<IRmsCartridge> pRmsCart;
|
|
HRESULT hrFind;
|
|
|
|
WsbAffirmHr(pHsm->GetHsmMediaMgr(&pRms));
|
|
WsbAffirmHr(pHsm->GetSegmentDb(&pDb));
|
|
WsbAffirmHr(pDb->Open(&pDbSession));
|
|
WsbAffirmHr(pDb->GetEntity(pDbSession, HSM_MEDIA_INFO_REC_TYPE, IID_IMediaInfo, (void**)&pMediaInfo));
|
|
|
|
if (Media) {
|
|
mediaDataSize = DATA_ALLOC_SIZE;
|
|
pMediasData = (BSTR *)WsbAlloc(mediaDataSize * sizeof(BSTR));
|
|
WsbAffirm(0 != mediaDataSize, E_OUTOFMEMORY);
|
|
}
|
|
|
|
for (hr = pMediaInfo->First(); S_OK == hr; hr = pMediaInfo->Next()) {
|
|
WsbAffirmHr(pMediaInfo->GetMediaSubsystemId(&mediaSubsystemId));
|
|
hrFind = pRms->FindCartridgeById(mediaSubsystemId, &pRmsCart);
|
|
if (S_OK == hrFind) { // Otherwise, the media is not valid anymore, it could have been deallocated
|
|
if (Media) {
|
|
if (mediaDataSize == mediaAllocated) {
|
|
mediaDataSize += DATA_ALLOC_SIZE;
|
|
pTemp = WsbRealloc(pMediasData, mediaDataSize * sizeof(BSTR));
|
|
WsbAffirm(0 != pTemp, E_OUTOFMEMORY);
|
|
pMediasData = (BSTR *)pTemp;
|
|
}
|
|
|
|
pMediasData[mediaAllocated] = NULL;
|
|
WsbAffirmHr(pRmsCart->GetName(&(pMediasData[mediaAllocated])));
|
|
if ( (NULL == pMediasData[mediaAllocated]) ||
|
|
(0 == wcscmp(pMediasData[mediaAllocated], OLESTR(""))) ) {
|
|
// Try decsription
|
|
if (NULL != pMediasData[mediaAllocated]) {
|
|
WsbFreeString(pMediasData[mediaAllocated]);
|
|
}
|
|
|
|
WsbAffirmHr(pRmsCart->GetDescription(&(pMediasData[mediaAllocated])));
|
|
}
|
|
|
|
}
|
|
|
|
mediaAllocated++;
|
|
pRmsCart = 0;
|
|
}
|
|
}
|
|
if (Media) {
|
|
mediaDataSize = mediaAllocated;
|
|
}
|
|
hr = S_OK;
|
|
|
|
if(pDb) {
|
|
pDb->Close(pDbSession);
|
|
pDb = 0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Print parameters
|
|
//
|
|
|
|
// General parameters
|
|
if (General) {
|
|
WsbTraceAndPrint(CLI_MESSAGE_GENERAL_PARMS, NULL);
|
|
|
|
// Status
|
|
WsbAffirmHr(DisplayServiceStatus());
|
|
|
|
// Manageable && Managed
|
|
WsbAffirmHr(param.LoadFromRsc(g_hInstance, IDS_NOF_MANAGEABLES));
|
|
swprintf(longData, OLESTR("%lu"), manageableCount);
|
|
WsbTraceAndPrint(CLI_MESSAGE_PARAM_DISPLAY, (WCHAR *)param, longData, NULL);
|
|
WsbAffirmHr(param.LoadFromRsc(g_hInstance, IDS_NOF_MANAGED));
|
|
swprintf(longData, OLESTR("%lu"), managedCount);
|
|
WsbTraceAndPrint(CLI_MESSAGE_PARAM_DISPLAY, (WCHAR *)param, longData, NULL);
|
|
|
|
// Tapes
|
|
WsbAffirmHr(param.LoadFromRsc(g_hInstance, IDS_NOF_CARTRIDGES));
|
|
swprintf(longData, OLESTR("%lu"), mediaAllocated);
|
|
WsbTraceAndPrint(CLI_MESSAGE_PARAM_DISPLAY, (WCHAR *)param, longData, NULL);
|
|
|
|
// Data in RS
|
|
WsbAffirmHr(param.LoadFromRsc(g_hInstance, IDS_REMOTE_DATA));
|
|
WsbAffirmHr(ShortSizeFormat64(dataInStorage, longData));
|
|
WsbTraceAndPrint(CLI_MESSAGE_PARAM_DISPLAY, (WCHAR *)param, longData, NULL);
|
|
|
|
// Version
|
|
{
|
|
CComPtr<IWsbServer> pWsbHsm;
|
|
CWsbStringPtr ntProductVersionHsm;
|
|
ULONG ntProductBuildHsm;
|
|
ULONG buildVersionHsm;
|
|
|
|
WsbAffirmHr(pHsm->QueryInterface(IID_IWsbServer, (void **)&pWsbHsm));
|
|
WsbAffirmHr(pWsbHsm->GetNtProductBuild(&ntProductBuildHsm));
|
|
WsbAffirmHr(pWsbHsm->GetNtProductVersion(&ntProductVersionHsm, 0));
|
|
WsbAffirmHr(pWsbHsm->GetBuildVersion(&buildVersionHsm));
|
|
|
|
WsbAffirmHr(param.LoadFromRsc(g_hInstance, IDS_HSM_VERSION));
|
|
WsbAffirmHr(data.Realloc(wcslen(ntProductVersionHsm) + 30));
|
|
swprintf(data, L"%ls.%d [%ls]", (WCHAR*)ntProductVersionHsm, ntProductBuildHsm, RsBuildVersionAsString(buildVersionHsm));
|
|
WsbTraceAndPrint(CLI_MESSAGE_PARAM_DISPLAY, (WCHAR *)param, (WCHAR *)data, NULL);
|
|
}
|
|
}
|
|
|
|
// Manageable volumes
|
|
if (Manageables) {
|
|
WsbTraceAndPrint(CLI_MESSAGE_MANAGEABLE_VOLS, NULL);
|
|
|
|
for (ULONG i=0; i<volDataSize; i++) {
|
|
if (pVolumesData[i].Name) {
|
|
WsbTraceAndPrint(CLI_MESSAGE_VALUE_DISPLAY, pVolumesData[i].Name, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Managed volumes
|
|
if (Managed) {
|
|
WsbTraceAndPrint(CLI_MESSAGE_MANAGED_VOLS, NULL);
|
|
|
|
for (ULONG i=0; i<volDataSize; i++) {
|
|
if (pVolumesData[i].Name && pVolumesData[i].Managed) {
|
|
WsbTraceAndPrint(CLI_MESSAGE_VALUE_DISPLAY, pVolumesData[i].Name, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Allocated Medias
|
|
if (Media) {
|
|
WsbTraceAndPrint(CLI_MESSAGE_MEDIAS, NULL);
|
|
|
|
for (ULONG i=0; i<mediaDataSize; i++) {
|
|
if (NULL != pMediasData[i]) {
|
|
WsbTraceAndPrint(CLI_MESSAGE_VALUE_DISPLAY, (WCHAR *)pMediasData[i], NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Schedule
|
|
if (Schedule) {
|
|
// Use Task Scheduler objects to get the data
|
|
CComPtr<ISchedulingAgent> pSchedAgent;
|
|
CComPtr<ITask> pTask;
|
|
CWsbStringPtr manageJobName;
|
|
|
|
// Initialize scheduling agent
|
|
WsbAffirmHr(CoCreateInstance(CLSID_CSchedulingAgent, 0, CLSCTX_SERVER, IID_ISchedulingAgent, (void **)&pSchedAgent));
|
|
pSchedAgent->SetTargetComputer(NULL); // local machine
|
|
|
|
// Get the relevant task
|
|
WsbAffirmHr(WsbGetResourceString(IDS_HSM_SCHED_TASK_TITLE, &manageJobName));
|
|
hr = pSchedAgent->Activate(manageJobName, IID_ITask, (IUnknown**)&pTask);
|
|
if (E_INVALIDARG == hr) {
|
|
// Print no scheduling message (Manage job is not found as a scheduled task)
|
|
WsbTraceAndPrint(CLI_MESSAGE_NO_SCHEDULING, NULL);
|
|
hr = S_OK;
|
|
|
|
} else if (S_OK == hr) {
|
|
// Get scheduling strings and print
|
|
WORD wTriggerCount;
|
|
WsbAffirmHr(pTask->GetTriggerCount(&wTriggerCount));
|
|
if (wTriggerCount == 0) {
|
|
WsbTraceAndPrint(CLI_MESSAGE_NO_SCHEDULING, NULL);
|
|
} else {
|
|
WsbTraceAndPrint(CLI_MESSAGE_SCHEDULING_LIST, NULL);
|
|
}
|
|
for (WORD triggerIndex = 0; triggerIndex < wTriggerCount; triggerIndex++) {
|
|
WCHAR *pTriggerString = NULL;
|
|
WsbAffirmHr(pTask->GetTriggerString(triggerIndex, &pTriggerString));
|
|
|
|
// Print
|
|
WsbTraceAndPrint(CLI_MESSAGE_VALUE_DISPLAY, pTriggerString, NULL);
|
|
|
|
CoTaskMemFree(pTriggerString);
|
|
}
|
|
|
|
} else {
|
|
WsbAffirmHr(hr);
|
|
}
|
|
}
|
|
|
|
// Limits and Media Copies
|
|
if (RecallLimit || AdminExempt) {
|
|
// Need Fsa filter here
|
|
CComPtr<IFsaFilter> pFsaFilter;
|
|
WsbAffirmHr(pFsa->GetFilter(&pFsaFilter));
|
|
|
|
if (RecallLimit) {
|
|
ULONG maxRecalls;
|
|
WsbAffirmHr(pFsaFilter->GetMaxRecalls(&maxRecalls));
|
|
WsbAffirmHr(param.LoadFromRsc(g_hInstance, IDS_RECALL_LIMIT));
|
|
swprintf(longData, OLESTR("%lu"), maxRecalls);
|
|
WsbTraceAndPrint(CLI_MESSAGE_PARAM_DISPLAY, (WCHAR *)param, longData, NULL);
|
|
}
|
|
|
|
if (AdminExempt) {
|
|
BOOL adminExempt;
|
|
WsbAffirmHr(pFsaFilter->GetAdminExemption(&adminExempt));
|
|
WsbAffirmHr(param.LoadFromRsc(g_hInstance, IDS_ADMIN_EXEMPT));
|
|
WsbTraceAndPrint(CLI_MESSAGE_PARAM_DISPLAY, (WCHAR *)param, WsbBoolAsString(adminExempt), NULL);
|
|
}
|
|
}
|
|
|
|
if (Concurrency) {
|
|
ULONG concurrentTasks;
|
|
WsbAffirmHr(pHsm->GetCopyFilesUserLimit(&concurrentTasks));
|
|
WsbAffirmHr(param.LoadFromRsc(g_hInstance, IDS_CONCURRENCY));
|
|
swprintf(longData, OLESTR("%lu"), concurrentTasks);
|
|
WsbTraceAndPrint(CLI_MESSAGE_PARAM_DISPLAY, (WCHAR *)param, longData, NULL);
|
|
}
|
|
|
|
if (MediaCopies) {
|
|
CComPtr<IHsmStoragePool> pStoragePool;
|
|
CComPtr<IWsbIndexedCollection> pCollection;
|
|
ULONG count;
|
|
USHORT numCopies;
|
|
|
|
// Get the storage pools collection. There should only be one member.
|
|
WsbAffirmHr(pHsm->GetStoragePools(&pCollection));
|
|
WsbAffirmHr(pCollection->GetEntries(&count));
|
|
WsbAffirm(1 == count, E_FAIL);
|
|
WsbAffirmHr(pCollection->At(0, IID_IHsmStoragePool, (void **)&pStoragePool));
|
|
WsbAffirmHr(pStoragePool->GetNumMediaCopies(&numCopies));
|
|
|
|
WsbAffirmHr(param.LoadFromRsc(g_hInstance, IDS_MEDIA_COPIES));
|
|
swprintf(longData, OLESTR("%ld"), (int)numCopies);
|
|
WsbTraceAndPrint(CLI_MESSAGE_PARAM_DISPLAY, (WCHAR *)param, longData, NULL);
|
|
}
|
|
|
|
} WsbCatchAndDo(hr,
|
|
if(pDb) {
|
|
pDb->Close(pDbSession);
|
|
pDb = 0;
|
|
}
|
|
);
|
|
|
|
// Free stored data
|
|
if (pVolumesData) {
|
|
for (ULONG i=0; i<volDataSize; i++) {
|
|
if (pVolumesData[i].Name) {
|
|
WsbFree(pVolumesData[i].Name);
|
|
}
|
|
}
|
|
WsbFree(pVolumesData);
|
|
pVolumesData = NULL;
|
|
}
|
|
|
|
if (pMediasData) {
|
|
for (ULONG i=0; i<mediaDataSize; i++) {
|
|
if (NULL != pMediasData[i]) {
|
|
WsbFreeString(pMediasData[i]);
|
|
}
|
|
}
|
|
WsbFree(pMediasData);
|
|
pMediasData = NULL;
|
|
}
|
|
|
|
WsbTraceOut(OLESTR("AdminShow"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Internal utilities
|
|
//
|
|
HRESULT DisplayServiceStatus(void)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Displays HSM service status.
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
S_OK - If status is retrieved and displayed succeessfully
|
|
|
|
Notes:
|
|
The function handle cases such as the service not runnig, pending, not initialized, etc.
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("DisplayServiceStatus"), OLESTR(""));
|
|
|
|
try {
|
|
CWsbStringPtr param, data;
|
|
ULONG statusId = INVALID_DWORD_ARG;
|
|
DWORD serviceStatus;
|
|
HRESULT hrService;
|
|
|
|
hrService = WsbGetServiceStatus(NULL, APPID_RemoteStorageEngine, &serviceStatus);
|
|
if (S_OK != hrService) {
|
|
// HSM service not registered at all
|
|
WsbTrace(OLESTR("DisplayServiceStatus: Got hr = <%ls> from WsbGetServiceStatus\n"), WsbHrAsString(hrService));
|
|
statusId = IDS_SERVICE_STATUS_NOT_REGISTERED;
|
|
} else {
|
|
if (SERVICE_RUNNING == serviceStatus) {
|
|
CComPtr<IHsmServer> pHsm;
|
|
HRESULT hrSetup;
|
|
|
|
WsbAffirmHr(HsmConnectFromId(HSMCONN_TYPE_HSM, g_nullGuid, IID_IHsmServer, (void**)&pHsm));
|
|
hrSetup = IsHsmInitialized(pHsm);
|
|
if (S_FALSE == hrSetup) {
|
|
// HSM running but no initialized yet (Startup Wizard was not completed yet)
|
|
statusId = IDS_SERVICE_STATUS_NOT_SETUP;
|
|
} else if (S_OK == hrSetup) {
|
|
// Service is running, life is good
|
|
statusId = IDS_SERVICE_STATUS_RUNNING;
|
|
} else {
|
|
// Unexpected error
|
|
WsbAffirmHr(hrSetup);
|
|
}
|
|
} else {
|
|
// Service is not running, set exact string according to status
|
|
switch(serviceStatus) {
|
|
case SERVICE_STOPPED:
|
|
statusId = IDS_SERVICE_STATUS_STOPPED;
|
|
break;
|
|
case SERVICE_START_PENDING:
|
|
statusId = IDS_SERVICE_STATUS_START_PENDING;
|
|
break;
|
|
case SERVICE_STOP_PENDING:
|
|
statusId = IDS_SERVICE_STATUS_STOP_PENDING;
|
|
break;
|
|
case SERVICE_CONTINUE_PENDING:
|
|
statusId = IDS_SERVICE_STATUS_CONTINUE_PENDING;
|
|
break;
|
|
case SERVICE_PAUSE_PENDING:
|
|
statusId = IDS_SERVICE_STATUS_PAUSE_PENDING;
|
|
break;
|
|
case SERVICE_PAUSED:
|
|
statusId = IDS_SERVICE_STATUS_PAUSED;
|
|
break;
|
|
default:
|
|
WsbThrow(E_FAIL);
|
|
}
|
|
}
|
|
}
|
|
|
|
WsbAffirm(INVALID_DWORD_ARG != statusId, E_UNEXPECTED)
|
|
WsbAffirmHr(param.LoadFromRsc(g_hInstance, IDS_HSM_STATUS));
|
|
WsbAffirmHr(data.LoadFromRsc(g_hInstance, statusId));
|
|
WsbTraceAndPrint(CLI_MESSAGE_PARAM_DISPLAY, (WCHAR *)param, (WCHAR *)data, NULL);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("DisplayServiceStatus"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return (hr);
|
|
}
|
|
|
|
HRESULT IsHsmInitialized(IN IHsmServer *pHsm)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Check if HSM is initialized, i.e. if Startup wizard was completed successfully
|
|
|
|
Arguments:
|
|
|
|
pHsm - The HSM server to check with
|
|
|
|
Return Value:
|
|
|
|
S_OK - HSM initialized
|
|
S_FALSE - HSM not initialized
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
|
|
WsbTraceIn(OLESTR("IsHsmInitialized"), OLESTR(""));
|
|
|
|
try {
|
|
GUID guid;
|
|
CWsbBstrPtr poolName;
|
|
CComPtr<IWsbIndexedCollection> pCollection;
|
|
ULONG count;
|
|
CComPtr<IHsmStoragePool> pPool;
|
|
|
|
WsbAffirmHr(pHsm->GetStoragePools(&pCollection));
|
|
WsbAffirmHr(pCollection->GetEntries(&count));
|
|
WsbAffirm(1 == count, E_FAIL);
|
|
WsbAffirmHr(pCollection->At(0, IID_IHsmStoragePool, (void **)&pPool));
|
|
|
|
WsbAffirmHr(pPool->GetMediaSet(&guid, &poolName));
|
|
if(! IsEqualGUID(guid, GUID_NULL)) {
|
|
hr = S_OK;
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("IsHsmInitialized"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return (hr);
|
|
}
|
|
|
|
HRESULT AdminJob(IN BOOL Enable)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Enable/Disable HSM jobs
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
S_OK - Success
|
|
HSM_E_DISABLE_RUNNING_JOBS - Returned by Engine when trying to disbale jobs
|
|
while jobs are running
|
|
Other - Other unexpected error
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
|
|
WsbTraceIn(OLESTR("AdminJob"), OLESTR(""));
|
|
|
|
try {
|
|
CComPtr<IHsmServer> pHsm;
|
|
|
|
WsbAffirmHr(HsmConnectFromId(HSMCONN_TYPE_HSM, g_nullGuid, IID_IHsmServer, (void**)&pHsm));
|
|
if (Enable) {
|
|
hr = pHsm->EnableAllJobs();
|
|
} else {
|
|
hr = pHsm->DisableAllJobs();
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("AdminJob"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return (hr);
|
|
}
|