windows-server-2003/base/fs/hsm/engine/hsmeng/hsmstgpl.cpp

/*++

� 1998 Seagate Software, Inc.  All rights reserved.

Module Name:

    HsmStgPl.cpp

Abstract:

    This component is an object representation of the HSM Storage Pool. It
    is both a persistable and collectable.

Author:

    Cat Brant   [cbrant]   09-Feb-1997

Revision History:

--*/


#include "stdafx.h"
#include "Wsb.h"
#include "HsmEng.h"
#include "HsmServ.h"
#include "HsmConn.h"
#include "HsmStgPl.h"
#include "Fsa.h"
#include "Rms.h"

#define WSB_TRACE_IS        WSB_TRACE_BIT_HSMENG

HRESULT 
CHsmStoragePool::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 CWsbObject::FinalConstruct().

--*/
{
    HRESULT     hr = S_OK;

    try {

        WsbAffirmHr(CWsbObject::FinalConstruct());
        
        m_MediaSetId = GUID_NULL;
        m_PolicyId = GUID_NULL;
        m_NumOnlineMedia = 0;
        m_NumMediaCopies = 0;
        m_MediaSetName = "  ";
        
        WsbAffirmHr(CoCreateGuid( &m_Id ));
        
    } WsbCatch(hr);

    return(hr);
}

HRESULT 
CHsmStoragePool::GetId(
    OUT GUID *pId
    ) 
/*++

Routine Description:

  See IHsmStoragePool::GetId

Arguments:

  See IHsmStoragePool::GetId

Return Value:
  
    See IHsmStoragePool::GetId

--*/
{
    
    HRESULT     hr = S_OK;

    WsbTraceIn(OLESTR("CHsmStoragePool::GetId"),OLESTR(""));

    try {
        //Make sure we can provide data memebers
        WsbAssert(0 != pId, E_POINTER);

        //Provide the data members
        *pId = m_Id;

    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CHsmStoragePool::GetId"),
        OLESTR("hr = <%ls>, Id = <%ls>>"),WsbHrAsString(hr), WsbPtrToGuidAsString(pId));

    return(hr);
}

HRESULT 
CHsmStoragePool::SetId(
    GUID Id
    ) 
/*++

Routine Description:

  See IHsmStoragePool::SetId

Arguments:

  See IHsmStoragePool::SetId

Return Value:
  
    See IHsmStoragePool::SetId

--*/
{
    
    HRESULT     hr = S_OK;

    WsbTraceIn(OLESTR("CHsmStoragePool::SetId"),OLESTR("Id = <%ls>>"), WsbGuidAsString(Id));

    try {

        //Provide the data members
        m_Id = Id;

    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CHsmStoragePool::SetId"),OLESTR("hr = <%ls>"),WsbHrAsString(hr));

    return(hr);
}

HRESULT 
CHsmStoragePool::GetClassID (
    OUT LPCLSID pClsId
    ) 
/*++

Routine Description:

  See IPerist::GetClassID()

Arguments:

  See IPerist::GetClassID()

Return Value:

    See IPerist::GetClassID()

--*/

{
    HRESULT     hr = S_OK;

    WsbTraceIn(OLESTR("CHsmStoragePool::GetClassID"), OLESTR(""));


    try {
        WsbAssert(0 != pClsId, E_POINTER);
        *pClsId = CLSID_CHsmStoragePool;

    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CHsmStoragePool::GetClassID"), OLESTR("hr = <%ls>, CLSID = <%ls>"), WsbHrAsString(hr), WsbGuidAsString(*pClsId));
    return(hr);
}

HRESULT 
CHsmStoragePool::GetSizeMax (
    OUT ULARGE_INTEGER* pcbSize
    ) 
/*++

Routine Description:

  See IPersistStream::GetSizeMax().

Arguments:

  See IPersistStream::GetSizeMax().

Return Value:

  See IPersistStream::GetSizeMax().

--*/
{
    HRESULT     hr = S_OK;

    WsbTraceIn(OLESTR("CHsmStoragePool::GetSizeMax"), OLESTR(""));

    try {
        ULONG nameLen;
        
        WsbAssert(0 != pcbSize, E_POINTER);
        
        nameLen = SysStringByteLen(m_MediaSetName);

        pcbSize->QuadPart = ((3 * WsbPersistSizeOf(GUID)) +  // m_id + m_MediaSetID + m_PolicyId
                             WsbPersistSizeOf(ULONG) +       // m_NumOnlineMedia
                             WsbPersistSizeOf(USHORT) +      // m_NumMediaCopies
                             nameLen);                       // m_MediaSetName
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CHsmStoragePool::GetSizeMax"), 
        OLESTR("hr = <%ls>, Size = <%ls>"), WsbHrAsString(hr), 
        WsbPtrToUliAsString(pcbSize));

    return(hr);
}

HRESULT 
CHsmStoragePool::Load (
    IN IStream* pStream
    ) 
/*++

Routine Description:

  See IPersistStream::Load().

Arguments:

  See IPersistStream::Load().

Return Value:

  See IPersistStream::Load().

--*/
{
    HRESULT     hr = S_OK;

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

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


        WsbAffirmHr(WsbLoadFromStream(pStream, &m_Id));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_MediaSetId));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_PolicyId));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_NumOnlineMedia));
        WsbAffirmHr(WsbLoadFromStream(pStream, &m_NumMediaCopies));
        m_MediaSetName.Free();
        WsbAffirmHr(WsbBstrFromStream(pStream, &m_MediaSetName));
        
    } WsbCatch(hr);
    
    WsbTraceOut(OLESTR("CHsmStoragePool::Load"), 
        OLESTR("hr = <%ls>,  GUID = <%ls>"), 
        WsbHrAsString(hr), 
        WsbGuidAsString(m_Id));
    return(hr);
}

HRESULT 
CHsmStoragePool::Save (
    IN IStream* pStream, 
    IN BOOL clearDirty
    ) 
/*++

Routine Description:

  See IPersistStream::Save().

Arguments:

  See IPersistStream::Save().

Return Value:

  See IPersistStream::Save().

--*/
{
    HRESULT     hr = S_OK;

    WsbTraceIn(OLESTR("CHsmStoragePool::Save"), OLESTR("clearDirty = <%ls>"), WsbBoolAsString(clearDirty));

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

        WsbAffirmHr(WsbSaveToStream(pStream, m_Id));
        WsbAffirmHr(WsbSaveToStream(pStream, m_MediaSetId));
        WsbAffirmHr(WsbSaveToStream(pStream, m_PolicyId));
        WsbAffirmHr(WsbSaveToStream(pStream, m_NumOnlineMedia));
        WsbAffirmHr(WsbSaveToStream(pStream, m_NumMediaCopies));
        WsbAffirmHr(WsbBstrToStream(pStream, m_MediaSetName));
        
        if (clearDirty) {
            m_isDirty = FALSE;
        }
    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CHsmStoragePool::Save"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));

    return(hr);
}


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

Routine Description:

  See IWsbTestable::Test().

Arguments:

  See IWsbTestable::Test().

Return Value:

  See IWsbTestable::Test().

--*/
{
    HRESULT                 hr = S_OK;
    CComPtr<IHsmStoragePool>        pHsmStoragePool1;
    CComPtr<IHsmStoragePool>        pHsmStoragePool2;
    GUID                    l_Id;

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

    *pTestsPassed = *pTestsFailed = 0;
    try {
        // Get the pHsmStoragePool interface.
        WsbAffirmHr(((IUnknown*)(IHsmStoragePool*) this)->QueryInterface(IID_IHsmStoragePool,
                    (void**) &pHsmStoragePool1));


        hr = S_OK;
        try {
            //Create another instance and test the comparisson methods:
            WsbAffirmHr(CoCreateInstance(CLSID_CHsmStoragePool, NULL, CLSCTX_ALL, IID_IHsmStoragePool, (void**) &pHsmStoragePool2));

            // Check the default values.
            WsbAffirmHr(pHsmStoragePool2->GetId(&l_Id));
            WsbAffirm((l_Id == GUID_NULL), E_FAIL);
        }  WsbCatch(hr);

        if (hr == S_OK) {
            (*pTestsPassed)++;
        } else {
            (*pTestsFailed)++;
        }

    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CHsmStoragePool::Test"),    OLESTR("hr = <%ls>"),WsbHrAsString(hr));
    return(S_OK);
}

HRESULT 
CHsmStoragePool::CompareTo (
    IN IUnknown* pCollectable, 
    OUT short* pResult
    ) 
/*++

Routine Description:

        1  : object > value
        0  : object = value
        -1 : object < value
    In addition, the return code is S_OK if the object = value and
    S_FALSE otherwise.

Arguments:


Return Value:

    S_OK        - object = value

    S_FALSE     - object != value

--*/

{
    HRESULT                  hr = S_OK;
    CComPtr<IHsmStoragePool> pHsmStoragePool;

    WsbTraceIn(OLESTR("CHsmStoragePool::CompareTo"), OLESTR(""));


    // Did they give us a valid item to compare to?
    try {
        WsbAssert(pCollectable != NULL, E_POINTER);

        // We need the IWsbLong interface to get the value of the object.
        WsbAffirmHr(pCollectable->QueryInterface(IID_IHsmStoragePool, (void**) &pHsmStoragePool));
        hr = pHsmStoragePool->CompareToIHsmStoragePool(this, pResult);
        } WsbCatch(hr);

    WsbTraceOut(OLESTR("CHsmStoragePool::CompareTo"), OLESTR("hr = <%ls>, pResult = <%d>"), WsbHrAsString(hr), pResult);

    return(hr);
}

HRESULT 
CHsmStoragePool::CompareToIHsmStoragePool (
    IN IHsmStoragePool* pHsmStoragePool, 
    OUT short* pResult
    )
{
    HRESULT                 hr = S_OK;
    GUID                    l_Id;
    BOOL                    areGuidsEqual;


    WsbTraceIn(OLESTR("CHsmStoragePool::CompareToIHsmStoragePool"), OLESTR(""));

    try {

        // Did they give us a valid item to compare to?
        WsbAssert(pHsmStoragePool != NULL, E_POINTER);

        WsbAffirmHr(((IHsmStoragePool *)pHsmStoragePool)->GetId(&l_Id));

        // Make sure the GUID matches.  Then see if the SegStartLoc is in the range of this entry
        areGuidsEqual = IsEqualGUID(m_Id, l_Id);
        WsbAffirm( (areGuidsEqual == TRUE), S_FALSE); 

    } WsbCatch(hr);

    WsbTraceOut(OLESTR("CHsmStoragePool::CompareToIHsmStoragePool"), OLESTR("hr = <%ls>, pResult = <%d>"), WsbHrAsString(hr), pResult);

    return(hr);
}

HRESULT 
CHsmStoragePool::GetMediaSet( 
    GUID *pMediaSetId, 
    BSTR *pMediaSetName 
    )
/*++

Routine Description:

  See IHsmStoragePool::

Arguments:

  See IHsmStoragePool::

Return Value:

  See IHsmStoragePool::

--*/
{
    HRESULT                 hr = S_OK;
    
    WsbTraceIn(OLESTR("CHsmStoragePool::GetMediaSet"),OLESTR(""));
    
    try  {
        WsbAssert(0 != pMediaSetId, E_POINTER);
        WsbAssert(0 != pMediaSetName, E_POINTER);
        *pMediaSetName = WsbAllocString( m_MediaSetName );
        
        *pMediaSetId = m_MediaSetId;
    } WsbCatch( hr );
    
    WsbTraceOut(OLESTR("CHsmStoragePool::GetMediaSet"),
        OLESTR("hr = <%ls>, Id = <%ls>>"),WsbHrAsString(hr), WsbPtrToGuidAsString(pMediaSetId));
    return( hr );
}    
    

HRESULT 
CHsmStoragePool::SetMediaSet( 
    GUID mediaSetId, 
    BSTR mediaSetName 
    )
/*++

Routine Description:

  See IHsmStoragePool::

Arguments:

  See IHsmStoragePool::

Return Value:

  See IHsmStoragePool::

--*/
{
    HRESULT                 hr = S_OK;
    
    WsbTraceIn(OLESTR("CHsmStoragePool::SetMediaSet"),OLESTR(""));
    
    try  {
        m_MediaSetId = mediaSetId;
        m_MediaSetName = mediaSetName;
        
        m_isDirty = TRUE;
        
    } WsbCatch( hr );
    
    WsbTraceOut(OLESTR("CHsmStoragePool::SetMediaSet"), OLESTR("hr = <%ls>"),WsbHrAsString(hr));

    return( hr );
}    

HRESULT 
CHsmStoragePool::GetNumOnlineMedia( 
    ULONG *pNumOnlineMedia 
    )
/*++

Routine Description:

  See IHsmStoragePool::

Arguments:

  See IHsmStoragePool::

Return Value:

  See IHsmStoragePool::

--*/
{
    HRESULT                 hr = S_OK;
    WsbTraceIn(OLESTR("CHsmStoragePool::GetNumOnlineMedia"),OLESTR(""));
    
    try  {
        
        WsbAffirm(0 != pNumOnlineMedia, E_POINTER);
        *pNumOnlineMedia = m_NumOnlineMedia;
        
    } WsbCatch( hr );
    
    WsbTraceOut(OLESTR("CHsmStoragePool::GetNumOnlineMedia"),
        OLESTR("hr = <%ls>"),WsbHrAsString(hr));

    return( hr );
}    

HRESULT 
CHsmStoragePool::SetNumOnlineMedia( 
    ULONG numOnlineMedia 
    )
/*++

Routine Description:

  See IHsmStoragePool::

Arguments:

  See IHsmStoragePool::

Return Value:

  See IHsmStoragePool::

--*/
{
    HRESULT                 hr = S_OK;
    WsbTraceIn(OLESTR("CHsmStoragePool::SetNumOnlineMedia"),OLESTR(""));
    
    m_NumOnlineMedia = numOnlineMedia;
    m_isDirty = TRUE;
    
    WsbTraceOut(OLESTR("CHsmStoragePool::SetNumOnlineMedia"),
        OLESTR("hr = <%ls>"),WsbHrAsString(hr));

    return( hr );
}    

HRESULT 
CHsmStoragePool::GetNumMediaCopies( 
    USHORT *pNumMediaCopies 
    )
/*++

Routine Description:

  See IHsmStoragePool::

Arguments:

  See IHsmStoragePool::

Return Value:

  See IHsmStoragePool::

--*/
{
    HRESULT                 hr = S_OK;
    WsbTraceIn(OLESTR("CHsmStoragePool::GetNumMediaCopies"),OLESTR(""));
    
    try  {
        
        WsbAffirm(0 != pNumMediaCopies, E_POINTER);
        *pNumMediaCopies = m_NumMediaCopies;
        
    } WsbCatch( hr );
    
    WsbTraceOut(OLESTR("CHsmStoragePool::GetNumMediaCopies"),
        OLESTR("hr = <%ls>"),WsbHrAsString(hr));

    return( hr );
}    

HRESULT 
CHsmStoragePool::SetNumMediaCopies( 
    USHORT numMediaCopies 
    )
/*++

Routine Description:

  See IHsmStoragePool::

Arguments:

  See IHsmStoragePool::

Return Value:

  See IHsmStoragePool::

--*/
{
    HRESULT                 hr = S_OK;
    
    WsbTraceIn(OLESTR("CHsmStoragePool::SetNumMediaCopies"),OLESTR(""));

    m_NumMediaCopies = numMediaCopies;
    m_isDirty = TRUE;
    
    WsbTraceOut(OLESTR("CHsmStoragePool::SetNumMediaCopies"),OLESTR("hr = <%ls>"),WsbHrAsString(hr));
    return( hr );
}    

HRESULT 
CHsmStoragePool::GetManagementPolicy( 
    GUID *pManagementPolicyId 
    )
/*++

Routine Description:

  See IHsmStoragePool::

Arguments:

  See IHsmStoragePool::

Return Value:

  See IHsmStoragePool::

--*/
{
    HRESULT                 hr = S_OK;
    
    WsbTraceIn(OLESTR("CHsmStoragePool::GetManagementPolicy"),OLESTR(""));
    
    try  {
        
        WsbAffirm(0 != pManagementPolicyId, E_POINTER);
        *pManagementPolicyId = m_PolicyId;
        
    } WsbCatch( hr );
    
    WsbTraceOut(OLESTR("CHsmStoragePool::GetManagementPolicy"),OLESTR("hr = <%ls>"),WsbHrAsString(hr));

    return( hr );
}    

HRESULT 
CHsmStoragePool::SetManagementPolicy( 
    GUID managementPolicyId 
    )
/*++

Routine Description:

  See IHsmStoragePool::

Arguments:

  See IHsmStoragePool::

Return Value:

  See IHsmStoragePool::

--*/
{
    HRESULT                 hr = S_OK;
    
    WsbTraceIn(OLESTR("CHsmStoragePool::SetManagementPolicy"),OLESTR(""));

    m_PolicyId = managementPolicyId;
    m_isDirty = TRUE;
    
    WsbTraceOut(OLESTR("CHsmStoragePool::SetManagementPolicy"),OLESTR("hr = <%ls>"),WsbHrAsString(hr));

    return( hr );
}    

HRESULT 
CHsmStoragePool::GetRmsMediaSet (
    IUnknown **ppIRmsMediaSet
    )
/*++

Routine Description:

  See IHsmStoragePool::

Arguments:

  See IHsmStoragePool::

Return Value:

  See IHsmStoragePool::

--*/
{
    HRESULT                 hr = S_OK;
    
    WsbTraceIn(OLESTR("CHsmStoragePool::GetRmsMediaSet"),OLESTR(""));
    
    try  {
        WsbAffirm(0 != ppIRmsMediaSet, E_POINTER );
        hr = E_NOTIMPL;
        
    } WsbCatch( hr );

    WsbTraceOut(OLESTR("CHsmStoragePool::GetRmsMediaSet"),OLESTR("hr = <%ls>"),WsbHrAsString(hr));

    return( hr );
}    

#define     HSM_DEFAULT_MAXSIZE_OPTICAL     (1024)
#define     HSM_DEFAULT_MAXSIZE_TAPE        (1024*10)

HRESULT 
CHsmStoragePool::InitFromRmsMediaSet (
    IUnknown *pIRmsMediaSet
    )
/*++

Routine Description:                                                                

  See IHsmStoragePool::

Arguments:

  See IHsmStoragePool::

Return Value:

  See IHsmStoragePool::

--*/
{
    HRESULT                 hr = S_OK;
    
    WsbTraceIn(OLESTR("CHsmStoragePool::InitFromRmsMediaSet"),OLESTR(""));
    
    try  {
        WsbAffirm(0 != pIRmsMediaSet, E_POINTER );
        //
        // Get the real interface                                                                            
        //
        CComPtr<IRmsMediaSet>       l_pIRmsMediaSet;
        WsbAffirmHr(pIRmsMediaSet->QueryInterface(IID_IRmsMediaSet, (void **)&l_pIRmsMediaSet));
        WsbAffirmHr(l_pIRmsMediaSet->GetMediaSetId(&m_MediaSetId));
        m_MediaSetName.Free();
        WsbAffirmHr(l_pIRmsMediaSet->GetName(&m_MediaSetName));

        // Set in the Registry which media type is being used
        // Set in the Registry max-file-size-to-migrate (in MB)
        //  Note: This hack should be removed when HSM supports more than one media type on the same system
        LONG            mediaType;
        DWORD           dwType;
        DWORD           dwSize;
        WsbAffirmHr(l_pIRmsMediaSet->GetMediaSupported(&mediaType));
        switch (mediaType) {
        case RmsMediaOptical: 
        case RmsMediaFixed:
        case RmsMediaDVD:
            dwType = HSM_VALUE_TYPE_DIRECTACCESS;
            dwSize = HSM_DEFAULT_MAXSIZE_OPTICAL;
            break;
        case RmsMedia8mm:
        case RmsMedia4mm:
        case RmsMediaDLT:
        case RmsMediaTape:
            dwType = HSM_VALUE_TYPE_SEQUENTIAL;
            dwSize = HSM_DEFAULT_MAXSIZE_TAPE;
            break;
        default:
            // This is not expected, however, we set tape as default
            WsbTraceAlways(OLESTR("CHsmStoragePool::InitFromRmsMediaSet : Got an unexpected media type %ld !!!\n"), mediaType);
            dwType = HSM_VALUE_TYPE_SEQUENTIAL;
            dwSize = HSM_DEFAULT_MAXSIZE_TAPE;
            break;
        }

        WsbAffirmHr(WsbSetRegistryValueDWORD(NULL, HSM_ENGINE_REGISTRY_STRING, HSM_MEDIA_TYPE, dwType));
        WsbAffirmHr(WsbSetRegistryValueDWORD(NULL, HSM_ENGINE_REGISTRY_STRING, HSM_MAX_FILE_TO_MIGRATE, dwSize));

    } WsbCatch( hr );

    WsbTraceOut(OLESTR("CHsmStoragePool::InitFromRmsMediaSet"),OLESTR("hr = <%ls>"),WsbHrAsString(hr));

    return( hr );
}    

HRESULT 
CHsmStoragePool::GetMediaSetType (
    USHORT *pMediaType
    )
/*++

Routine Description:                                                                

  Gets the media type of the corresponding media set

Arguments:

  pMediaType - media type, currently, the only options are direct-access or sequential

Return Value:

  S_OK for success

Notes:

  Future: Might consider keeping the media type instead of asking the media-set object again and again -
          Media type is not a dynamic propery. However, this reuires a change in the .col file structure.

--*/
{
    HRESULT                 hr = S_OK;
    
    WsbTraceIn(OLESTR("CHsmStoragePool::GetMediaSetType"),OLESTR(""));
    
    try  {
        WsbAffirm(0 != pMediaType, E_POINTER );

        // Get media-set object
        CComPtr<IHsmServer>         pHsmServer;
        CComPtr<IRmsServer>         pRmsServer;
        CComPtr<IRmsMediaSet>       pRmsMediaSet;

        WsbAssertHr(HsmConnectFromId(HSMCONN_TYPE_HSM, GUID_NULL, IID_IHsmServer, (void**) &pHsmServer));
        WsbAffirmHr(pHsmServer->GetHsmMediaMgr(&pRmsServer));
        WsbAffirmHr(pRmsServer->CreateObject(m_MediaSetId, CLSID_CRmsMediaSet, IID_IRmsMediaSet, RmsOpenExisting, (void **)&pRmsMediaSet));

        // Determine media type
        LONG            mediaType;
        WsbAffirmHr(pRmsMediaSet->GetMediaSupported(&mediaType));
        switch (mediaType) {
            case RmsMediaOptical: 
            case RmsMediaFixed:
            case RmsMediaDVD:
                *pMediaType = HSM_VALUE_TYPE_DIRECTACCESS;
                break;
            case RmsMedia8mm:
            case RmsMedia4mm:
            case RmsMediaDLT:
            case RmsMediaTape:
                *pMediaType = HSM_VALUE_TYPE_SEQUENTIAL;
                break;
            default:
                // This is not expected, however, we set tape as default
                WsbTraceAlways(OLESTR("CHsmStoragePool::GetMediaSetType : Got an unexpected media type %hu !!!\n"), *pMediaType);
                *pMediaType = HSM_VALUE_TYPE_SEQUENTIAL;
                break;
        }

    } WsbCatch( hr );

    WsbTraceOut(OLESTR("CHsmStoragePool::GetMediaSetType"),OLESTR("Media-type = %hu hr = <%ls>"), *pMediaType, WsbHrAsString(hr));

    return( hr );
}