Note
Access to this page requires authorization. You can try signing in or changing directories.
Access to this page requires authorization. You can try changing directories.
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