source: vbox/trunk/src/VBox/Main/src-server/CloudProviderManagerImpl.cpp@ 86012

/* $Id: CloudProviderManagerImpl.cpp 86012 2020-09-03 00:08:56Z vboxsync $ */
/** @file
 * ICloudProviderManager  COM class implementations.
 */

/*
 * Copyright (C) 2008-2020 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.215389.xyz. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */


#define LOG_GROUP LOG_GROUP_MAIN_CLOUDPROVIDERMANAGER
#include <iprt/cpp/utils.h>
#include <VBox/com/array.h>

#include "VirtualBoxImpl.h"
#include "CloudProviderManagerImpl.h"
#include "ExtPackManagerImpl.h"
#include "AutoCaller.h"
#include "LoggingNew.h"


////////////////////////////////////////////////////////////////////////////////
//
// CloudProviderManager constructor / destructor
//
// ////////////////////////////////////////////////////////////////////////////////
CloudProviderManager::CloudProviderManager()
  : m_pVirtualBox(NULL)
{
}

CloudProviderManager::~CloudProviderManager()
{
}


HRESULT CloudProviderManager::FinalConstruct()
{
    return BaseFinalConstruct();
}

void CloudProviderManager::FinalRelease()
{
    uninit();

    BaseFinalRelease();
}

HRESULT CloudProviderManager::init(VirtualBox *aVirtualBox)
{
    // Enclose the state transition NotReady->InInit->Ready.
    AutoInitSpan autoInitSpan(this);
    AssertReturn(autoInitSpan.isOk(), E_FAIL);

    m_apCloudProviders.clear();
    unconst(m_pVirtualBox) = aVirtualBox;

    autoInitSpan.setSucceeded();
    return S_OK;
}

void CloudProviderManager::uninit()
{
    // Enclose the state transition Ready->InUninit->NotReady.
    AutoUninitSpan autoUninitSpan(this);
    if (autoUninitSpan.uninitDone())
        return;

    m_mapCloudProviderManagers.clear();
    m_apCloudProviders.clear();

    unconst(m_pVirtualBox) = NULL; // not a ComPtr, but be pedantic
}


#ifdef VBOX_WITH_EXTPACK

bool CloudProviderManager::i_canRemoveExtPack(IExtPack *aExtPack)
{
    AssertReturn(aExtPack, false);

    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);

    // If any cloud provider in this extension pack fails to prepare the
    // uninstall it and the cloud provider will be kept, so that the user
    // can retry safely later. All other cloud providers in this extpack
    // will be done as usual. No attempt is made to bring back the other
    // cloud providers into working shape.

    bool fRes = true;

    Bstr bstrExtPackName;
    aExtPack->COMGETTER(Name)(bstrExtPackName.asOutParam());
    Utf8Str strExtPackName(bstrExtPackName);

    /* is there a cloud provider in this extpack? */
    ExtPackNameCloudProviderManagerMap::iterator it
        = m_mapCloudProviderManagers.find(strExtPackName);
    if (it != m_mapCloudProviderManagers.end())
    {
        // const ComPtr<ICloudProviderManager> pManager(it->second); /* unused */

        /* loop over all providers checking for those from the aExtPack */
        Assert(m_astrExtPackNames.size() == m_apCloudProviders.size());
        for (size_t i = 0; i < m_astrExtPackNames.size(); )
        {
            /* the horse it rode in on? */
            if (m_astrExtPackNames[i] != strExtPackName)
            {
                i++;
                continue;     /* not the extpack we are looking for */
            }

            /* note the id of this provider to send an event later */
            Bstr bstrProviderId;

            /*
             * pTmpProvider will point to an object with refcount > 0
             * until the ComPtr is removed from m_apCloudProviders.
             * PrepareUninstall checks that that is the only reference
             */
            HRESULT hrc = S_OK;
            ULONG uRefCnt = 1;
            ICloudProvider *pTmpProvider(m_apCloudProviders[i]);
            if (pTmpProvider)
            {
                /* do this before the provider goes over the rainbow bridge */
                pTmpProvider->COMGETTER(Id)(bstrProviderId.asOutParam());

                /**
                 * @todo r=uwe We send the event @em before we even
                 * try to uninstall the provider.  The GUI can get the
                 * event and get rid of any references to the objects
                 * related to this provider that it still has.  The
                 * current uninstall attempt might fail, but the GUI
                 * can then retry once and likely succeed.  Needs more
                 * thought and feeback from dsen.
                 */
                m_pVirtualBox->i_onCloudProviderRegistered(bstrProviderId, FALSE);

                hrc = pTmpProvider->PrepareUninstall();
                pTmpProvider->AddRef();
                uRefCnt = pTmpProvider->Release();
            }

            /* has PrepareUninstall uninited the provider? */
            if (SUCCEEDED(hrc) && uRefCnt == 1)
            {
                m_astrExtPackNames.erase(m_astrExtPackNames.begin() + (ssize_t)i);
                m_apCloudProviders.erase(m_apCloudProviders.begin() + (ssize_t)i);
                /* NB: not advancing loop index */
            }
            else
            {
                LogRel(("CloudProviderManager: provider '%s' blocks extpack uninstall, result=%Rhrc, refcount=%u\n",
                        strExtPackName.c_str(), hrc, uRefCnt));
                fRes = false;
                i++;
            }
        }

        if (fRes)
            m_mapCloudProviderManagers.erase(it);
    }

    return fRes;
}

void CloudProviderManager::i_addExtPack(IExtPack *aExtPack)
{
    HRESULT hrc;

    AssertReturnVoid(aExtPack);
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);

    Bstr bstrExtPackName;
    aExtPack->COMGETTER(Name)(bstrExtPackName.asOutParam());
    Utf8Str strExtPackName(bstrExtPackName);

    /* get the extpack's cloud provider manager object if present */
    ComPtr<IUnknown> pObj;
    com::Guid idObj(COM_IIDOF(ICloudProviderManager));
    hrc = aExtPack->QueryObject(Bstr(idObj.toString()).raw(), pObj.asOutParam());
    if (FAILED(hrc))
        return;
    const ComPtr<ICloudProviderManager> pManager(pObj);
    if (pManager.isNull())
        return;

    /* get the list of cloud providers */
    SafeIfaceArray<ICloudProvider> apProvidersFromCurrExtPack;
    hrc = pManager->COMGETTER(Providers)(ComSafeArrayAsOutParam(apProvidersFromCurrExtPack));
    if (FAILED(hrc))
        return;
    if (apProvidersFromCurrExtPack.size() == 0)
        return;

    m_mapCloudProviderManagers[strExtPackName] = pManager;

    /* collect provider ids for bulk-sending the events */
    std::vector<Utf8Str> aProviderIds;
    aProviderIds.reserve(apProvidersFromCurrExtPack.size());

    for (unsigned i = 0; i < apProvidersFromCurrExtPack.size(); i++)
    {
        const ComPtr<ICloudProvider> pProvider(apProvidersFromCurrExtPack[i]);
        if (!pProvider.isNull())
        {
            // Sanity check each cloud provider by forcing a QueryInterface call,
            // making sure that it implements the right interface.
            ComPtr<ICloudProvider> pProviderCheck;
            pProvider.queryInterfaceTo(pProviderCheck.asOutParam());
            if (!pProviderCheck.isNull()) /* ok, seems legit */
            {
                /* save the provider and the name of the extpack it came from */
                Assert(m_astrExtPackNames.size() == m_apCloudProviders.size());
                m_astrExtPackNames.push_back(strExtPackName);
                m_apCloudProviders.push_back(pProvider);

                /* note the id of this provider to send an event later */
                Bstr bstrProviderId;
                pProvider->COMGETTER(Id)(bstrProviderId.asOutParam());
                aProviderIds.push_back(bstrProviderId);
            }
        }
    }

    /* bulk-send ICloudProviderRegisteredEvent's */
    for (size_t i = 0; i < aProviderIds.size(); ++i)
    {
        m_pVirtualBox->i_onCloudProviderRegistered(aProviderIds[i], TRUE);
    }
}

#endif  /* VBOX_WITH_EXTPACK */

HRESULT CloudProviderManager::getProviders(std::vector<ComPtr<ICloudProvider> > &aProviders)
{
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    aProviders = m_apCloudProviders;
    return S_OK;
}

HRESULT CloudProviderManager::getProviderById(const com::Guid &aProviderId,
                                              ComPtr<ICloudProvider> &aProvider)
{
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    for (size_t i = 0; i < m_apCloudProviders.size(); i++)
    {
        Bstr bstrId;
        HRESULT hrc = m_apCloudProviders[i]->COMGETTER(Id)(bstrId.asOutParam());
        if (SUCCEEDED(hrc) && aProviderId == bstrId)
        {
            aProvider = m_apCloudProviders[i];
            return S_OK;
        }
    }
    return setError(VBOX_E_OBJECT_NOT_FOUND, tr("Could not find a cloud provider with UUID {%RTuuid}"),
                    aProviderId.raw());
}

HRESULT CloudProviderManager::getProviderByShortName(const com::Utf8Str &aProviderName,
                                                     ComPtr<ICloudProvider> &aProvider)
{
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    for (size_t i = 0; i < m_apCloudProviders.size(); i++)
    {
        Bstr bstrName;
        HRESULT hrc = m_apCloudProviders[i]->COMGETTER(ShortName)(bstrName.asOutParam());
        if (SUCCEEDED(hrc) && bstrName.equals(aProviderName))
        {
            aProvider = m_apCloudProviders[i];
            return S_OK;
        }
    }
    return setError(VBOX_E_OBJECT_NOT_FOUND, tr("Could not find a cloud provider with short name '%s'"),
                    aProviderName.c_str());
}

HRESULT CloudProviderManager::getProviderByName(const com::Utf8Str &aProviderName,
                                                ComPtr<ICloudProvider> &aProvider)
{
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    for (size_t i = 0; i < m_apCloudProviders.size(); i++)
    {
        Bstr bstrName;
        HRESULT hrc = m_apCloudProviders[i]->COMGETTER(Name)(bstrName.asOutParam());
        if (SUCCEEDED(hrc) && bstrName.equals(aProviderName))
        {
            aProvider = m_apCloudProviders[i];
            return S_OK;
        }
    }
    return setError(VBOX_E_OBJECT_NOT_FOUND, tr("Could not find a cloud provider with name '%s'"),
                    aProviderName.c_str());
}