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_;
};
}
}