DavsHandler.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 ACSDKDAVSCLIENT_DAVSHANDLER_H_
#define ACSDKDAVSCLIENT_DAVSHANDLER_H_

#include <AVSCommon/SDKInterfaces/AuthDelegateInterface.h>
#include <AVSCommon/Utils/Logger/Logger.h>
#include <AVSCommon/Utils/Power/PowerResource.h>
#include <AVSCommon/Utils/Timing/Timer.h>

#include <chrono>
#include <future>
#include <mutex>

#include "acsdkAssetsCommon/AmdMetricWrapper.h"
#include "acsdkAssetsCommon/CurlProgressCallbackInterface.h"
#include "acsdkAssetsInterfaces/VendableArtifact.h"
#include "acsdkDavsClientInterfaces/ArtifactHandlerInterface.h"
#include "acsdkDavsClientInterfaces/DavsEndpointHandlerInterface.h"

namespace alexaClientSDK {
namespace acsdkAssets {
namespace davs {

class DavsHandler
        : public common::CurlProgressCallbackInterface
        , public std::enable_shared_from_this<DavsHandler> {
public:
    static std::shared_ptr<DavsHandler> create(
            std::shared_ptr<commonInterfaces::DavsRequest> artifactRequest,
            const std::shared_ptr<davsInterfaces::DavsDownloadCallbackInterface>& downloadRequester,
            const std::shared_ptr<davsInterfaces::DavsCheckCallbackInterface>& checkRequester,
            std::string workingDirectory,
            std::chrono::milliseconds baseBackOffTime,
            std::chrono::milliseconds maxBackOffTime,
            std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::AuthDelegateInterface> authDelegate,
            std::shared_ptr<davsInterfaces::DavsEndpointHandlerInterface> davsEndpointHandler,
            std::shared_ptr<alexaClientSDK::avsCommon::utils::power::PowerResource> powerResource = nullptr,
            std::chrono::seconds forcedUpdateInterval = std::chrono::seconds(0));
    ~DavsHandler() override;

    inline bool isRelevant() {
        return !m_checkRequester.expired() && !m_downloadRequester.expired();
    }

    void requestAndDownload(bool isUserInitiated);

    void cancel();

    inline void enableUpdate(bool enable) {
        std::lock_guard<std::mutex> lock(m_eventMutex);
        m_updateEnabled = enable;
        handleUpdateLocked();
    }

    inline bool isUpdateEnabled() {
        return m_updateEnabled;
    }

    /***
     * Expose the inside ArtifactRequest containing type and key to DavsClient check then update
     * @return ArtifactRequest
     */
    inline std::shared_ptr<commonInterfaces::DavsRequest> getDavsRequest() {
        return m_artifactRequest;
    }

    inline void setFirstBackOff(std::chrono::milliseconds firstBackOffTime) {
        m_firstBackOffTime = firstBackOffTime;
    }

    std::chrono::milliseconds getBackOffTime(std::chrono::milliseconds prevBackOffTime);

    static std::string parseFileFromLink(const std::string& url, const std::string& defaultValue);

    bool isThrottled() const;

    void setThrottled(bool throttle);

    void setConnectionState(bool connected);

private:
    DavsHandler(
            std::shared_ptr<commonInterfaces::DavsRequest> artifactRequest,
            const std::shared_ptr<davsInterfaces::DavsDownloadCallbackInterface>& downloadRequester,
            const std::shared_ptr<davsInterfaces::DavsCheckCallbackInterface>& checkRequester,
            std::string workingDirectory,
            std::chrono::milliseconds baseBackOffTime,
            std::chrono::milliseconds maxBackOffTime,
            std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::AuthDelegateInterface> authDelegate,
            std::shared_ptr<davsInterfaces::DavsEndpointHandlerInterface> davsEndpointHandler,
            std::shared_ptr<alexaClientSDK::avsCommon::utils::power::PowerResource> powerResource,
            std::chrono::seconds forcedUpdateInterval);

    void runner(bool isUserInitiated);

    commonInterfaces::ResultCode checkArtifact(std::shared_ptr<commonInterfaces::VendableArtifact>& artifact);

    commonInterfaces::ResultCode downloadArtifact(
            const std::shared_ptr<commonInterfaces::VendableArtifact>& artifact,
            bool isUserInitiated,
            std::string& path);
    commonInterfaces::ResultCode checkWithRetryLoop(std::shared_ptr<commonInterfaces::VendableArtifact>& artifact);

    void downloadWithRetryLoop(
            const std::shared_ptr<commonInterfaces::VendableArtifact>& artifact,
            bool isUserInitiated);

    bool waitForRetry(std::chrono::milliseconds& waitTime);

    bool waitForNetworkConnection();

    void handleUpdateLocked();

    inline std::string getTmpParentDirectory() const {
        return m_workingDirectory + "/" + m_artifactRequest->getSummary();
    }

    inline std::shared_ptr<davsInterfaces::DavsCheckCallbackInterface> getChecker() {
        auto checker = m_checkRequester.lock();
        if (checker == nullptr) {
            ACSDK_WARN(alexaClientSDK::avsCommon::utils::logger::LogEntry("DavsHandler", "getChecker")
                               .m("Check requester is no longer available")
                               .d("request", m_artifactRequest->getSummary()));
            s_metrics().addCounter(METRIC_PREFIX_ERROR("checkRequesterNotAvailable"));
            return nullptr;
        }
        return checker;
    }

    inline std::shared_ptr<davsInterfaces::DavsDownloadCallbackInterface> getDownloader() {
        auto downloader = m_downloadRequester.lock();
        if (downloader == nullptr) {
            ACSDK_WARN(alexaClientSDK::avsCommon::utils::logger::LogEntry("DavsHandler", "getDownloader")
                               .m("Download requester is no longer available")
                               .d("request", m_artifactRequest->getSummary()));
            s_metrics().addCounter(METRIC_PREFIX_ERROR("downloadRequesterNotAvailable"));
            return nullptr;
        }
        return downloader;
    }

    inline void sendOnCheckFailure(commonInterfaces::ResultCode resultCode) {
        auto checker = getChecker();
        if (checker == nullptr) {
            return;
        }
        ACSDK_ERROR(alexaClientSDK::avsCommon::utils::logger::LogEntry("DavsHandler", "sendOnCheckFailure")
                            .m("Check failed")
                            .d("request", m_artifactRequest->getSummary()));
        s_metrics().addZeroCounter("downloadCheckSuccess").addCounter(METRIC_PREFIX_ERROR("downloadCheckFailed"));
        checker->onCheckFailure(resultCode);
    }

    inline bool sendCheckIfOkToDownload(
            const std::shared_ptr<commonInterfaces::VendableArtifact>& artifact,
            size_t spaceNeeded) {
        auto checker = getChecker();
        if (checker == nullptr) {
            return false;
        }
        s_metrics().addCounter("downloadCheckSuccess");
        if (!checker->checkIfOkToDownload(artifact, spaceNeeded)) {
            ACSDK_WARN(alexaClientSDK::avsCommon::utils::logger::LogEntry("DavsHandler", "sendCheckIfOkToDownload")
                               .m("Requester rejected download")
                               .d("request", m_artifactRequest->getSummary()));
            s_metrics().addCounter("downloadRejected");
            return false;
        }
        return true;
    }

    inline bool sendOnStartAndCheckIfAvailable() {
        auto downloader = getDownloader();
        if (downloader == nullptr) {
            return false;
        }
        ACSDK_INFO(alexaClientSDK::avsCommon::utils::logger::LogEntry("DavsHandler", "sendOnStartAndCheckIfAvailable")
                           .m("Download started")
                           .d("request", m_artifactRequest->getSummary()));
        downloader->onStart();
        return true;
    }

    inline void sendOnDownloadFailure(commonInterfaces::ResultCode resultCode) {
        auto downloader = getDownloader();
        if (downloader == nullptr) {
            return;
        }
        ACSDK_ERROR(alexaClientSDK::avsCommon::utils::logger::LogEntry("DavsHandler", "sendOnDownloadFailure")
                            .m("Download utterly failed")
                            .d("request", m_artifactRequest->getSummary()));
        s_metrics().addZeroCounter("downloadSuccess").addCounter(METRIC_PREFIX_ERROR("downloadFailed"));
        downloader->onDownloadFailure(resultCode);
    }

    inline void sendOnArtifactDownloaded(
            const std::shared_ptr<commonInterfaces::VendableArtifact>& artifact,
            const std::string& path) {
        auto downloader = m_downloadRequester.lock();
        if (downloader == nullptr) {
            return;
        }
        ACSDK_INFO(alexaClientSDK::avsCommon::utils::logger::LogEntry("DavsHandler", "sendOnArtifactDownloaded")
                           .m("Download succeeded")
                           .d("request", m_artifactRequest->getSummary()));
        s_metrics().addCounter("downloadSuccess");
        downloader->onArtifactDownloaded(artifact, path);
    }

    bool onProgressUpdate(long dlTotal, long dlNow, long ulTotal, long ulNow) override;
private:
    static const std::function<common::AmdMetricsWrapper()> s_metrics;

    const std::shared_ptr<commonInterfaces::DavsRequest> m_artifactRequest;
    const std::weak_ptr<davsInterfaces::DavsDownloadCallbackInterface> m_downloadRequester;
    const std::weak_ptr<davsInterfaces::DavsCheckCallbackInterface> m_checkRequester;
    const std::string m_workingDirectory;

    // controls retry logic and how much to backoff
    const std::chrono::milliseconds m_baseBackOffTime;
    const std::chrono::milliseconds m_maxBackOffTime;
    const std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::AuthDelegateInterface> m_authDelegate;
    const std::shared_ptr<davsInterfaces::DavsEndpointHandlerInterface> m_davsEndpointHandler;
    std::shared_ptr<alexaClientSDK::avsCommon::utils::power::PowerResource> m_powerResource;
    const std::chrono::seconds m_forcedUpdateInterval;
    std::chrono::milliseconds m_firstBackOffTime;

    // whether cancel request has been issued during DAVS download
    std::mutex m_eventMutex;
    std::condition_variable m_eventTrigger;
    bool m_shutdown;
    std::atomic_flag m_running;
    std::future<void> m_taskFuture;
    alexaClientSDK::avsCommon::utils::timing::Timer m_scheduler;

    bool m_updateEnabled;
    commonInterfaces::VendableArtifact::TimeEpoch m_artifactExpiry;

    bool m_throttled;
    bool m_networkConnected;

    bool m_unpack;
};

}  // namespace davs
}  // namespace acsdkAssets
}  // namespace alexaClientSDK

#endif  // ACSDKDAVSCLIENT_DAVSHANDLER_H_