UpdateService.hpp

Go to the documentation of this file.

/*
    Copyright (C) 2014-2016 Leosac

    This file is part of Leosac.

    Leosac is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Leosac is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#pragma once

#include "UpdateFwd.hpp"
#include "core/SecurityContext.hpp"
#include "tools/JSONUtils.hpp"
#include "tools/bs2.hpp"
#include "tools/registry/Registry.hpp"
#include "tools/serializers/ExtensibleSerializer.hpp"
#include <mutex>

namespace Leosac
{
namespace update
{
enum class Severity
{
    LOW      = 0,
    NORMAL   = 1,
    HIGHT    = 2,
    CRITICAL = 3,
};

struct UpdateDescriptor
{
    UpdateDescriptor();
    virtual ~UpdateDescriptor() = default;

    std::string uuid;
    Severity severity;
    std::string source_module;
    std::string update_desc;

  private:
    virtual void implement_me_() = 0;
};

class UpdateBackend
{
  public:
    virtual std::vector<UpdateDescriptorPtr> check_update() = 0;

    virtual IUpdatePtr create_update(const UpdateDescriptor &ud,
                                     const ExecutionContext &) = 0;

    virtual void ack_update(IUpdatePtr u, const ExecutionContext &) = 0;

    virtual void cancel_update(IUpdatePtr u, const ExecutionContext &) = 0;
};

class UpdateService
    : public ExtensibleSerializer<json, IUpdate, const SecurityContext &>
{
  public:
    std::vector<UpdateDescriptorPtr> check_update();

    IUpdatePtr create_update(const std::string &update_descriptor_uuid,
                             const ExecutionContext &ec);

    std::vector<IUpdatePtr> pending_updates();

    void ack_update(IUpdatePtr update, const ExecutionContext &ec);

    void cancel_update(IUpdatePtr update, const ExecutionContext &ec);

    void register_backend(UpdateBackendPtr backend);

  private:
    mutable std::mutex mutex_;

    using CheckUpdateT =
        boost::signals2::signal<std::vector<UpdateDescriptorPtr>(void),
                                VectorAppenderCombiner<UpdateDescriptorPtr>>;

    using CreateUpdateT =
        boost::signals2::signal<IUpdatePtr(const UpdateDescriptor &,
                                           const ExecutionContext &),
                                AtMostOneCombiner<IUpdatePtr>>;

    using AckUpdateT =
        boost::signals2::signal<void(IUpdatePtr, const ExecutionContext &)>;

    using CancelUpdateT =
        boost::signals2::signal<void(IUpdatePtr, const ExecutionContext &)>;

    CheckUpdateT check_update_sig_;
    CreateUpdateT create_update_sig_;
    AckUpdateT ack_update_sig_;
    CancelUpdateT cancel_update_sig_;

    std::map<std::string, UpdateDescriptorPtr> published_descriptors_;
};
}
}