strepsirrhini/libreoffice-online
3
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1
libreoffice-online/loolwsd/LOOLWSD.hpp

89 lines
2.5 KiB
C++
Raw Normal View History

Bump Emacs fill-column to 100 The default 70 is so last century.
2015-04-13 04:09:02 -05:00
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
Use separate child processes for LibreOfficeKit For now, each LOOL client has a separate child process (or none at all, if it has accessed only information found in the cache). This will obviously have to chnage to handle collaboration. Etc. The parent process talks the same Websocket protocol with the child processes. When there is a child process for a client, traffic from the client is forwarded as such to the child process and vice versa.
2015-03-17 18:56:15 -05:00
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#ifndef INCLUDED_LOOLWSD_HPP
#define INCLUDED_LOOLWSD_HPP
Add some fairly hackish things to make this run better on OS X
2015-05-22 08:34:21 -05:00
#include "config.h"
Use separate child processes for LibreOfficeKit For now, each LOOL client has a separate child process (or none at all, if it has accessed only information found in the cache). This will obviously have to chnage to handle collaboration. Etc. The parent process talks the same Websocket protocol with the child processes. When there is a child process for a client, traffic from the client is forwarded as such to the child process and vice versa.
2015-03-17 18:56:15 -05:00
#include <string>
loolwsd: Use fork but no execve
2015-07-13 09:13:06 -05:00
#include <mutex>
Use separate child processes for LibreOfficeKit For now, each LOOL client has a separate child process (or none at all, if it has accessed only information found in the cache). This will obviously have to chnage to handle collaboration. Etc. The parent process talks the same Websocket protocol with the child processes. When there is a child process for a client, traffic from the client is forwarded as such to the child process and vice versa.
2015-03-17 18:56:15 -05:00
#include <Poco/Util/OptionSet.h>
loolwsd: Use fork but no execve
2015-07-13 09:13:06 -05:00
#include <Poco/Random.h>
#include <Poco/Path.h>
Use separate child processes for LibreOfficeKit For now, each LOOL client has a separate child process (or none at all, if it has accessed only information found in the cache). This will obviously have to chnage to handle collaboration. Etc. The parent process talks the same Websocket protocol with the child processes. When there is a child process for a client, traffic from the client is forwarded as such to the child process and vice versa.
2015-03-17 18:56:15 -05:00
#include <Poco/Util/ServerApplication.h>
loolwsd: move server socket to parent process
2015-07-17 13:02:25 -05:00
#include <Poco/SharedMemory.h>
loolwsd: change named mutex to private static.
2015-07-18 11:35:16 -05:00
#include <Poco/NamedMutex.h>
Use separate child processes for LibreOfficeKit For now, each LOOL client has a separate child process (or none at all, if it has accessed only information found in the cache). This will obviously have to chnage to handle collaboration. Etc. The parent process talks the same Websocket protocol with the child processes. When there is a child process for a client, traffic from the client is forwarded as such to the child process and vice versa.
2015-03-17 18:56:15 -05:00
class LOOLWSD: public Poco::Util::ServerApplication
{
public:
LOOLWSD();
~LOOLWSD();
// An Application is a singleton anyway, so just keep these as
// statics
static int portNumber;
loolwsd: process sleep for amount of time ... specified by MAINTENANCE_INTERVAL
2015-07-24 13:10:24 -05:00
static int timeoutCounter;
loolwsd: ensure one child when debugging when used with --test option: ./loolwsd --test --systemplate=${SYSTEMPLATE} --lotemplate=${MASTER}/instdir --childroot=${ROOTFORJAILS} ensure that one child is created and attach to it easily to debug lokit messages
2015-08-05 19:01:39 -05:00
static bool doTest;
loolwsd: handle a graceful shutdown
2015-11-25 20:49:34 -06:00
static bool volatile isShutDown;
Take the tile cache directory as an option, too
2015-06-04 09:07:49 -05:00
static std::string cache;
Work in progress: "pre-forking", chroot, etc. Non-working state Lots of changes to the server code, LOOLWSD and LOOLSession mainly. This is an intermediate commit.
2015-04-08 09:22:42 -05:00
static std::string sysTemplate;
static std::string loTemplate;
static std::string childRoot;
static std::string loSubPath;
static std::string jail;
loolwsd: move server socket to parent process
2015-07-17 13:02:25 -05:00
static Poco::SharedMemory _sharedForkChild;
loolwsd: fix child fork when debugging one child
2015-08-05 17:19:51 -05:00
static Poco::NamedMutex _namedMutexLOOL;
tdf#94607 downloadAs command that generates an URL for the doc When requested, the document is exported under /jail_path/CHILD_ID/user/thedocument/RANDOMDIR/filename and CHILD_ID, RANDOMDIR and the filename are communicated to the client. When the client requests http://server:port/CHILD_ID/RANDOMDIR/filename, the exported document is served and then RANDOMDIR is removed
2015-10-09 07:55:49 -05:00
static Poco::Random _rng;
loolwsd: remove child root folder when it is a gracefull shut down
2015-11-25 21:17:08 -06:00
static Poco::UInt64 _childId;
Work in progress: "pre-forking", chroot, etc. Non-working state Lots of changes to the server code, LOOLWSD and LOOLSession mainly. This is an intermediate commit.
2015-04-08 09:22:42 -05:00
Use a separate HTTPServer listening for child processes connnecting Otherwise, if we use the same port number and same HTTPServer, if enough clients try to contact us and, we won't be able to accept child processes having been spawned. Also add some temporary debugging output here and there to debug lifecycle management issues.
2015-05-08 13:24:46 -05:00
static const int DEFAULT_CLIENT_PORT_NUMBER = 9980;
static const int MASTER_PORT_NUMBER = 9981;
loolwsd: process sleep for amount of time ... specified by MAINTENANCE_INTERVAL
2015-07-24 13:10:24 -05:00
static const int INTERVAL_PROBES = 10;
loolwsd: remove _pendingPreSpawnedChildren. _pendingPreSpawnedChildren is no longer need it, because fork() is used. Also adjusted time sleep to 1 second.
2015-07-24 14:17:46 -05:00
static const int MAINTENANCE_INTERVAL = 1;
loolwsd: call poll, to check the status of the websocket
2015-11-25 20:23:08 -06:00
static const int POLL_TIMEOUT = 1000000;
Use separate classes derived from LOOLSession for parent and child processes Work in progress. Does not work properly yet.
2015-04-20 09:43:31 -05:00
static const std::string CHILD_URI;
loolwsd: create PID log file. The PID log file is used by external utilities to report processes, threads, etc.
2015-07-19 15:49:11 -05:00
static const std::string PIDLOG;
loolwsd: create lokit process id logs Also, when used with --test option, create lokit PID log so it is attached to the debugger. gdb loolwsd $(cat /tmp/lokit.pid)
2015-08-05 19:20:05 -05:00
static const std::string LOKIT_PIDLOG;
Make DEFAULT_PORT_NUMBER public
2015-03-26 01:36:35 -05:00
Use separate child processes for LibreOfficeKit For now, each LOOL client has a separate child process (or none at all, if it has accessed only information found in the cache). This will obviously have to chnage to handle collaboration. Etc. The parent process talks the same Websocket protocol with the child processes. When there is a child process for a client, traffic from the client is forwarded as such to the child process and vice versa.
2015-03-17 18:56:15 -05:00
protected:
loolwsd: add signal handler
2015-11-25 20:37:08 -06:00
static void setSignals(bool bIgnore);
static void handleSignal(int nSignal);
Use separate child processes for LibreOfficeKit For now, each LOOL client has a separate child process (or none at all, if it has accessed only information found in the cache). This will obviously have to chnage to handle collaboration. Etc. The parent process talks the same Websocket protocol with the child processes. When there is a child process for a client, traffic from the client is forwarded as such to the child process and vice versa.
2015-03-17 18:56:15 -05:00
void initialize(Poco::Util::Application& self) override;
void uninitialize() override;
void defineOptions(Poco::Util::OptionSet& options) override;
void handleOption(const std::string& name, const std::string& value) override;
int main(const std::vector<std::string>& args) override;
private:
void displayHelp();
loolwsd: Use fork but no execve
2015-07-13 09:13:06 -05:00
void componentMain();
void desktopMain();
void startupComponent(int nComponents);
void startupDesktop(int nDesktop);
int createComponent();
int createDesktop();
Use separate child processes for LibreOfficeKit For now, each LOOL client has a separate child process (or none at all, if it has accessed only information found in the cache). This will obviously have to chnage to handle collaboration. Etc. The parent process talks the same Websocket protocol with the child processes. When there is a child process for a client, traffic from the client is forwarded as such to the child process and vice versa.
2015-03-17 18:56:15 -05:00
No need for this member to be public
2015-04-28 03:02:29 -05:00
static int _numPreSpawnedChildren;
loolwsd: Use fork but no execve
2015-07-13 09:13:06 -05:00
static std::mutex _rngMutex;
Add some fairly hackish things to make this run better on OS X
2015-05-22 08:34:21 -05:00
#if ENABLE_DEBUG
public:
static bool runningAsRoot;
Pass the --uid option to the child too
2015-05-22 11:42:36 -05:00
static int uid;
Add some fairly hackish things to make this run better on OS X
2015-05-22 08:34:21 -05:00
#endif
Use separate child processes for LibreOfficeKit For now, each LOOL client has a separate child process (or none at all, if it has accessed only information found in the cache). This will obviously have to chnage to handle collaboration. Etc. The parent process talks the same Websocket protocol with the child processes. When there is a child process for a client, traffic from the client is forwarded as such to the child process and vice versa.
2015-03-17 18:56:15 -05:00
};
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue Copy permalink