server.h

/*
 * SPDX-FileCopyrightText: (C) 2016-2023 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#pragma once
 
#include <Cutelyst/cutelyst_global.h>
 
#include <QObject>
 
class QCoreApplication;
 
namespace Cutelyst {
 
class Application;
class ServerPrivate;
class CUTELYST_SERVER_EXPORT Server : public QObject
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(Server)
public:
    explicit Server(QObject *parent = nullptr);
 
    virtual ~Server();
 
    void parseCommandLine(const QStringList &args);
 
    int exec(Cutelyst::Application *app = nullptr);
 
    bool start(Cutelyst::Application *app = nullptr);
 
    void stop();
 
    Q_PROPERTY(QString application READ application WRITE setApplication NOTIFY changed)
    void setApplication(const QString &application);
    [[nodiscard]] QString application() const;
 
    Q_PROPERTY(QString threads READ threads WRITE setThreads NOTIFY changed)
    void setThreads(const QString &threads);
    [[nodiscard]] QString threads() const;
 
    Q_PROPERTY(QString processes READ processes WRITE setProcesses NOTIFY changed)
    void setProcesses(const QString &process);
    [[nodiscard]] QString processes() const;
 
    Q_PROPERTY(QString chdir READ chdir WRITE setChdir NOTIFY changed)
    void setChdir(const QString &chdir);
    [[nodiscard]] QString chdir() const;
 
    Q_PROPERTY(QStringList http_socket READ httpSocket WRITE setHttpSocket NOTIFY changed)
    void setHttpSocket(const QStringList &httpSocket);
    [[nodiscard]] QStringList httpSocket() const;
 
    Q_PROPERTY(QStringList http2_socket READ http2Socket WRITE setHttp2Socket NOTIFY changed)
    void setHttp2Socket(const QStringList &http2Socket);
    [[nodiscard]] QStringList http2Socket() const;
 
    Q_PROPERTY(quint32 http2_header_table_size READ http2HeaderTableSize WRITE
                   setHttp2HeaderTableSize NOTIFY changed)
    void setHttp2HeaderTableSize(quint32 headerTableSize);
    [[nodiscard]] quint32 http2HeaderTableSize() const;
 
    Q_PROPERTY(bool upgrade_h2c READ upgradeH2c WRITE setUpgradeH2c NOTIFY changed)
    void setUpgradeH2c(bool enable);
    [[nodiscard]] bool upgradeH2c() const;
 
    Q_PROPERTY(bool https_h2 READ httpsH2 WRITE setHttpsH2 NOTIFY changed)
    void setHttpsH2(bool enable);
    [[nodiscard]] bool httpsH2() const;
 
    Q_PROPERTY(QStringList https_socket READ httpsSocket WRITE setHttpsSocket NOTIFY changed)
    void setHttpsSocket(const QStringList &httpsSocket);
    [[nodiscard]] QStringList httpsSocket() const;
 
    Q_PROPERTY(QStringList fastcgi_socket READ fastcgiSocket WRITE setFastcgiSocket NOTIFY changed)
    void setFastcgiSocket(const QStringList &fastcgiSocket);
    [[nodiscard]] QStringList fastcgiSocket() const;
 
    Q_PROPERTY(QString socket_access READ socketAccess WRITE setSocketAccess NOTIFY changed)
    void setSocketAccess(const QString &socketAccess);
    [[nodiscard]] QString socketAccess() const;
 
    Q_PROPERTY(int socket_timeout READ socketTimeout WRITE setSocketTimeout NOTIFY changed)
    void setSocketTimeout(int timeout);
    [[nodiscard]] int socketTimeout() const;
 
    Q_PROPERTY(QString chdir2 READ chdir2 WRITE setChdir2 NOTIFY changed)
    void setChdir2(const QString &chdir2);
    [[nodiscard]] QString chdir2() const;
 
    Q_PROPERTY(QStringList ini READ ini WRITE setIni NOTIFY changed)
    void setIni(const QStringList &files);
    [[nodiscard]] QStringList ini() const;
 
    Q_PROPERTY(QStringList json READ json WRITE setJson NOTIFY changed)
    void setJson(const QStringList &files);
    [[nodiscard]] QStringList json() const;
 
    Q_PROPERTY(QStringList static_map READ staticMap WRITE setStaticMap NOTIFY changed)
    void setStaticMap(const QStringList &staticMap);
    [[nodiscard]] QStringList staticMap() const;
 
    Q_PROPERTY(QStringList static_map2 READ staticMap2 WRITE setStaticMap2 NOTIFY changed)
    void setStaticMap2(const QStringList &staticMap);
    [[nodiscard]] QStringList staticMap2() const;
 
    Q_PROPERTY(bool master READ master WRITE setMaster NOTIFY changed)
    void setMaster(bool enable);
    [[nodiscard]] bool master() const;
 
    Q_PROPERTY(bool auto_reload READ autoReload WRITE setAutoReload NOTIFY changed)
    void setAutoReload(bool enable);
    [[nodiscard]] bool autoReload() const;
 
    Q_PROPERTY(QStringList touch_reload READ touchReload WRITE setTouchReload NOTIFY changed)
    void setTouchReload(const QStringList &files);
    [[nodiscard]] QStringList touchReload() const;
 
    Q_PROPERTY(int listen READ listenQueue WRITE setListenQueue NOTIFY changed)
    void setListenQueue(int size);
    [[nodiscard]] int listenQueue() const;
 
    Q_PROPERTY(int buffer_size READ bufferSize WRITE setBufferSize NOTIFY changed)
    void setBufferSize(int size);
    [[nodiscard]] int bufferSize() const;
 
    Q_PROPERTY(qint64 post_buffering READ postBuffering WRITE setPostBuffering NOTIFY changed)
    void setPostBuffering(qint64 size);
    [[nodiscard]] qint64 postBuffering() const;
 
    Q_PROPERTY(qint64 post_buffering_bufsize READ postBufferingBufsize WRITE setPostBufferingBufsize
                   NOTIFY changed)
    void setPostBufferingBufsize(qint64 size);
    [[nodiscard]] qint64 postBufferingBufsize() const;
 
    Q_PROPERTY(bool tcp_nodelay READ tcpNodelay WRITE setTcpNodelay NOTIFY changed)
    void setTcpNodelay(bool enable);
    [[nodiscard]] bool tcpNodelay() const;
 
    Q_PROPERTY(bool so_keepalive READ soKeepalive WRITE setSoKeepalive NOTIFY changed)
    void setSoKeepalive(bool enable);
    [[nodiscard]] bool soKeepalive() const;
 
    Q_PROPERTY(int socket_sndbuf READ socketSndbuf WRITE setSocketSndbuf NOTIFY changed)
    void setSocketSndbuf(int value);
    [[nodiscard]] int socketSndbuf() const;
 
    Q_PROPERTY(int socket_rcvbuf READ socketRcvbuf WRITE setSocketRcvbuf NOTIFY changed)
    void setSocketRcvbuf(int value);
    [[nodiscard]] int socketRcvbuf() const;
 
    Q_PROPERTY(
        int websocket_max_size READ websocketMaxSize WRITE setWebsocketMaxSize NOTIFY changed)
    void setWebsocketMaxSize(int value);
    [[nodiscard]] int websocketMaxSize() const;
 
    Q_PROPERTY(QString pidfile READ pidfile WRITE setPidfile NOTIFY changed)
    void setPidfile(const QString &file);
    [[nodiscard]] QString pidfile() const;
 
    Q_PROPERTY(QString pidfile2 READ pidfile2 WRITE setPidfile2 NOTIFY changed)
    void setPidfile2(const QString &file);
    [[nodiscard]] QString pidfile2() const;
 
    Q_PROPERTY(QString uid READ uid WRITE setUid NOTIFY changed)
    void setUid(const QString &uid);
    [[nodiscard]] QString uid() const;
 
    Q_PROPERTY(QString gid READ gid WRITE setGid NOTIFY changed)
    void setGid(const QString &gid);
    [[nodiscard]] QString gid() const;
 
    Q_PROPERTY(bool no_initgroups READ noInitgroups WRITE setNoInitgroups NOTIFY changed)
    void setNoInitgroups(bool enable);
    [[nodiscard]] bool noInitgroups() const;
 
    Q_PROPERTY(QString chown_socket READ chownSocket WRITE setChownSocket NOTIFY changed)
    void setChownSocket(const QString &chownSocket);
    [[nodiscard]] QString chownSocket() const;
 
    Q_PROPERTY(QString umask READ umask WRITE setUmask NOTIFY changed)
    void setUmask(const QString &value);
    [[nodiscard]] QString umask() const;
 
    Q_PROPERTY(int cpu_affinity READ cpuAffinity WRITE setCpuAffinity NOTIFY changed)
    void setCpuAffinity(int value);
    [[nodiscard]] int cpuAffinity() const;
 
    Q_PROPERTY(bool reuse_port READ reusePort WRITE setReusePort NOTIFY changed)
    void setReusePort(bool enable);
    [[nodiscard]] bool reusePort() const;
 
    Q_PROPERTY(bool lazy READ lazy WRITE setLazy NOTIFY changed)
    void setLazy(bool enable);
    [[nodiscard]] bool lazy() const;
 
    Q_PROPERTY(bool using_frontend_proxy READ usingFrontendProxy WRITE setUsingFrontendProxy NOTIFY
                   changed)
    void setUsingFrontendProxy(bool enable);
    [[nodiscard]] bool usingFrontendProxy() const;
 
    [[nodiscard]] QVariantMap config() const noexcept;
 
Q_SIGNALS:
    void ready();
 
    void stopped();
 
    void changed();
 
    void errorOccured(const QString &error);
 
protected:
    ServerPrivate *d_ptr;
};
 
} // namespace Cutelyst