Authority.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Module.h"
#include "common/Snapshot.h"
#include "common/SquirrelOwnership.h"
 
#include <cstdint>
#include <deque>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::authority {
 
struct AuthorityStoreHandleTag {};
using AuthorityStoreHandleRef = eve::script::RuntimeHandleRef<AuthorityStoreHandleTag>;
 
enum class RuleEffect { Grant, Deny };
 
struct Rule {
    std::string id;
    std::string actor;
    std::string scope;
    std::string capability;
    std::string source;
    RuleEffect  effect    = RuleEffect::Grant;
    int         priority  = 0;
    double      duration  = 0.0;
    double      remaining = -1.0;
    uint64_t    order     = 0;
};
 
struct Decision {
    bool        allowed = false;
    std::string reason;
    std::string winningRuleId;
    std::string source;
    int         priority = 0;
};
 
enum class EventKind { Granted, Denied, Revoked, Expired };
 
struct Event {
    uint64_t    sequence = 0;
    EventKind   kind     = EventKind::Granted;
    std::string ruleId;
    std::string actor;
    std::string scope;
    std::string capability;
    std::string source;
    std::string reason;
};
 
class EVENGINE_API_FOUNDATION Store {
public:
    explicit Store(eve::PersistentId instanceId = {});
 
    std::string grant(const std::string& actor, const std::string& scope, const std::string& capability,
                      const std::string& source, int priority = 0, double duration = 0.0);
    std::string deny(const std::string& actor, const std::string& scope, const std::string& capability,
                     const std::string& source, int priority = 0, double duration = 0.0);
    bool revoke(const std::string& id, const std::string& reason = "revoked");
    int revokeBySource(const std::string& source, const std::string& reason = "source_revoked");
    void update(double dtSeconds);
 
    bool can(const std::string& actor, const std::string& scope, const std::string& capability) const;
    Decision explain(const std::string& actor, const std::string& scope, const std::string& capability) const;
    const Rule* find(const std::string& id) const;
 
    int queryActor(const std::string& actor);
    int queryScope(const std::string& scope);
    int queryCapability(const std::string& capability);
    int query(const std::string& actor, const std::string& scope, const std::string& capability);
    const Rule* queryAt(int index) const;
 
    int eventCount() const;
    const Event* eventAt(int index) const;
    void clearEvents();
    std::string snapshotJson() const;
    [[nodiscard]] eve::Result<void> restoreJson(const std::string& json);
 
    [[nodiscard]] eve::Result<eve::SnapshotEnvelope> snapshot(const eve::SnapshotHashProvider& hashProvider) const;
 
    [[nodiscard]] eve::Result<void> restoreSnapshot(const eve::SnapshotEnvelope&     snapshot,
                                                    const eve::SnapshotHashProvider& hashProvider);
 
    [[nodiscard]] eve::Result<std::string> snapshotEnvelopeJson(const eve::SnapshotHashProvider& hashProvider) const;
 
    [[nodiscard]] eve::Result<void> restoreSnapshotJson(std::string_view                 json,
                                                        const eve::SnapshotHashProvider& hashProvider);
 
private:
    std::string add(RuleEffect effect, const std::string& actor, const std::string& scope,
                    const std::string& capability, const std::string& source, int priority, double duration);
    void        emit(EventKind kind, const Rule& rule, const std::string& reason = {});
 
    uint64_t                 nextId_       = 1;
    uint64_t                 nextOrder_    = 1;
    uint64_t                 nextSequence_ = 1;
    eve::PersistentId        instanceId_;
    eve::Revision            revision_;
    eve::SimulationTick      tick_;
    std::deque<Rule>         rules_;
    std::deque<Event>        events_;
    std::vector<const Rule*> query_;
};
 
std::string effectName(RuleEffect effect);
EVENGINE_API_FOUNDATION std::string eventKindName(EventKind kind);
 
class Authority : public Module {
public:
    Module_REG(Authority);
    Authority()           = default;
    ~Authority() override = default;
 
    [[nodiscard]] static eve::Result<AuthorityStoreHandleRef> newStore();
    [[nodiscard]] static eve::script::Borrowed<Store> resolve(AuthorityStoreHandleRef reference) noexcept;
    [[nodiscard]] static eve::Result<void> release(AuthorityStoreHandleRef reference);
    [[nodiscard]] static bool isStale(AuthorityStoreHandleRef reference) noexcept;
 
private:
    eve::script::RuntimeObjectRegistry<Store, AuthorityStoreHandleTag> stores_;
};
 
}  // namespace eve::authority