Production.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/BorrowedRef.h"
#include "common/Module.h"
#include "common/Scheduling.h"
#include "common/Snapshot.h"
#include "common/SquirrelOwnership.h"
#include "common/Time.h"
#include "common/definitions/DefinitionRuntime.h"
 
#include <cstdint>
#include <deque>
#include <memory>
#include <ostream>
#include <string>
#include <string_view>
#include <tuple>
#include <vector>
 
namespace eve::production {
 
struct WorkQueueHandleTag {};
using WorkQueueHandleRef = eve::script::RuntimeHandleRef<WorkQueueHandleTag>;
 
enum class TaskState { Queued, Running, Paused, ReadyToSettle, SettlementFailed, Completed, Cancelled, Failed };
 
enum class ProductionEventKind {
    Enqueued,
    Started,
    Paused,
    Resumed,
    ReadyToSettle,
    SettlementFailed,
    Completed,
    Cancelled,
    Failed
};
 
struct ProductionSettlementReceipt {
    std::string settlementId;
    eve::Value payload = eve::Value(eve::Value::Object{});
};
 
enum class TaskDependencyMode { AllOf, AnyOf };
 
struct ProductionDependencies {
    TaskDependencyMode       mode = TaskDependencyMode::AllOf;
    std::vector<std::string> prerequisites;
    std::vector<std::string> blocks;
    std::vector<eve::definition::DefinitionHandle> requiredDefinitions;
    std::vector<std::string> requiredTags;
};
 
struct ProductionResourceRequirement {
    std::string resource;
    int         units = 1;
};
 
enum class RefundPolicy { None, Full, Proportional };
 
enum class ReservationState { None, Reserved, Started, Consumed, Released };
 
struct ProductionReservationRelease {
    std::string   releaseId;
    eve::Value    reservation = eve::Value(eve::Value::Object{});
    std::uint32_t refundPermille = 0;
};
 
enum class SchedulerStrategy { Priority, Fifo, ShortestRemaining };
 
struct OutputRandomProvenance {
    std::string   stream;
    std::uint64_t seed      = 0;
    std::uint64_t drawStart = 0;
    std::uint32_t drawCount = 0;
};
 
struct ProductionRepeatPolicy {
    std::uint32_t totalCycles = 1;
    bool          continuous = false;
    int           maintainStockTarget = -1;
    int           observedStock = 0;
};
 
struct ProductionPrediction {
    std::string   blockReason;
    eve::Duration ownWorkRemaining = eve::Duration::zero();
    eve::Duration estimatedStartAfter = eve::Duration::zero();
    eve::Duration estimatedCompletionAfter = eve::Duration::zero();
    bool          exact = false;
};
 
struct ProductionDiagnostic {
    std::string correlationId;
    std::string taskId;
    std::string code;
    std::string message;
    eve::SimulationTick tick = eve::SimulationTick::zero();
};
 
struct ProductionTerminationPolicy {
    RefundPolicy cancellation = RefundPolicy::Full;
    RefundPolicy failure      = RefundPolicy::Full;
};
 
struct WorkContribution {
    std::string   contributor;
    eve::Duration effort = eve::Duration::zero();
    std::uint32_t efficiencyPermille = 1000;
};
 
struct ProductionRequest {
    std::string                       owner;
    std::string                       kind;
    std::string                       product;
    eve::Value                        context = eve::Value(eve::Value::Object{});
    eve::Duration                     duration = eve::Duration::zero();
    int                               priority = 0;
    eve::definition::DefinitionHandle definition;
    eve::Value                        reservation = eve::Value(eve::Value::Object{});
    ProductionDependencies            dependencies;
    std::vector<ProductionResourceRequirement> resources;
    ProductionTerminationPolicy       termination;
    OutputRandomProvenance             random;
    ProductionRepeatPolicy             repeat;
    std::string                        correlationId;
    std::uint32_t                     batchSize = 1;
    std::uint32_t                     efficiencyPermille = 1000;
    bool                              settlementRequired = true;
};
 
struct ProductionTask : eve::scheduling::ItemMetadata {
    std::string owner;
    std::string kind;
    std::string product;
    eve::Value    context         = eve::Value(eve::Value::Object{});
    eve::Duration duration        = eve::Duration::zero();
    eve::Duration progress        = eve::Duration::zero();
    TaskState   state           = TaskState::Queued;
    uint64_t      enqueueSequence = 0;
    eve::definition::DefinitionHandle definition;
    eve::Value                        reservation = eve::Value(eve::Value::Object{});
    ReservationState                  reservationState = ReservationState::None;
    ProductionReservationRelease      reservationRelease;
    ProductionSettlementReceipt       settlement;
    std::string                       lastSettlementId;
    ProductionDependencies            dependencies;
    std::vector<ProductionResourceRequirement> resources;
    ProductionTerminationPolicy       termination;
    OutputRandomProvenance             random;
    ProductionRepeatPolicy             repeat;
    std::string                        correlationId;
    std::uint32_t                     completedCycles = 0;
    std::uint32_t                     batchSize = 1;
    std::uint32_t                     efficiencyPermille = 1000;
    std::uint32_t                     workRemainderPermille = 0;
    std::uint32_t                     refundPermille = 0;
    bool                              settlementRequired = false;
};
 
struct ProductionEvent : eve::scheduling::EventMetadata {
    eve::SimulationTick tick     = eve::SimulationTick::zero();
    ProductionEventKind kind     = ProductionEventKind::Enqueued;
    std::string         taskId;
    std::string         owner;
    std::string         taskKind;
    std::string         product;
    std::string         correlationId;
};
 
class EVENGINE_API_FOUNDATION WorkQueue {
public:
    // The queue owns move-only members (std::deque<std::unique_ptr<ProductionTask>>),
    // so it is not copyable; dllexport must not instantiate the implicitly declared
    // copy operations, whose bodies cannot compile. Deleting the copies is a no-op and
    // the defaulted moves keep the previous implicit behaviour.
    WorkQueue(const WorkQueue&)            = delete;
    WorkQueue& operator=(const WorkQueue&) = delete;
    WorkQueue(WorkQueue&&)                 = default;
    WorkQueue& operator=(WorkQueue&&)      = default;
 
    explicit WorkQueue(eve::PersistentId instanceId = {});
    [[nodiscard]] eve::Result<std::string> enqueue(std::string_view owner, std::string_view kind,
                                                   std::string_view product, eve::Value context, double duration,
                                                   int priority = 0);
    [[nodiscard]] eve::Result<std::string> enqueue(ProductionRequest request);
    [[nodiscard]] eve::Result<void> pause(std::string_view taskId);
    [[nodiscard]] eve::Result<void> resume(std::string_view taskId);
    [[nodiscard]] eve::Result<void> cancel(std::string_view taskId, std::string_view reason = "cancelled");
    [[nodiscard]] eve::Result<void> fail(std::string_view taskId, std::string_view reason = "failed");
    [[nodiscard]] eve::Result<void> settle(std::string_view taskId, ProductionSettlementReceipt receipt);
    [[nodiscard]] eve::Result<void> failSettlement(std::string_view taskId, std::string_view reason);
    [[nodiscard]] eve::Result<void> retrySettlement(std::string_view taskId);
    [[nodiscard]] eve::Result<ProductionReservationRelease> releaseReservation(
        std::string_view taskId, std::string_view releaseId);
    [[nodiscard]] eve::Result<void> contribute(std::string_view taskId, WorkContribution contribution);
    [[nodiscard]] eve::Result<void> reportStock(std::string_view taskId, int observedStock);
 
    [[nodiscard]] eve::Result<void> advance(const eve::SimulationStep& step);
    [[nodiscard]] eve::Result<std::uint32_t> advanceTo(eve::SimulationTick target, eve::Duration fixedDelta,
                                                       std::uint32_t maxSteps);
 
    [[nodiscard]] eve::SimulationTick currentTick() const noexcept { return tick_; }
 
    [[nodiscard]] eve::Result<void> setSlotCount(std::string_view owner, int slots);
    int slotCount(std::string_view owner) const;
    int runningCount(std::string_view owner) const;
    [[nodiscard]] eve::Result<void> setSchedulerStrategy(std::string_view owner, SchedulerStrategy strategy);
    SchedulerStrategy schedulerStrategy(std::string_view owner) const;
    [[nodiscard]] eve::Result<void> setResourceCapacity(std::string_view owner, std::string_view resource,
                                                        int capacity);
    int resourceCapacity(std::string_view owner, std::string_view resource) const;
    [[nodiscard]] eve::Result<std::string> blockReason(std::string_view taskId) const;
    [[nodiscard]] eve::Result<void> setDefinitionAvailable(
        std::string_view owner, const eve::definition::DefinitionHandle& definition, bool available);
    [[nodiscard]] eve::Result<void> setTagAvailable(std::string_view owner, std::string_view tag, bool available);
    [[nodiscard]] bool definitionAvailable(
        std::string_view owner, const eve::definition::DefinitionHandle& definition) const;
    [[nodiscard]] bool tagAvailable(std::string_view owner, std::string_view tag) const;
    [[nodiscard]] eve::Result<ProductionPrediction> predict(std::string_view taskId) const;
    [[nodiscard]] eve::Result<ProductionDiagnostic> diagnose(std::string_view taskId) const;
 
    [[nodiscard]] eve::OptionalRef<const ProductionTask> find(std::string_view taskId);
    [[nodiscard]] eve::OptionalRef<const ProductionTask> find(std::string_view taskId) const;
    int taskCount() const;
    [[nodiscard]] eve::OptionalRef<const ProductionTask> taskAt(int index);
    [[nodiscard]] eve::OptionalRef<const ProductionTask> taskAt(int index) const;
    int ownerTaskCount(std::string_view owner) const;
    [[nodiscard]] eve::OptionalRef<const ProductionTask> ownerTaskAt(std::string_view owner, int index);
    [[nodiscard]] eve::OptionalRef<const ProductionTask> ownerTaskAt(std::string_view owner, int index) const;
 
    int eventCount() const;
    [[nodiscard]] eve::OptionalRef<ProductionEvent> eventAt(int index);
    [[nodiscard]] eve::OptionalRef<const ProductionEvent> eventAt(int index) const;
    void clearEvents();
    [[nodiscard]] eve::Result<std::string> snapshot() const;
    [[nodiscard]] eve::Result<void> restore(std::string_view json);
    void clear();
 
    [[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:
    [[nodiscard]] ProductionTask* mutableFind(std::string_view taskId);
    [[nodiscard]] bool dependenciesSatisfied(const ProductionTask& task) const;
    [[nodiscard]] bool resourcesAvailable(const ProductionTask& task) const;
    void completeIfReady(ProductionTask& task);
    void continueAfterCycle(ProductionTask& task);
    static std::uint32_t refundFor(const ProductionTask& task, RefundPolicy policy);
    void scheduleAll();
    void schedule(std::string_view owner);
    void emit(ProductionEventKind kind, const ProductionTask& task, std::string_view reason = {});
 
    uint64_t                                    nextTaskId_          = 1;
    uint64_t                                    nextEnqueueSequence_ = 1;
    uint64_t                                    nextEventSequence_   = 1;
    eve::PersistentId                           instanceId_;
    eve::Revision                               revision_ = eve::Revision::zero();
    eve::SimulationTick                         tick_     = eve::SimulationTick::zero();
    std::deque<std::unique_ptr<ProductionTask>> tasks_;
    std::deque<ProductionEvent>                 events_;
    std::vector<std::pair<std::string, int>>    slots_;
    std::vector<std::pair<std::pair<std::string, std::string>, int>> resources_;
    std::vector<std::pair<std::string, SchedulerStrategy>> schedulerStrategies_;
    std::vector<std::tuple<std::string, std::string, std::uint64_t>> availableDefinitions_;
    std::vector<std::pair<std::string, std::string>> availableTags_;
};
 
EVENGINE_API_FOUNDATION std::string_view taskStateName(TaskState state);
inline std::ostream& operator<<(std::ostream& stream, TaskState state) { return stream << taskStateName(state); }
EVENGINE_API_FOUNDATION std::string_view eventKindName(ProductionEventKind kind);
 
class Production : public Module {
public:
    Module_REG(Production);
    Production()           = default;
    ~Production() override = default;
 
    [[nodiscard]] static eve::Result<WorkQueueHandleRef> newQueueHandle();
    [[nodiscard]] static eve::ResultRef<WorkQueue> resolve(WorkQueueHandleRef reference);
    [[nodiscard]] static eve::Result<void> release(WorkQueueHandleRef reference);
    [[nodiscard]] static bool isStale(WorkQueueHandleRef reference) noexcept;
 
private:
    eve::script::RuntimeObjectRegistry<WorkQueue, WorkQueueHandleTag> queues_;
};
 
}  // namespace eve::production