Scheduling a Storage Report using WMI
Starting with Windows Server 2012 FSRM uses WMI to schedule reports to run.
The following C++ example shows how to schedule a storage report using WMI.
#include "main.h"
void __cdecl wmain()
{
MI_Result result = MI_RESULT_OK;
MI_Application application = MI_APPLICATION_NULL;
MI_Session session = MI_SESSION_NULL;
MI_Operation createScheduleResult = MI_OPERATION_NULL;
MI_Operation createReportResult = MI_OPERATION_NULL;
MI_Instance *pSchedule = NULL;
MI_Instance *pStorageReport = NULL;
const MI_Instance *pScheduleResult = NULL;
const MI_Instance *pStorageReportResult = NULL;
MI_Instance *pScheduledTaskInParams = NULL;
MI_Boolean moreResults = MI_TRUE;
MI_Value value;
::ZeroMemory(&value, sizeof(MI_Value));
static const unsigned int aDaysOfTheWeek[] = {0, 6};
static const MI_Datetime time = {1 /* is a timestamp */, {2012, 1, 1, 1, 0, 0, 0, 1}};
static PCWSTR pwszNamespace = L"Root\\Microsoft\\Windows\\FSRM";
static PCWSTR aNamespaces[] = {L"P:\\namespace1", L"P:\\namespace2"};
// 1 - Large files report
// 3 - Least recently accessed report
static const unsigned int aReportTypes[] = {1, 3};
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
wprintf(L"\nInitializing ...\n");
CheckResultAndExit( "MI_Application_Initialize",
MI_Application_Initialize(0, NULL, NULL, &application) );
assert( application.ft );
CheckResultAndExit( "MI_Application_NewSession",
MI_Application_NewSession(&application, NULL, NULL, NULL, NULL, NULL, &session) );
assert( session.ft );
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
wprintf(L"\nCreating a scheduled task ...\n");
CheckResultAndExit( "MI_Application_NewParameterSet for method to create schedule",
MI_Application_NewParameterSet(&application, NULL, &pScheduledTaskInParams) );
assert( pScheduledTaskInParams );
// Set the day of the week to trigger the scheduled task
// 0 - Sunday
// 6 - Saturday
// This means schedule will run every weekend
value.uint32a.data = (MI_Uint32 *) aDaysOfTheWeek;
value.uint32a.size = ARRAYSIZE(aDaysOfTheWeek);
CheckResultAndExit( "MI_Instance_AddElement for day of the week for schedule",
MI_Instance_AddElement(pScheduledTaskInParams, L"Weekly", &value, MI_UINT32A, MI_FLAG_ANY) );
// Set the time of the day to trigger the scheduled task
// Time stamp used is 1:00:00 AM on 1:1:2012 in UTC.
// This means schedule will run at 1 AM on the scheduled days in UTC time.
value.datetime = time;
CheckResultAndExit( "MI_Instance_AddElement for time of the day for schedule",
MI_Instance_AddElement(pScheduledTaskInParams, L"Time", &value, MI_DATETIME, MI_FLAG_ANY) );
MI_Session_Invoke(&session,
0,
NULL,
pwszNamespace,
L"MSFT_FSRMScheduledTask",
L"CreateScheduledTask",
NULL,
pScheduledTaskInParams,
NULL,
&createScheduleResult);
while (moreResults == MI_TRUE)
{
// MI_Session_Invoke results should be obtained using
// MI_Operation_GetInstance until there are no more results left
const MI_Char *errorMessage = NULL;
CheckResultAndExit( "MI_Operation_GetInstance for schedule",
MI_Operation_GetInstance(&createScheduleResult,
&pScheduleResult,
&moreResults,
&result,
&errorMessage,
NULL) );
if (result != MI_RESULT_OK)
{
fwprintf(stderr,
L"MI_Session_Invoke to create a scheduled task sent back failure with MI Result = %d and error message = \n",
result,
errorMessage);
goto end;
}
assert( pScheduleResult );
MI_Type type;
::ZeroMemory(&type, sizeof(MI_Type));
// Extract the scheduled task instance from the output using MI_Instance_GetElement
CheckResultAndExit( "MI_Instance_GetElement",
MI_Instance_GetElement(pScheduleResult, L"ScheduledTask", &value, &type, NULL, NULL) );
assert( type == MI_INSTANCE );
pSchedule = value.instance;
assert( pSchedule );
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
wprintf(L"Creating a storage report ...\n");
CheckResultAndExit( "MI_Application_NewInstance for storage report",
MI_Application_NewInstance(&application, L"MSFT_FSRMStorageReport", NULL, &pStorageReport) );
assert( pStorageReport );
// Set name for the storage report
value.string = L"Storage Report 1";
CheckResultAndExit( "MI_Instance_AddElement for name",
MI_Instance_AddElement(pStorageReport, L"Name", &value, MI_STRING, MI_FLAG_KEY) );
// Set namespaces for the storage report
value.stringa.data = (MI_Char **) aNamespaces;
value.stringa.size = ARRAYSIZE(aNamespaces);
CheckResultAndExit( "MI_Instance_AddElement for namespace",
MI_Instance_AddElement(pStorageReport, L"Namespace", &value, MI_STRINGA, MI_FLAG_ANY) );
// Set report types for the storage report
value.uint32a.data = (MI_Uint32 *) aReportTypes;
value.uint32a.size = ARRAYSIZE(aReportTypes);
CheckResultAndExit( "MI_Instance_AddElement for report type",
MI_Instance_AddElement(pStorageReport, L"ReportType", &value, MI_UINT32A, MI_FLAG_ANY) );
// Set least accessed minimum bar to 100 days for the least recently accessed report in the storage report
value.uint32 = 100;
CheckResultAndExit( "MI_Instance_AddElement for least accessed minimum",
MI_Instance_AddElement(pStorageReport, L"LeastAccessedMinimum", &value, MI_UINT32, MI_FLAG_ANY) );
// Set file pattern to *.mp3 for the large files report in the storage report
value.string = L"*.mp3";
CheckResultAndExit( "MI_Instance_AddElement for large file pattern",
MI_Instance_AddElement(pStorageReport, L"LargeFilePattern", &value, MI_STRING, MI_FLAG_ANY) );
// Set schedule for the storage report
value.instance = pSchedule;
CheckResultAndExit( "MI_Instance_AddElement for schedule",
MI_Instance_AddElement(pStorageReport, L"Schedule", &value, MI_INSTANCE, MI_FLAG_ANY) );
MI_Session_CreateInstance(&session, 0, 0, pwszNamespace, pStorageReport, NULL, &createReportResult);
moreResults = MI_TRUE;
while (moreResults == MI_TRUE)
{
const MI_Char *errorMessage;
// MI_Session_CreateInstance results should be obtained using
// MI_Operation_GetInstance until there are no more results left
MI_Operation_GetInstance(&createReportResult, &pStorageReportResult, &moreResults, &result, &errorMessage, NULL);
if (result != MI_RESULT_OK)
{
fwprintf(stderr,
L"MI_Session_CreateInstance for storage report sent back failure with MI Result = %d and error message = \n",
result,
errorMessage);
goto end;
}
}
end:
if (createReportResult.ft)
{
CheckResult( "MI_Operation_Close for operation result", MI_Operation_Close(&createReportResult) );
// This frees objects in the operation
}
if (createScheduleResult.ft)
{
CheckResult( "MI_Operation_Close for operation result", MI_Operation_Close(&createScheduleResult) );
// This frees objects in the operation including pSchedule
}
if (pStorageReport)
{
CheckResult( "MI_Instance_Delete for pStorageReport", MI_Instance_Delete(pStorageReport) );
pStorageReport = NULL;
}
if (pScheduledTaskInParams)
{
CheckResult( "MI_Instance_Delete for pScheduledTaskInParams", MI_Instance_Delete(pScheduledTaskInParams) );
pScheduledTaskInParams = NULL;
}
if (session.ft)
{
CheckResult( "MI_Session_Close", MI_Session_Close(&session, NULL, NULL) );
}
if (application.ft)
{
CheckResult( "MI_Application_Close", MI_Application_Close(&application) );
}
wchar_t chTemp = L'\0';
::wprintf(L"\nDone.\nPress \"Enter\" to quit");
::wscanf_s(L"%c", &chTemp, 1);
}
This is the header named Main.h used by the example above.
#pragma once
#include <stdio.h>
#include <objbase.h>
#include <assert.h>
#include <tchar.h>
#include <crtdbg.h>
#define MI_CHAR_TYPE 2 // Maps MI_CHAR to wchar_t
#include <mi.h>
inline
bool
CheckResult(
__in PCSTR pwszOperation,
__in MI_Result Result
)
{
if (Result != MI_RESULT_OK)
{
fwprintf(stderr, L"%s failed with MI Result = %d\n", pwszOperation, Result);
return false;
}
return true;
}
#define CheckResultAndExit(Operation, Result) { if (!CheckResult(Operation, Result)) { goto end; } }
Related topics
-
FSRM
-
WMI