windows-xp/Source/XPSP1/NT/base/fs/hsm/engine/task/medinfo.cpp

/*++

Copyright (c) 1998 Seagate Software, Inc.  All rights reserved.

Module Name:

    MedInfo.cpp

Abstract:

    This component is an object representation of the HSM Metadata media information
    record.

Author:

    Cat Brant   [cbrant]   27-Feb-1997

Revision History:

--*/


#include "stdafx.h"

#include "wsbgen.h"
#include "engine.h"
#include "metaint.h"
#include "metalib.h"
#include "MedInfo.h"
#include "segdb.h"

#undef  WSB_TRACE_IS     
#define WSB_TRACE_IS        WSB_TRACE_BIT_META
static USHORT iCountMedinfo = 0;


HRESULT 
CMediaInfo::FinalConstruct(
    void
    ) 
/*++

Routine Description:

  This method does some initialization of the object that is necessary
  after construction.

Arguments:

  None.

Return Value:

  S_OK
  Anything returned by CWsbDbEntity::FinalConstruct().

--*/
{
    HRESULT     hr = S_OK;

    WsbTraceIn(OLESTR("CMediaInfo::FinalConstruct"),OLESTR(""));
    try {

        WsbAssertHr(CWsbDbEntity::FinalConstruct());

        //
        // Initialize the master media record
        //
        m_Master.id = GUID_NULL;
        m_Master.ntmsId = GUID_NULL;
        m_Master.storagePoolId = GUID_NULL;
        m_Master.description = OLESTR("");
        m_Master.name = OLESTR("");
        m_Master.type = HSM_JOB_MEDIA_TYPE_UNKNOWN;
        m_Master.lastUpdate = WsbLLtoFT(0);
        m_Master.lastError = S_OK;
        m_Master.recallOnly = FALSE;
        m_Master.freeBytes = 0;
        m_Master.capacity = 0;
        m_Master.nextRemoteDataSet = 0;
        
        m_Recreate = FALSE;
        m_LogicalValidBytes = 0;
        
        //
        // Now initialize the last known good master
        //
        m_LastKnownGoodMaster.id = GUID_NULL;
        m_LastKnownGoodMaster.ntmsId = GUID_NULL;
        m_LastKnownGoodMaster.storagePoolId = GUID_NULL;
        m_LastKnownGoodMaster.description = OLESTR("");
        m_LastKnownGoodMaster.name = OLESTR("");
        m_LastKnownGoodMaster.type = HSM_JOB_MEDIA_TYPE_UNKNOWN;
        m_LastKnownGoodMaster.lastUpdate = WsbLLtoFT(0);
        m_LastKnownGoodMaster.lastError = S_OK;
        m_LastKnownGoodMaster.recallOnly = FALSE;
        m_LastKnownGoodMaster.freeBytes = 0;
        m_LastKnownGoodMaster.capacity = 0;
        m_LastKnownGoodMaster.nextRemoteDataSet = 0;
            
        //
        // Initialize the master's copy media records
        //
        for (int i = 0; i < HSM_MAX_NUMBER_MEDIA_COPIES; i++)  {
            m_Copy[i].id = GUID_NULL;
            m_Copy[i].description = OLESTR("");
            m_Copy[i].name = OLESTR("");
            m_Copy[i].lastUpdate = WsbLLtoFT(0);
            m_Copy[i].lastError = S_OK;
            m_Copy[i].nextRemoteDataSet = 0;
        }            
        
    } WsbCatch(hr);
    iCountMedinfo++;
    WsbTraceOut(OLESTR("CMediaInfo::FinalConstruct"), OLESTR("hr = <%ls>, Count is <%d>"), 
            WsbHrAsString(hr), iCountMedinfo);
    return(hr);
}



void
CMediaInfo::FinalRelease(
    void
    )

/*++

Implements:

  CMediaInfo::FinalRelease().

--*/
{
    
    WsbTraceIn(OLESTR("CMediaInfo::FinalRelease"), OLESTR(""));
    
    CWsbDbEntity::FinalRelease();
    iCountMedinfo--;
    
    WsbTraceOut(OLESTR("CMediaInfo::FinalRelease"), OLESTR("Count is <%d>"), iCountMedinfo);
}



HRESULT
CMediaInfo::GetName(
    OLECHAR **pName,
    ULONG   bufferSize
    )
/*++

Implements:

  IMediaInfo::GetName

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetName"),OLESTR("buffer size = <%lu>"), bufferSize);
    try {
        WsbAssertPointer(pName);
        CWsbStringPtr tmpName;
        tmpName = m_Master.name;
        WsbAffirmHr(tmpName.CopyTo(pName, bufferSize));
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetName"), OLESTR("hr = <%ls>, Name = <%ls>"), WsbHrAsString(hr), WsbPtrToStringAsString(pName));
    return(hr);
}


HRESULT
CMediaInfo::GetCapacity( 
    LONGLONG *pCapacity 
    )
/*++

Implements:

  IMediaInfo::GetCapacity

--*/

{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetCapacity"),OLESTR(""));
    try {
        WsbAssertPointer(pCapacity);
        *pCapacity = m_Master.capacity;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetCapacity"), OLESTR("hr = <%ls>, Capacity = <%ls>"), WsbHrAsString(hr), WsbPtrToLonglongAsString(pCapacity));
    return(hr);
}

HRESULT CMediaInfo::GetClassID
(
    OUT LPCLSID pclsid
    ) 
/*++

Implements:

  IPerist::GetClassID()

--*/

{
    HRESULT     hr = S_OK;

    WsbTraceIn(OLESTR("CMediaInfo::GetClassID"), OLESTR(""));
    try {
        WsbAssert(0 != pclsid, E_POINTER);

        *pclsid = CLSID_CMediaInfo;

    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetClassID"), OLESTR("hr = <%ls>, CLSID = <%ls>"), WsbHrAsString(hr), WsbGuidAsString(*pclsid));
    return(hr);
}

HRESULT
CMediaInfo:: GetCopyName( 
    USHORT copyNumber, 
    OLECHAR **pName,
    ULONG   bufferSize
    )
/*++

Implements:

  IMediaInfo::GetCopyName

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetCopyName"),OLESTR(""));
    try {
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        WsbAssertPointer(pName);
        CWsbStringPtr tmpString;
        tmpString = m_Copy[copyNumber - 1].name;
        WsbAffirmHr(tmpString.CopyTo(pName, bufferSize));
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetCopyName"), OLESTR("hr = <%ls>, Name = <%ls>"), WsbHrAsString(hr), WsbPtrToStringAsString(pName));
    return(hr);
}

HRESULT
CMediaInfo:: GetCopyNextRemoteDataSet( 
    USHORT copyNumber, 
    SHORT  *pNextRemoteDataSet
    )
/*++

Implements:

  IMediaInfo::GetCopyNextRemoteDataSet

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetCopyNextRemoteDataSet"),OLESTR(""));
    try {
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        WsbAssertPointer(pNextRemoteDataSet);
        *pNextRemoteDataSet = m_Copy[copyNumber - 1].nextRemoteDataSet;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetCopyNextRemoteDataSet"), OLESTR("hr = <%ls>, NextRemoteDataSet = <%ls>"), WsbHrAsString(hr), WsbPtrToShortAsString(pNextRemoteDataSet));
    return(hr);
}

HRESULT
CMediaInfo::GetCopyDescription( 
    USHORT copyNumber, 
    OLECHAR **pDescription,
    ULONG   bufferSize
    )       
/*++

Implements:

  IMediaInfo::GetCopyDescription

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetCopyDescription"),OLESTR("Copy = <%u>"), copyNumber);
    try {
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        WsbAssertPointer(pDescription);
        CWsbStringPtr tmpDescription;
        tmpDescription = m_Copy[copyNumber - 1].description;
        WsbAffirmHr(tmpDescription.CopyTo(pDescription, bufferSize));
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetCopyDescription"), OLESTR("hr = <%ls>, CopyDescription = <%ls>"), WsbHrAsString(hr), WsbPtrToStringAsString(pDescription));
    return(hr);
}


HRESULT
CMediaInfo::GetCopyInfo( 
    USHORT copyNumber, 
    GUID *pMediaSubsystemId, 
    OLECHAR **pDescription, 
    ULONG   descriptionBufferSize,
    OLECHAR **pName, 
    ULONG   nameBufferSize,
    FILETIME *pUpdate, 
    HRESULT *pLastError,
    SHORT  *pNextRemoteDataSet
    )
/*++

Implements:

  IMediaInfo::GetCopyInfo

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetCopyInfo"),OLESTR("Copy is <%u>"), copyNumber);
    try {
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        if (pMediaSubsystemId != 0)  {
            *pMediaSubsystemId = m_Copy[copyNumber - 1].id;
        }
        if (pDescription != 0)  {
            CWsbStringPtr tmpDescription;
            tmpDescription = m_Copy[copyNumber - 1].description;
            tmpDescription.CopyTo(pDescription, descriptionBufferSize);
        }
        if (pName != 0)  {
            CWsbStringPtr tmpString;
            tmpString = m_Copy[copyNumber - 1].name;
            tmpString.CopyTo(pName, nameBufferSize);
        }
        if (pUpdate != 0)  {
            *pUpdate = m_Copy[copyNumber - 1].lastUpdate;
        }
        if (pLastError != 0 )  {
            *pLastError = m_Copy[copyNumber - 1].lastError;
        }
    
        if (pNextRemoteDataSet != 0 )  {
            *pNextRemoteDataSet = m_Copy[copyNumber - 1].nextRemoteDataSet;
        }
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetCopyInfo"), 
            OLESTR("hr = <%ls>, SubSystemID = <%ls>, Description = <%ls>, Name = <%ls>, Update = <%ls>, LastError = <%ls>, NextRemoteDataSet = <%ls>"), 
            WsbHrAsString(hr), WsbPtrToGuidAsString(pMediaSubsystemId), 
            WsbQuickString(WsbPtrToStringAsString(pDescription)), WsbQuickString(WsbPtrToStringAsString(pName)),
            WsbPtrToFiletimeAsString(FALSE, pUpdate), WsbPtrToHrAsString(pLastError),
            WsbPtrToShortAsString(pNextRemoteDataSet));
    return(hr);
}

HRESULT
CMediaInfo::GetCopyLastError( 
    USHORT copyNumber, 
    HRESULT *pLastError 
    )
/*++

Implements:

  IMediaInfo::GetCopyLastError

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetCopyLastError"),OLESTR("Copy is <%u>"), copyNumber);
    try {
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        WsbAssertPointer(pLastError); 
        *pLastError = m_Copy[copyNumber - 1].lastError;                               
    
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetCopyLastError"), OLESTR("hr = <%ls>, Last Error = <%ls>"), WsbHrAsString(hr), WsbPtrToHrAsString(pLastError));
    return(hr);
}

HRESULT
CMediaInfo::GetCopyMediaSubsystemId( 
    USHORT copyNumber, 
    GUID *pMediaSubsystemId 
    )
/*++

Implements:

  IMediaInfo::GetCopyMediaSubsystemId

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetCopyMediaSubsystemId"),OLESTR("Copy is <%u>"), copyNumber);
    try {
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        WsbAssertPointer(pMediaSubsystemId); 
        *pMediaSubsystemId = m_Copy[copyNumber - 1].id;
    
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetCopyMediaSubsystemId"), OLESTR("hr = <%ls>, ID = <%ls>"), WsbHrAsString(hr), WsbPtrToGuidAsString(pMediaSubsystemId));
    return(hr);
}

HRESULT
CMediaInfo::GetCopyUpdate(
    USHORT copyNumber, 
    FILETIME *pUpdate 
    )
/*++

Implements:

  IMediaInfo::GetCopyUpdate

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetCopyUpdate"),OLESTR("Copy is <%u>"), copyNumber);
    try {
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        WsbAssertPointer(pUpdate);
        *pUpdate = m_Copy[copyNumber - 1].lastUpdate;
    
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetCopyUpdate"), OLESTR("hr = <%ls>, Update = <%ls>"), WsbHrAsString(hr), WsbPtrToFiletimeAsString(FALSE,pUpdate));
    return(hr);
}

HRESULT
CMediaInfo::GetDescription(
    OLECHAR **pDescription,
    ULONG bufferSize
    )
/*++

Implements:

  IMediaInfo::GetDescription

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetDescription"),OLESTR(""));
    try {
        WsbAssertPointer(pDescription);
        CWsbStringPtr tmpDescription;
        tmpDescription = m_Master.description;
        WsbAffirmHr(tmpDescription.CopyTo(pDescription, bufferSize));
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetDescription"), OLESTR("hr = <%ls>, Description = <%ls>"), WsbHrAsString(hr), WsbPtrToStringAsString(pDescription));
    return(hr);
}

HRESULT
CMediaInfo::GetFreeBytes( 
    LONGLONG *pFreeBytes
    )
/*++

Implements:

  IMediaInfo::GetFreeBytes

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetFreeBytes"),OLESTR(""));
    try {
        WsbAssertPointer(pFreeBytes);
        *pFreeBytes = m_Master.freeBytes;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetFreeBytes"), OLESTR("hr = <%ls>, Free Space = <%ls>"), WsbHrAsString(hr), WsbPtrToLonglongAsString(pFreeBytes));
    return(hr);
}

HRESULT
CMediaInfo::GetId(
    GUID *pId
    )
/*++

Implements:

  IMediaInfo::GetId

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetId"),OLESTR(""));
    try {
        WsbAssertPointer(pId);
        *pId = m_Master.id;
    
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetId"), OLESTR("hr = <%ls>, Id = <%ls>"), WsbHrAsString(hr), WsbPtrToGuidAsString(pId));
    return(hr);
}

HRESULT
CMediaInfo::GetLastError(
    HRESULT *pLastError
    )
/*++

Implements:

  IMediaInfo::GetLastError

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetLastError"),OLESTR(""));
    try {
        WsbAssertPointer(pLastError);
        *pLastError = m_Master.lastError;
    
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetLastError"), OLESTR("hr = <%ls>, LastError = <%ls>"), WsbHrAsString(hr), WsbPtrToHrAsString(pLastError));
    return(hr);
}

HRESULT
CMediaInfo::GetLogicalValidBytes(
    LONGLONG *pLogicalValidBytes
    )
/*++

Implements:

  IMediaInfo::GetLogicalValidBytes

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetLogicalValidBytes"),OLESTR(""));
    try {
        WsbAssertPointer(pLogicalValidBytes);
        *pLogicalValidBytes = m_LogicalValidBytes;
    
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetLogicalValidBytes"), OLESTR("hr = <%ls>, LogicalValidBytes = <%ls>"), WsbHrAsString(hr), WsbPtrToLonglongAsString(pLogicalValidBytes));
    return(hr);
}

HRESULT
CMediaInfo::GetMediaInfo( 
    GUID* pMediaId, 
    GUID *pMediaSubsystemId, 
    GUID *pStoragePoolId, 
    LONGLONG *pFreeBytes, 
    LONGLONG *pCapacity, 
    HRESULT *pLastError, 
    SHORT *pNextRemoteDataSet, 
    OLECHAR **pDescription,
    ULONG descriptionBufferSize,
    HSM_JOB_MEDIA_TYPE *pType,
    OLECHAR **pName,
    ULONG nameBufferSize,
    BOOL *pRecallOnly,
    FILETIME *pUpdate,
    LONGLONG *pLogicalValidBytes,
    BOOL *pRecreate
    )
/*++

Implements:

  IMediaInfo::GetMediaInfo

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetMediaInfo"),OLESTR(""));
    try {
        //Make sure we can provide data memebers
        if (0 != pMediaId)  {
            *pMediaId = m_Master.id;
        }
        
        if (0 != pMediaSubsystemId)  {
            *pMediaSubsystemId = m_Master.ntmsId;
        }
        if (0 != pStoragePoolId)  {
            *pStoragePoolId = m_Master.storagePoolId;
        }
        if (0 != pDescription)  {
            CWsbStringPtr tmpString;
            tmpString = m_Master.description;
            WsbAffirmHr(tmpString.CopyTo(pDescription, descriptionBufferSize));
        }
        if (0 != pName)  {
            CWsbStringPtr tmpString;
            tmpString = m_Master.name;
            tmpString.CopyTo(pName, nameBufferSize);
        }
        if (0 != pType)  {
            *pType = m_Master.type;
        }
        if (0 != pUpdate)  {
            *pUpdate = m_Master.lastUpdate;
        }
        if (0 != pLastError)  {
            *pLastError = m_Master.lastError;
        }
        if (0 != pRecallOnly)  {
            *pRecallOnly = m_Master.recallOnly;
        }
        if (0 != pFreeBytes)  {
            *pFreeBytes = m_Master.freeBytes;
        }
        if (0 != pCapacity)  {
            *pCapacity = m_Master.capacity;
        }
        if (0 != pNextRemoteDataSet)  {
            *pNextRemoteDataSet = m_Master.nextRemoteDataSet;
        }
        if (0 != pLogicalValidBytes)  {
            *pLogicalValidBytes = m_LogicalValidBytes;
        }
        if (0 != pRecreate)  {
            *pRecreate = m_Recreate;
        }


    } WsbCatch(hr);

    WsbTrace(OLESTR("CMediaInfo::GetMediaInfo id = <%ls>, ntmsId = <%ls>, StgPoolId = <%ls>\n"),
        WsbPtrToGuidAsString(pMediaId), WsbQuickString(WsbPtrToGuidAsString(pMediaSubsystemId)),
        WsbQuickString(WsbPtrToGuidAsString(pStoragePoolId)));
    WsbTrace(OLESTR("CMediaInfo::GetMediaInfo Free = <%ls>, Cap = <%ls>, Last Error = <%ls>\n"), 
        WsbPtrToLonglongAsString(pFreeBytes),WsbQuickString(WsbPtrToLonglongAsString(pCapacity)),
        WsbPtrToHrAsString(pLastError));
    WsbTrace(OLESTR("CMediaInfo::GetMediaInfo NextRemoteDataSet = <%ls>, Description = <%ls>, Type = <%ls>\n"), 
        WsbPtrToShortAsString(pNextRemoteDataSet),
        WsbPtrToStringAsString(pDescription),
        WsbQuickString(WsbPtrToShortAsString((SHORT *)pType)));
    WsbTrace(OLESTR("CMediaInfo::GetMediaInfo Name = <%ls>, RecallOnly = <%ls>, Update = <%ls>\n"),
        WsbQuickString(WsbPtrToStringAsString(pName)),
        WsbQuickString(WsbPtrToBoolAsString(pRecallOnly)),
        WsbPtrToFiletimeAsString(FALSE, pUpdate));
    WsbTrace(OLESTR("CMediaInfo::GetMediaInfo LogicalValid = <%ls>, Recreate = <%ls>\n"),
        WsbQuickString(WsbPtrToLonglongAsString(pLogicalValidBytes)),
        WsbQuickString(WsbPtrToBoolAsString(pRecreate)));
        
    WsbTraceOut(OLESTR("CMediaInfo::GetMediaInfo"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::GetMediaSubsystemId( 
    GUID *pMediaSubsystemId 
    )
/*++

Implements:

  IMediaInfo::GetMediaSubsystemId

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetMediaSubsystemId"),OLESTR(""));
    try {
        WsbAssertPointer(pMediaSubsystemId);
        *pMediaSubsystemId = m_Master.ntmsId;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetMediaSubsystemId"), OLESTR("hr = <%ls>, SubsystemID = <%ls>"), WsbHrAsString(hr), WsbPtrToGuidAsString(pMediaSubsystemId));
    return(hr);
}

HRESULT
CMediaInfo::GetNextRemoteDataSet( 
    short *pNextRemoteDataSet 
    )
/*++

Implements:

  IMediaInfo::GetNextRemoteDataSet

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetNextRemoteDataSet"),OLESTR(""));
    try {                              
        WsbAssertPointer(pNextRemoteDataSet);
        *pNextRemoteDataSet = m_Master.nextRemoteDataSet;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetNextRemoteDataSet"), OLESTR("hr = <%ls>, Next Remote Data Set = <%ls>"), WsbHrAsString(hr), WsbPtrToShortAsString(pNextRemoteDataSet));
    return(hr);
}

HRESULT
CMediaInfo::GetRecallOnlyStatus( 
    BOOL *pRecallOnlyStatus 
    )
/*++

Implements:

  IMediaInfo::GetRecallOnlyStatus

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetRecallOnlyStatus"),OLESTR(""));
    try {
        WsbAssertPointer(pRecallOnlyStatus);
        *pRecallOnlyStatus = m_Master.recallOnly;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetRecallOnlyStatus"), OLESTR("hr = <%ls>, Read only Status = <%ls>"), WsbHrAsString(hr), WsbPtrToBoolAsString(pRecallOnlyStatus));
    return(hr);
}

HRESULT CMediaInfo::GetSizeMax
(
    OUT ULARGE_INTEGER* pcbSize
    ) 
/*++

Implements:

  IPersistStream::GetSizeMax().

--*/
{
    HRESULT     hr = S_OK;

    WsbTraceIn(OLESTR("CMediaInfo::GetSizeMax"), OLESTR(""));
    try {
        hr = E_NOTIMPL;
        pcbSize = 0;        
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetSizeMax"), 
        OLESTR("hr = <%ls>, Size = <%ls>"), WsbHrAsString(hr), 
        WsbPtrToUliAsString(pcbSize));
    return(hr);
}

HRESULT
CMediaInfo::GetStoragePoolId( 
    GUID *pStoragePoolId 
    )
/*++

Implements:

  IMediaInfo::GetStoragePoolId

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetStoragePoolId"),OLESTR(""));
    try {
        WsbAssertPointer(pStoragePoolId);
        *pStoragePoolId = m_Master.storagePoolId;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetStoragePoolId"), OLESTR("hr = <%ls>, Storage Pool Id = <%ls>"), WsbHrAsString(hr), WsbPtrToGuidAsString(pStoragePoolId));
    return(hr);
}

HRESULT
CMediaInfo::GetType( 
    HSM_JOB_MEDIA_TYPE *pType 
    )
/*++

Implements:

  IMediaInfo::GetType

--*/

{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetType"),OLESTR(""));
    try {
        WsbAssertPointer(pType);
        *pType = m_Master.type;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetType"), OLESTR("hr = <%ls>, type = <%ls>"), WsbHrAsString(hr), WsbPtrToShortAsString((SHORT *)pType));
    return(hr);
}

HRESULT
CMediaInfo::GetUpdate( 
    FILETIME *pUpdate 
    )
/*++

Implements:

  IMediaInfo::GetUpdate

--*/

{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetUpdate"),OLESTR(""));
    try {
        WsbAssertPointer(pUpdate);
        *pUpdate = m_Master.lastUpdate;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetUpdate"), OLESTR("hr = <%ls>, Update = <%ls>"), WsbHrAsString(hr), WsbPtrToFiletimeAsString(FALSE, pUpdate));
    return(hr);
}

HRESULT CMediaInfo::Load
(
    IN IStream* pStream
    ) 
/*++

Implements:

  IPersistStream::Load().

--*/
{
    HRESULT     hr = S_OK;

    WsbTraceIn(OLESTR("CMediaInfo::Load"), OLESTR(""));

    try {
        WsbAssert(0 != pStream, E_POINTER);
        ULONG descriptionLen = (ULONG)SEG_DB_MAX_MEDIA_NAME_LEN;
        ULONG nameLen = (ULONG)SEG_DB_MAX_MEDIA_BAR_CODE_LEN;

        WsbAffirmHr(WsbLoadFromStream(pStream, &m_Master.id));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_Master.ntmsId));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_Master.storagePoolId));
        
        m_Master.description.Realloc(SEG_DB_MAX_MEDIA_NAME_LEN);
        WsbAffirmHr(WsbLoadFromStream(pStream, (OLECHAR **)&m_Master.description, descriptionLen));
        m_Master.name.Realloc(SEG_DB_MAX_MEDIA_BAR_CODE_LEN);
        WsbAffirmHr(WsbLoadFromStream(pStream, (OLECHAR **)&m_Master.name, nameLen));
        LONG tmpLong;
        WsbAffirmHr(WsbLoadFromStream(pStream, &tmpLong));
        m_Master.type = (HSM_JOB_MEDIA_TYPE)tmpLong;
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_Master.freeBytes));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_Master.capacity));
        WsbAffirmHr(WsbLoadFromStream(pStream, (LONG *)&m_Master.lastError));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_Master.recallOnly));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_Master.lastUpdate));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_Master.nextRemoteDataSet));
        
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_LogicalValidBytes));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_Recreate));
        
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_LastKnownGoodMaster.id));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_LastKnownGoodMaster.ntmsId));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_LastKnownGoodMaster.storagePoolId));
        
        m_LastKnownGoodMaster.description.Realloc(SEG_DB_MAX_MEDIA_NAME_LEN);
        WsbAffirmHr(WsbLoadFromStream(pStream, (OLECHAR **)&m_LastKnownGoodMaster.description, descriptionLen));
        m_LastKnownGoodMaster.name.Realloc(SEG_DB_MAX_MEDIA_BAR_CODE_LEN);
        WsbAffirmHr(WsbLoadFromStream(pStream, (OLECHAR **)&m_LastKnownGoodMaster.name, nameLen));
        WsbAffirmHr(WsbLoadFromStream(pStream, &tmpLong));
        m_LastKnownGoodMaster.type = (HSM_JOB_MEDIA_TYPE)tmpLong;
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_LastKnownGoodMaster.freeBytes));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_LastKnownGoodMaster.capacity));
        WsbAffirmHr(WsbLoadFromStream(pStream, (LONG *)&m_LastKnownGoodMaster.lastError));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_LastKnownGoodMaster.recallOnly));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_LastKnownGoodMaster.lastUpdate));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_LastKnownGoodMaster.nextRemoteDataSet));
        
        for (int i = 0; i < HSM_MAX_NUMBER_MEDIA_COPIES; i++ )  {
            WsbAffirmHr(WsbLoadFromStream(pStream, &(m_Copy[i].id)));
            m_Copy[i].description.Realloc(SEG_DB_MAX_MEDIA_NAME_LEN);
            WsbAffirmHr(WsbLoadFromStream(pStream, (OLECHAR **)&(m_Copy[i].description), descriptionLen));
            m_Copy[i].name.Realloc(SEG_DB_MAX_MEDIA_BAR_CODE_LEN);
            WsbAffirmHr(WsbLoadFromStream(pStream, (OLECHAR **)&(m_Copy[i].name), nameLen));
            WsbAffirmHr(WsbLoadFromStream(pStream, &(m_Copy[i].lastUpdate)));
            WsbAffirmHr(WsbLoadFromStream(pStream, (LONG *)&(m_Copy[i].lastError)));
            WsbAffirmHr(WsbLoadFromStream(pStream, &(m_Copy[i].nextRemoteDataSet)));
        }

    } WsbCatch(hr);
    
    WsbTrace(OLESTR("ID = <%ls>, rmsId = <%ls>, stgPoolId = <%ls>\n"),  
        WsbQuickString(WsbGuidAsString(m_Master.id)), 
        WsbQuickString(WsbGuidAsString(m_Master.ntmsId)),
        WsbQuickString(WsbGuidAsString(m_Master.storagePoolId)));
    WsbTrace(OLESTR("Description = <%ls>, name = <%ls>, type = <%u>\n"), 
        (OLECHAR *)m_Master.description,
        (OLECHAR *)m_Master.name,
        m_Master.type);
    WsbTrace(OLESTR("FreeBytes = <%ls>, capacity = <%ls>, lastError = <%ls>\n"),
        WsbQuickString(WsbLonglongAsString(m_Master.freeBytes)),
        WsbQuickString(WsbLonglongAsString(m_Master.capacity)),
        WsbQuickString(WsbHrAsString(m_Master.lastError)));
    WsbTrace(OLESTR("RecallOnly = <%ls>, NextRemotDataSet = <%u>\n"),   
        WsbBoolAsString(m_Master.recallOnly),
        m_Master.nextRemoteDataSet);
    WsbTrace(OLESTR("LastUpdate = <%ls>, logicalValidBytes = <%ls>, Recreate = <%ls>\n"),    
        WsbFiletimeAsString(FALSE, m_Master.lastUpdate),
        WsbLonglongAsString(m_LogicalValidBytes),
        WsbBoolAsString(m_Recreate));
    
    
    WsbTraceOut(OLESTR("CMediaInfo::Load"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}


HRESULT CMediaInfo::Print
(
    IN IStream* pStream
    ) 
/*++

Implements:

  IWsbDbEntity::Print

--*/
{
    HRESULT     hr = S_OK;

    WsbTraceIn(OLESTR("CMediaInfo::Print"), OLESTR(""));

    try {
        WsbAssert(0 != pStream, E_POINTER);
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" id = %ls,"), 
                WsbGuidAsString(m_Master.id)));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" ntmsId = %ls,"), 
                WsbGuidAsString(m_Master.ntmsId)));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" StoragePoolId = %ls,"), 
                WsbGuidAsString(m_Master.storagePoolId)));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" RS Media Name = %ls,"), (OLECHAR *)m_Master.description));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" RMS Media Name = %ls,"), (OLECHAR *)m_Master.name));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Media Type = %u,"), m_Master.type));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Last Update = %ls,"), 
                WsbFiletimeAsString(FALSE, m_Master.lastUpdate)));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Last Error = %ls,"), WsbHrAsString(m_Master.lastError)));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Is Recall Only = %ls,"), WsbBoolAsString(m_Master.recallOnly)));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Free Bytes = %ls,"), 
                WsbQuickString(WsbLonglongAsString(m_Master.freeBytes))));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Capacity = %ls,"),
                WsbQuickString(WsbLonglongAsString(m_Master.capacity))));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Logical Valid Bytes = %ls,"),
                WsbQuickString(WsbLonglongAsString(m_LogicalValidBytes))));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" NextRemoteDataSet = %u,"), m_Master.nextRemoteDataSet));
        
        WsbAffirmHr(CWsbDbEntity::Print(pStream));
        //
        // Last Known Good Master
        //
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR("\n   Last Known Good id = %ls,"), 
            WsbGuidAsString(m_LastKnownGoodMaster.id)));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" ntmsId = %ls,"), 
                WsbGuidAsString(m_LastKnownGoodMaster.ntmsId)));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" StoragePoolId = %ls,"), 
                WsbGuidAsString(m_LastKnownGoodMaster.storagePoolId)));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" RS Media Name = %ls,"), (OLECHAR *)m_LastKnownGoodMaster.description));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" RMS Media Name = %ls,"), (OLECHAR *)m_LastKnownGoodMaster.name));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Media Type = %u,"), m_LastKnownGoodMaster.type));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Last Update = %ls,"), 
                WsbFiletimeAsString(FALSE, m_LastKnownGoodMaster.lastUpdate)));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Last Error = %ls,"), WsbHrAsString(m_LastKnownGoodMaster.lastError)));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Is Recall Only = %ls,"), WsbBoolAsString(m_LastKnownGoodMaster.recallOnly)));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Free Bytes = %ls,"), 
                WsbQuickString(WsbLonglongAsString(m_LastKnownGoodMaster.freeBytes))));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Capacity = %ls,"),
                WsbQuickString(WsbLonglongAsString(m_LastKnownGoodMaster.capacity))));
        WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" NextRemoteDataSet = %u,"), m_LastKnownGoodMaster.nextRemoteDataSet));
        //
        // Media Copies
        //
        for (int i = 0; i < HSM_MAX_NUMBER_MEDIA_COPIES; i++ )  {
            WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR("\n   RS Media Copy %d RMS ID = %ls,") ,(i+1), WsbGuidAsString(m_Copy[i].id)));
            WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" RS Media Name = %ls,") , (OLECHAR *)m_Copy[i].description));
            WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" RMS Media Name = %ls,") , (OLECHAR *)m_Copy[i].name));
            WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Last Update = %ls,") , WsbFiletimeAsString(FALSE,m_Copy[i].lastUpdate)));
            WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Last Error = %ls,") , WsbHrAsString(m_Copy[i].lastError)));
            WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" NextRemoteDataSet = %u,") , m_Copy[i].nextRemoteDataSet));
        }

        

    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::Print"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));

    return(hr);
}


HRESULT CMediaInfo::Save
(
    IN IStream* pStream, 
    IN BOOL clearDirty
    ) 
/*++

Implements:

  IPersistStream::Save().

--*/
{
    HRESULT     hr = S_OK;

    WsbTraceIn(OLESTR("CMediaInfo::Save"), OLESTR("clearDirty = <%ls>"), WsbBoolAsString(clearDirty));
    
    WsbTrace(OLESTR("ID = <%ls>, rmsId = <%ls>, stgPoolId = <%ls>\n"),
        WsbQuickString(WsbGuidAsString(m_Master.id)), 
        WsbQuickString(WsbGuidAsString(m_Master.ntmsId)),
        WsbQuickString(WsbGuidAsString(m_Master.storagePoolId)));
    WsbTrace(OLESTR("Description = <%ls>, name = <%ls>, type = <%u>\n"),
        (OLECHAR *)m_Master.description,
        (OLECHAR *)m_Master.name,
        m_Master.type);
    WsbTrace(OLESTR("FreeBytes = <%ls>, capacity = <%ls>, lastError = <%ls>\n"), 
        WsbQuickString(WsbLonglongAsString(m_Master.freeBytes)),
        WsbQuickString(WsbLonglongAsString(m_Master.capacity)),
        WsbHrAsString(m_Master.lastError));
    WsbTrace(OLESTR("RecallOnly = <%ls>, NextRemotDataSet = <%u>\n"),
        WsbBoolAsString(m_Master.recallOnly),
        m_Master.nextRemoteDataSet);
    WsbTrace(OLESTR("LastUpdate = <%ls>, logicalValidBytes = <%ls>, Recreate = <%ls>\n"),    
        WsbFiletimeAsString(FALSE, m_Master.lastUpdate),
        WsbLonglongAsString(m_LogicalValidBytes),
        WsbBoolAsString(m_Recreate));

    try {
        WsbAssert(0 != pStream, E_POINTER);

        WsbAffirmHr(WsbSaveToStream(pStream, m_Master.id));
        WsbAffirmHr(WsbSaveToStream(pStream, m_Master.ntmsId));
        WsbAffirmHr(WsbSaveToStream(pStream, m_Master.storagePoolId));
        
        WsbAffirmHr(WsbSaveToStream(pStream, (OLECHAR *)m_Master.description));
        WsbAffirmHr(WsbSaveToStream(pStream, (OLECHAR *)m_Master.name));
        WsbAffirmHr(WsbSaveToStream(pStream, (LONG)m_Master.type));
        WsbAffirmHr(WsbSaveToStream(pStream, m_Master.freeBytes));
        WsbAffirmHr(WsbSaveToStream(pStream, m_Master.capacity));
        WsbAffirmHr(WsbSaveToStream(pStream, (LONG)m_Master.lastError));
        WsbAffirmHr(WsbSaveToStream(pStream, m_Master.recallOnly));
        WsbAffirmHr(WsbSaveToStream(pStream, m_Master.lastUpdate));
        WsbAffirmHr(WsbSaveToStream(pStream, m_Master.nextRemoteDataSet));
        
        WsbAffirmHr(WsbSaveToStream(pStream, m_LogicalValidBytes));
        WsbAffirmHr(WsbSaveToStream(pStream, m_Recreate));
        
        WsbAffirmHr(WsbSaveToStream(pStream, m_LastKnownGoodMaster.id));
        WsbAffirmHr(WsbSaveToStream(pStream, m_LastKnownGoodMaster.ntmsId));
        WsbAffirmHr(WsbSaveToStream(pStream, m_LastKnownGoodMaster.storagePoolId));
        
        WsbAffirmHr(WsbSaveToStream(pStream, (OLECHAR *)m_LastKnownGoodMaster.description));
        WsbAffirmHr(WsbSaveToStream(pStream, (OLECHAR *)m_LastKnownGoodMaster.name));
        WsbAffirmHr(WsbSaveToStream(pStream, (LONG)m_LastKnownGoodMaster.type));
        WsbAffirmHr(WsbSaveToStream(pStream, m_LastKnownGoodMaster.freeBytes));
        WsbAffirmHr(WsbSaveToStream(pStream, m_LastKnownGoodMaster.capacity));
        WsbAffirmHr(WsbSaveToStream(pStream, (LONG)m_LastKnownGoodMaster.lastError));
        WsbAffirmHr(WsbSaveToStream(pStream, m_LastKnownGoodMaster.recallOnly));
        WsbAffirmHr(WsbSaveToStream(pStream, m_LastKnownGoodMaster.lastUpdate));
        WsbAffirmHr(WsbSaveToStream(pStream, m_LastKnownGoodMaster.nextRemoteDataSet));
        
        for (int i = 0; i < HSM_MAX_NUMBER_MEDIA_COPIES; i++ )  {
            WsbAffirmHr(WsbSaveToStream(pStream, m_Copy[i].id));
            WsbAffirmHr(WsbSaveToStream(pStream, m_Copy[i].description));
            WsbAffirmHr(WsbSaveToStream(pStream, m_Copy[i].name));
            WsbAffirmHr(WsbSaveToStream(pStream, m_Copy[i].lastUpdate));
            WsbAffirmHr(WsbSaveToStream(pStream, (LONG)(m_Copy[i].lastError)));
            WsbAffirmHr(WsbSaveToStream(pStream, m_Copy[i].nextRemoteDataSet));
        }

        // 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("CMediaInfo::Save"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));

    return(hr);
}

HRESULT
CMediaInfo::SetName(
    OLECHAR *name
    )
/*++

Implements:

  IMediaInfo::SetName

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetName"),OLESTR("Name = <%ls>"), name);
    try {
        WsbAssertPointer(name);
        m_Master.name = name;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetName"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetCapacity( 
    LONGLONG capacity
    )
/*++

Implements:

  IMediaInfo::SetCapacity

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetCapacity"),OLESTR("Capacity = <%ls>"), WsbLonglongAsString(capacity));
    try {
        m_Master.capacity = capacity;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetCapacity"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetCopyName( 
    USHORT copyNumber, 
    OLECHAR *name
    ) 
/*++

Implements:

  IMediaInfo::SetCopyName

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetCopyName"),OLESTR("copy = <%u>, Name = <%ls>"), copyNumber, name);
    try {
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        m_Copy[copyNumber - 1].name = name;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetCopyName"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetCopyNextRemoteDataSet( 
    USHORT copyNumber, 
    SHORT nextRemoteDataSet
    ) 
/*++

Implements:

  IMediaInfo::SetCopyNextRemoteDataSet

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetCopyNextRemoteDataSet"),OLESTR("copy = <%u>, NextRemoteDataSet = <%d>"), copyNumber, nextRemoteDataSet);
    try {
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        m_Copy[copyNumber - 1].nextRemoteDataSet = nextRemoteDataSet;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetCopyNextRemoteDataSet"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetCopyDescription( 
    USHORT copyNumber, 
    OLECHAR *description
    ) 
/*++

Implements:

  IMediaInfo::SetCopyDescription

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetCopyDescription"),OLESTR("copy = <%u>, description = <%ls>"), copyNumber, description);
    try {
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        m_Copy[copyNumber - 1].description = description;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetCopyDescription"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetCopyInfo( 
    USHORT copyNumber, 
    GUID mediaSubsystemId, 
    OLECHAR *description, 
    OLECHAR *name, 
    FILETIME update, 
    HRESULT lastError,
    SHORT  nextRemoteDataSet
    )
/*++

Implements:

  IMediaInfo::SetCopyInfo

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetCopyInfo"),OLESTR("copy = <%u>, SubsystemId = <%ls>, Description = <%ls>, Name = <%ls>, update = <%ls>, lastError = <%ls>, NextRemoteDataSet = <%d> "),
    copyNumber, WsbGuidAsString(mediaSubsystemId), description, name, WsbFiletimeAsString(FALSE, update),WsbHrAsString(lastError));
    try {
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        m_Copy[copyNumber - 1].id = mediaSubsystemId;
        m_Copy[copyNumber - 1].description = description;
        m_Copy[copyNumber - 1].name = name;
        m_Copy[copyNumber - 1].lastUpdate = update;
        m_Copy[copyNumber - 1].lastError = lastError;
        m_Copy[copyNumber - 1].nextRemoteDataSet = nextRemoteDataSet;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetCopyInfo"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetCopyLastError( 
    USHORT copyNumber, 
    HRESULT lastError 
    )
/*++

Implements:

  IMediaInfo::SetCopyLastError

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetCopyLastError"),OLESTR("Last Error = <%ls>"), WsbHrAsString(lastError));
    try {
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        m_Copy[copyNumber - 1].lastError = lastError;        
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetCopyLastError"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetCopyMediaSubsystemId( 
    USHORT copyNumber, 
    GUID mediaSubsystemId 
    ) 
/*++

Implements:

  IMediaInfo::SetCopyMediaSubsystemId

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetCopyMediaSubsystemId"),OLESTR("SubsystemId = <%ls>"), WsbGuidAsString(mediaSubsystemId));
    try {
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        m_Copy[copyNumber - 1].id = mediaSubsystemId;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetCopyMediaSubsystemId"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetCopyUpdate( 
    USHORT copyNumber, 
    FILETIME update 
    ) 
/*++

Implements:

  IMediaInfo::SetCopyUpdate

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetCopyUpdate"),OLESTR("update = <%ls>"), WsbFiletimeAsString(FALSE, update));
    try {
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        m_Copy[copyNumber - 1].lastUpdate = update;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetCopyUpdate"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetDescription(
    OLECHAR *description 
    )
/*++

Implements:

  IMediaInfo::SetDescription

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetDescription"),OLESTR("description = <%ls>"), description);
    try {
        WsbAssertPointer(description);
        m_Master.description = description;    
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetDescription"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetFreeBytes( 
    LONGLONG FreeBytes 
    )
/*++

Implements:

  IMediaInfo::SetFreeBytes

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetFreeBytes"),OLESTR("Free Space = <%ls>"), WsbLonglongAsString(FreeBytes));
    try {
        m_Master.freeBytes = FreeBytes;    
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetFreeBytes"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetId( 
    GUID id
    )
/*++

Implements:

  IMediaInfo::SetId

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetId"),OLESTR("ID = <%ls>"), WsbGuidAsString(id));
    try {
        m_Master.id = id;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetId"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetLastError( 
    HRESULT lastError
    )
/*++

Implements:

  IMediaInfo::SetLastError

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetLastError"),OLESTR("last error = <%ls>"), WsbHrAsString(lastError));
    try {
        m_Master.lastError = lastError;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetLastError"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetLogicalValidBytes(
    LONGLONG logicalValidBytes
    )
/*++

Implements:

  IMediaInfo::SetLogicalValidBytes

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetLogicalValidBytes"),OLESTR("LogicalValidBytes = <%ls>"), WsbLonglongAsString(logicalValidBytes));
    try {
        m_LogicalValidBytes = logicalValidBytes;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetLogicalValidBytes"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT 
CMediaInfo::SetMediaInfo
(
    GUID mediaId, 
    GUID mediaSubsystemId,
    GUID storagePoolId,
    LONGLONG FreeBytes,
    LONGLONG Capacity,
    HRESULT lastError,
    short nextRemoteDataSet,
    OLECHAR *description,
    HSM_JOB_MEDIA_TYPE type,
    OLECHAR *name,
    BOOL RecallOnly,
    FILETIME update,
    LONGLONG logicalValidBytes,
    BOOL recreate
    )
 /*++

Implements:

  IMediaInfo::SetMediaInfo().

--*/
{
    WsbTraceIn(OLESTR("CMediaInfo::SetMediaInfo"), OLESTR(""));
    
    WsbTrace(OLESTR("CMediaInfo::SetMediaInfo id = <%ls>, SubsystemId = <%ls>, StoragePoolId = <%ls>\n"), 
        WsbGuidAsString(mediaId), 
        WsbQuickString(WsbGuidAsString(mediaSubsystemId)), 
        WsbQuickString(WsbGuidAsString(storagePoolId)));
    WsbTrace(OLESTR("CMediaInfo::SetMediaInfo FreeBytes = <%ls>, Capacity = <%ls>, lastError = <%ls>\n"),
        WsbLonglongAsString(FreeBytes), 
        WsbQuickString(WsbLonglongAsString(Capacity)), 
        WsbHrAsString(lastError));
    WsbTrace(OLESTR("CMediaInfo::SetMediaInfo NextRemoteDataSet = <%d>, Description = <%ls>, Type = <%d>\n"), 
        nextRemoteDataSet, 
        (OLECHAR *)description, 
        type);
    WsbTrace(OLESTR("CMediaInfo::SetMediaInfo Name = <%ls>, RecallOnly = <%ls>, update = <%ls>\n"), 
        (OLECHAR *)name,
        WsbBoolAsString(RecallOnly),
        WsbFiletimeAsString(FALSE, update));
    WsbTrace(OLESTR("CMediaInfo::SetMediaInfo logicalValidBytes = <%ls>, recreate = <%ls>\n)"), 
        WsbLonglongAsString(logicalValidBytes), WsbBoolAsString(m_Recreate));

    m_isDirty = TRUE;
    
    m_Master.id = mediaId;
    m_Master.ntmsId = mediaSubsystemId;
    m_Master.storagePoolId = storagePoolId;
    m_Master.freeBytes = FreeBytes;
    m_Master.capacity = Capacity;
    m_Master.lastError = lastError;
    m_Master.description = description;
    m_Master.type = type;
    m_Master.name = name;
    m_Master.recallOnly = RecallOnly;
    m_Master.lastUpdate = update;
    m_Master.nextRemoteDataSet = nextRemoteDataSet;
    
    m_LogicalValidBytes = logicalValidBytes;
    m_Recreate = recreate;
    
    WsbTraceOut(OLESTR("CMediaInfo::SetMediaInfo"), OLESTR("hr = <%ls>"),WsbHrAsString(S_OK));
    return(S_OK);
}

HRESULT
CMediaInfo::SetMediaSubsystemId( 
    GUID mediaSubsystemId 
    )
/*++

Implements:

  IMediaInfo::SetMediaSubsystemId 

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetMediaSubsystemId "),OLESTR("Subsystem Id = <%ls>"),
            WsbGuidAsString(mediaSubsystemId));
    try {
        m_Master.ntmsId = mediaSubsystemId;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetMediaSubsystemId "), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetNextRemoteDataSet( 
    short nextRemoteDataSet 
    )
/*++

Implements:

  IMediaInfo::SetNextRemoteDataSet 

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetNextRemoteDataSet"),OLESTR("Data Set = <%u>"), nextRemoteDataSet);
    try {
        m_Master.nextRemoteDataSet = nextRemoteDataSet;
        m_LastKnownGoodMaster.nextRemoteDataSet = nextRemoteDataSet;

        //
        // Handle exception case where a copy reports more data sets than the
        // master.  This occurs when we increment the data set count, but
        // never write to the media, then create a media copy, then write
        // to the master which decrements the data set count to handle the
        // missing data set, then finally increment the data set count.
        for (int i=0; i< HSM_MAX_NUMBER_MEDIA_COPIES; i++) {
            if (m_Copy[i].nextRemoteDataSet > 0) {
                if (nextRemoteDataSet < m_Copy[i].nextRemoteDataSet) {
                    WsbAssert(nextRemoteDataSet+1 == m_Copy[i].nextRemoteDataSet, E_UNEXPECTED);
                    m_Copy[i].nextRemoteDataSet--;
                }
            }
        }

    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetNextRemoteDataSet"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetRecallOnlyStatus( 
    BOOL RecallOnlyStatus 
    )
/*++

Implements:

  IMediaInfo::SetRecallOnlyStatus

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetRecallOnlyStatus"),OLESTR("Read Only Status = <%ls>"), 
        WsbBoolAsString(RecallOnlyStatus));
    try {
        m_Master.recallOnly = RecallOnlyStatus;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetRecallOnlyStatus"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetStoragePoolId( 
    GUID storagePoolId 
    )
/*++

Implements:

  IMediaInfo::SetStoragePoolId

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetStoragePoolId"),OLESTR("Storage Pool Id = <%ls>"),
        WsbGuidAsString(storagePoolId));
    try {
        m_Master.storagePoolId = storagePoolId;    
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetStoragePoolId"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetType( 
    HSM_JOB_MEDIA_TYPE type 
    )
/*++

Implements:

  IMediaInfo::SetType

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetType"),OLESTR("type = <%u>"), (USHORT)type);
    try {
        m_Master.type = type;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetType"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetUpdate( 
    FILETIME update 
    )
/*++

Implements:

  IMediaInfo::SetUpdate

--*/

{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetUpdate"),OLESTR("Update = <%ls>"),
        WsbFiletimeAsString(FALSE, update));
    try {
        m_Master.lastUpdate = update;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetUpdate"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}


HRESULT 
CMediaInfo::Test
(
    OUT USHORT *pTestsPassed, 
    OUT USHORT *pTestsFailed 
    ) 
/*++

Implements:

  IWsbTestable::Test().

--*/
{
    HRESULT                 hr = S_OK;
    CComPtr<IMediaInfo>     pMediaInfo1;
    CComPtr<IMediaInfo>     pMediaInfo2;

    WsbTraceIn(OLESTR("CMediaInfo::Test"), OLESTR(""));

    *pTestsPassed = *pTestsFailed = 0;
    try {
    
        hr = E_NOTIMPL;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::Test"), OLESTR("hr = <%ls>"),WsbHrAsString(hr));
    return( hr );
}



HRESULT 
CMediaInfo::UpdateKey(
    IWsbDbKey *pKey
    ) 
/*++

Implements:

  IWsbDbEntity::UpdateKey

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::UpdateKey"),OLESTR(""));
    try {
        WsbAffirmHr(pKey->SetToGuid(m_Master.id));
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::UpdateKey"),OLESTR("hr = <%ls>"),WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::SetRecreate( 
    BOOL recreate
    )
/*++

Implements:

  IMediaInfo::SetRecreate

--*/

{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::SetRecreate"),OLESTR("Recreate = <%ls>"), WsbBoolAsString(recreate));
    try {
        m_Recreate = recreate;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::SetRecreate"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}


HRESULT
CMediaInfo::GetRecreate( 
    BOOL *pRecreate
    )
/*++

Implements:

  IMediaInfo::GetRecreate

--*/

{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetRecreate"),OLESTR(""));
    try {
    
        WsbAssertPointer(pRecreate);
        *pRecreate = m_Recreate;
        
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetRecreate"), OLESTR("hr = <%ls>, recreate = <%ls>"), 
        WsbHrAsString(hr), WsbPtrToBoolAsString(pRecreate));
    return(hr);
}


HRESULT
CMediaInfo::GetLastKnownGoodMasterInfo( 
    GUID* pId, 
    GUID *pNtmsId, 
    GUID *pStoragePoolId, 
    LONGLONG *pFreeBytes, 
    LONGLONG *pCapacity, 
    HRESULT *pLastError, 
    OLECHAR **pDescription, 
    ULONG descriptionBufferSize,
    HSM_JOB_MEDIA_TYPE *pType,
    OLECHAR **pName,
    ULONG nameBufferSize,
    BOOL *pRecallOnly,
    FILETIME *pUpdate,
    SHORT *pNextRemoteDataSet
    )
/*++

Implements:

  IMediaInfo::GetLastKnownGoodMasterInfo

--*/

{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetLastKnownGoodMasterInfo"),OLESTR(""));
    try {
        //Make sure we can provide data memebers
        if (0 != pId)  {
            *pId = m_LastKnownGoodMaster.id;
        }
        
        if (0 != pNtmsId)  {
            *pNtmsId = m_LastKnownGoodMaster.ntmsId;
        }
        if (0 != pStoragePoolId)  {
            *pStoragePoolId = m_LastKnownGoodMaster.storagePoolId;
        }
        if (0 != pDescription)  {
            CWsbStringPtr tmpString;
            tmpString = m_LastKnownGoodMaster.description;
            tmpString.CopyTo(pDescription, descriptionBufferSize);
        }
        if (0 != pName)  {
            CWsbStringPtr tmpString;
            tmpString = m_LastKnownGoodMaster.name;
            tmpString.CopyTo(pName, nameBufferSize);
        }
        if (0 != pType)  {
            *pType = m_LastKnownGoodMaster.type;
        }
        if (0 != pUpdate)  {
            *pUpdate = m_LastKnownGoodMaster.lastUpdate;
        }
        if (0 != pLastError)  {
            *pLastError = m_LastKnownGoodMaster.lastError;
        }
        if (0 != pRecallOnly)  {
            *pRecallOnly = m_LastKnownGoodMaster.recallOnly;
        }
        if (0 != pFreeBytes)  {
            *pFreeBytes = m_LastKnownGoodMaster.freeBytes;
        }
        if (0 != pCapacity)  {
            *pCapacity = m_LastKnownGoodMaster.capacity;
        }
        if (0 != pNextRemoteDataSet)  {
            *pNextRemoteDataSet = m_LastKnownGoodMaster.nextRemoteDataSet;
        }


    } WsbCatch(hr);

    WsbTrace(OLESTR("CMediaInfo::GetLastKnownGoodMasterInfo Id = <%ls>, ntmsId = <%ls>, StgPoolId = <%ls>\n"),
        WsbPtrToGuidAsString(pId), WsbQuickString(WsbPtrToGuidAsString(pNtmsId)),
        WsbQuickString(WsbPtrToGuidAsString(pStoragePoolId)));
    WsbTrace(OLESTR("CMediaInfo::GetLastKnownGoodMasterInfo Free = <%ls>, Cap = <%ls>, Last Error = <%ls>\n"), 
        WsbPtrToLonglongAsString(pFreeBytes),WsbQuickString(WsbPtrToLonglongAsString(pCapacity)),
        WsbPtrToHrAsString(pLastError));
    WsbTrace(OLESTR("CMediaInfo::GetLastKnownGoodMasterInfo Description = <%ls>, Type = <%d)\n"), 
        WsbPtrToStringAsString(pDescription),
        WsbQuickString(WsbPtrToShortAsString((SHORT *)pType)));
    WsbTrace(OLESTR("CMediaInfo::GetLastKnownGoodMasterInfo Name = <%ls>, RecallOnly = <%ls>, Update = <%ls>, NextRemoteDataSet = <%ls>\n"),
        WsbQuickString(WsbPtrToStringAsString(pName)),
        WsbQuickString(WsbPtrToBoolAsString(pRecallOnly)),
        WsbPtrToFiletimeAsString(FALSE, pUpdate),
        WsbPtrToShortAsString(pNextRemoteDataSet));
        
    WsbTraceOut(OLESTR("CMediaInfo::GetLastKnownGoodMasterInfo"),   OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}

HRESULT
CMediaInfo::GetLKGMasterNextRemoteDataSet( 
    short *pNextRemoteDataSet 
    )
/*++

Implements:

  IMediaInfo::GetLKGMasterNextRemoteDataSet

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::GetLKGMasterNextRemoteDataSet"),OLESTR(""));
    try {                              
        WsbAssertPointer(pNextRemoteDataSet);
        *pNextRemoteDataSet = m_LastKnownGoodMaster.nextRemoteDataSet;
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::GetLKGMasterNextRemoteDataSet"), OLESTR("hr = <%ls>, Next Last-Known-Good-Master Remote-Data-Set = <%ls>"), WsbHrAsString(hr), WsbPtrToShortAsString(pNextRemoteDataSet));
    return(hr);
}


HRESULT 
CMediaInfo::SetLastKnownGoodMasterInfo
(
    GUID mediaId, 
    GUID mediaSubsystemId,
    GUID storagePoolId,
    LONGLONG FreeBytes,
    LONGLONG Capacity,
    HRESULT lastError,
    OLECHAR *description,
    HSM_JOB_MEDIA_TYPE type,
    OLECHAR *name,
    BOOL RecallOnly,
    FILETIME update,
    SHORT nextRemoteDataSet
    )
 /*++

Implements:

  IMediaInfo::SetLastKnownGoodMasterInfo().

--*/
{
    WsbTraceIn(OLESTR("CMediaInfo::SetLastKnownGoodMasterInfo"), OLESTR(""));
    
    WsbTrace(OLESTR("CMediaInfo::SetLastKnownGoodMasterInfo"), OLESTR("id = <%ls>, SubsystemId = <%ls>, StoragePoolId = <%ls>\n"), 
        WsbGuidAsString(mediaId), 
        WsbQuickString(WsbGuidAsString(mediaSubsystemId)), 
        WsbQuickString(WsbGuidAsString(storagePoolId)));
    WsbTrace(OLESTR("CMediaInfo::SetLastKnownGoodMasterInfo"), OLESTR("FreeBytes = <%ls>, Capacity = <%ls>, lastError = <%ls>\n"),
        WsbLonglongAsString(FreeBytes), 
        WsbQuickString(WsbLonglongAsString(Capacity)), 
        WsbHrAsString(lastError));
    WsbTrace(OLESTR("CMediaInfo::SetLastKnownGoodMasterInfo"), OLESTR("Description = <%ls>, Type = <%d>\n"), 
        (OLECHAR *)description, 
        type);
    WsbTrace(OLESTR("CMediaInfo::SetLastKnownGoodMasterInfo"), OLESTR("Name = <%ls>, RecallOnly = <%ls>, update = <%ls>, nextRemoteDataSet = <%d>\n"), 
        (OLECHAR *)name,
        WsbBoolAsString(RecallOnly),
        WsbFiletimeAsString(FALSE, update),
        nextRemoteDataSet);

    m_isDirty = TRUE;
    
    m_LastKnownGoodMaster.id = mediaId;
    m_LastKnownGoodMaster.ntmsId = mediaSubsystemId;
    m_LastKnownGoodMaster.storagePoolId = storagePoolId;
    m_LastKnownGoodMaster.freeBytes = FreeBytes;
    m_LastKnownGoodMaster.capacity = Capacity;
    m_LastKnownGoodMaster.lastError = lastError;
    m_LastKnownGoodMaster.description = description;
    m_LastKnownGoodMaster.type = type;
    m_LastKnownGoodMaster.name = name;
    m_LastKnownGoodMaster.recallOnly = RecallOnly;
    m_LastKnownGoodMaster.lastUpdate = update;
    m_LastKnownGoodMaster.nextRemoteDataSet = nextRemoteDataSet;

    WsbTraceOut(OLESTR("CMediaInfo::SetLastKnownGoodMasterInfo"), OLESTR("hr = <%ls>"),WsbHrAsString(S_OK));
    return(S_OK);
}



HRESULT
CMediaInfo::DeleteCopy( 
    USHORT copyNumber
    ) 
/*++

Implements:

  IMediaInfo::DeleteCopy

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::DeleteCopy"),OLESTR("copy = <%u>"), copyNumber);
    try {
        //
        // Make sure we have a valid copy number
        //
        WsbAffirm(((0 < copyNumber) && (copyNumber <= HSM_MAX_NUMBER_MEDIA_COPIES)),
                E_INVALIDARG);
        
        //
        // Null out the existing copy information
        //
        m_Copy[copyNumber - 1].id = GUID_NULL;
        m_Copy[copyNumber - 1].description = "";
        m_Copy[copyNumber - 1].name = "";
        m_Copy[copyNumber - 1].lastUpdate = WsbLLtoFT(0);
        m_Copy[copyNumber - 1].lastError = S_OK;
        m_Copy[copyNumber - 1].nextRemoteDataSet = 0;
        
        
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::DeleteCopy"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
    return(hr);
}



HRESULT
CMediaInfo::RecreateMaster( void )
/*++

Implements:

  IMediaInfo::RecreateMaster

--*/
{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::RecreateMaster"),OLESTR(""));
    try {
        //
        // Mark the master as one that needs to be recreated
        //
        m_Recreate = TRUE;
        
        //
        // Also, make sure we don't add data to this master
        //
        m_Master.recallOnly = TRUE;

    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CMediaInfo::RecreateMaster"), OLESTR("hr = <%ls>"), 
                                                        WsbHrAsString(hr));
    return(hr);
}


//
// Internal (non COM) Helper functions
//


HRESULT
CMediaInfo::UpdateLastKnownGoodMaster( void )
/*++

Implements:

  IMediaInfo::UpdateLastKnownGoodMaster

--*/

{ 
    HRESULT  hr = S_OK; 

    WsbTraceIn(OLESTR("CMediaInfo::UpdateLastKnownGoodMaster"),OLESTR(""));

    m_LastKnownGoodMaster.id = m_Master.id;
    m_LastKnownGoodMaster.ntmsId = m_Master.ntmsId;
    m_LastKnownGoodMaster.storagePoolId = m_Master.storagePoolId;
    m_LastKnownGoodMaster.freeBytes = m_Master.freeBytes;
    m_LastKnownGoodMaster.capacity = m_Master.capacity;
    m_LastKnownGoodMaster.lastError = m_Master.lastError;
    m_LastKnownGoodMaster.description = m_Master.description;
    m_LastKnownGoodMaster.type = m_Master.type;
    m_LastKnownGoodMaster.name = m_Master.name;
    m_LastKnownGoodMaster.recallOnly = m_Master.recallOnly;
    m_LastKnownGoodMaster.lastUpdate = m_Master.lastUpdate;
    m_LastKnownGoodMaster.nextRemoteDataSet = m_Master.nextRemoteDataSet;

    WsbTraceOut(OLESTR("CMediaInfo::UpdateLastKnownGoodMaster"), OLESTR("hr = <%ls>"), 
        WsbHrAsString(hr));
    return(hr);
}



HRESULT
CMediaInfo::WriteToDatabase( void )
/*++

Routine Description:

  This function writes the information to the metadata
  database.  Note all other set functions require the
  caller to call the Write() funtion for the entity.

Arguments:

  None

Return Value:
  
  S_OK: If the LastKnownGoodMaster is to be updated
  

--*/

{ 
    HRESULT                     hr = S_OK; 
    BOOLEAN                     openedDb = FALSE;
    CComPtr<IWsbDb>             pSegmentDb;
    CComPtr<IMediaInfo>         pMediaInfo;
    CComPtr<IHsmServer>         pServer;
    CComPtr<IWsbDbSession>      pDbSession;

    WsbTraceIn(OLESTR("CMediaInfo::WriteToDatabase"),OLESTR(""));
    try {
        //
        // Find the database containing the record that matches this 
        // collectable.  
        //
        WsbAffirmHr(CoCreateInstance( CLSID_HsmServer, 0, CLSCTX_SERVER, IID_IHsmServer, (void **)&pServer ));
        WsbAffirmHr(pServer->GetSegmentDb(&pSegmentDb));
        
        //
        // Find the database entity
        //
        WsbAffirmHr(pSegmentDb->Open(&pDbSession));
        openedDb = TRUE;
        WsbTrace(OLESTR("CMediaInfo::WriteToDatabase - Opened the database\n"));
        WsbAffirmHr(pSegmentDb->GetEntity(pDbSession, HSM_MEDIA_INFO_REC_TYPE, IID_IMediaInfo,
                       (void**)&pMediaInfo));
        WsbAffirmHr(pMediaInfo->SetId(m_Master.id));
        WsbAffirmHr(pMediaInfo->FindEQ());
        
        // 
        // Write the changes to the database.  To be sure that the "outside" world
        // doesn't change anything but the allowed fields, just set the fields that are
        // allowed to be changed.
        //
        WsbAffirmHr(pMediaInfo->SetRecreate(m_Recreate));
        WsbAffirmHr(SetRecallOnlyStatus(m_Master.recallOnly));
        for (int i = 1; i <= HSM_MAX_NUMBER_MEDIA_COPIES; i++)  {
            WsbAffirmHr(pMediaInfo->SetCopyInfo( (SHORT)i, 
                                                m_Copy[i-1].id,
                                                (OLECHAR *)m_Copy[i-1].description, 
                                                (OLECHAR *)m_Copy[i-1].name, 
                                                m_Copy[i-1].lastUpdate,
                                                m_Copy[i-1].lastError,
                                                m_Copy[i-1].nextRemoteDataSet));
        }            
        WsbAffirmHr(pMediaInfo->Write());
        
    } WsbCatch(hr);

    if (openedDb) {
        WsbTrace(OLESTR("CMediaInfo::WriteToDatabase - Closing the database\n"));
        pSegmentDb->Close(pDbSession);
        pDbSession = 0;
        openedDb = FALSE;
    }
    
    WsbTraceOut(OLESTR("CMediaInfo::WriteToDatabase"), OLESTR("hr = <%ls>"), 
        WsbHrAsString(hr));
    return(hr);
}