ScriptManager.h

//
//  ScriptManager.h
//  libraries/script-engine/src
//
//  Created by Brad Hefta-Gaub on 12/14/13.
//  Copyright 2013 High Fidelity, Inc.
//  Copyright 2020 Vircadia contributors.
//  Copyright 2022-2023 Overte e.V.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//  SPDX-License-Identifier: Apache-2.0
//
 
#ifndef hifi_ScriptManager_h
#define hifi_ScriptManager_h
 
#include <atomic>
#include <chrono>
#include <functional>
#include <memory>
#include <unordered_map>
#include <mutex>
 
#include <QtCore/QFuture>
#include <QtCore/QHash>
#include <QtCore/QObject>
#include <QtCore/QReadWriteLock>
#include <QtCore/QSet>
#include <QtCore/QSharedPointer>
#include <QtCore/QString>
#include <QtCore/QTimer>
#include <QtCore/QUrl>
#include <QtCore/QVariant>
 
#include "EntityItemID.h"
#include "EntitiesScriptEngineProvider.h"
#include "EntityScriptUtils.h"
#include <ExternalResource.h>
#include <SettingHandle.h>
 
#include "AssetScriptingInterface.h"
#include "ConsoleScriptingInterface.h"
#include "Mat4.h"
#include "PointerEvent.h"
#include "Quat.h"
#include "ScriptUUID.h"
#include "ScriptValue.h"
#include "ScriptException.h"
#include "Vec3.h"
 
static const QString NO_SCRIPT("");
 
static const int SCRIPT_FPS = 60;
static const int DEFAULT_MAX_ENTITY_PPS = 9000;
static const int DEFAULT_ENTITY_PPS_PER_SCRIPT = 900;
 
class ScriptEngine;
class ScriptEngines;
class ScriptManager;
class ScriptManagerScriptingInterface;
 
using ScriptEnginePointer = std::shared_ptr<ScriptEngine>;
using ScriptManagerPointer = std::shared_ptr<ScriptManager>;
using ScriptManagerScriptingInterfacePointer = std::shared_ptr<ScriptManagerScriptingInterface>;
using ScriptValueList = QList<ScriptValue>;
 
Q_DECLARE_METATYPE(ScriptManagerPointer)
 
const int QTREGISTER_QTimerStar = qRegisterMetaType<QTimer*>();
 
 
class CallbackData {
public:
    ScriptValue function;
 
    EntityItemID definingEntityIdentifier;
 
    QUrl definingSandboxURL;
};
 
 
class DeferredLoadEntity {
public:
    EntityItemID entityID;
    QString entityScript;
    //bool forceRedownload;
};
 
struct EntityScriptContentAvailable {
    EntityItemID entityID;
 
    QString scriptOrURL;
 
    QString contents;
 
    bool isURL;
 
    bool success;
 
    QString status;
};
 
typedef std::unordered_map<EntityItemID, EntityScriptContentAvailable> EntityScriptContentAvailableMap;
 
typedef QList<CallbackData> CallbackList;
typedef QHash<QString, CallbackList> RegisteredEventHandlers;
 
 
class EntityScriptDetails {
public:
 
    EntityScriptStatus status { EntityScriptStatus::PENDING };
 
    QString errorInfo { "" };
 
 
    QString scriptText { "" };
 
    ScriptValue scriptObject{ ScriptValue() };
 
    int64_t lastModified { 0 };
 
    QUrl definingSandboxURL { QUrl("about:EntityScript") };
};
 
// declare a static script initializers
#define STATIC_SCRIPT_TYPES_INITIALIZER(init)                                     \
    static ScriptManager::StaticTypesInitializerNode static_script_types_initializer_(init);
 
#define STATIC_SCRIPT_INITIALIZER(init)                                     \
    static ScriptManager::StaticInitializerNode static_script_initializer_(init);
 
 
 
 
class ScriptManager : public QObject, public EntitiesScriptEngineProvider, public std::enable_shared_from_this<ScriptManager> {
    Q_OBJECT
public:
    static const QString SCRIPT_EXCEPTION_FORMAT;
    static const QString SCRIPT_BACKTRACE_SEP;
 
    enum Context {
        CLIENT_SCRIPT,
 
        ENTITY_CLIENT_SCRIPT,
 
        ENTITY_SERVER_SCRIPT,
 
        AGENT_SCRIPT,
 
        NETWORKLESS_TEST_SCRIPT
    };
 
    enum Type {
        CLIENT,
 
        ENTITY_CLIENT,
 
        ENTITY_SERVER,
 
        AGENT,
 
        AVATAR,
 
        NETWORKLESS_TEST
    };
    Q_ENUM(Type);
 
    static int processLevelMaxRetries;
private:
    // Constructor is private so that only properly generated shared pointer can be used
    explicit ScriptManager(Context context, const QString& scriptContents = NO_SCRIPT, const QString& fileNameString = QString("about:ScriptEngine"));
public:
    ~ScriptManager() override;
 
    // static initialization support
    typedef void (*ScriptManagerInitializer)(ScriptManager*);
    class StaticInitializerNode {
    public:
        ScriptManagerInitializer init;
        StaticInitializerNode* prev;
        inline explicit StaticInitializerNode(ScriptManagerInitializer&& pInit) : init(std::move(pInit)),prev(nullptr) { registerNewStaticInitializer(this); }
    };
    static void registerNewStaticInitializer(StaticInitializerNode* dest);
 
    class StaticTypesInitializerNode {
    public:
        ScriptManagerInitializer init;
        StaticTypesInitializerNode* prev;
        inline explicit StaticTypesInitializerNode(ScriptManagerInitializer&& pInit) : init(std::move(pInit)),prev(nullptr) { registerNewStaticTypesInitializer(this); }
    };
    static void registerNewStaticTypesInitializer(StaticTypesInitializerNode* dest);
 
    void runInThread();
 
    void run();
 
 
    QString getFilename() const;
 
    QString getAbsoluteFilename() const;
 
    inline ScriptEnginePointer engine() { return _engine; }
 
    QList<EntityItemID> getListOfEntityScriptIDs();
 
    bool isStopped() const;
 
 
 
    Q_INVOKABLE void stop(bool marshal = false);
 
 
    void waitTillDoneRunning(bool shutdown = false);
 
    void removeFromScriptEngines();
 
    void loadURL(const QUrl& scriptURL, bool reload);
 
    bool hasValidScriptSuffix(const QString& scriptFileName);
 
 
 
    Q_INVOKABLE QString getContext() const;
 
    Q_INVOKABLE bool isClientScript() const { return _context == CLIENT_SCRIPT; }
 
    Q_INVOKABLE bool isDebugMode() const;
 
    Q_INVOKABLE bool isEntityClientScript() const { return _context == ENTITY_CLIENT_SCRIPT; }
 
 
    Q_INVOKABLE bool isEntityServerScript() const { return _context == ENTITY_SERVER_SCRIPT; }
 
    Q_INVOKABLE bool isAgentScript() const { return _context == AGENT_SCRIPT; }
 
    Q_INVOKABLE void registerValue(const QString& valueName, ScriptValue value);
 
    // NOTE - these are intended to be public interfaces available to scripts
 
    Q_INVOKABLE QString formatException(const ScriptValue& exception, bool includeExtendedDetails);
 
 
 
    Q_INVOKABLE void addEventHandler(const EntityItemID& entityID, const QString& eventName, const ScriptValue& handler);
 
    Q_INVOKABLE void removeEventHandler(const EntityItemID& entityID, const QString& eventName, const ScriptValue& handler);
 
 
    Q_INVOKABLE void load(const QString& loadfile);
 
    Q_INVOKABLE void include(const QStringList& includeFiles, const ScriptValue& callback = ScriptValue());
 
    Q_INVOKABLE void include(const QString& includeFile, const ScriptValue& callback = ScriptValue());
 
 
 
 
 
 
 
    Q_INVOKABLE ScriptValue require(const QString& moduleId);
 
    Q_INVOKABLE void resetModuleCache(bool deleteScriptCache = false);
 
    ScriptValue currentModule();
 
    bool registerModuleWithParent(const ScriptValue& module, const ScriptValue& parent);
 
    ScriptValue newModule(const QString& modulePath, const ScriptValue& parent = ScriptValue());
 
    QVariantMap fetchModuleSource(const QString& modulePath, const bool forceDownload = false);
 
    ScriptValue instantiateModule(const ScriptValue& module, const QString& sourceCode);
 
    ScriptValue evaluate(const QString& program, const QString& fileName = QString());
 
    Q_INVOKABLE QTimer* setInterval(const ScriptValue& function, int intervalMS);
 
 
    Q_INVOKABLE QTimer* setTimeout(const ScriptValue& function, int timeoutMS);
 
    Q_INVOKABLE void clearInterval(QTimer* timer) { stopTimer(timer); }
 
    Q_INVOKABLE void clearInterval(QVariantMap timer) { ; }
 
    Q_INVOKABLE void clearTimeout(QTimer* timer) { stopTimer(timer); }
 
    Q_INVOKABLE void clearTimeout(QVariantMap timer) { ; }
 
 
    Q_INVOKABLE void print(const QString& message);
 
    Q_INVOKABLE QUrl resolvePath(const QString& path) const;
 
    Q_INVOKABLE QUrl resourcesPath() const;
 
    Q_INVOKABLE void beginProfileRange(const QString& label) const;
 
    Q_INVOKABLE void endProfileRange(const QString& label) const;
 
 
 
    // Entity Script Related methods
 
 
 
    Q_INVOKABLE bool isEntityScriptRunning(const EntityItemID& entityID, const QString& scriptURL) {
        QReadLocker locker { &_entityScriptsLock };
        auto it = _entityScripts.constFind(entityID);
        if (it != _entityScripts.constEnd()) {
            auto it2 = it.value().constFind(scriptURL);
            return it2 != it.value().constEnd() && it2.value().status == EntityScriptStatus::RUNNING; 
        }
        return false;
    }
 
    QVariant cloneEntityScriptDetails(const EntityItemID& entityID, const QString& scriptURL);
 
 
    QFuture<QVariant> getLocalEntityScriptDetails(const EntityItemID& entityID, const QString& scriptURL) override;
 
 
    Q_INVOKABLE void requestGarbageCollection();
 
    Q_INVOKABLE void logBacktrace(const QString &title);
 
    Q_INVOKABLE void loadEntityScript(const EntityItemID& entityID, const QString& entityScript, bool forceRedownload);
 
    Q_INVOKABLE void unloadEntityScript(const EntityItemID& entityID, const QString& scriptURL, bool shouldRemoveFromMap = false); // will call unload method
 
    Q_INVOKABLE void unloadAllEntityScriptsForEntity(const EntityItemID& entityID, bool shouldRemoveFromMap = false); // will call unload method
 
 
    Q_INVOKABLE void unloadAllEntityScripts(bool blockingCall = false);
 
    Q_INVOKABLE void callEntityScriptMethod(const EntityItemID& entityID, const QString& methodName,
                                            const QStringList& params = QStringList(),
                                            const QUuid& remoteCallerID = QUuid()) override;
 
    Q_INVOKABLE void callEntityScriptMethodForScript(const EntityItemID& entityID,
                                                     const QString& scriptURL,
                                                     const QString& methodName,
                                                     const QStringList& params = QStringList(),
                                                     const QUuid& remoteCallerID = QUuid()) override;
 
    Q_INVOKABLE void callEntityScriptMethodForScript(const EntityItemID& entityID,
                                                     const QString& scriptURL,
                                                     const QString& methodName,
                                                     const QString& param);
 
    Q_INVOKABLE void callEntityScriptMethod(const EntityItemID& entityID, const QString& methodName, const PointerEvent& event);
 
 
    Q_INVOKABLE void callEntityScriptMethod(const EntityItemID& entityID, const QString& methodName, const EntityItemID& otherID, const Collision& collision);
 
 
    void setType(Type type) { _type = type; };
 
    Type getType() { return _type; };
 
    QString getTypeAsString() const;
 
    bool isFinished() const { return _isFinished; } // used by Application and ScriptWidget
 
    bool isRunning() const { return _isRunning; } // used by ScriptWidget
 
    // this is used by code in ScriptEngines.cpp during the "reload all" operation
    bool isStopping() const { return _isStopping; }
 
    void disconnectNonEssentialSignals();
 
 
 
 
 
    void setUserLoaded(bool isUserLoaded) { _isUserLoaded = isUserLoaded; }
 
    bool isUserLoaded() const { return _isUserLoaded; }
 
    void setQuitWhenFinished(const bool quitWhenFinished) { _quitWhenFinished = quitWhenFinished; }
 
    bool isQuitWhenFinished() const { return _quitWhenFinished; }
 
    void setEmitScriptUpdatesFunction(std::function<bool()> func) { _emitScriptUpdates = func; }
 
    void scriptErrorMessage(const QString& message, const QString& fileName, int lineNumber);
 
    void scriptWarningMessage(const QString& message, const QString& fileName, int lineNumber);
 
    void scriptInfoMessage(const QString& message, const QString& fileName, int lineNumber);
 
    void scriptPrintedMessage(const QString& message, const QString& fileName, int lineNumber);
 
    void clearDebugLogWindow();
 
    int getNumRunningEntityScripts() const;
 
    bool getEntityScriptDetails(const EntityItemID& entityID, const QString& scriptURL, EntityScriptDetails &details) const;
 
    bool hasEntityScriptDetails(const EntityItemID& entityID, const QString& scriptURL) const;
 
    void setScriptEngines(QSharedPointer<ScriptEngines>& scriptEngines) { _scriptEngines = scriptEngines; }
 
 
    void forwardHandlerCall(const EntityItemID& entityID, const QString& eventName, const ScriptValueList& eventHanderArgs);
 
    void removeAllEventHandlers(const EntityItemID& entityID);
 
 
    ScriptValue getReturnValue() const { return _returnValue; }
 
 
    Q_INVOKABLE QString getExternalPath(ExternalResource::Bucket bucket, const QString& path);
 
 
    std::shared_ptr<ScriptException> getUncaughtException() const;
 
    bool getAbortOnUncaughtException() const { return _abortOnUncaughtException; }
 
    void setAbortOnUncaughtException(bool value) { _abortOnUncaughtException = value; }
 
    bool isDoneRunning() { return _isDoneRunning; };
 
public slots:
 
    void updateMemoryCost(const qint64 &deltaSize);
 
signals:
 
 
 
    void scriptLoaded(const QString& scriptFilename);
 
 
    void errorLoadingScript(const QString& scriptFilename);
 
 
    void update(float deltaTime);
 
 
 
    void scriptEnding();
 
 
 
    void finished(const QString& fileNameString, ScriptManagerPointer);
 
    void printedMessage(const QString& message, const QString& scriptName);
 
 
    void errorMessage(const QString& message, const QString& scriptName);
 
 
 
    void warningMessage(const QString& message, const QString& scriptName);
 
 
    void infoMessage(const QString& message, const QString& scriptName);
 
    void printedEntityMessage(const QString& message, const QString& fileName, int lineNumber, const EntityItemID& entityID, bool isServerScript);
 
 
    void errorEntityMessage(const QString& message, const QString& fileName, int lineNumber, const EntityItemID& entityID, bool isServerScript);
 
 
 
    void warningEntityMessage(const QString& message, const QString& fileName, int lineNumber, const EntityItemID& entityID, bool isServerScript);
 
 
    void infoEntityMessage(const QString& message, const QString& fileName, int lineNumber, const EntityItemID& entityID, bool isServerScript);
 
 
    void runningStateChanged();
 
 
    void clearDebugWindow();
 
 
    void loadScript(const QString& scriptName, bool isUserLoaded);
 
 
    void reloadScript(const QString& scriptName, bool isUserLoaded);
 
    void doneRunning();
 
    void entityScriptDetailsUpdated();
 
    void entityScriptPreloadFinished(const EntityItemID& entityID);
 
 
    void unhandledException(std::shared_ptr<ScriptException> exception);
 
 
    void attachDefaultEventHandlers();
 
    void releaseEntityPacketSenderMessages(bool wait);
 
protected:
    // Is called by the constructor, bceause all types need to be registered before method discovery with ScriptObjectV8Proxy::investigate()
    void initMetaTypes();
 
    void init();
 
    Q_INVOKABLE void executeOnScriptThread(std::function<void()> function, const Qt::ConnectionType& type = Qt::QueuedConnection );
 
    Q_INVOKABLE QString _requireResolve(const QString& moduleId, const QString& relativeTo = QString());
 
    QString logException(const ScriptValue& exception);
    void timerFired();
    void stopAllTimers();
    void stopAllTimersForEntityScript(const EntityItemID& entityID);
    void refreshFileScript(const EntityItemID& entityID, const QString& scriptURL);
 
    void updateEntityScriptStatus(const EntityItemID& entityID, const QString& scriptURL, const EntityScriptStatus& status, const QString& errorInfo = QString());
 
 
    void setEntityScriptDetails(const EntityItemID& entityID, const QString& scriptURL, const EntityScriptDetails& details);
 
    void setParentURL(const QString& parentURL) { _parentURL = parentURL; }
 
    QTimer* setupTimerWithInterval(const ScriptValue& function, int intervalMS, bool isSingleShot);
 
    void stopTimer(QTimer* timer);
 
    QHash<EntityItemID, RegisteredEventHandlers> _registeredHandlers;
 
 
    Q_INVOKABLE void entityScriptContentAvailable(const EntityItemID& entityID, const QString& scriptOrURL, const QString& contents, bool isURL, bool success, const QString& status);
 
    EntityItemID currentEntityIdentifier; // Contains the defining entity script entity id during execution, if any. Empty for interface script execution.
    QUrl currentSandboxURL; // The toplevel url string for the entity script that loaded the code being executed, else empty.
 
    void doWithEnvironment(const EntityItemID& entityID, const QUrl& sandboxURL, std::function<void()> operation);
 
    void callWithEnvironment(const EntityItemID& entityID, const QUrl& sandboxURL, const ScriptValue& function, const ScriptValue& thisObject, const ScriptValueList& args);
 
    Context _context;
    Type _type;
    ScriptEnginePointer _engine;
    QString _scriptContents;
    QString _parentURL;
    std::atomic<bool> _isFinished { false };
    std::atomic<bool> _isRunning { false };
    std::atomic<bool> _isStopping { false };
    std::atomic<bool> _isDoneRunning { false };
    bool _areMetaTypesInitialized { false };
    bool _isInitialized { false };
    QHash<QTimer*, CallbackData> _timerFunctionMap;
    QSet<QUrl> _includedURLs;
    mutable QReadWriteLock _entityScriptsLock { QReadWriteLock::Recursive };
    QHash<EntityItemID, QHash<QString, EntityScriptDetails>> _entityScripts;
    EntityScriptContentAvailableMap _contentAvailableQueue;
    ScriptValue _returnValue;
 
    bool _isThreaded { false };
    qint64 _lastUpdate;
 
    QString _fileNameString;
    std::shared_ptr<Quat> _quatLibrary;
    std::shared_ptr<Vec3> _vec3Library;
    std::shared_ptr<Mat4> _mat4Library;
    std::shared_ptr<ScriptUUID> _uuidLibrary;
    std::shared_ptr<ConsoleScriptingInterface> _consoleScriptingInterface;
    std::atomic<bool> _isUserLoaded { false };
    bool _isReloading { false };
 
    std::atomic<bool> _quitWhenFinished;
 
    std::shared_ptr<AssetScriptingInterface> _assetScriptingInterface;
 
    std::function<bool()> _emitScriptUpdates{ []() { return true; }  };
 
    std::recursive_mutex _lock;
 
    std::chrono::microseconds _totalTimerExecution { 0 };
 
    static const QString _SETTINGS_ENABLE_EXTENDED_EXCEPTIONS;
 
    Setting::Handle<bool> _enableExtendedJSExceptions { _SETTINGS_ENABLE_EXTENDED_EXCEPTIONS, true };
 
    QWeakPointer<ScriptEngines> _scriptEngines;
 
 
 
    // For debugging performance issues
    int _timerCallCounter{ 0 };
    double _totalTimeInTimerEvents_s{ 0.0 };
 
    ScriptManagerScriptingInterfacePointer _scriptingInterface;
 
    bool _abortOnUncaughtException{ false };
 
    friend ScriptManagerPointer newScriptManager(Context context, const QString& scriptContents, const QString& fileNameString);
    friend class ScriptManagerScriptingInterface;
 
    std::atomic<bool> _isDeleted {false}; // This is used for debugging use-after-delete. It happens quite often, so I'm keeping it here for now.
};
 
ScriptManagerPointer newScriptManager(ScriptManager::Context context,
                                      const QString& scriptContents,
                                      const QString& fileNameString);
 
ScriptManagerPointer scriptManagerFactory(ScriptManager::Context context,
                                        const QString& scriptContents,
                                        const QString& fileNameString);
 
#endif // hifi_ScriptManager_h