StorageManager.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_SRC_STORAGEMANAGER_H_
#define ACSDKASSETMANAGER_SRC_STORAGEMANAGER_H_
 
#include <AVSCommon/Utils/FileSystem/FileSystemUtils.h>
#include <memory>
#include <mutex>
#include <unordered_map>
#include <utility>
#include "Resource.h"
 
namespace alexaClientSDK {
namespace acsdkAssets {
namespace manager {
 
class AssetManager;
 
class StorageManager : public std::enable_shared_from_this<StorageManager> {
public:
    static constexpr auto MAX_BUDGET_MB = 500;
 
    struct ReservationToken {
    public:
        ~ReservationToken() {
            if (m_reservedSize == 0) {
                return;
            }
 
            if (auto sm = m_storageManager.lock()) {
                sm->freeReservedSpace(m_reservedSize);
            }
        }
 
    private:
        ReservationToken(std::weak_ptr<StorageManager> storageManager, size_t reservedSize) :
                m_storageManager(std::move(storageManager)),
                m_reservedSize(reservedSize) {
        }
 
        // parent storage manager class used to free up any reserved space
        std::weak_ptr<StorageManager> m_storageManager;
        // amount of space reserved
        size_t m_reservedSize;
 
        // it's important that the space reservation and freeing happens only by the Storage Manager.
        friend StorageManager;
    };
 
    static std::shared_ptr<StorageManager> create(
            const std::string& workingDirectory,
            const std::shared_ptr<AssetManager>& assetManager);
 
    ~StorageManager() = default;
 
    void purgeUnreferenced();
 
    std::shared_ptr<Resource> registerAndAcquireResource(
            std::unique_ptr<StorageManager::ReservationToken> reservationToken,
            const std::string& id,
            const std::string& sourcePath);
 
    std::shared_ptr<Resource> acquireResource(const std::string& id);
 
    size_t releaseResource(const std::shared_ptr<Resource>& resource);
 
    std::unique_ptr<ReservationToken> reserveSpace(size_t requestedAmount);
 
    size_t availableBudget();
 
    size_t getBudget();
 
    void setBudget(size_t valueMB);
 
protected:
    explicit StorageManager(
            const std::string& workingDirectory,
            const std::shared_ptr<AssetManager>& assetManager,
            size_t budget);
 
    bool init();
 
    void requestGarbageCollection(size_t requestedAmount);
 
    bool requestSpace(size_t requestedAmount);
 
    void freeReservedSpace(size_t size);
 
private:
    const std::string m_workingDirectory;
    const std::weak_ptr<AssetManager> m_assetManager;
    size_t m_budget;
    std::mutex m_allocationMutex;
    std::unordered_map<std::string, std::shared_ptr<Resource>> m_bank;
 
    size_t m_allocatedSize;
};
 
}  // namespace manager
}  // namespace acsdkAssets
}  // namespace alexaClientSDK
 
#endif  // ACSDKASSETMANAGER_SRC_STORAGEMANAGER_H_