AssetManager.h

Go to the documentation of this file.

/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *     http://aws.amazon.com/apache2.0/
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

#ifndef ACSDKASSETMANAGER_ASSETMANAGER_H_
#define ACSDKASSETMANAGER_ASSETMANAGER_H_

#include <AVSCommon/Utils/FileSystem/FileSystemUtils.h>
#include <AVSCommon/Utils/Metrics/MetricRecorderInterface.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <atomic>
#include <memory>
#include <unordered_set>

#include "acsdkAssetManager/UrlAllowListWrapper.h"
#include "acsdkAssetsInterfaces/Communication/AmdCommunicationInterface.h"
#include "acsdkDavsClient/DavsClient.h"

namespace alexaClientSDK {
namespace acsdkAssets {
namespace manager {

class RequesterFactory;
class StorageManager;
class Requester;

enum class IdleState { ACTIVE = 0, IDLE = 1 };

class AssetManager
        : public std::enable_shared_from_this<AssetManager>
        , public acsdkCommunicationInterfaces::FunctionInvokerInterface<bool, std::string> {
public:
    static std::shared_ptr<AssetManager> create(
            const std::shared_ptr<commonInterfaces::AmdCommunicationInterface>& communicationHandler,
            const std::shared_ptr<davs::DavsClient>& davsClient,
            const std::string& artifactsDirectory,
            const std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::AuthDelegateInterface>& authDelegate,
            const std::shared_ptr<UrlAllowListWrapper>& allowList);

    ~AssetManager() override;

    bool downloadArtifact(const std::shared_ptr<commonInterfaces::ArtifactRequest>& request);

    inline void queueDownloadArtifact(const std::shared_ptr<commonInterfaces::ArtifactRequest>& request) {
        m_executor.execute([this, request] { downloadArtifact(request); });
    }

    bool queueDownloadArtifact(const std::string& requestString);

    void deleteArtifact(const std::string& summaryString);

    inline void queueDeleteArtifact(const std::string& summaryString) {
        m_executor.execute([this, summaryString] { deleteArtifact(summaryString); });
    }

    void handleUpdate(const std::string& summaryString, bool acceptUpdate);

    inline void queueHandleUpdate(const std::string& summaryString, bool acceptUpdate) {
        m_executor.execute([this, summaryString, acceptUpdate] { handleUpdate(summaryString, acceptUpdate); });
    }

    bool freeUpSpace(size_t requestedAmount);

    inline void queueFreeUpSpace(size_t requestedAmount) {
        m_executor.execute([this, requestedAmount] { freeUpSpace(requestedAmount); });
    }

    void onIdleChanged(int value);

    size_t getBudget();

    void setBudget(uint32_t valueMB);

    // override functionInvokerInterface for download and delete.
    bool functionToBeInvoked(const std::string& name, std::string arg) override;

private:
    explicit AssetManager(
            std::shared_ptr<commonInterfaces::AmdCommunicationInterface> communicationHandler,
            std::shared_ptr<davs::DavsClient> davsClient,
            const std::string& baseDirectory,
            std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::AuthDelegateInterface> authDelegate,
            std::shared_ptr<UrlAllowListWrapper> allowUrlList);

    bool init();

    std::shared_ptr<Requester> findRequesterLocked(
            const std::shared_ptr<commonInterfaces::ArtifactRequest>& request) const;

private:
    const std::shared_ptr<commonInterfaces::AmdCommunicationInterface> m_communicationHandler;
    const std::shared_ptr<davs::DavsClient> m_davsClient;
    const std::string m_resourcesDirectory;
    const std::string m_requestsDirectory;
    const std::string m_urlTmpDirectory;
    const std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::AuthDelegateInterface> m_authDelegate;
    const std::shared_ptr<UrlAllowListWrapper> m_urlAllowList;
    std::unique_ptr<RequesterFactory> m_requesterFactory;
    alexaClientSDK::avsCommon::utils::threading::Executor m_executor;
    std::mutex m_requestersMutex;
    std::unordered_set<std::shared_ptr<Requester>> m_requesters;
    std::shared_ptr<StorageManager> m_storageManager;
};

}  // namespace manager
}  // namespace acsdkAssets
}  // namespace alexaClientSDK

#endif  // ACSDKASSETMANAGER_ASSETMANAGER_H_