You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1273 lines
27 KiB
1273 lines
27 KiB
/*++
|
|
|
|
© 1998 Seagate Software, Inc. All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
hsmsesst.cpp
|
|
|
|
Abstract:
|
|
|
|
This class is the phase component, which keeps track the status/totals for a phase of a
|
|
session.
|
|
|
|
Author:
|
|
|
|
Chuck Bardeen [cbardeen] 14-Feb-1997
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "wsb.h"
|
|
#include "job.h"
|
|
#include "hsmphase.h"
|
|
|
|
#define WSB_TRACE_IS WSB_TRACE_BIT_JOB
|
|
|
|
static USHORT iCount = 0;
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::AddItem(
|
|
IN IFsaScanItem* pItem,
|
|
IN HRESULT hrItem
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhasePriv::AddItem().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LONGLONG size;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPhase::AddItem"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
// Did they give us a valid item to compare to?
|
|
WsbAssert(0 != pItem, E_POINTER);
|
|
|
|
// Get the size of the file.
|
|
WsbAffirmHr(pItem->GetLogicalSize(&size));
|
|
|
|
// Update the appropriate stats.
|
|
switch (hrItem) {
|
|
case S_OK:
|
|
m_items++;
|
|
m_size += size;
|
|
break;
|
|
case S_FALSE:
|
|
case JOB_E_FILEEXCLUDED:
|
|
case JOB_E_DOESNTMATCH:
|
|
case FSA_E_REPARSE_NOT_WRITTEN_FILE_CHANGED:
|
|
case HSM_E_FILE_CHANGED:
|
|
case HSM_E_WORK_SKIPPED_FILE_TOO_BIG:
|
|
m_skippedItems++;
|
|
m_skippedSize += size;
|
|
break;
|
|
default:
|
|
m_errorItems++;
|
|
m_errorSize += size;
|
|
break;
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPhase::AddItem"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::Clone(
|
|
OUT IHsmPhase** ppPhase
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::Clone().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CComPtr<IHsmPhase> pPhase;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPhase::Clone"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
// Did they give us a valid item?
|
|
WsbAssert(0 != ppPhase, E_POINTER);
|
|
*ppPhase = 0;
|
|
|
|
// Create the new instance.
|
|
WsbAffirmHr(CoCreateInstance(CLSID_CHsmPhase, 0, CLSCTX_ALL, IID_IHsmPhase, (void**) &pPhase));
|
|
|
|
// Fill it in with the new values.
|
|
WsbAffirmHr(CopyTo(pPhase));
|
|
|
|
// Return it to the caller.
|
|
*ppPhase = pPhase;
|
|
pPhase.p->AddRef();
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPhase::Clone"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::Clone(
|
|
OUT IHsmPhasePriv** ppPhasePriv
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhasePriv::Clone().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CComPtr<IHsmPhasePriv> pPhasePriv;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPhase::Clone"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
// Did they give us a valid item?
|
|
WsbAssert(0 != ppPhasePriv, E_POINTER);
|
|
*ppPhasePriv = 0;
|
|
|
|
// Create the new instance.
|
|
WsbAffirmHr(CoCreateInstance(CLSID_CHsmPhase, 0, CLSCTX_ALL, IID_IHsmPhasePriv, (void**) &pPhasePriv));
|
|
|
|
// Fill it in with the new values.
|
|
WsbAffirmHr(CopyTo(pPhasePriv));
|
|
|
|
// Return it to the caller.
|
|
*ppPhasePriv = pPhasePriv;
|
|
pPhasePriv.p->AddRef();
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPhase::Clone"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::CompareTo(
|
|
IN IUnknown* pUnknown,
|
|
OUT SHORT* pResult
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbCollectable::CompareTo().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CComPtr<IHsmPhase> pPhase;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPhase::CompareTo"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
// Did they give us a valid item to compare to?
|
|
WsbAssert(0 != pUnknown, E_POINTER);
|
|
|
|
// We need the IWsbBool interface to get the value of the object.
|
|
WsbAffirmHr(pUnknown->QueryInterface(IID_IHsmPhase, (void**) &pPhase));
|
|
|
|
// Compare the rules.
|
|
hr = CompareToIPhase(pPhase, pResult);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPhase::CompareTo"), OLESTR("hr = <%ls>, result = <%ls>"), WsbHrAsString(hr), WsbPtrToShortAsString(pResult));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::CompareToPhase(
|
|
IN HSM_JOB_PHASE phase,
|
|
OUT SHORT* pResult
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::CompareToPhase().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SHORT aResult = 0;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPhase::CompareToPhase"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
// Compare the guids.
|
|
if (m_phase > phase) {
|
|
aResult = 1;
|
|
}
|
|
else if (m_phase < phase) {
|
|
aResult = -1;
|
|
}
|
|
|
|
if (0 != aResult) {
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
if (0 != pResult) {
|
|
*pResult = aResult;
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPhase::CompareToPhase"), OLESTR("hr = <%ls>, result = <%d>"), WsbHrAsString(hr), aResult);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::CompareToIPhase(
|
|
IN IHsmPhase* pPhase,
|
|
OUT SHORT* pResult
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::CompareToIPhase().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
HSM_JOB_PHASE phase;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPhase::CompareToIPhase"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
// Did they give us a valid item to compare to?
|
|
WsbAssert(0 != pPhase, E_POINTER);
|
|
|
|
// Get the identifier.
|
|
WsbAffirmHr(pPhase->GetPhase(&phase));
|
|
|
|
// Compare to the identifier.
|
|
hr = CompareToPhase(phase, pResult);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPhase::CompareToIPhase"), OLESTR("hr = <%ls>, result = <%ls>"), WsbHrAsString(hr), WsbPtrToShortAsString(pResult));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::CopyTo(
|
|
IN IHsmPhase* pPhase
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::CopyTo().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CComPtr<IHsmPhasePriv> pPhasePriv;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPhase::CopyTo"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
// Did they give us a valid item?
|
|
WsbAssert(0 != pPhase, E_POINTER);
|
|
|
|
// Get the private interface for the destination and copy the values.
|
|
WsbAffirmHr(pPhase->QueryInterface(IID_IHsmPhasePriv, (void**) &pPhasePriv));
|
|
WsbAffirmHr(pPhasePriv->SetInternalStuff(m_mountCount, m_transferCount, m_elapsedTime, m_startTime, m_restartTime, m_stopTime));
|
|
WsbAffirmHr(pPhasePriv->SetMediaState(m_mediaState));
|
|
WsbAffirmHr(pPhasePriv->SetPhase(m_phase));
|
|
WsbAffirmHr(pPhasePriv->SetPriority(m_priority));
|
|
WsbAffirmHr(pPhasePriv->SetState(m_state));
|
|
WsbAffirmHr(pPhasePriv->SetStats(m_items, m_size, m_skippedItems, m_skippedSize, m_errorItems, m_errorSize));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPhase::CopyTo"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::CopyTo(
|
|
IN IHsmPhasePriv* pPhasePriv
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::CopyTo().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPhase::CopyTo"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
// Did they give us a valid item?
|
|
WsbAssert(0 != pPhasePriv, E_POINTER);
|
|
|
|
// Get the private interface for the destination and copy the values.
|
|
WsbAffirmHr(pPhasePriv->SetInternalStuff(m_mountCount, m_transferCount, m_elapsedTime, m_startTime, m_restartTime, m_stopTime));
|
|
WsbAffirmHr(pPhasePriv->SetMediaState(m_mediaState));
|
|
WsbAffirmHr(pPhasePriv->SetPhase(m_phase));
|
|
WsbAffirmHr(pPhasePriv->SetPriority(m_priority));
|
|
WsbAffirmHr(pPhasePriv->SetState(m_state));
|
|
WsbAffirmHr(pPhasePriv->SetStats(m_items, m_size, m_skippedItems, m_skippedSize, m_errorItems, m_errorSize));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPhase::CopyTo"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::FinalConstruct(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
CComObjectRoot::FinalConstruct().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPhase::FinalConstruct"), OLESTR(""));
|
|
try {
|
|
|
|
WsbAffirmHr(CWsbObject::FinalConstruct());
|
|
|
|
m_mediaState = HSM_JOB_MEDIA_STATE_IDLE;
|
|
m_mountCount = 0;
|
|
m_transferCount = 0;
|
|
m_phase = HSM_JOB_PHASE_ALL;
|
|
m_priority = HSM_JOB_PRIORITY_NORMAL;
|
|
m_state = HSM_JOB_STATE_IDLE;
|
|
m_items = 0;
|
|
m_size = 0;
|
|
m_skippedItems = 0;
|
|
m_skippedSize = 0;
|
|
m_errorItems = 0;
|
|
m_errorSize = 0;
|
|
m_elapsedTime = 0;
|
|
m_startTime.dwLowDateTime = 0;
|
|
m_startTime.dwHighDateTime = 0;
|
|
m_restartTime.dwLowDateTime = 0;
|
|
m_restartTime.dwHighDateTime = 0;
|
|
m_stopTime.dwLowDateTime = 0;
|
|
m_stopTime.dwHighDateTime = 0;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
iCount++;
|
|
WsbTraceOut(OLESTR("CHsmPhase::FinalConstruct"), OLESTR("hr = <%ls>, count is <%d>"), WsbHrAsString(hr), iCount);
|
|
return(hr);
|
|
}
|
|
|
|
|
|
void
|
|
CHsmPhase::FinalRelease(
|
|
void
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
CHsmPhase::FinalRelease().
|
|
|
|
--*/
|
|
{
|
|
|
|
WsbTraceIn(OLESTR("CHsmPhase::FinalRelease"), OLESTR(""));
|
|
|
|
CWsbObject::FinalRelease();
|
|
iCount--;
|
|
|
|
WsbTraceOut(OLESTR("CHsmPhase::FinalRelease"), OLESTR("Count is <%d>"), iCount);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::GetClassID(
|
|
OUT CLSID* pClsid
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersist::GetClassID().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPhase::GetClassID"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pClsid, E_POINTER);
|
|
*pClsid = CLSID_CHsmPhase;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPhase::GetClassID"), OLESTR("hr = <%ls>, CLSID = <%ls>"), WsbHrAsString(hr), WsbGuidAsString(*pClsid));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::GetElapsedTime(
|
|
OUT ULONG* pDays,
|
|
OUT USHORT* pHours,
|
|
OUT USHORT* pMinutes,
|
|
OUT USHORT* pSeconds
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::GetElapsedTime().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LONGLONG remainingTime = 0;
|
|
FILETIME currentTime;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pDays, E_POINTER);
|
|
WsbAssert(0 != pHours, E_POINTER);
|
|
WsbAssert(0 != pMinutes, E_POINTER);
|
|
WsbAssert(0 != pSeconds, E_POINTER);
|
|
|
|
// If the phase is still active, then add the time since the last start or restart.
|
|
remainingTime = m_elapsedTime;
|
|
|
|
if (HSM_JOB_STATE_IS_ACTIVE(m_state)) {
|
|
WsbAffirmHr(CoFileTimeNow(¤tTime));
|
|
|
|
if (WsbFTtoLL(m_restartTime) != 0) {
|
|
remainingTime += WsbFTtoLL(currentTime) - WsbFTtoLL(m_restartTime);
|
|
} else {
|
|
remainingTime += WsbFTtoLL(currentTime) - WsbFTtoLL(m_startTime);
|
|
}
|
|
}
|
|
|
|
*pDays = (ULONG) (remainingTime / WSB_FT_TICKS_PER_DAY);
|
|
remainingTime = remainingTime % WSB_FT_TICKS_PER_DAY;
|
|
|
|
*pHours = (USHORT) (remainingTime / (WSB_FT_TICKS_PER_HOUR));
|
|
remainingTime = remainingTime % WSB_FT_TICKS_PER_HOUR;
|
|
|
|
*pMinutes = (USHORT) (remainingTime / WSB_FT_TICKS_PER_MINUTE);
|
|
*pSeconds = (USHORT) ((remainingTime % WSB_FT_TICKS_PER_MINUTE) / WSB_FT_TICKS_PER_SECOND);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::GetMediaState(
|
|
OUT HSM_JOB_MEDIA_STATE* pState
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::GetMediaState().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pState, E_POINTER);
|
|
*pState = m_mediaState;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::GetMediaStateAsString(
|
|
OUT OLECHAR** pName,
|
|
IN ULONG bufferSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::GetMediaStateAsString().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CWsbStringPtr tmpString;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pName, E_POINTER);
|
|
|
|
WsbAffirmHr(tmpString.LoadFromRsc(_Module.m_hInst, IDS_HSMJOBMEDIASTATEIDLE + m_mediaState));
|
|
WsbAffirmHr(tmpString.CopyTo(pName, bufferSize));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::GetName(
|
|
OUT OLECHAR** pName,
|
|
IN ULONG bufferSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::GetName().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CWsbStringPtr tmpString;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pName, E_POINTER);
|
|
|
|
WsbAffirmHr(tmpString.LoadFromRsc(_Module.m_hInst, IDS_HSMJOBPHASEALL + m_phase));
|
|
WsbAffirmHr(tmpString.CopyTo(pName, bufferSize));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::GetPhase(
|
|
OUT HSM_JOB_PHASE* pPhase
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::GetPhase().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pPhase, E_POINTER);
|
|
*pPhase = m_phase;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::GetPriority(
|
|
OUT HSM_JOB_PRIORITY* pPriority
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::GetPriority().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pPriority, E_POINTER);
|
|
*pPriority = m_priority;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::GetPriorityAsString(
|
|
OUT OLECHAR** pName,
|
|
IN ULONG bufferSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::GetPriorityAsString().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CWsbStringPtr tmpString;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pName, E_POINTER);
|
|
|
|
WsbAffirmHr(tmpString.LoadFromRsc(_Module.m_hInst, IDS_HSMJOBPRIORITY_IDLE + m_priority));
|
|
WsbAffirmHr(tmpString.CopyTo(pName, bufferSize));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::GetSizeMax(
|
|
OUT ULARGE_INTEGER* pSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::GetSizeMax().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
|
|
WsbTraceIn(OLESTR("CHsmPhase::GetSizeMax"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pSize, E_POINTER);
|
|
|
|
// Determine the size for a rule with no criteria.
|
|
pSize->QuadPart = 5 * WsbPersistSizeOf(LONGLONG) + 6 * WsbPersistSizeOf(ULONG) + 3 * WsbPersistSizeOf(FILETIME);
|
|
|
|
// In theory we should be saving the errorItems and errorSize, but at the
|
|
// time this was added, we didn't want to force a reinstall because of
|
|
// pSize->QuadPart += 2 * WsbPersistSizeOf(LONGLONG);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPhase::GetSizeMax"), OLESTR("hr = <%ls>, Size = <%ls>"), WsbHrAsString(hr), WsbPtrToUliAsString(pSize));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::GetStartTime(
|
|
OUT FILETIME* pTime
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::GetStartTime().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pTime, E_POINTER);
|
|
*pTime = m_startTime;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::GetState(
|
|
OUT HSM_JOB_STATE* pState
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::GetState().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pState, E_POINTER);
|
|
*pState = m_state;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::GetStateAsString(
|
|
OUT OLECHAR** pName,
|
|
IN ULONG bufferSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::GetStateAsString().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CWsbStringPtr tmpString;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pName, E_POINTER);
|
|
|
|
WsbAffirmHr(tmpString.LoadFromRsc(_Module.m_hInst, IDS_HSMJOBSTATEACTIVE + m_state));
|
|
WsbAffirmHr(tmpString.CopyTo(pName, bufferSize));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::GetStats(
|
|
OUT LONGLONG* pItems,
|
|
OUT LONGLONG* pSize,
|
|
OUT LONGLONG* pSkippedItems,
|
|
OUT LONGLONG* pSkippedSize,
|
|
OUT LONGLONG* pErrorItems,
|
|
OUT LONGLONG* pErrorSize
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::GetStats().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (0 != pItems) {
|
|
*pItems = m_items;
|
|
}
|
|
|
|
if (0 != pSize) {
|
|
*pSize = m_size;
|
|
}
|
|
|
|
if (0 != pSkippedItems) {
|
|
*pSkippedItems = m_skippedItems;
|
|
}
|
|
|
|
if (0 != pSkippedSize) {
|
|
*pSkippedSize = m_skippedSize;
|
|
}
|
|
|
|
if (0 != pErrorItems) {
|
|
*pErrorItems = m_errorItems;
|
|
}
|
|
|
|
if (0 != pSize) {
|
|
*pErrorSize = m_errorSize;
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::GetStopTime(
|
|
OUT FILETIME* pTime
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::GetStopTime().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pTime, E_POINTER);
|
|
*pTime = m_stopTime;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::Load(
|
|
IN IStream* pStream
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::Load().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPhase::Load"), OLESTR(""));
|
|
|
|
try {
|
|
ULONG ul_tmp;
|
|
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
// Do the easy stuff, but make sure that this order matches the order
|
|
// in the load method.
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &ul_tmp));
|
|
m_mediaState = static_cast<HSM_JOB_MEDIA_STATE>(ul_tmp);
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_mountCount));
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_transferCount));
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &ul_tmp));
|
|
m_phase = static_cast<HSM_JOB_PHASE>(ul_tmp);
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &ul_tmp));
|
|
m_priority = static_cast<HSM_JOB_PRIORITY>(ul_tmp);
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &ul_tmp));
|
|
m_state = static_cast<HSM_JOB_STATE>(ul_tmp);
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_items));
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_size));
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_skippedItems));
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_skippedSize));
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_elapsedTime));
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_startTime));
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_restartTime));
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_stopTime));
|
|
|
|
// In theory we should be saving the errorItems and errorSize, but at the
|
|
// time this was added, we didn't want to force a reinstall because of
|
|
// changes in the persistant data.
|
|
// WsbAffirmHr(WsbLoadFromStream(pStream, &m_errorItems));
|
|
// WsbAffirmHr(WsbLoadFromStream(pStream, &m_errorSize));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPhase::Load"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::Save(
|
|
IN IStream* pStream,
|
|
IN BOOL clearDirty
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::Save().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPhase::Save"), OLESTR("clearDirty = <%ls>"), WsbBoolAsString(clearDirty));
|
|
|
|
try {
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
// Do the easy stuff, but make sure that this order matches the order
|
|
// in the load method.
|
|
WsbAffirmHr(WsbSaveToStream(pStream, static_cast<ULONG>(m_mediaState)));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_mountCount));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_transferCount));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, static_cast<ULONG>(m_phase)));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, static_cast<ULONG>(m_priority)));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, static_cast<ULONG>(m_state)));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_items));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_size));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_skippedItems));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_skippedSize));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_elapsedTime));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_startTime));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_restartTime));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_stopTime));
|
|
|
|
// In theory we should be saving the errorItems and errorSize, but at the
|
|
// time this was added, we didn't want to force a reinstall because of
|
|
// changes in the persistant data.
|
|
// WsbAffirmHr(WsbSaveToStream(pStream, m_errorItems));
|
|
// WsbAffirmHr(WsbSaveToStream(pStream, m_errorSize));
|
|
|
|
// If we got it saved and we were asked to clear the dirty bit, then
|
|
// do so now.
|
|
if (clearDirty) {
|
|
m_isDirty = FALSE;
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPhase::Save"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::SetInternalStuff(
|
|
IN ULONG mountCount,
|
|
IN ULONG transferCount,
|
|
IN LONGLONG elapsedTime,
|
|
IN FILETIME startTime,
|
|
IN FILETIME restartTime,
|
|
IN FILETIME stopTime
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhasePriv::SetInternalStuff().
|
|
|
|
--*/
|
|
{
|
|
m_mountCount = mountCount;
|
|
m_transferCount = transferCount;
|
|
m_elapsedTime = elapsedTime;
|
|
m_startTime = startTime;
|
|
m_restartTime = restartTime;
|
|
m_stopTime = stopTime;
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::SetMediaState(
|
|
IN HSM_JOB_MEDIA_STATE state
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhasePriv::SetMediaState().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// Determine whether the state being reported will cause the overall state to
|
|
// change. The overall state should be mounted/transferring/transferred if any
|
|
// media are mounted.
|
|
|
|
switch (state) {
|
|
case HSM_JOB_MEDIA_STATE_BUSY:
|
|
case HSM_JOB_MEDIA_STATE_UNAVAILABLE:
|
|
if ((HSM_JOB_MEDIA_STATE_IDLE == m_mediaState) ||
|
|
(HSM_JOB_MEDIA_STATE_MOUNTING == m_mediaState)) {
|
|
m_mediaState = state;
|
|
}
|
|
break;
|
|
|
|
case HSM_JOB_MEDIA_STATE_MOUNTING:
|
|
if ((HSM_JOB_MEDIA_STATE_MOUNTED != m_mediaState) &&
|
|
(HSM_JOB_MEDIA_STATE_TRANSFERRED != m_mediaState) &&
|
|
(HSM_JOB_MEDIA_STATE_TRANSFERRING != m_mediaState)) {
|
|
m_mediaState = state;
|
|
}
|
|
break;
|
|
|
|
case HSM_JOB_MEDIA_STATE_MOUNTED:
|
|
if ((HSM_JOB_MEDIA_STATE_MOUNTED != m_mediaState) &&
|
|
(HSM_JOB_MEDIA_STATE_TRANSFERRED != m_mediaState) &&
|
|
(HSM_JOB_MEDIA_STATE_TRANSFERRING != m_mediaState)) {
|
|
m_mediaState = state;
|
|
}
|
|
m_mountCount++;
|
|
break;
|
|
|
|
case HSM_JOB_MEDIA_STATE_TRANSFERRING:
|
|
if ((HSM_JOB_MEDIA_STATE_TRANSFERRING != m_mediaState) &&
|
|
(HSM_JOB_MEDIA_STATE_TRANSFERRED != m_mediaState)) {
|
|
m_mediaState = state;
|
|
}
|
|
m_transferCount++;
|
|
break;
|
|
|
|
case HSM_JOB_MEDIA_STATE_TRANSFERRED:
|
|
if (m_transferCount <= 1) {
|
|
m_mediaState = state;
|
|
}
|
|
m_transferCount--;
|
|
break;
|
|
|
|
case HSM_JOB_MEDIA_STATE_DISMOUNTING:
|
|
if (m_mountCount <= 1) {
|
|
m_mediaState = state;
|
|
}
|
|
break;
|
|
|
|
case HSM_JOB_MEDIA_STATE_DISMOUNTED:
|
|
if (m_mountCount <= 1) {
|
|
m_mediaState = state;
|
|
}
|
|
m_mountCount--;
|
|
break;
|
|
|
|
case HSM_JOB_MEDIA_STATE_FAILED:
|
|
m_mediaState = state;
|
|
break;
|
|
|
|
default:
|
|
case HSM_JOB_MEDIA_STATE_IDLE:
|
|
break;
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::SetPhase(
|
|
IN HSM_JOB_PHASE phase
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhase::SetPhase().
|
|
|
|
--*/
|
|
{
|
|
m_phase = phase;
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::SetPriority(
|
|
IN HSM_JOB_PRIORITY priority
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhasePriv::SetPriority().
|
|
|
|
--*/
|
|
{
|
|
m_priority = priority;
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::SetState(
|
|
IN HSM_JOB_STATE state
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhasePriv::SetState().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
FILETIME currentTime;
|
|
LONGLONG restartTicks;
|
|
LONGLONG stopTicks;
|
|
|
|
try {
|
|
|
|
GetSystemTimeAsFileTime(¤tTime);
|
|
|
|
switch(state) {
|
|
case HSM_JOB_STATE_ACTIVE:
|
|
// If this is a resume, then update the restartTime not the startTime.
|
|
if (HSM_JOB_STATE_RESUMING == m_state) {
|
|
m_restartTime = currentTime;
|
|
} else {
|
|
m_restartTime = WsbLLtoFT(0);
|
|
m_startTime = currentTime;
|
|
m_elapsedTime = 0;
|
|
}
|
|
m_state = state;
|
|
break;
|
|
|
|
case HSM_JOB_STATE_CANCELLED:
|
|
case HSM_JOB_STATE_DONE:
|
|
case HSM_JOB_STATE_FAILED:
|
|
case HSM_JOB_STATE_SKIPPED:
|
|
case HSM_JOB_STATE_PAUSED:
|
|
case HSM_JOB_STATE_SUSPENDED:
|
|
// Record the stop time and update the elapsed time.
|
|
m_stopTime = currentTime;
|
|
restartTicks = WsbFTtoLL(m_restartTime);
|
|
stopTicks = WsbFTtoLL(m_stopTime);
|
|
if (restartTicks == 0) {
|
|
m_elapsedTime = stopTicks - WsbFTtoLL(m_startTime);
|
|
} else {
|
|
m_elapsedTime += stopTicks - restartTicks;
|
|
}
|
|
m_state = state;
|
|
break;
|
|
|
|
case HSM_JOB_STATE_CANCELLING:
|
|
case HSM_JOB_STATE_IDLE:
|
|
case HSM_JOB_STATE_PAUSING:
|
|
case HSM_JOB_STATE_RESUMING:
|
|
case HSM_JOB_STATE_STARTING:
|
|
case HSM_JOB_STATE_SUSPENDING:
|
|
// Don't need to do anything for these other than record the state change.
|
|
m_state = state;
|
|
break;
|
|
|
|
default:
|
|
WsbAssert(FALSE, E_UNEXPECTED);
|
|
break;
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::SetStats(
|
|
IN LONGLONG items,
|
|
IN LONGLONG size,
|
|
IN LONGLONG skippedItems,
|
|
IN LONGLONG skippedSize,
|
|
IN LONGLONG errorItems,
|
|
IN LONGLONG errorSize
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPhasePriv::SetStats().
|
|
|
|
--*/
|
|
{
|
|
m_items = items;
|
|
m_size = size;
|
|
m_skippedItems = skippedItems;
|
|
m_skippedSize = skippedSize;
|
|
m_errorItems = errorItems;
|
|
m_errorSize = errorSize;
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPhase::Test(
|
|
USHORT* passed,
|
|
USHORT* failed
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTestable::Test().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != passed, E_POINTER);
|
|
WsbAssert(0 != failed, E_POINTER);
|
|
|
|
*passed = 0;
|
|
*failed = 0;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|