849 lines
25 KiB
C++
849 lines
25 KiB
C++
/*++
|
||
|
||
Copyright (c) 1998 Seagate Software, Inc. All rights reserved.
|
||
|
||
Module Name:
|
||
|
||
rslaunch.cpp
|
||
|
||
Abstract:
|
||
|
||
HSM Remote Storage Job Launch Program.
|
||
|
||
This program is used by the HSM Remote Storage system to submit
|
||
user-requested jobs to the NT Task Scheduler. This standalone command
|
||
line program has two primary functions: to start the HSM job specified
|
||
and not return until the job has completed; and to call into the HSM
|
||
Engine to either update secondary storage copy set media, or to
|
||
re-create a master secondary storage media from its most recent copy.
|
||
|
||
NOTE: This program is linked as a windows program, but has no visible
|
||
window. It creates an invisible window so it can get the WM_CLOSE
|
||
message from the Task Scheduler if the user wants to cancel the job.
|
||
|
||
ALSO NOTE: This program has no correspoinding header file.
|
||
|
||
--*/
|
||
|
||
#include "stdafx.h"
|
||
#include "windows.h"
|
||
#include "stdio.h"
|
||
|
||
#include "wsb.h"
|
||
#include "hsmeng.h"
|
||
#include "fsa.h"
|
||
#include "job.h"
|
||
#include "rms.h"
|
||
#include "hsmconn.h"
|
||
|
||
HINSTANCE g_hInstance;
|
||
|
||
//#define RSL_TRACE
|
||
#if defined(RSL_TRACE)
|
||
#define LTRACE(x) WsbTracef x
|
||
#else
|
||
#define LTRACE(x)
|
||
#endif
|
||
|
||
#define TRACE_FILE L"RsLaunch.trc"
|
||
#define WINDOW_CLASS L"RsLaunchWin"
|
||
|
||
// Typedefs
|
||
typedef enum { // Type of work requested
|
||
WORK_NONE,
|
||
WORK_RUN,
|
||
WORK_RECREATE,
|
||
WORK_SYNCH
|
||
} WORK_TYPE;
|
||
|
||
typedef struct { // For passing data to/from DoWork
|
||
WCHAR * pCmdLine;
|
||
WORK_TYPE wtype;
|
||
HRESULT hr;
|
||
IHsmJob * pJob;
|
||
} DO_WORK_DATA;
|
||
|
||
// Global data
|
||
CComModule _Module;
|
||
|
||
// Local data
|
||
|
||
// Local functions
|
||
static HRESULT CancelWork(DO_WORK_DATA* pWork);
|
||
static HRESULT ConnectToServer(IHsmServer** ppServer);
|
||
static BOOL CreateOurWindow(HINSTANCE hInstance);
|
||
static DWORD DoWork(void* pVoid);
|
||
static HRESULT RecreateMaster(GUID oldMasterMediaId,
|
||
OLECHAR* oldMasterMediaName, USHORT copySet);
|
||
static void ReportError(HRESULT hr);
|
||
static HRESULT RunJob(OLECHAR* jobName, IHsmJob** ppJob);
|
||
static HRESULT SynchronizeMedia(OLECHAR* poolName, USHORT copySet);
|
||
static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam,
|
||
LPARAM lParam);
|
||
|
||
|
||
//****************************** Functions:
|
||
|
||
|
||
static HRESULT
|
||
CancelWork(
|
||
IN DO_WORK_DATA* pWork
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Try to cancel the current work.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
S_OK - Success
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = E_FAIL;
|
||
|
||
LTRACE((L"CancelWork: entry\n"));
|
||
|
||
try {
|
||
CComPtr<IHsmServer> pServer;
|
||
|
||
WsbAffirmHr(ConnectToServer(&pServer));
|
||
|
||
// Because of a possible timing problem, we may have to wait
|
||
// for the operation to start before we can cancel it
|
||
for (int i = 0; i < 60; i++) {
|
||
if (WORK_RUN == pWork->wtype) {
|
||
LTRACE((L"CancelWork: wtype = WORK_RUN, pJob = %p\n",
|
||
pWork->pJob));
|
||
if (pWork->pJob) {
|
||
LTRACE((L"CancelWork: cancelling job\n"));
|
||
hr = pWork->pJob->Cancel(HSM_JOB_PHASE_ALL);
|
||
break;
|
||
}
|
||
} else {
|
||
LTRACE((L"CancelWork: cancelling copy media operation\n"));
|
||
if (S_OK == pServer->CancelCopyMedia()) {
|
||
hr = S_OK;
|
||
break;
|
||
}
|
||
}
|
||
|
||
Sleep(1000);
|
||
}
|
||
} WsbCatch(hr);
|
||
|
||
|
||
LTRACE((L"CancelWork: exit = %ls\n", WsbHrAsString(hr)));
|
||
return(hr);
|
||
}
|
||
|
||
|
||
static HRESULT
|
||
ConnectToServer(
|
||
IN OUT IHsmServer** ppServer
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Connect to the server that will do the work.
|
||
|
||
Arguments:
|
||
|
||
ppServer - Pointer to pointer to server.
|
||
|
||
Return Value:
|
||
|
||
S_OK - Success
|
||
|
||
--*/
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
LTRACE((L"ConnectToServer: entry\n"));
|
||
|
||
try {
|
||
CWsbStringPtr tmpString;
|
||
|
||
WsbAffirm(ppServer, E_POINTER);
|
||
WsbAffirm(!(*ppServer), E_FAIL);
|
||
|
||
// Store of the name of the server.
|
||
WsbAffirmHr( WsbGetComputerName( tmpString ) );
|
||
|
||
// Find the Hsm to get it's id.
|
||
WsbAffirmHr(HsmConnectFromName(HSMCONN_TYPE_HSM, tmpString, IID_IHsmServer,
|
||
(void**) ppServer));
|
||
} WsbCatch(hr);
|
||
|
||
|
||
LTRACE((L"ConnectToServer: exit = %ls\n", WsbHrAsString(hr)));
|
||
return(hr);
|
||
}
|
||
|
||
|
||
static BOOL
|
||
CreateOurWindow(
|
||
HINSTANCE hInstance
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Create our invisible window.
|
||
|
||
NOTE: If the Task Scheduler ever gets smarter and can send the WM_CLOSE
|
||
message to an application without a window, the invisible window may
|
||
not be needed.
|
||
|
||
Arguments:
|
||
|
||
hInstance - Handle for this instance of the program.
|
||
|
||
Return Value:
|
||
|
||
TRUE - Everything worked.
|
||
|
||
FALSE - Something went wrong.
|
||
|
||
|
||
|
||
--*/
|
||
{
|
||
BOOL bRet = FALSE;
|
||
WNDCLASS wc;
|
||
|
||
// Register our window type
|
||
wc.style = 0;
|
||
wc.lpfnWndProc = &WindowProc;
|
||
wc.cbClsExtra = 0;
|
||
wc.cbWndExtra = 0;
|
||
wc.hInstance = hInstance;
|
||
wc.hIcon = NULL;
|
||
wc.hCursor = NULL;
|
||
wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
|
||
wc.lpszMenuName = NULL;
|
||
wc.lpszClassName = WINDOW_CLASS;
|
||
if (RegisterClass(&wc)) {
|
||
|
||
// Create the window (invisible by default)
|
||
if (CreateWindowEx( 0,
|
||
WINDOW_CLASS,
|
||
L"RsLaunch",
|
||
WS_OVERLAPPEDWINDOW,
|
||
CW_USEDEFAULT,
|
||
CW_USEDEFAULT,
|
||
CW_USEDEFAULT,
|
||
CW_USEDEFAULT,
|
||
NULL,
|
||
NULL,
|
||
hInstance,
|
||
NULL)) {
|
||
bRet = TRUE;
|
||
} else {
|
||
LTRACE((L"CreateWindowEx failed\n"));
|
||
}
|
||
} else {
|
||
LTRACE((L"RegisterClass failed\n"));
|
||
}
|
||
return(bRet);
|
||
}
|
||
|
||
|
||
static DWORD
|
||
DoWork(
|
||
IN void* pVoid
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Process the command line and start the processing.
|
||
|
||
Arguments:
|
||
|
||
pVoid - A pointer (cast to void*) to a DO_WORK_DATA structure.
|
||
|
||
Return Value:
|
||
|
||
The return value from the job
|
||
|
||
--*/
|
||
|
||
{
|
||
HRESULT hr = S_OK;
|
||
DO_WORK_DATA * pWork;
|
||
|
||
LTRACE((L"DoWork: entry\n"));
|
||
|
||
pWork = static_cast<DO_WORK_DATA*>(pVoid);
|
||
|
||
try {
|
||
WCHAR delims[] = L" \r\n\t\"";
|
||
WCHAR delims2[] = L" \t";
|
||
WCHAR delims3[] = L"\"";
|
||
WCHAR * pToken;
|
||
|
||
WsbAssert(pWork, E_POINTER);
|
||
WsbAssert(pWork->pCmdLine, E_POINTER);
|
||
LTRACE((L"DoWork: CmdLine = %ls\n", pWork->pCmdLine));
|
||
|
||
// Validate we have a parameter
|
||
pToken = wcstok(pWork->pCmdLine, delims);
|
||
WsbAssert(pToken, E_INVALIDARG);
|
||
|
||
// What type of request is it?
|
||
if (_wcsicmp(pToken, OLESTR("run")) == 0) {
|
||
CWsbStringPtr jobName;
|
||
|
||
// 'run' option passed in
|
||
pWork->wtype = WORK_RUN;
|
||
|
||
// The job name can have embedded spaces so it may be in quotes.
|
||
// This means that using wcstok may not work correctly.
|
||
pToken = pToken + wcslen(pToken) + 1; // Skip "run" & NULL
|
||
pToken = pToken + wcsspn(pToken, delims2); // Skip spaces
|
||
if (L'\"' == *pToken) {
|
||
// Job name is in quotes
|
||
jobName = wcstok(pToken, delims3);
|
||
} else {
|
||
jobName = wcstok(pToken, delims);
|
||
}
|
||
WsbAssert(jobName, E_INVALIDARG);
|
||
LTRACE((L"DoWork: calling RunJob(%ls)\n", jobName));
|
||
WsbAffirmHr(RunJob(jobName, &(pWork->pJob)));
|
||
|
||
} else if (_wcsicmp(pToken, OLESTR("sync")) == 0) {
|
||
CWsbStringPtr poolName;
|
||
USHORT copySet = 1;
|
||
WCHAR * pTemp;
|
||
|
||
// 'sync' (update a copy set) option passed in
|
||
pWork->wtype = WORK_SYNCH;
|
||
pToken = wcstok(NULL, delims);
|
||
WsbAssert(pToken, E_INVALIDARG);
|
||
pTemp = wcstok(NULL, delims);
|
||
if (!pTemp) {
|
||
// will pass NULL for poolName if no pool name specified
|
||
copySet = (USHORT) _wtoi(pToken);
|
||
} else {
|
||
poolName = pToken;
|
||
copySet = (USHORT) _wtoi(pTemp);
|
||
}
|
||
|
||
WsbAffirmHr(SynchronizeMedia(poolName, copySet));
|
||
|
||
} else if (_wcsicmp(pToken, OLESTR("recreate")) == 0) {
|
||
USHORT copySet = 0;
|
||
CWsbStringPtr mediaName;
|
||
GUID mediaId = GUID_NULL;
|
||
|
||
// 'recreate' (re-create a master media) option passed in
|
||
pWork->wtype = WORK_RECREATE;
|
||
pToken = wcstok(NULL, delims);
|
||
WsbAssert(pToken, E_INVALIDARG);
|
||
if ( _wcsicmp(pToken, OLESTR("-i")) == 0 ) {
|
||
|
||
// media id was passed in, convert from string to GUID
|
||
pToken = wcstok(NULL, delims);
|
||
WsbAssert(pToken, E_INVALIDARG);
|
||
WsbAffirmHr(WsbGuidFromString( pToken, &mediaId ));
|
||
} else if ( _wcsicmp(pToken, OLESTR("-n")) == 0 ) {
|
||
|
||
// Media description (name) was passed in.
|
||
// The function RecreateMaster() will look up its id (GUID).
|
||
pToken = wcstok(NULL, delims);
|
||
WsbAssert(pToken, E_INVALIDARG);
|
||
mediaName = pToken;
|
||
}
|
||
|
||
// Get copySet number
|
||
pToken = wcstok(NULL, delims);
|
||
if (pToken && _wcsicmp(pToken, OLESTR("-c")) == 0) {
|
||
pToken = wcstok(NULL, delims);
|
||
WsbAssert(pToken, E_INVALIDARG);
|
||
copySet = (USHORT) _wtoi(pToken);
|
||
}
|
||
|
||
WsbAffirmHr( RecreateMaster( mediaId, mediaName, copySet ));
|
||
|
||
} else {
|
||
WsbThrow(E_INVALIDARG);
|
||
}
|
||
} WsbCatch(hr);
|
||
|
||
if (pWork) {
|
||
pWork->hr = hr;
|
||
}
|
||
|
||
LTRACE((L"DoWork: exit = %ls\n", WsbHrAsString(hr)));
|
||
return(static_cast<DWORD>(hr));
|
||
}
|
||
|
||
|
||
static HRESULT
|
||
RecreateMaster(
|
||
IN GUID oldMasterMediaId,
|
||
IN OLECHAR* oldMasterMediaName,
|
||
IN USHORT copySet
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine implements the method that will cause a Remote Storage master media
|
||
to be re-created by calling the appropraite method on the Remote Storage engine.
|
||
The master will be re-created from the specified copy or its most recent copy.
|
||
|
||
Arguments:
|
||
|
||
oldMasterMediaId - The GUID of the current master media which is to be re-created.
|
||
Normally passed, but an option exists where if the master's
|
||
description is passed, the id (GUID) will be looked up by this
|
||
method prior to invoking the engine. See below.
|
||
|
||
oldMasterMediaName - A wide character string representing the master media's
|
||
description (display name). If this argument is passed with a valid
|
||
string, the string is used to look up the oldMasterMediaId above.
|
||
|
||
copySet - The copyset number of the copy to use for the recreation or zero, which
|
||
indicates that the Engine should just use the most recent copy
|
||
|
||
Return Value:
|
||
|
||
S_OK - The call succeeded (the specified master was re-created).
|
||
|
||
E_FAIL - Could not get host computer's name (highly unexpected error).
|
||
|
||
E_UNEXPECTED - The argument 'oldMasterMediaId' equaled GUID_NULL just prior to
|
||
calling the HSM Engine to re-create a media master. This argument should
|
||
either be received with a valid value (the norm), or it should be set by this
|
||
method if a valid media description was passed in as 'oldMasterMediaName'.
|
||
|
||
Any other value - The call failed because one of the Remote Storage API calls
|
||
contained internally in this method failed. The error value returned is
|
||
specific to the API call which failed.
|
||
|
||
--*/
|
||
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
try {
|
||
CComPtr<IHsmServer> pServer;
|
||
|
||
WsbAffirmHr(ConnectToServer(&pServer));
|
||
|
||
// If we were passed a media name, find its id. Since the name option is
|
||
// presently only used internally and it bypasses the UI, also mark
|
||
// the media record for re-creation (normally done by the UI) otherwise
|
||
// the RecreateMaster() call below will fail.
|
||
|
||
// If the string is not null...
|
||
if ( oldMasterMediaName != 0 ) {
|
||
// and if the 1st character of the string is not the null terminator
|
||
if ( *oldMasterMediaName != 0 ) {
|
||
WsbAffirmHr(pServer->FindMediaIdByDescription(oldMasterMediaName,
|
||
&oldMasterMediaId));
|
||
WsbAffirmHr(pServer->MarkMediaForRecreation(oldMasterMediaId));
|
||
}
|
||
}
|
||
|
||
// Ensure we have a non-null media id
|
||
WsbAffirm( oldMasterMediaId != GUID_NULL, E_UNEXPECTED );
|
||
|
||
// Re-create the master media.
|
||
WsbAffirmHr(pServer->RecreateMaster( oldMasterMediaId, copySet ));
|
||
|
||
} WsbCatch(hr);
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
static void
|
||
ReportError(
|
||
IN HRESULT hr
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Report errors.
|
||
|
||
Arguments:
|
||
|
||
hr - The error.
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
CWsbStringPtr BoxTitle;
|
||
CWsbStringPtr BoxString;
|
||
CWsbStringPtr BoxString1;
|
||
CWsbStringPtr BoxString2;
|
||
CWsbStringPtr BoxString3;
|
||
CWsbStringPtr BoxString4;
|
||
CWsbStringPtr BoxString5;
|
||
CWsbStringPtr BoxString6;
|
||
BOOL displayMsg = FALSE;
|
||
UINT style = MB_OK;
|
||
|
||
#if DBG
|
||
if (E_INVALIDARG == hr) {
|
||
// If this is a Debug build then command line invocation is allowed.
|
||
// (Debug build implies Development/Test usage.)
|
||
// Tell them the valid command lines. Since this program, originally
|
||
// written as a console app, is now linked as a Windows program, pop
|
||
// this up as a message box.
|
||
|
||
// define the lines of text to appear in the message box
|
||
BoxString = L"Remote Storage Launch Program\r\n";
|
||
BoxString1 = L"allowable command line options:\r\n\n";
|
||
BoxString2 = L" RSLAUNCH run <job name>\r\n";
|
||
BoxString3 = L" RSLAUNCH sync <copyset number>\r\n";
|
||
BoxString4 = L" RSLAUNCH sync <pool name> <copyset number>\r\n";
|
||
BoxString5 = L" RSLAUNCH recreate -i <media id> [-c <copyset number>]\r\n";
|
||
BoxString6 = L" RSLAUNCH recreate -n <media name> [-c <copyset number>]\r\n";
|
||
|
||
// display the Help message box
|
||
style = MB_OK | MB_ICONEXCLAMATION | MB_SETFOREGROUND;
|
||
displayMsg = TRUE;
|
||
|
||
} else {
|
||
|
||
// message box text lines
|
||
BoxString = L"An error occurred while Remote Storage Launch was launching a job.\n";
|
||
BoxString1 = WsbHrAsString(hr);
|
||
|
||
// display the Error message box
|
||
style = MB_OK | MB_ICONERROR | MB_TOPMOST;
|
||
displayMsg = TRUE;
|
||
}
|
||
|
||
#else
|
||
if (E_INVALIDARG == hr) {
|
||
// error message box if the Release version:
|
||
|
||
// message box text lines
|
||
BoxString.LoadFromRsc( g_hInstance, IDS_INVALID_PARAMETER );
|
||
|
||
// display the Error message box
|
||
style = MB_OK | MB_ICONERROR | MB_SETFOREGROUND;
|
||
displayMsg = TRUE;
|
||
}
|
||
#endif // DBG
|
||
|
||
if (displayMsg) {
|
||
// concatenate all text lines
|
||
BoxString.Append( BoxString1 );
|
||
BoxString.Append( BoxString2 );
|
||
BoxString.Append( BoxString3 );
|
||
BoxString.Append( BoxString4 );
|
||
BoxString.Append( BoxString5 );
|
||
BoxString.Append( BoxString6 );
|
||
WsbAffirm(0 != (WCHAR *)BoxString, E_OUTOFMEMORY);
|
||
|
||
// message box title line
|
||
WsbAffirmHr(BoxTitle.LoadFromRsc( g_hInstance, IDS_APPLICATION_TITLE ));
|
||
|
||
// display the Help message box
|
||
MessageBox( NULL, BoxString, BoxTitle, style);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
static HRESULT
|
||
RunJob(
|
||
IN OLECHAR* jobName,
|
||
OUT IHsmJob** ppJob
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine implements the method for running a Remote Storage job.
|
||
|
||
Arguments:
|
||
|
||
jobName - A wide character string containing the name of the job to run.
|
||
|
||
ppJob - Pointer to pointer to Job interface obtained from the server
|
||
|
||
Return Value:
|
||
|
||
S_OK - The call succeeded (the specified job ran successfully).
|
||
|
||
E_POINTER - Input argument 'jobName' is null.
|
||
|
||
E_FAIL - Used to indicate 2 error conditions:
|
||
1. could not get host computer's name (highly unexpected error);
|
||
2. the job run by this method returned an HRESULT other than S_OK.
|
||
|
||
Any other value - The call failed because one of the Remote Storage API calls
|
||
contained internally in this method failed. The error value returned is
|
||
specific to the API call which failed.
|
||
|
||
--*/
|
||
|
||
{
|
||
HRESULT hr = S_OK;
|
||
|
||
try {
|
||
CComPtr<IHsmServer> pServer;
|
||
|
||
WsbAssert(0 != jobName, E_POINTER);
|
||
WsbAssert(ppJob, E_POINTER);
|
||
WsbAffirmHr(ConnectToServer(&pServer));
|
||
|
||
// Find the job, start the job, wait for the job to complete.
|
||
WsbAffirmHr(pServer->FindJobByName(jobName, ppJob));
|
||
WsbAffirmHr((*ppJob)->Start());
|
||
WsbAffirmHr((*ppJob)->WaitUntilDone());
|
||
|
||
} WsbCatch(hr);
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|
||
|
||
static HRESULT
|
||
SynchronizeMedia(
|
||
IN OLECHAR* poolName,
|
||
IN USHORT copySet
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine implements the method that will cause the updating (synchronizing) of
|
||
an entire copy set by calling the appropriate method on the Remote Storage engine.
|
||
Specifically, this method causes all copy media belonging to a specified copy set
|
||
to be checked for synchronization (being up to date) with each of their respective
|
||
master media. Those out of date will be brought up to date. Running this method
|
||
assumes that Remote Storage has already been configured for a certain number of
|
||
copy sets.
|
||
|
||
Arguments:
|
||
|
||
poolName - A wide character string containing the name of a specific storage pool
|
||
that the user wants the specified copy set synchronized for. If this
|
||
argument is passed as NULL then all storage pools will have the specified
|
||
copy set synchronized.
|
||
|
||
copySet - A number indicating which copy set is to be synchronized.
|
||
|
||
Return Value:
|
||
|
||
S_OK - The call succeeded (the specified copy set of the specified storage pool was
|
||
updated).
|
||
|
||
E_FAIL - Could not get host computer's name (highly unexpected error).
|
||
|
||
Any other value - The call failed because one of the Remote Storage API calls
|
||
contained internally in this method failed. The error value returned is
|
||
specific to the API call which failed.
|
||
|
||
--*/
|
||
|
||
{
|
||
HRESULT hr = S_OK;
|
||
GUID poolId = GUID_NULL;
|
||
CComPtr<IHsmStoragePool> pPool;
|
||
|
||
try {
|
||
CComPtr<IHsmServer> pServer;
|
||
|
||
WsbAffirmHr(ConnectToServer(&pServer));
|
||
|
||
// If they specified a pool, then find it's id.
|
||
if ( poolName != 0 ) {
|
||
if ( *poolName != 0 ) {
|
||
CWsbStringPtr tmpString;
|
||
|
||
WsbAffirmHr(pServer->FindStoragePoolByName(poolName, &pPool));
|
||
WsbAffirmHr(pPool->GetMediaSet(&poolId, &tmpString));
|
||
}
|
||
}
|
||
|
||
// Synchronize the media. Note that if no pool name was passed in, we pass
|
||
// GUID_NULL as the pool id.
|
||
WsbAffirmHr(pServer->SynchronizeMedia(poolId, copySet));
|
||
|
||
} WsbCatch(hr);
|
||
|
||
return(hr);
|
||
}
|
||
|
||
// WindowProc - Needed for our invisible window
|
||
static LRESULT CALLBACK
|
||
WindowProc(
|
||
HWND hwnd,
|
||
UINT uMsg,
|
||
WPARAM wParam,
|
||
LPARAM lParam
|
||
)
|
||
{
|
||
LTRACE((L"WindowProc: msg = %4.4x\n", uMsg));
|
||
return(DefWindowProc(hwnd, uMsg, wParam, lParam));
|
||
}
|
||
|
||
|
||
//****************************** MAIN *********************************
|
||
|
||
extern "C"
|
||
int WINAPI wWinMain(HINSTANCE hInstance,
|
||
HINSTANCE /*hPrevInstance*/,
|
||
LPTSTR lpCmdLine,
|
||
int /*nShowCmd*/
|
||
)
|
||
{
|
||
HRESULT hr = S_OK;
|
||
#if defined(RSL_TRACE)
|
||
CComPtr<IWsbTrace> pTrace;
|
||
#endif
|
||
|
||
// Store our instance handle so it can be used by called code.
|
||
g_hInstance = hInstance;
|
||
|
||
try {
|
||
HANDLE hJobThread[1] = { NULL };
|
||
DO_WORK_DATA workData = { NULL, WORK_NONE, E_FAIL, NULL };
|
||
|
||
// Register & create our invisible window
|
||
WsbAssert(CreateOurWindow(hInstance), E_FAIL);
|
||
|
||
// Initialize COM
|
||
WsbAffirmHr(CoInitializeEx(NULL, COINIT_MULTITHREADED));
|
||
|
||
// This provides a NULL DACL which will allow access to everyone.
|
||
CSecurityDescriptor sd;
|
||
sd.InitializeFromThreadToken();
|
||
WsbAffirmHr(CoInitializeSecurity(sd, -1, NULL, NULL,
|
||
RPC_C_AUTHN_LEVEL_CONNECT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL,
|
||
EOAC_NONE, NULL));
|
||
|
||
try {
|
||
DWORD ThreadId = 0;
|
||
|
||
#if defined(RSL_TRACE)
|
||
// Start tracing
|
||
CoCreateInstance(CLSID_CWsbTrace, 0, CLSCTX_SERVER, IID_IWsbTrace,
|
||
(void **) &pTrace);
|
||
pTrace->DirectOutput(WSB_TRACE_OUT_DEBUG_SCREEN | WSB_TRACE_OUT_FILE);
|
||
pTrace->SetTraceFileControls(TRACE_FILE, FALSE, 3000000, NULL);
|
||
pTrace->SetOutputFormat(TRUE, TRUE, TRUE);
|
||
pTrace->SetTraceSettings(0xffffffffffffffffL);
|
||
pTrace->StartTrace();
|
||
#endif
|
||
|
||
LTRACE((L"Main: lpCmdLine = %ls\n", lpCmdLine));
|
||
workData.pCmdLine = lpCmdLine;
|
||
|
||
// Create a thread to start the work and wait for it
|
||
// to finish
|
||
LTRACE((L"Main: creating thread for DoWork\n"));
|
||
hJobThread[0] = CreateThread(0, 0, DoWork,
|
||
static_cast<void*>(&workData), 0, &ThreadId);
|
||
if (!hJobThread[0]) {
|
||
LTRACE((L"Main: CreateThread failed\n"));
|
||
WsbThrow(HRESULT_FROM_WIN32(GetLastError()));
|
||
}
|
||
|
||
// Don't exit if we're waiting for work to complete
|
||
while (TRUE) {
|
||
DWORD exitcode;
|
||
DWORD waitStatus;
|
||
|
||
// Wait for a message or thread to end
|
||
LTRACE((L"Main: waiting for multiple objects\n"));
|
||
waitStatus = MsgWaitForMultipleObjects(1, hJobThread, FALSE,
|
||
INFINITE, QS_ALLINPUT);
|
||
|
||
// Find out which event happened
|
||
if (WAIT_OBJECT_0 == waitStatus) {
|
||
|
||
// The thread ended; get it's exit code
|
||
LTRACE((L"Main: got event on thread\n"));
|
||
if (GetExitCodeThread(hJobThread[0], &exitcode)) {
|
||
if (STILL_ACTIVE == exitcode) {
|
||
// This shouldn't happen; don't know what to do!
|
||
} else {
|
||
WsbThrow(static_cast<HRESULT>(exitcode));
|
||
}
|
||
} else {
|
||
WsbThrow(HRESULT_FROM_WIN32(GetLastError()));
|
||
}
|
||
|
||
} else if ((WAIT_OBJECT_0 + 1) == waitStatus) {
|
||
|
||
// Message in queue
|
||
MSG msg;
|
||
|
||
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
|
||
LTRACE((L"Main: message = %4.4x\n", msg.message));
|
||
if (WM_CLOSE == msg.message) {
|
||
|
||
// Cancel the job since someone cancelled us.
|
||
// (Should we kill the thread that is waiting?)
|
||
LTRACE((L"Main: got WM_CLOSE\n"));
|
||
WsbThrow(CancelWork(&workData));
|
||
}
|
||
DispatchMessage(&msg);
|
||
}
|
||
|
||
} else if (0xFFFFFFFF == waitStatus) {
|
||
|
||
// Error in MsgWaitForMultipleObjects
|
||
WsbThrow(HRESULT_FROM_WIN32(GetLastError()));
|
||
|
||
} else {
|
||
|
||
// This shouldn't happend; don't know what to do
|
||
}
|
||
}
|
||
|
||
} WsbCatch(hr);
|
||
|
||
if (hJobThread[0]) {
|
||
CloseHandle(hJobThread[0]);
|
||
}
|
||
|
||
if (workData.pJob) {
|
||
workData.pJob->Release();
|
||
}
|
||
|
||
// Cleanup COM
|
||
CoUninitialize();
|
||
|
||
} WsbCatch(hr);
|
||
|
||
LTRACE((L"Main: exit hr = %ls\n", WsbHrAsString(hr)));
|
||
if (FAILED(hr)) {
|
||
ReportError(hr);
|
||
}
|
||
|
||
return(hr);
|
||
}
|
||
|
||
|