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

1044 lines
34 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 -*- */
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06: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/.
*/
Preserve timestamp of directories created in the jail Needed for /usr/share/fonts so that fontconfig trusts its cache, but no harm doing it for all directories. (Except a slight slowdown, need to see it if has any significant impact if we would do the utime() only for directories under /usr/share/fonts.) Thus we need to pass the FTW_DEPTH flag to nftw() and handle FTP_DP instead of FTP_D. We also need to make sure the directory is created also in the case of an empty directory, for which no FTW_F callback of files inside it has been received. It is safest to not exit the nftw() in the FTW_SLN case.
2015-04-27 07:51:33 -05:00
#include <sys/stat.h>
#include <sys/types.h>
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
#include <ftw.h>
Preserve timestamp of directories created in the jail Needed for /usr/share/fonts so that fontconfig trusts its cache, but no harm doing it for all directories. (Except a slight slowdown, need to see it if has any significant impact if we would do the utime() only for directories under /usr/share/fonts.) Thus we need to pass the FTW_DEPTH flag to nftw() and handle FTP_DP instead of FTP_D. We also need to make sure the directory is created also in the case of an empty directory, for which no FTW_F callback of files inside it has been received. It is safest to not exit the nftw() in the FTW_SLN case.
2015-04-27 07:51:33 -05:00
#include <utime.h>
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 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 <cassert>
Add code to wait for a child session to become available Not sure it is completely correct. Lots of testing needed.
2015-05-07 08:29:36 -05:00
#include <condition_variable>
Add first cut at caching of tiles
2015-03-12 09:18:35 -05:00
#include <cstring>
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
#include <fstream>
#include <iostream>
Handle file: and http: URLs
2015-04-30 07:58:13 -05:00
#include <iterator>
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
#include <map>
Add first cut at caching of tiles
2015-03-12 09:18:35 -05:00
#include <memory>
Add code to wait for a child session to become available Not sure it is completely correct. Lots of testing needed.
2015-05-07 08:29:36 -05:00
#include <mutex>
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
#include <set>
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
Start on load testing Add a new program, loadtest, that runs a requested number of client sessions in parallel to a loolwsd server. A client session loads one of a list of test documents, and does some operations on it. Move the getTokenInteger() and getTokenString() functions out from LOOLSession into a new namespace LOOLProtocol, as they are neeeded also in the loadtest program. Add, also in LOOLProtocol, functions to parse some of the messages from the server. (In general that is done in client JavaScript code, of course; only for testing purposes needed in C++ code.)
2015-03-26 09:49:07 -05:00
#define LOK_USE_UNSTABLE_API
#include <LibreOfficeKit/LibreOfficeKit.h>
#include <LibreOfficeKit/LibreOfficeKitEnums.h>
Be more consistent in using 'using'
2015-05-29 00:49:49 -05:00
#include <Poco/Exception.h>
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
#include <Poco/File.h>
Handle file: and http: URLs
2015-04-30 07:58:13 -05:00
#include <Poco/Net/HTTPStreamFactory.h>
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
#include <Poco/Net/WebSocket.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/Process.h>
#include <Poco/Random.h>
Use Poco::StreamCopier, just because it looks nicer A test program did not show any performance difference between using the std::copy() thing, Poco::StreamCopier, or std output << input.rdbuf() trick.
2015-04-30 10:01:21 -05:00
#include <Poco/StreamCopier.h>
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
#include <Poco/String.h>
#include <Poco/StringTokenizer.h>
Must use thread-local storage for the variables used by the nftw callback Otherwise two or more linkOrCopy() functions running simultaneously will lead to a mess. Actually nftw() is not guaranteed to be thread-safe, I think, so we should really use something that is, like Poco's SimpleRecursiveDirectoryIterator.
2015-05-07 12:15:05 -05:00
#include <Poco/ThreadLocal.h>
Add 'saveas'
2015-03-23 15:13:57 -05:00
#include <Poco/URI.h>
Handle file: and http: URLs
2015-04-30 07:58:13 -05:00
#include <Poco/URIStreamOpener.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/Application.h>
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
Add a separate include file for some helper functions
2015-03-28 06:22:15 -05:00
#include "LOKitHelper.hpp"
Start on load testing Add a new program, loadtest, that runs a requested number of client sessions in parallel to a loolwsd server. A client session loads one of a list of test documents, and does some operations on it. Move the getTokenInteger() and getTokenString() functions out from LOOLSession into a new namespace LOOLProtocol, as they are neeeded also in the loadtest program. Add, also in LOOLProtocol, functions to parse some of the messages from the server. (In general that is done in client JavaScript code, of course; only for testing purposes needed in C++ code.)
2015-03-26 09:49:07 -05:00
#include "LOOLProtocol.hpp"
Rename LOOLConnectionServer to LOOLSession That is hopefully a better name.
2015-03-09 03:01:30 -05:00
#include "LOOLSession.hpp"
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 "LOOLWSD.hpp"
Add first cut at caching of tiles
2015-03-12 09:18:35 -05:00
#include "TileCache.hpp"
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 "Util.hpp"
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
Start on load testing Add a new program, loadtest, that runs a requested number of client sessions in parallel to a loolwsd server. A client session loads one of a list of test documents, and does some operations on it. Move the getTokenInteger() and getTokenString() functions out from LOOLSession into a new namespace LOOLProtocol, as they are neeeded also in the loadtest program. Add, also in LOOLProtocol, functions to parse some of the messages from the server. (In general that is done in client JavaScript code, of course; only for testing purposes needed in C++ code.)
2015-03-26 09:49:07 -05:00
using namespace LOOLProtocol;
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
using Poco::File;
Be more consistent in using 'using'
2015-05-29 00:49:49 -05:00
using Poco::IOException;
Handle file: and http: URLs
2015-04-30 07:58:13 -05:00
using Poco::Net::HTTPStreamFactory;
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
using Poco::Net::WebSocket;
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
using Poco::Path;
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
using Poco::Process;
using Poco::ProcessHandle;
using Poco::Random;
Use Poco::StreamCopier, just because it looks nicer A test program did not show any performance difference between using the std::copy() thing, Poco::StreamCopier, or std output << input.rdbuf() trick.
2015-04-30 10:01:21 -05:00
using Poco::StreamCopier;
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
using Poco::StringTokenizer;
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
using Poco::Thread;
Must use thread-local storage for the variables used by the nftw callback Otherwise two or more linkOrCopy() functions running simultaneously will lead to a mess. Actually nftw() is not guaranteed to be thread-safe, I think, so we should really use something that is, like Poco's SimpleRecursiveDirectoryIterator.
2015-05-07 12:15:05 -05:00
using Poco::ThreadLocal;
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
using Poco::UInt64;
Add 'saveas'
2015-03-23 15:13:57 -05:00
using Poco::URI;
Handle file: and http: URLs
2015-04-30 07:58:13 -05:00
using Poco::URIStreamOpener;
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
using Poco::Util::Application;
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
const std::string LOOLSession::jailDocumentURL = "/user/thedocument";
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 shared_ptr to the WebSockets for increased robustness Why did I wait so long to do this? This is obviously the right thing to do, I hope, and has a very significant impact on the robustness of the server...
2015-05-28 08:42:38 -05:00
LOOLSession::LOOLSession(std::shared_ptr<WebSocket> ws, Kind kind) :
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
_kind(kind),
Use shared_ptr to the WebSockets for increased robustness Why did I wait so long to do this? This is obviously the right thing to do, I hope, and has a very significant impact on the robustness of the server...
2015-05-28 08:42:38 -05:00
_ws(ws),
_childId is used only in MasterProcessSession
2015-04-22 11:48:20 -05:00
_docURL("")
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
{
Use shared_ptr to the WebSockets for increased robustness Why did I wait so long to do this? This is obviously the right thing to do, I hope, and has a very significant impact on the robustness of the server...
2015-05-28 08:42:38 -05:00
std::cout << Util::logPrefix() << "LOOLSession ctor this=" << this << " " << _kind << " ws=" << _ws.get() << std::endl;
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
}
Rename LOOLConnectionServer to LOOLSession That is hopefully a better name.
2015-03-09 03:01:30 -05:00
LOOLSession::~LOOLSession()
Pass callbacks from LOKit on to the client, and some other changes Use a larger buffer in the TestOutput class to handle a bit larger tiles. Too bad that the current Poco::WebSocket::receiveFrame() takes a fixed size buffer. (I will submit a patch to Poco for a receiveFrame() that takes a dynamically resizable buffer and handles whatever size frame the other side sends.)
2015-03-07 05:23:46 -06:00
{
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
std::cout << Util::logPrefix() << "LOOLSession dtor this=" << this << " " << _kind << std::endl;
Factor out WebSocket::shutdown() ignoring IOException
2015-04-22 03:14:11 -05:00
Util::shutdownWebSocket(*_ws);
Pass callbacks from LOKit on to the client, and some other changes Use a larger buffer in the TestOutput class to handle a bit larger tiles. Too bad that the current Poco::WebSocket::receiveFrame() takes a fixed size buffer. (I will submit a patch to Poco for a receiveFrame() that takes a dynamically resizable buffer and handles whatever size frame the other side sends.)
2015-03-07 05:23:46 -06:00
}
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
void LOOLSession::sendTextFrame(const std::string& text)
{
Add a "canceltiles" message to the protocol and handle it Implementing this Was harder than I first expected. The basic idea is as follows: The master process puts each message arriving from a client that isn't "canceltiles" into a (client-specific) queue. A separate thread that pulls messages from the queue at its own pace and handles them as before. Incoming "canceltiles" messages are handled specially, though: The queue is emptied of "tile" messages. The above sounds simple but there are several details that were a bit tricky to get right.
2015-06-05 08:12:06 -05:00
std::unique_lock<std::mutex> lock(_mutex);
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
_ws->sendFrame(text.data(), text.size());
}
void LOOLSession::sendBinaryFrame(const char *buffer, int length)
{
Add a "canceltiles" message to the protocol and handle it Implementing this Was harder than I first expected. The basic idea is as follows: The master process puts each message arriving from a client that isn't "canceltiles" into a (client-specific) queue. A separate thread that pulls messages from the queue at its own pace and handles them as before. Incoming "canceltiles" messages are handled specially, though: The queue is emptied of "tile" messages. The above sounds simple but there are several details that were a bit tricky to get right.
2015-06-05 08:12:06 -05:00
std::unique_lock<std::mutex> lock(_mutex);
if (length > 1000)
{
std::string nextmessage = "nextmessage: size=" + std::to_string(length);
_ws->sendFrame(nextmessage.data(), nextmessage.size());
}
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
_ws->sendFrame(buffer, length, WebSocket::FRAME_BINARY);
}
Another intermediate commit, code still in a non-working state
2015-04-13 07:13:38 -05:00
Add code to wait for a child session to become available Not sure it is completely correct. Lots of testing needed.
2015-05-07 08:29:36 -05:00
std::map<Process::PID, UInt64> MasterProcessSession::_childProcesses;
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
std::set<UInt64> MasterProcessSession::_pendingPreSpawnedChildren;
Use shared_ptr and weak_ptr in attempt to make the pointer dance more robust It was obviously very wrong to use both a unique_ptr to the MasterProcessSession in WebSocketRequestHandler::handleRequest(), and then a bare pointers to the peer object in the MasterProcessSession object. We got crashes here and there related to the destructors. Let's see if we can manage without mutexes.
2015-04-22 13:35:52 -05:00
std::set<std::shared_ptr<MasterProcessSession>> MasterProcessSession::_availableChildSessions;
Add code to wait for a child session to become available Not sure it is completely correct. Lots of testing needed.
2015-05-07 08:29:36 -05:00
std::mutex MasterProcessSession::_availableChildSessionMutex;
std::condition_variable MasterProcessSession::_availableChildSessionCV;
Be more consistent in using 'using'
2015-05-29 00:49:49 -05:00
Random MasterProcessSession::_rng;
Use just one RNG for the MasterProcessSession objects It probably is not a good idea to keep depleting the entropy source needlessly by having a separate RNG in the preSpawn(). Use just one shared RNG and protect access to it with a mutex.
2015-05-07 12:01:40 -05:00
std::mutex MasterProcessSession::_rngMutex;
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
Use shared_ptr to the WebSockets for increased robustness Why did I wait so long to do this? This is obviously the right thing to do, I hope, and has a very significant impact on the robustness of the server...
2015-05-28 08:42:38 -05:00
MasterProcessSession::MasterProcessSession(std::shared_ptr<WebSocket> ws, Kind kind) :
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
LOOLSession(ws, kind),
Handle LOK_CALLBACK_INVALIDATE_TILES in the server too Remove any intersecting cached tiles. It is the parent process that handles the tile cache, so it must look for invalidatetiles: messages, too, before passing them on to the client. To know for which part we should remove tiles, add an "ephemeral" curpart: message that the child process sends to the parent process before the invalidatetils: message.
2015-05-28 10:39:05 -05:00
_childId(0),
_curPart(0)
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
{
Use shared_ptr to the WebSockets for increased robustness Why did I wait so long to do this? This is obviously the right thing to do, I hope, and has a very significant impact on the robustness of the server...
2015-05-28 08:42:38 -05:00
std::cout << Util::logPrefix() << "MasterProcessSession ctor this=" << this << " ws=" << _ws.get() << std::endl;
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
}
MasterProcessSession::~MasterProcessSession()
{
Use shared_ptr and weak_ptr in attempt to make the pointer dance more robust It was obviously very wrong to use both a unique_ptr to the MasterProcessSession in WebSocketRequestHandler::handleRequest(), and then a bare pointers to the peer object in the MasterProcessSession object. We got crashes here and there related to the destructors. Let's see if we can manage without mutexes.
2015-04-22 13:35:52 -05:00
std::cout << Util::logPrefix() << "MasterProcessSession dtor this=" << this << " _peer=" << _peer.lock().get() << std::endl;
Factor out WebSocket::shutdown() ignoring IOException
2015-04-22 03:14:11 -05:00
Util::shutdownWebSocket(*_ws);
Use shared_ptr and weak_ptr in attempt to make the pointer dance more robust It was obviously very wrong to use both a unique_ptr to the MasterProcessSession in WebSocketRequestHandler::handleRequest(), and then a bare pointers to the peer object in the MasterProcessSession object. We got crashes here and there related to the destructors. Let's see if we can manage without mutexes.
2015-04-22 13:35:52 -05:00
auto peer = _peer.lock();
if (_kind == Kind::ToClient && peer)
Catch (and ignore) Poco::IOException in a couple of places There probably are more places where I should catch those and act appropriately. At least in these places, where the websocket connection is already closed, or being closed, anyway, the right thing to do is just to ignore exceptions, which are generated from attempts to write to an already closed Poco WebSocket, for instance.
2015-04-21 07:06:41 -05:00
{
Use shared_ptr and weak_ptr in attempt to make the pointer dance more robust It was obviously very wrong to use both a unique_ptr to the MasterProcessSession in WebSocketRequestHandler::handleRequest(), and then a bare pointers to the peer object in the MasterProcessSession object. We got crashes here and there related to the destructors. Let's see if we can manage without mutexes.
2015-04-22 13:35:52 -05:00
Util::shutdownWebSocket(*(peer->_ws));
Catch (and ignore) Poco::IOException in a couple of places There probably are more places where I should catch those and act appropriately. At least in these places, where the websocket connection is already closed, or being closed, anyway, the right thing to do is just to ignore exceptions, which are generated from attempts to write to an already closed Poco WebSocket, for instance.
2015-04-21 07:06:41 -05:00
}
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
}
The buffer parameter to handleInput() can be const
2015-06-08 08:35:52 -05:00
bool MasterProcessSession::handleInput(const char *buffer, int length)
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
{
Log the input to MasterProcessSession::handleInput() earlier
2015-05-28 04:58:08 -05:00
Application::instance().logger().information(Util::logPrefix() + "Input: " + getAbbreviatedMessage(buffer, length));
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
Now the chroot etc re-work is getting closer to working Works now for the trivial 'connect' test program. Still need to add pre-spawning of a new child process as soon as an existing one from the pool has been taking into use. And need to test with the actual JS client.
2015-04-14 09:50:38 -05:00
std::string firstLine = getFirstLine(buffer, length);
StringTokenizer tokens(firstLine, " ", StringTokenizer::TOK_IGNORE_EMPTY | StringTokenizer::TOK_TRIM);
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
if (haveSeparateProcess())
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
{
Now the chroot etc re-work is getting closer to working Works now for the trivial 'connect' test program. Still need to add pre-spawning of a new child process as soon as an existing one from the pool has been taking into use. And need to test with the actual JS client.
2015-04-14 09:50:38 -05:00
// Note that this handles both forwarding requests from the client to the child process, and
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
// forwarding replies from the child process to the client. Or does it?
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
Handle LOK_CALLBACK_INVALIDATE_TILES in the server too Remove any intersecting cached tiles. It is the parent process that handles the tile cache, so it must look for invalidatetiles: messages, too, before passing them on to the client. To know for which part we should remove tiles, add an "ephemeral" curpart: message that the child process sends to the parent process before the invalidatetils: message.
2015-05-28 10:39:05 -05:00
// Snoop at some messages and manipulate tile cache information as needed
Use shared_ptr and weak_ptr in attempt to make the pointer dance more robust It was obviously very wrong to use both a unique_ptr to the MasterProcessSession in WebSocketRequestHandler::handleRequest(), and then a bare pointers to the peer object in the MasterProcessSession object. We got crashes here and there related to the destructors. Let's see if we can manage without mutexes.
2015-04-22 13:35:52 -05:00
auto peer = _peer.lock();
Handle LOK_CALLBACK_INVALIDATE_TILES in the server too Remove any intersecting cached tiles. It is the parent process that handles the tile cache, so it must look for invalidatetiles: messages, too, before passing them on to the client. To know for which part we should remove tiles, add an "ephemeral" curpart: message that the child process sends to the parent process before the invalidatetils: message.
2015-05-28 10:39:05 -05:00
if (_kind == Kind::ToPrisoner)
{
if (tokens[0] == "curpart:" &&
tokens.count() == 2 &&
getTokenInteger(tokens[1], "part", _curPart))
{
return true;
}
}
Use shared_ptr and weak_ptr in attempt to make the pointer dance more robust It was obviously very wrong to use both a unique_ptr to the MasterProcessSession in WebSocketRequestHandler::handleRequest(), and then a bare pointers to the peer object in the MasterProcessSession object. We got crashes here and there related to the destructors. Let's see if we can manage without mutexes.
2015-04-22 13:35:52 -05:00
if (_kind == Kind::ToPrisoner && peer && peer->_tileCache)
Now the chroot etc re-work is getting closer to working Works now for the trivial 'connect' test program. Still need to add pre-spawning of a new child process as soon as an existing one from the pool has been taking into use. And need to test with the actual JS client.
2015-04-14 09:50:38 -05:00
{
if (tokens[0] == "tile:")
{
Add a part parameter to the tile messages The JS code always passes in 0 for now. The server parses the parameter and calls LibreOfficeKitDocument::setPart() before calling paintTile(). Probably also the status, key, mouse and selection messages will need a part number. The intent is after all that the protocol is as stateless as possible. (So maybe we should also pass the document URL in each message?)
2015-04-27 13:24:05 -05:00
int part, width, height, tilePosX, tilePosY, tileWidth, tileHeight;
if (tokens.count() != 8 ||
!getTokenInteger(tokens[1], "part", part) ||
!getTokenInteger(tokens[2], "width", width) ||
!getTokenInteger(tokens[3], "height", height) ||
!getTokenInteger(tokens[4], "tileposx", tilePosX) ||
!getTokenInteger(tokens[5], "tileposy", tilePosY) ||
!getTokenInteger(tokens[6], "tilewidth", tileWidth) ||
!getTokenInteger(tokens[7], "tileheight", tileHeight))
Now the chroot etc re-work is getting closer to working Works now for the trivial 'connect' test program. Still need to add pre-spawning of a new child process as soon as an existing one from the pool has been taking into use. And need to test with the actual JS client.
2015-04-14 09:50:38 -05:00
assert(false);
assert(firstLine.size() < static_cast<std::string::size_type>(length));
Add a part parameter to the tile messages The JS code always passes in 0 for now. The server parses the parameter and calls LibreOfficeKitDocument::setPart() before calling paintTile(). Probably also the status, key, mouse and selection messages will need a part number. The intent is after all that the protocol is as stateless as possible. (So maybe we should also pass the document URL in each message?)
2015-04-27 13:24:05 -05:00
peer->_tileCache->saveTile(part, width, height, tilePosX, tilePosY, tileWidth, tileHeight, buffer + firstLine.size() + 1, length - firstLine.size() - 1);
Now the chroot etc re-work is getting closer to working Works now for the trivial 'connect' test program. Still need to add pre-spawning of a new child process as soon as an existing one from the pool has been taking into use. And need to test with the actual JS client.
2015-04-14 09:50:38 -05:00
}
else if (tokens[0] == "status:")
{
assert(firstLine.size() == static_cast<std::string::size_type>(length));
Use shared_ptr and weak_ptr in attempt to make the pointer dance more robust It was obviously very wrong to use both a unique_ptr to the MasterProcessSession in WebSocketRequestHandler::handleRequest(), and then a bare pointers to the peer object in the MasterProcessSession object. We got crashes here and there related to the destructors. Let's see if we can manage without mutexes.
2015-04-22 13:35:52 -05:00
peer->_tileCache->saveStatus(firstLine);
Now the chroot etc re-work is getting closer to working Works now for the trivial 'connect' test program. Still need to add pre-spawning of a new child process as soon as an existing one from the pool has been taking into use. And need to test with the actual JS client.
2015-04-14 09:50:38 -05:00
}
Handle LOK_CALLBACK_INVALIDATE_TILES in the server too Remove any intersecting cached tiles. It is the parent process that handles the tile cache, so it must look for invalidatetiles: messages, too, before passing them on to the client. To know for which part we should remove tiles, add an "ephemeral" curpart: message that the child process sends to the parent process before the invalidatetils: message.
2015-05-28 10:39:05 -05:00
else if (tokens[0] == "invalidatetiles:")
{
assert(firstLine.size() == static_cast<std::string::size_type>(length));
peer->_tileCache->invalidateTiles(_curPart, firstLine);
}
Now the chroot etc re-work is getting closer to working Works now for the trivial 'connect' test program. Still need to add pre-spawning of a new child process as soon as an existing one from the pool has been taking into use. And need to test with the actual JS client.
2015-04-14 09:50:38 -05:00
}
Pass callbacks from LOKit on to the client, and some other changes Use a larger buffer in the TestOutput class to handle a bit larger tiles. Too bad that the current Poco::WebSocket::receiveFrame() takes a fixed size buffer. (I will submit a patch to Poco for a receiveFrame() that takes a dynamically resizable buffer and handles whatever size frame the other side sends.)
2015-03-07 05:23:46 -06:00
Now the chroot etc re-work is getting closer to working Works now for the trivial 'connect' test program. Still need to add pre-spawning of a new child process as soon as an existing one from the pool has been taking into use. And need to test with the actual JS client.
2015-04-14 09:50:38 -05:00
forwardToPeer(buffer, length);
return true;
}
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
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
if (tokens[0] == "child")
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
{
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
if (_kind != Kind::ToPrisoner)
{
sendTextFrame("error: cmd=child kind=invalid");
return false;
}
Use shared_ptr and weak_ptr in attempt to make the pointer dance more robust It was obviously very wrong to use both a unique_ptr to the MasterProcessSession in WebSocketRequestHandler::handleRequest(), and then a bare pointers to the peer object in the MasterProcessSession object. We got crashes here and there related to the destructors. Let's see if we can manage without mutexes.
2015-04-22 13:35:52 -05:00
if (!_peer.expired())
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
{
sendTextFrame("error: cmd=child kind=invalid");
return false;
}
if (tokens.count() != 2)
{
sendTextFrame("error: cmd=child kind=syntax");
return false;
}
UInt64 childId = std::stoull(tokens[1]);
Terminology change: s/fork/spawn We aren't doing any fork-but-not-exec trick anyway, just a straightforward start of a child process.
2015-04-15 07:17:15 -05:00
if (_pendingPreSpawnedChildren.find(childId) == _pendingPreSpawnedChildren.end())
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
{
sendTextFrame("error: cmd=child kind=notfound");
return false;
}
Terminology change: s/fork/spawn We aren't doing any fork-but-not-exec trick anyway, just a straightforward start of a child process.
2015-04-15 07:17:15 -05:00
_pendingPreSpawnedChildren.erase(childId);
Add code to wait for a child session to become available Not sure it is completely correct. Lots of testing needed.
2015-05-07 08:29:36 -05:00
std::unique_lock<std::mutex> lock(_availableChildSessionMutex);
Use shared_ptr and weak_ptr in attempt to make the pointer dance more robust It was obviously very wrong to use both a unique_ptr to the MasterProcessSession in WebSocketRequestHandler::handleRequest(), and then a bare pointers to the peer object in the MasterProcessSession object. We got crashes here and there related to the destructors. Let's see if we can manage without mutexes.
2015-04-22 13:35:52 -05:00
_availableChildSessions.insert(shared_from_this());
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
std::cout << Util::logPrefix() << "Inserted " << this << " id=" << childId << " into _availableChildSessions, size=" << _availableChildSessions.size() << std::endl;
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
_childId = childId;
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
lock.unlock();
Add code to wait for a child session to become available Not sure it is completely correct. Lots of testing needed.
2015-05-07 08:29:36 -05:00
_availableChildSessionCV.notify_one();
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
}
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
else if (_kind == Kind::ToPrisoner)
{
// Message from child process to be forwarded to client.
// I think we should never get here
assert(false);
}
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
else if (tokens[0] == "load")
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06: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
if (_docURL != "")
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
{
Fix typo and bin leftover FOO debug output
2015-04-13 09:03:55 -05:00
sendTextFrame("error: cmd=load kind=docalreadyloaded");
Pass callbacks from LOKit on to the client, and some other changes Use a larger buffer in the TestOutput class to handle a bit larger tiles. Too bad that the current Poco::WebSocket::receiveFrame() takes a fixed size buffer. (I will submit a patch to Poco for a receiveFrame() that takes a dynamically resizable buffer and handles whatever size frame the other side sends.)
2015-03-07 05:23:46 -06:00
return false;
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06: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
return loadDocument(buffer, length, tokens);
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
}
Handle LOK_CALLBACK_INVALIDATE_TILES in the server too Remove any intersecting cached tiles. It is the parent process that handles the tile cache, so it must look for invalidatetiles: messages, too, before passing them on to the client. To know for which part we should remove tiles, add an "ephemeral" curpart: message that the child process sends to the parent process before the invalidatetils: message.
2015-05-28 10:39:05 -05:00
else if (tokens[0] != "invalidatetiles" &&
Improve error handling
2015-05-27 09:14:13 -05:00
tokens[0] != "key" &&
tokens[0] != "mouse" &&
tokens[0] != "resetselection" &&
Handle LOK_CALLBACK_INVALIDATE_TILES in the server too Remove any intersecting cached tiles. It is the parent process that handles the tile cache, so it must look for invalidatetiles: messages, too, before passing them on to the client. To know for which part we should remove tiles, add an "ephemeral" curpart: message that the child process sends to the parent process before the invalidatetils: message.
2015-05-28 10:39:05 -05:00
tokens[0] != "saveas" &&
tokens[0] != "selectgraphic" &&
tokens[0] != "selecttext" &&
tokens[0] != "status" &&
tokens[0] != "tile" &&
tokens[0] != "uno")
Improve error handling
2015-05-27 09:14:13 -05:00
{
sendTextFrame("error: cmd=" + tokens[0] + " kind=unknown");
return false;
}
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
else if (_docURL == "")
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
{
Small fix to error handling
2015-03-13 06:59:51 -05:00
sendTextFrame("error: cmd=" + tokens[0] + " kind=nodocloaded");
Pass callbacks from LOKit on to the client, and some other changes Use a larger buffer in the TestOutput class to handle a bit larger tiles. Too bad that the current Poco::WebSocket::receiveFrame() takes a fixed size buffer. (I will submit a patch to Poco for a receiveFrame() that takes a dynamically resizable buffer and handles whatever size frame the other side sends.)
2015-03-07 05:23:46 -06:00
return false;
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
}
Handle LOK_CALLBACK_INVALIDATE_TILES in the server too Remove any intersecting cached tiles. It is the parent process that handles the tile cache, so it must look for invalidatetiles: messages, too, before passing them on to the client. To know for which part we should remove tiles, add an "ephemeral" curpart: message that the child process sends to the parent process before the invalidatetils: message.
2015-05-28 10:39:05 -05:00
else if (tokens[0] == "invalidatetiles")
{
return invalidateTiles(buffer, length, tokens);
}
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
else if (tokens[0] == "status")
{
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
return getStatus(buffer, length);
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
}
else if (tokens[0] == "tile")
{
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
sendTile(buffer, length, tokens);
}
else
{
Reduce copypasta Handle the start of a child process when needed centrally, not in each command handler. Also, handle unrecognized commands always already in the parent process. (Command syntax checks still done in child process, though.)
2015-03-20 08:50:23 -05:00
// All other commands are such that they always require a
// LibreOfficeKitDocument session, i.e. need to be handled in
// a child process.
Use shared_ptr and weak_ptr in attempt to make the pointer dance more robust It was obviously very wrong to use both a unique_ptr to the MasterProcessSession in WebSocketRequestHandler::handleRequest(), and then a bare pointers to the peer object in the MasterProcessSession object. We got crashes here and there related to the destructors. Let's see if we can manage without mutexes.
2015-04-22 13:35:52 -05:00
if (_peer.expired())
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
dispatchChild();
forwardToPeer(buffer, length);
}
return true;
}
bool MasterProcessSession::haveSeparateProcess()
{
return _childId != 0;
}
Be more consistent in using 'using'
2015-05-29 00:49:49 -05:00
Path MasterProcessSession::getJailPath(UInt64 childId)
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
{
return Path::forDirectory(LOOLWSD::childRoot + Path::separator() + std::to_string(childId));
}
namespace
{
Must use thread-local storage for the variables used by the nftw callback Otherwise two or more linkOrCopy() functions running simultaneously will lead to a mess. Actually nftw() is not guaranteed to be thread-safe, I think, so we should really use something that is, like Poco's SimpleRecursiveDirectoryIterator.
2015-05-07 12:15:05 -05:00
ThreadLocal<std::string> sourceForLinkOrCopy;
ThreadLocal<Path> destinationForLinkOrCopy;
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
int linkOrCopyFunction(const char *fpath,
const struct stat *sb,
int typeflag,
struct FTW *ftwbuf)
{
Must use thread-local storage for the variables used by the nftw callback Otherwise two or more linkOrCopy() functions running simultaneously will lead to a mess. Actually nftw() is not guaranteed to be thread-safe, I think, so we should really use something that is, like Poco's SimpleRecursiveDirectoryIterator.
2015-05-07 12:15:05 -05:00
if (strcmp(fpath, sourceForLinkOrCopy->c_str()) == 0)
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
return 0;
Must use thread-local storage for the variables used by the nftw callback Otherwise two or more linkOrCopy() functions running simultaneously will lead to a mess. Actually nftw() is not guaranteed to be thread-safe, I think, so we should really use something that is, like Poco's SimpleRecursiveDirectoryIterator.
2015-05-07 12:15:05 -05:00
assert(fpath[strlen(sourceForLinkOrCopy->c_str())] == '/');
const char *relativeOldPath = fpath + strlen(sourceForLinkOrCopy->c_str()) + 1;
For some reason linking the PkgInfo file fails in OS X No idea. Does not even work from the command line... But after "fixing" this, we run into other weird problems anyway. (Maybe one needs to use lower-level (Mach) APIs for esoteric stuff like chroot?) So, getting loolwsd to work on OS X seems unexpectedly hard even before considering what changes might be needed to LibreOfficeKit. Oh well.
2015-05-22 06:40:24 -05:00
#ifdef __APPLE__
if (strcmp(relativeOldPath, "PkgInfo") == 0)
return 0;
#endif
Must use thread-local storage for the variables used by the nftw callback Otherwise two or more linkOrCopy() functions running simultaneously will lead to a mess. Actually nftw() is not guaranteed to be thread-safe, I think, so we should really use something that is, like Poco's SimpleRecursiveDirectoryIterator.
2015-05-07 12:15:05 -05:00
Path newPath(*destinationForLinkOrCopy, Path(relativeOldPath));
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
switch (typeflag)
{
case FTW_F:
Preserve timestamp of directories created in the jail Needed for /usr/share/fonts so that fontconfig trusts its cache, but no harm doing it for all directories. (Except a slight slowdown, need to see it if has any significant impact if we would do the utime() only for directories under /usr/share/fonts.) Thus we need to pass the FTW_DEPTH flag to nftw() and handle FTP_DP instead of FTP_D. We also need to make sure the directory is created also in the case of an empty directory, for which no FTW_F callback of files inside it has been received. It is safest to not exit the nftw() in the FTW_SLN case.
2015-04-27 07:51:33 -05:00
File(newPath.parent()).createDirectories();
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
if (link(fpath, newPath.toString().c_str()) == -1)
Reduce copypasta Handle the start of a child process when needed centrally, not in each command handler. Also, handle unrecognized commands always already in the parent process. (Command syntax checks still done in child process, though.)
2015-03-20 08:50:23 -05:00
{
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
Application::instance().logger().error(Util::logPrefix() +
"link(\"" + fpath + "\",\"" + newPath.toString() + "\") failed: " +
strerror(errno));
exit(1);
Reduce copypasta Handle the start of a child process when needed centrally, not in each command handler. Also, handle unrecognized commands always already in the parent process. (Command syntax checks still done in child process, though.)
2015-03-20 08:50:23 -05:00
}
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
break;
Preserve timestamp of directories created in the jail Needed for /usr/share/fonts so that fontconfig trusts its cache, but no harm doing it for all directories. (Except a slight slowdown, need to see it if has any significant impact if we would do the utime() only for directories under /usr/share/fonts.) Thus we need to pass the FTW_DEPTH flag to nftw() and handle FTP_DP instead of FTP_D. We also need to make sure the directory is created also in the case of an empty directory, for which no FTW_F callback of files inside it has been received. It is safest to not exit the nftw() in the FTW_SLN case.
2015-04-27 07:51:33 -05:00
case FTW_DP:
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
{
Preserve timestamp of directories created in the jail Needed for /usr/share/fonts so that fontconfig trusts its cache, but no harm doing it for all directories. (Except a slight slowdown, need to see it if has any significant impact if we would do the utime() only for directories under /usr/share/fonts.) Thus we need to pass the FTW_DEPTH flag to nftw() and handle FTP_DP instead of FTP_D. We also need to make sure the directory is created also in the case of an empty directory, for which no FTW_F callback of files inside it has been received. It is safest to not exit the nftw() in the FTW_SLN case.
2015-04-27 07:51:33 -05:00
struct stat st;
if (stat(fpath, &st) == -1)
{
Application::instance().logger().error(Util::logPrefix() +
"stat(\"" + fpath + "\") failed: " +
strerror(errno));
return 1;
}
File(newPath).createDirectories();
struct utimbuf ut;
ut.actime = st.st_atime;
ut.modtime = st.st_mtime;
if (utime(newPath.toString().c_str(), &ut) == -1)
{
Application::instance().logger().error(Util::logPrefix() +
"utime(\"" + newPath.toString() + "\", &ut) failed: " +
strerror(errno));
return 1;
}
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
}
break;
case FTW_DNR:
Application::instance().logger().error(Util::logPrefix() +
"Cannot read directory '" + fpath + "'");
return 1;
case FTW_NS:
Application::instance().logger().error(Util::logPrefix() +
"nftw: stat failed for '" + fpath + "'");
return 1;
case FTW_SLN:
Preserve timestamp of directories created in the jail Needed for /usr/share/fonts so that fontconfig trusts its cache, but no harm doing it for all directories. (Except a slight slowdown, need to see it if has any significant impact if we would do the utime() only for directories under /usr/share/fonts.) Thus we need to pass the FTW_DEPTH flag to nftw() and handle FTP_DP instead of FTP_D. We also need to make sure the directory is created also in the case of an empty directory, for which no FTW_F callback of files inside it has been received. It is safest to not exit the nftw() in the FTW_SLN case.
2015-04-27 07:51:33 -05:00
Application::instance().logger().information(Util::logPrefix() +
"nftw: symlink to nonexistent file: '" + fpath + "', ignored");
break;
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
default:
assert(false);
}
return 0;
}
void linkOrCopy(const std::string& source, const Path& destination)
{
Must use thread-local storage for the variables used by the nftw callback Otherwise two or more linkOrCopy() functions running simultaneously will lead to a mess. Actually nftw() is not guaranteed to be thread-safe, I think, so we should really use something that is, like Poco's SimpleRecursiveDirectoryIterator.
2015-05-07 12:15:05 -05:00
*sourceForLinkOrCopy = source;
*destinationForLinkOrCopy = destination;
Preserve timestamp of directories created in the jail Needed for /usr/share/fonts so that fontconfig trusts its cache, but no harm doing it for all directories. (Except a slight slowdown, need to see it if has any significant impact if we would do the utime() only for directories under /usr/share/fonts.) Thus we need to pass the FTW_DEPTH flag to nftw() and handle FTP_DP instead of FTP_D. We also need to make sure the directory is created also in the case of an empty directory, for which no FTW_F callback of files inside it has been received. It is safest to not exit the nftw() in the FTW_SLN case.
2015-04-27 07:51:33 -05:00
if (nftw(source.c_str(), linkOrCopyFunction, 10, FTW_DEPTH) == -1)
LOOLSession: log error if nftw() fails Should help finding out the problem if --lotemplate is given a non-existing directory by mistake.
2015-04-24 11:09:01 -05:00
Application::instance().logger().error(Util::logPrefix() +
"linkOrCopy: nftw() failed for '" + source + "'");
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
}
}
void MasterProcessSession::preSpawn()
{
// Create child-specific subtree that will become its chroot root
Use just one RNG for the MasterProcessSession objects It probably is not a good idea to keep depleting the entropy source needlessly by having a separate RNG in the preSpawn(). Use just one shared RNG and protect access to it with a mutex.
2015-05-07 12:01:40 -05:00
std::unique_lock<std::mutex> rngLock(_rngMutex);
UInt64 childId = (((UInt64)_rng.next()) << 32) | _rng.next() | 1;
rngLock.unlock();
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
Path jail = getJailPath(childId);
File(jail).createDirectory();
Path jailLOInstallation(jail, LOOLWSD::loSubPath);
Preserve timestamp of directories created in the jail Needed for /usr/share/fonts so that fontconfig trusts its cache, but no harm doing it for all directories. (Except a slight slowdown, need to see it if has any significant impact if we would do the utime() only for directories under /usr/share/fonts.) Thus we need to pass the FTW_DEPTH flag to nftw() and handle FTP_DP instead of FTP_D. We also need to make sure the directory is created also in the case of an empty directory, for which no FTW_F callback of files inside it has been received. It is safest to not exit the nftw() in the FTW_SLN case.
2015-04-27 07:51:33 -05:00
jailLOInstallation.makeDirectory();
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
File(jailLOInstallation).createDirectory();
// Copy (link) LO installation and other necessary files into it from the template
linkOrCopy(LOOLWSD::sysTemplate, jail);
linkOrCopy(LOOLWSD::loTemplate, jailLOInstallation);
_pendingPreSpawnedChildren.insert(childId);
Process::Args args;
Add some fairly hackish things to make this run better on OS X
2015-05-22 08:34:21 -05:00
#if ENABLE_DEBUG
if (LOOLWSD::runningAsRoot)
args.push_back(Application::instance().commandPath());
#endif
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
args.push_back("--child=" + std::to_string(childId));
args.push_back("--port=" + std::to_string(LOOLWSD::portNumber));
args.push_back("--jail=" + jail.toString());
args.push_back("--losubpath=" + LOOLWSD::loSubPath);
Fix non-debug build.
2015-05-26 03:08:27 -05:00
std::string executable;
Pass the --uid option to the child too
2015-05-22 11:42:36 -05:00
#if ENABLE_DEBUG
if (LOOLWSD::runningAsRoot)
Fix non-debug build.
2015-05-26 03:08:27 -05:00
{
Pass the --uid option to the child too
2015-05-22 11:42:36 -05:00
args.push_back("--uid=" + std::to_string(LOOLWSD::uid));
Fix non-debug build.
2015-05-26 03:08:27 -05:00
executable = "/usr/bin/sudo";
}
else
Pass the --uid option to the child too
2015-05-22 11:42:36 -05:00
#endif
Fix non-debug build.
2015-05-26 03:08:27 -05:00
{
executable = Application::instance().commandPath();
}
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
Add some fairly hackish things to make this run better on OS X
2015-05-22 08:34:21 -05:00
Application::instance().logger().information(Util::logPrefix() + "Launching child: " + executable + " " + Poco::cat(std::string(" "), args.begin(), args.end()));
#if ENABLE_DEBUG
ProcessHandle child = Process::launch(executable, args);
#else
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
ProcessHandle child = Process::launch(Application::instance().commandPath(), args);
Add some fairly hackish things to make this run better on OS X
2015-05-22 08:34:21 -05:00
#endif
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
_childProcesses[child.id()] = childId;
}
Handle LOK_CALLBACK_INVALIDATE_TILES in the server too Remove any intersecting cached tiles. It is the parent process that handles the tile cache, so it must look for invalidatetiles: messages, too, before passing them on to the client. To know for which part we should remove tiles, add an "ephemeral" curpart: message that the child process sends to the parent process before the invalidatetils: message.
2015-05-28 10:39:05 -05:00
bool MasterProcessSession::invalidateTiles(const char *buffer, int length, StringTokenizer& tokens)
{
int part, tilePosX, tilePosY, tileWidth, tileHeight;
if (tokens.count() != 6 ||
!getTokenInteger(tokens[1], "part", part) ||
!getTokenInteger(tokens[2], "tileposx", tilePosX) ||
!getTokenInteger(tokens[3], "tileposy", tilePosY) ||
!getTokenInteger(tokens[4], "tilewidth", tileWidth) ||
!getTokenInteger(tokens[5], "tileheight", tileHeight))
{
sendTextFrame("error: cmd=invalidatetiles kind=syntax");
return false;
}
_tileCache->invalidateTiles(_curPart, tilePosX, tilePosY, tileWidth, tileHeight);
return true;
}
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
bool MasterProcessSession::loadDocument(const char *buffer, int length, StringTokenizer& tokens)
{
if (tokens.count() != 2)
{
sendTextFrame("error: cmd=load kind=syntax");
return false;
}
if (tokens[1].find("url=") == 0)
_docURL = tokens[1].substr(strlen("url="));
else
_docURL = tokens[1];
_tileCache.reset(new TileCache(_docURL));
return true;
}
bool MasterProcessSession::getStatus(const char *buffer, int length)
{
std::string status;
status = _tileCache->getStatus();
if (status.size() > 0)
{
sendTextFrame(status);
return true;
}
Use shared_ptr and weak_ptr in attempt to make the pointer dance more robust It was obviously very wrong to use both a unique_ptr to the MasterProcessSession in WebSocketRequestHandler::handleRequest(), and then a bare pointers to the peer object in the MasterProcessSession object. We got crashes here and there related to the destructors. Let's see if we can manage without mutexes.
2015-04-22 13:35:52 -05:00
if (_peer.expired())
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
dispatchChild();
forwardToPeer(buffer, length);
return true;
}
void MasterProcessSession::sendTile(const char *buffer, int length, StringTokenizer& tokens)
{
Add a part parameter to the tile messages The JS code always passes in 0 for now. The server parses the parameter and calls LibreOfficeKitDocument::setPart() before calling paintTile(). Probably also the status, key, mouse and selection messages will need a part number. The intent is after all that the protocol is as stateless as possible. (So maybe we should also pass the document URL in each message?)
2015-04-27 13:24:05 -05:00
int part, width, height, tilePosX, tilePosY, tileWidth, tileHeight;
if (tokens.count() != 8 ||
!getTokenInteger(tokens[1], "part", part) ||
!getTokenInteger(tokens[2], "width", width) ||
!getTokenInteger(tokens[3], "height", height) ||
!getTokenInteger(tokens[4], "tileposx", tilePosX) ||
!getTokenInteger(tokens[5], "tileposy", tilePosY) ||
!getTokenInteger(tokens[6], "tilewidth", tileWidth) ||
!getTokenInteger(tokens[7], "tileheight", tileHeight))
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
{
sendTextFrame("error: cmd=tile kind=syntax");
return;
}
Add a part parameter to the tile messages The JS code always passes in 0 for now. The server parses the parameter and calls LibreOfficeKitDocument::setPart() before calling paintTile(). Probably also the status, key, mouse and selection messages will need a part number. The intent is after all that the protocol is as stateless as possible. (So maybe we should also pass the document URL in each message?)
2015-04-27 13:24:05 -05:00
if (part < 0 ||
width <= 0 ||
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
height <= 0 ||
tilePosX < 0 ||
tilePosY < 0 ||
tileWidth <= 0 ||
tileHeight <= 0)
{
sendTextFrame("error: cmd=tile kind=invalid");
return;
}
std::string response = "tile: " + Poco::cat(std::string(" "), tokens.begin() + 1, tokens.end()) + "\n";
std::vector<char> output;
output.reserve(4 * width * height);
output.resize(response.size());
std::memcpy(output.data(), response.data(), response.size());
Add a part parameter to the tile messages The JS code always passes in 0 for now. The server parses the parameter and calls LibreOfficeKitDocument::setPart() before calling paintTile(). Probably also the status, key, mouse and selection messages will need a part number. The intent is after all that the protocol is as stateless as possible. (So maybe we should also pass the document URL in each message?)
2015-04-27 13:24:05 -05:00
std::unique_ptr<std::fstream> cachedTile = _tileCache->lookupTile(part, width, height, tilePosX, tilePosY, tileWidth, tileHeight);
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
if (cachedTile && cachedTile->is_open())
{
cachedTile->seekg(0, std::ios_base::end);
size_t pos = output.size();
std::streamsize size = cachedTile->tellg();
output.resize(pos + size);
cachedTile->seekg(0, std::ios_base::beg);
cachedTile->read(output.data() + pos, size);
cachedTile->close();
sendBinaryFrame(output.data(), output.size());
return;
}
Use shared_ptr and weak_ptr in attempt to make the pointer dance more robust It was obviously very wrong to use both a unique_ptr to the MasterProcessSession in WebSocketRequestHandler::handleRequest(), and then a bare pointers to the peer object in the MasterProcessSession object. We got crashes here and there related to the destructors. Let's see if we can manage without mutexes.
2015-04-22 13:35:52 -05:00
if (_peer.expired())
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
dispatchChild();
forwardToPeer(buffer, length);
}
void MasterProcessSession::dispatchChild()
{
// Copy document into jail using the fixed name
Add code to wait for a child session to become available Not sure it is completely correct. Lots of testing needed.
2015-05-07 08:29:36 -05:00
std::shared_ptr<MasterProcessSession> childSession;
std::unique_lock<std::mutex> lock(_availableChildSessionMutex);
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
std::cout << Util::logPrefix() << "_availableChildSessions size=" << _availableChildSessions.size() << " _pendingChildSessions size=" << _pendingPreSpawnedChildren.size() << std::endl;
Add code to wait for a child session to become available Not sure it is completely correct. Lots of testing needed.
2015-05-07 08:29:36 -05:00
if (_availableChildSessions.size() == 0)
{
If we run out of pre-spawned children, spawn one more Just a stopgap measure so far. Clearly will need some logic to get rid of too many children if they are just hanging around with no clients incoming. Also, we need some sanity check not to spawn an unlimited number of children.
2015-05-08 04:45:04 -05:00
if (_pendingPreSpawnedChildren.size() == 0)
{
// Running out of pre-spawned children, so spawn one more
Application::instance().logger().information(Util::logPrefix() + "Running out of pre-spawned childred, adding one more");
lock.unlock();
preSpawn();
lock.lock();
}
Add code to wait for a child session to become available Not sure it is completely correct. Lots of testing needed.
2015-05-07 08:29:36 -05:00
std::cout << Util::logPrefix() << "waiting for a child session to become available" << std::endl;
_availableChildSessionCV.wait(lock, [] { return _availableChildSessions.size() > 0; });
std::cout << Util::logPrefix() << "waiting done" << std::endl;
}
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
Add code to wait for a child session to become available Not sure it is completely correct. Lots of testing needed.
2015-05-07 08:29:36 -05:00
childSession = *(_availableChildSessions.begin());
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
_availableChildSessions.erase(childSession);
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
std::cout << Util::logPrefix() << "_availableChildSessions size=" << _availableChildSessions.size() << std::endl;
Add code to wait for a child session to become available Not sure it is completely correct. Lots of testing needed.
2015-05-07 08:29:36 -05:00
lock.unlock();
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
assert(jailDocumentURL[0] == '/');
Path copy(getJailPath(childSession->_childId), jailDocumentURL.substr(1));
Application::instance().logger().information(Util::logPrefix() + "Copying " + _docURL + " to " + copy.toString());
Handle file: and http: URLs
2015-04-30 07:58:13 -05:00
URIStreamOpener opener;
opener.registerStreamFactory("http", new HTTPStreamFactory());
Improve error handling for documents that can't be opened Catch IOException when trying to copy the document and send error message. Otherwise, the exception will just propagate up to handleRequest() and the connection will be silently closed. Closing the connection is fine as such, I think, but we need to send an error message first.
2015-05-12 04:28:46 -05:00
try
Handle file: and http: URLs
2015-04-30 07:58:13 -05:00
{
Improve error handling for documents that can't be opened Catch IOException when trying to copy the document and send error message. Otherwise, the exception will just propagate up to handleRequest() and the connection will be silently closed. Closing the connection is fine as such, I think, but we need to send an error message first.
2015-05-12 04:28:46 -05:00
std::istream *input = opener.open(_docURL);
std::ofstream output(copy.toString());
if (!output)
{
Application::instance().logger().error(Util::logPrefix() + "Could not open " + copy.toString() + " for writing");
sendTextFrame("error: cmd=load kind=internal");
// We did not use the child session after all
lock.lock();
_availableChildSessions.insert(childSession);
std::cout << Util::logPrefix() << "_availableChildSessions size=" << _availableChildSessions.size() << std::endl;
lock.unlock();
Be more consistent in using 'using'
2015-05-29 00:49:49 -05:00
throw IOException(copy.toString());
Improve error handling for documents that can't be opened Catch IOException when trying to copy the document and send error message. Otherwise, the exception will just propagate up to handleRequest() and the connection will be silently closed. Closing the connection is fine as such, I think, but we need to send an error message first.
2015-05-12 04:28:46 -05:00
}
StreamCopier::copyStream(*input, output);
output.close();
Application::instance().logger().information(Util::logPrefix() + "Copying done");
Handle file: and http: URLs
2015-04-30 07:58:13 -05:00
}
Be more consistent in using 'using'
2015-05-29 00:49:49 -05:00
catch (IOException& exc)
Improve error handling for documents that can't be opened Catch IOException when trying to copy the document and send error message. Otherwise, the exception will just propagate up to handleRequest() and the connection will be silently closed. Closing the connection is fine as such, I think, but we need to send an error message first.
2015-05-12 04:28:46 -05:00
{
Application::instance().logger().error(Util::logPrefix() + "Copying failed: " + exc.message());
sendTextFrame("error: cmd=load kind=failed");
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
Improve error handling for documents that can't be opened Catch IOException when trying to copy the document and send error message. Otherwise, the exception will just propagate up to handleRequest() and the connection will be silently closed. Closing the connection is fine as such, I think, but we need to send an error message first.
2015-05-12 04:28:46 -05:00
lock.lock();
_availableChildSessions.insert(childSession);
std::cout << Util::logPrefix() << "_availableChildSessions size=" << _availableChildSessions.size() << std::endl;
lock.unlock();
throw;
}
Log also when copying of the document is done
2015-04-30 13:05:16 -05:00
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
_peer = childSession;
Use shared_ptr and weak_ptr in attempt to make the pointer dance more robust It was obviously very wrong to use both a unique_ptr to the MasterProcessSession in WebSocketRequestHandler::handleRequest(), and then a bare pointers to the peer object in the MasterProcessSession object. We got crashes here and there related to the destructors. Let's see if we can manage without mutexes.
2015-04-22 13:35:52 -05:00
childSession->_peer = shared_from_this();
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
std::string loadRequest = "load url=" + _docURL;
forwardToPeer(loadRequest.c_str(), loadRequest.size());
// As we took one child process into use, spawn a new one
preSpawn();
}
void MasterProcessSession::forwardToPeer(const char *buffer, int length)
{
Application::instance().logger().information(Util::logPrefix() + "forwardToPeer(" + getAbbreviatedMessage(buffer, length) + ")");
Use shared_ptr and weak_ptr in attempt to make the pointer dance more robust It was obviously very wrong to use both a unique_ptr to the MasterProcessSession in WebSocketRequestHandler::handleRequest(), and then a bare pointers to the peer object in the MasterProcessSession object. We got crashes here and there related to the destructors. Let's see if we can manage without mutexes.
2015-04-22 13:35:52 -05:00
auto peer = _peer.lock();
This is cleaner
2015-04-30 10:44:27 -05:00
if (!peer)
return;
Add a "canceltiles" message to the protocol and handle it Implementing this Was harder than I first expected. The basic idea is as follows: The master process puts each message arriving from a client that isn't "canceltiles" into a (client-specific) queue. A separate thread that pulls messages from the queue at its own pace and handles them as before. Incoming "canceltiles" messages are handled specially, though: The queue is emptied of "tile" messages. The above sounds simple but there are several details that were a bit tricky to get right.
2015-06-05 08:12:06 -05:00
peer->sendBinaryFrame(buffer, length);
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
}
Reduce copypasta Handle the start of a child process when needed centrally, not in each command handler. Also, handle unrecognized commands always already in the parent process. (Command syntax checks still done in child process, though.)
2015-03-20 08:50:23 -05:00
Use shared_ptr to the WebSockets for increased robustness Why did I wait so long to do this? This is obviously the right thing to do, I hope, and has a very significant impact on the robustness of the server...
2015-05-28 08:42:38 -05:00
ChildProcessSession::ChildProcessSession(std::shared_ptr<WebSocket> ws, LibreOfficeKit *loKit) :
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
LOOLSession(ws, Kind::ToMaster),
Handle LOK_CALLBACK_INVALIDATE_TILES in the server too Remove any intersecting cached tiles. It is the parent process that handles the tile cache, so it must look for invalidatetiles: messages, too, before passing them on to the client. To know for which part we should remove tiles, add an "ephemeral" curpart: message that the child process sends to the parent process before the invalidatetils: message.
2015-05-28 10:39:05 -05:00
_loKitDocument(NULL),
_loKit(loKit)
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
{
Use shared_ptr to the WebSockets for increased robustness Why did I wait so long to do this? This is obviously the right thing to do, I hope, and has a very significant impact on the robustness of the server...
2015-05-28 08:42:38 -05:00
std::cout << Util::logPrefix() << "ChildProcessSession ctor this=" << this << " ws=" << _ws.get() << std::endl;
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
}
ChildProcessSession::~ChildProcessSession()
{
std::cout << Util::logPrefix() << "ChildProcessSession dtor this=" << this << std::endl;
Register for callbacks from the LibreOfficeKit object, too They are used for statgus indicator callbacks while loading a document. (This is a fresh feature in LO master.)
2015-05-06 09:08:44 -05:00
if (LIBREOFFICEKIT_HAS(_loKit, registerCallback))
_loKit->pClass->registerCallback(_loKit, 0, 0);
Factor out WebSocket::shutdown() ignoring IOException
2015-04-22 03:14:11 -05:00
Util::shutdownWebSocket(*_ws);
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
}
The buffer parameter to handleInput() can be const
2015-06-08 08:35:52 -05:00
bool ChildProcessSession::handleInput(const char *buffer, int length)
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
{
Application& app = Application::instance();
std::string firstLine = getFirstLine(buffer, length);
StringTokenizer tokens(firstLine, " ", StringTokenizer::TOK_IGNORE_EMPTY | StringTokenizer::TOK_TRIM);
app.logger().information(Util::logPrefix() + "Input: " + getAbbreviatedMessage(buffer, length));
if (tokens[0] == "load")
{
if (_docURL != "")
{
sendTextFrame("error: cmd=load kind=docalreadyloaded");
return false;
Reduce copypasta Handle the start of a child process when needed centrally, not in each command handler. Also, handle unrecognized commands always already in the parent process. (Command syntax checks still done in child process, though.)
2015-03-20 08:50:23 -05:00
}
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
return loadDocument(buffer, length, tokens);
}
else if (_docURL == "")
{
sendTextFrame("error: cmd=" + tokens[0] + " kind=nodocloaded");
return false;
}
else if (tokens[0] == "status")
{
return getStatus(buffer, length);
}
else if (tokens[0] == "tile")
{
sendTile(buffer, length, tokens);
}
else
{
// All other commands are such that they always require a LibreOfficeKitDocument session,
// i.e. need to be handled in a child process.
assert(tokens[0] == "key" ||
tokens[0] == "mouse" ||
tokens[0] == "uno" ||
tokens[0] == "selecttext" ||
tokens[0] == "selectgraphic" ||
tokens[0] == "resetselection" ||
tokens[0] == "saveas");
Reduce copypasta Handle the start of a child process when needed centrally, not in each command handler. Also, handle unrecognized commands always already in the parent process. (Command syntax checks still done in child process, though.)
2015-03-20 08:50:23 -05:00
if (tokens[0] == "key")
{
return keyEvent(buffer, length, tokens);
}
else if (tokens[0] == "mouse")
{
return mouseEvent(buffer, length, tokens);
}
else if (tokens[0] == "uno")
{
return unoCommand(buffer, length, tokens);
}
else if (tokens[0] == "selecttext")
{
return selectText(buffer, length, tokens);
}
else if (tokens[0] == "selectgraphic")
{
return selectGraphic(buffer, length, tokens);
}
else if (tokens[0] == "resetselection")
{
Add 'saveas'
2015-03-23 15:13:57 -05:00
return resetSelection(buffer, length, tokens);
}
else if (tokens[0] == "saveas")
{
return saveAs(buffer, length, tokens);
Reduce copypasta Handle the start of a child process when needed centrally, not in each command handler. Also, handle unrecognized commands always already in the parent process. (Command syntax checks still done in child process, though.)
2015-03-20 08:50:23 -05:00
}
else
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
{
Reduce copypasta Handle the start of a child process when needed centrally, not in each command handler. Also, handle unrecognized commands always already in the parent process. (Command syntax checks still done in child process, though.)
2015-03-20 08:50:23 -05:00
assert(false);
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
}
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
}
Pass callbacks from LOKit on to the client, and some other changes Use a larger buffer in the TestOutput class to handle a bit larger tiles. Too bad that the current Poco::WebSocket::receiveFrame() takes a fixed size buffer. (I will submit a patch to Poco for a receiveFrame() that takes a dynamically resizable buffer and handles whatever size frame the other side sends.)
2015-03-07 05:23:46 -06:00
return true;
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
}
Pass callbacks from LOKit on to the client, and some other changes Use a larger buffer in the TestOutput class to handle a bit larger tiles. Too bad that the current Poco::WebSocket::receiveFrame() takes a fixed size buffer. (I will submit a patch to Poco for a receiveFrame() that takes a dynamically resizable buffer and handles whatever size frame the other side sends.)
2015-03-07 05:23:46 -06:00
extern "C"
{
static void myCallback(int nType, const char* pPayload, void* pData)
{
Handle LOK_CALLBACK_INVALIDATE_TILES in the server too Remove any intersecting cached tiles. It is the parent process that handles the tile cache, so it must look for invalidatetiles: messages, too, before passing them on to the client. To know for which part we should remove tiles, add an "ephemeral" curpart: message that the child process sends to the parent process before the invalidatetils: message.
2015-05-28 10:39:05 -05:00
ChildProcessSession *srv = reinterpret_cast<ChildProcessSession *>(pData);
Pass callbacks from LOKit on to the client, and some other changes Use a larger buffer in the TestOutput class to handle a bit larger tiles. Too bad that the current Poco::WebSocket::receiveFrame() takes a fixed size buffer. (I will submit a patch to Poco for a receiveFrame() that takes a dynamically resizable buffer and handles whatever size frame the other side sends.)
2015-03-07 05:23:46 -06:00
switch ((LibreOfficeKitCallbackType) nType)
{
case LOK_CALLBACK_INVALIDATE_TILES:
Add an invalidate: message that is in LOOL style with named parameters The invalidatetiles: message as generated directly from the LOK_CALLBACK_INVALIDATE_TILES will be dropped soon.
2015-05-29 01:44:39 -05:00
{
int curPart = srv->_loKitDocument->pClass->getPart(srv->_loKitDocument);
srv->sendTextFrame("curpart: part=" + std::to_string(curPart));
srv->sendTextFrame("invalidatetiles: " + std::string(pPayload));
StringTokenizer tokens(std::string(pPayload), " ", StringTokenizer::TOK_IGNORE_EMPTY | StringTokenizer::TOK_TRIM);
if (tokens.count() == 4)
{
int width(std::stoi(tokens[0]));
int height(std::stoi(tokens[1]));
int x(std::stoi(tokens[2]));
int y(std::stoi(tokens[3]));
srv->sendTextFrame("invalidate:"
" part=" + std::to_string(curPart) +
" x=" + std::to_string(x) +
" y=" + std::to_string(y) +
" width=" + std::to_string(width) +
" height=" + std::to_string(height));
}
}
Pass callbacks from LOKit on to the client, and some other changes Use a larger buffer in the TestOutput class to handle a bit larger tiles. Too bad that the current Poco::WebSocket::receiveFrame() takes a fixed size buffer. (I will submit a patch to Poco for a receiveFrame() that takes a dynamically resizable buffer and handles whatever size frame the other side sends.)
2015-03-07 05:23:46 -06:00
break;
case LOK_CALLBACK_INVALIDATE_VISIBLE_CURSOR:
Added missing rectangle to invalidate cursor.
2015-05-24 23:40:08 -05:00
srv->sendTextFrame("invalidatecursor: " + std::string(pPayload));
Missing break
2015-03-13 04:25:00 -05:00
break;
Pass callbacks from LOKit on to the client, and some other changes Use a larger buffer in the TestOutput class to handle a bit larger tiles. Too bad that the current Poco::WebSocket::receiveFrame() takes a fixed size buffer. (I will submit a patch to Poco for a receiveFrame() that takes a dynamically resizable buffer and handles whatever size frame the other side sends.)
2015-03-07 05:23:46 -06:00
case LOK_CALLBACK_TEXT_SELECTION:
srv->sendTextFrame("textselection: " + std::string(pPayload));
break;
case LOK_CALLBACK_TEXT_SELECTION_START:
srv->sendTextFrame("textselectionstart: " + std::string(pPayload));
break;
case LOK_CALLBACK_TEXT_SELECTION_END:
srv->sendTextFrame("textselectionend: " + std::string(pPayload));
break;
More LibreOfficeKitCallbackType values have been added
2015-03-13 04:30:23 -05:00
case LOK_CALLBACK_CURSOR_VISIBLE:
srv->sendTextFrame("cursorvisible: " + std::string(pPayload));
break;
case LOK_CALLBACK_GRAPHIC_SELECTION:
srv->sendTextFrame("graphicselection: " + std::string(pPayload));
break;
case LOK_CALLBACK_HYPERLINK_CLICKED:
srv->sendTextFrame("hyperlinkclicked: " + std::string(pPayload));
break;
Handle LOK_CALLBACK_STATE_CHANGED
2015-04-14 06:51:36 -05:00
case LOK_CALLBACK_STATE_CHANGED:
srv->sendTextFrame("statechanged: " + std::string(pPayload));
break;
Register for callbacks from the LibreOfficeKit object, too They are used for statgus indicator callbacks while loading a document. (This is a fresh feature in LO master.)
2015-05-06 09:08:44 -05:00
case LOK_CALLBACK_STATUS_INDICATOR_START:
srv->sendTextFrame("statusindicatorstart:");
break;
case LOK_CALLBACK_STATUS_INDICATOR_SET_VALUE:
srv->sendTextFrame("statusindicatorsetvalue: " + std::string(pPayload));
break;
case LOK_CALLBACK_STATUS_INDICATOR_FINISH:
srv->sendTextFrame("statusindicatorfinish:");
break;
Search not found callback handler
2015-05-19 03:56:04 -05:00
case LOK_CALLBACK_SEARCH_NOT_FOUND:
srv->sendTextFrame("searchnotfound: " + std::string(pPayload));
break;
LOOLSession: PAGE_COUNT -> DOCUMENT_SIZE
2015-05-27 10:34:10 -05:00
case LOK_CALLBACK_DOCUMENT_SIZE_CHANGED:
Handle LOK_CALLBACK_DOCUMENT_SIZE_CHANGED even better Just call the getStatus() function directly in the child process, which will always cause a complete status: message to be sent to the client. No documentsizechanged: messages now sent to the client at all.
2015-05-28 06:51:08 -05:00
srv->getStatus("", 0);
Handle LOK_CALLBACK_PAGE_COUNT_CHANGED
2015-05-23 05:26:11 -05:00
break;
LOOLSession: handle LOK_CALLBACK_SET_PART
2015-05-27 04:36:05 -05:00
case LOK_CALLBACK_SET_PART:
srv->sendTextFrame("setpart: " + std::string(pPayload));
break;
Pass callbacks from LOKit on to the client, and some other changes Use a larger buffer in the TestOutput class to handle a bit larger tiles. Too bad that the current Poco::WebSocket::receiveFrame() takes a fixed size buffer. (I will submit a patch to Poco for a receiveFrame() that takes a dynamically resizable buffer and handles whatever size frame the other side sends.)
2015-03-07 05:23:46 -06:00
}
}
}
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
bool ChildProcessSession::loadDocument(const char *buffer, int length, StringTokenizer& tokens)
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
{
if (tokens.count() != 2)
{
sendTextFrame("error: cmd=load kind=syntax");
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
return false;
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
}
Further hacking on tile cache
2015-03-12 18:34:42 -05:00
Add key and mouse event handling, uno command, and selection handling Not "handled" here of course, just pass them on to LibreOfficeKit.
2015-03-19 07:38:04 -05:00
if (tokens[1].find("url=") == 0)
_docURL = tokens[1].substr(strlen("url="));
else
_docURL = tokens[1];
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
// The URL in the request is the original one, not visible in the chroot jail.
// The child process uses the fixed name jailDocumentURL.
Call LibreOfficeKitDocument::initializeForRendering()
2015-04-10 04:20:42 -05:00
Register for callbacks from the LibreOfficeKit object, too They are used for statgus indicator callbacks while loading a document. (This is a fresh feature in LO master.)
2015-05-06 09:08:44 -05:00
if (LIBREOFFICEKIT_HAS(_loKit, registerCallback))
_loKit->pClass->registerCallback(_loKit, myCallback, this);
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
if ((_loKitDocument = _loKit->pClass->documentLoad(_loKit, jailDocumentURL.c_str())) == NULL)
Now the chroot etc re-work is getting closer to working Works now for the trivial 'connect' test program. Still need to add pre-spawning of a new child process as soon as an existing one from the pool has been taking into use. And need to test with the actual JS client.
2015-04-14 09:50:38 -05:00
{
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
sendTextFrame("error: cmd=load kind=failed");
return false;
Now the chroot etc re-work is getting closer to working Works now for the trivial 'connect' test program. Still need to add pre-spawning of a new child process as soon as an existing one from the pool has been taking into use. And need to test with the actual JS client.
2015-04-14 09:50:38 -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
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
_loKitDocument->pClass->initializeForRendering(_loKitDocument);
if (!getStatus(buffer, length))
return false;
_loKitDocument->pClass->registerCallback(_loKitDocument, myCallback, this);
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
return true;
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
}
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
bool ChildProcessSession::getStatus(const char *buffer, int length)
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
{
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
std::string status = "status: " + LOKitHelper::documentStatus(_loKitDocument);
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
sendTextFrame(status);
return true;
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
}
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
void ChildProcessSession::sendTile(const char *buffer, int length, StringTokenizer& tokens)
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
{
Add a part parameter to the tile messages The JS code always passes in 0 for now. The server parses the parameter and calls LibreOfficeKitDocument::setPart() before calling paintTile(). Probably also the status, key, mouse and selection messages will need a part number. The intent is after all that the protocol is as stateless as possible. (So maybe we should also pass the document URL in each message?)
2015-04-27 13:24:05 -05:00
int part, width, height, tilePosX, tilePosY, tileWidth, tileHeight;
if (tokens.count() != 8 ||
!getTokenInteger(tokens[1], "part", part) ||
!getTokenInteger(tokens[2], "width", width) ||
!getTokenInteger(tokens[3], "height", height) ||
!getTokenInteger(tokens[4], "tileposx", tilePosX) ||
!getTokenInteger(tokens[5], "tileposy", tilePosY) ||
!getTokenInteger(tokens[6], "tilewidth", tileWidth) ||
!getTokenInteger(tokens[7], "tileheight", tileHeight))
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
{
sendTextFrame("error: cmd=tile kind=syntax");
return;
}
Add a part parameter to the tile messages The JS code always passes in 0 for now. The server parses the parameter and calls LibreOfficeKitDocument::setPart() before calling paintTile(). Probably also the status, key, mouse and selection messages will need a part number. The intent is after all that the protocol is as stateless as possible. (So maybe we should also pass the document URL in each message?)
2015-04-27 13:24:05 -05:00
if (part < 0 ||
width <= 0 ||
Check 'tile' parameter validity
2015-03-24 11:59:04 -05:00
height <= 0 ||
tilePosX < 0 ||
tilePosY < 0 ||
tileWidth <= 0 ||
tileHeight <= 0)
{
sendTextFrame("error: cmd=tile kind=invalid");
return;
}
Add first cut at caching of tiles
2015-03-12 09:18:35 -05:00
std::string response = "tile: " + Poco::cat(std::string(" "), tokens.begin() + 1, tokens.end()) + "\n";
std::vector<char> output;
output.reserve(4 * width * height);
output.resize(response.size());
This is C++
2015-04-09 17:25:48 -05:00
std::memcpy(output.data(), response.data(), response.size());
Add first cut at caching of tiles
2015-03-12 09:18: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
unsigned char *pixmap = new unsigned char[4 * width * height];
Add a part parameter to the tile messages The JS code always passes in 0 for now. The server parses the parameter and calls LibreOfficeKitDocument::setPart() before calling paintTile(). Probably also the status, key, mouse and selection messages will need a part number. The intent is after all that the protocol is as stateless as possible. (So maybe we should also pass the document URL in each message?)
2015-04-27 13:24:05 -05:00
_loKitDocument->pClass->setPart(_loKitDocument, part);
paintTile does not take a row stride parameter any more
2015-03-20 06:16:41 -05:00
_loKitDocument->pClass->paintTile(_loKitDocument, pixmap, width, height, tilePosX, tilePosY, tileWidth, tileHeight);
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
Have lokitclient display tiles using ImageMagick's 'display' if available Refactor the PNG encoding of a pixmap out to Util.
2015-03-28 06:53:44 -05:00
if (!Util::encodePNGAndAppendToBuffer(pixmap, width, height, output))
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
{
sendTextFrame("error: cmd=tile kind=failure");
return;
}
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
delete[] pixmap;
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
sendBinaryFrame(output.data(), output.size());
}
Be more consistent in using 'using'
2015-05-29 00:49:49 -05:00
bool ChildProcessSession::keyEvent(const char *buffer, int length, StringTokenizer& tokens)
Add key and mouse event handling, uno command, and selection handling Not "handled" here of course, just pass them on to LibreOfficeKit.
2015-03-19 07:38:04 -05:00
{
int type, charcode, keycode;
if (tokens.count() != 4 ||
Introduce LOLProtocol::getTokenKeyword() and use it The new function takes a map from keywords to integer values, and accepts parameters in the form of either name=keyword, or for backward compatibility, name='keyword'. Use it to parse the type parameter of the key, mouse, selecttext and selectgraphic messages. This restricts the accepted keywords to those actually valid for each message.
2015-04-27 13:09:27 -05:00
!getTokenKeyword(tokens[1], "type",
{{"input", LOK_KEYEVENT_KEYINPUT}, {"up", LOK_KEYEVENT_KEYUP}},
type) ||
Start on load testing Add a new program, loadtest, that runs a requested number of client sessions in parallel to a loolwsd server. A client session loads one of a list of test documents, and does some operations on it. Move the getTokenInteger() and getTokenString() functions out from LOOLSession into a new namespace LOOLProtocol, as they are neeeded also in the loadtest program. Add, also in LOOLProtocol, functions to parse some of the messages from the server. (In general that is done in client JavaScript code, of course; only for testing purposes needed in C++ code.)
2015-03-26 09:49:07 -05:00
!getTokenInteger(tokens[2], "char", charcode) ||
!getTokenInteger(tokens[3], "key", keycode))
Add key and mouse event handling, uno command, and selection handling Not "handled" here of course, just pass them on to LibreOfficeKit.
2015-03-19 07:38:04 -05:00
{
sendTextFrame("error: cmd=key kind=syntax");
return false;
}
_loKitDocument->pClass->postKeyEvent(_loKitDocument, type, charcode, keycode);
return true;
}
Be more consistent in using 'using'
2015-05-29 00:49:49 -05:00
bool ChildProcessSession::mouseEvent(const char *buffer, int length, StringTokenizer& tokens)
Add key and mouse event handling, uno command, and selection handling Not "handled" here of course, just pass them on to LibreOfficeKit.
2015-03-19 07:38:04 -05:00
{
int type, x, y, count;
if (tokens.count() != 5 ||
Introduce LOLProtocol::getTokenKeyword() and use it The new function takes a map from keywords to integer values, and accepts parameters in the form of either name=keyword, or for backward compatibility, name='keyword'. Use it to parse the type parameter of the key, mouse, selecttext and selectgraphic messages. This restricts the accepted keywords to those actually valid for each message.
2015-04-27 13:09:27 -05:00
!getTokenKeyword(tokens[1], "type",
{{"buttondown", LOK_MOUSEEVENT_MOUSEBUTTONDOWN},
{"buttonup", LOK_MOUSEEVENT_MOUSEBUTTONUP},
{"move", LOK_MOUSEEVENT_MOUSEMOVE}},
type) ||
Start on load testing Add a new program, loadtest, that runs a requested number of client sessions in parallel to a loolwsd server. A client session loads one of a list of test documents, and does some operations on it. Move the getTokenInteger() and getTokenString() functions out from LOOLSession into a new namespace LOOLProtocol, as they are neeeded also in the loadtest program. Add, also in LOOLProtocol, functions to parse some of the messages from the server. (In general that is done in client JavaScript code, of course; only for testing purposes needed in C++ code.)
2015-03-26 09:49:07 -05:00
!getTokenInteger(tokens[2], "x", x) ||
!getTokenInteger(tokens[3], "y", y) ||
!getTokenInteger(tokens[4], "count", count))
Add key and mouse event handling, uno command, and selection handling Not "handled" here of course, just pass them on to LibreOfficeKit.
2015-03-19 07:38:04 -05:00
{
sendTextFrame("error: cmd=mouse kind=syntax");
return false;
}
_loKitDocument->pClass->postMouseEvent(_loKitDocument, type, x, y, count);
return true;
}
Be more consistent in using 'using'
2015-05-29 00:49:49 -05:00
bool ChildProcessSession::unoCommand(const char *buffer, int length, StringTokenizer& tokens)
Add key and mouse event handling, uno command, and selection handling Not "handled" here of course, just pass them on to LibreOfficeKit.
2015-03-19 07:38:04 -05:00
{
if (tokens.count() == 1)
{
sendTextFrame("error: cmd=uno kind=syntax");
return false;
}
Adapt to changed LibreOfficeKitDocument::postUnoCommand() API
2015-04-22 13:26:50 -05:00
_loKitDocument->pClass->postUnoCommand(_loKitDocument, tokens[1].c_str(), Poco::cat(std::string(" "), tokens.begin() + 2, tokens.end()).c_str());
Add key and mouse event handling, uno command, and selection handling Not "handled" here of course, just pass them on to LibreOfficeKit.
2015-03-19 07:38:04 -05:00
return true;
}
Be more consistent in using 'using'
2015-05-29 00:49:49 -05:00
bool ChildProcessSession::selectText(const char *buffer, int length, StringTokenizer& tokens)
Add key and mouse event handling, uno command, and selection handling Not "handled" here of course, just pass them on to LibreOfficeKit.
2015-03-19 07:38:04 -05:00
{
int type, x, y;
Start on load testing Add a new program, loadtest, that runs a requested number of client sessions in parallel to a loolwsd server. A client session loads one of a list of test documents, and does some operations on it. Move the getTokenInteger() and getTokenString() functions out from LOOLSession into a new namespace LOOLProtocol, as they are neeeded also in the loadtest program. Add, also in LOOLProtocol, functions to parse some of the messages from the server. (In general that is done in client JavaScript code, of course; only for testing purposes needed in C++ code.)
2015-03-26 09:49:07 -05:00
if (tokens.count() != 4 ||
Introduce LOLProtocol::getTokenKeyword() and use it The new function takes a map from keywords to integer values, and accepts parameters in the form of either name=keyword, or for backward compatibility, name='keyword'. Use it to parse the type parameter of the key, mouse, selecttext and selectgraphic messages. This restricts the accepted keywords to those actually valid for each message.
2015-04-27 13:09:27 -05:00
!getTokenKeyword(tokens[1], "type",
{{"start", LOK_SETTEXTSELECTION_START},
{"end", LOK_SETTEXTSELECTION_END},
{"reset", LOK_SETTEXTSELECTION_RESET}},
type) ||
Start on load testing Add a new program, loadtest, that runs a requested number of client sessions in parallel to a loolwsd server. A client session loads one of a list of test documents, and does some operations on it. Move the getTokenInteger() and getTokenString() functions out from LOOLSession into a new namespace LOOLProtocol, as they are neeeded also in the loadtest program. Add, also in LOOLProtocol, functions to parse some of the messages from the server. (In general that is done in client JavaScript code, of course; only for testing purposes needed in C++ code.)
2015-03-26 09:49:07 -05:00
!getTokenInteger(tokens[2], "x", x) ||
!getTokenInteger(tokens[3], "y", y))
Add key and mouse event handling, uno command, and selection handling Not "handled" here of course, just pass them on to LibreOfficeKit.
2015-03-19 07:38:04 -05:00
{
sendTextFrame("error: cmd=selecttext kind=syntax");
return false;
}
_loKitDocument->pClass->setTextSelection(_loKitDocument, type, x, y);
return true;
}
Be more consistent in using 'using'
2015-05-29 00:49:49 -05:00
bool ChildProcessSession::selectGraphic(const char *buffer, int length, StringTokenizer& tokens)
Add key and mouse event handling, uno command, and selection handling Not "handled" here of course, just pass them on to LibreOfficeKit.
2015-03-19 07:38:04 -05:00
{
int type, x, y;
if (tokens.count() != 4 ||
Introduce LOLProtocol::getTokenKeyword() and use it The new function takes a map from keywords to integer values, and accepts parameters in the form of either name=keyword, or for backward compatibility, name='keyword'. Use it to parse the type parameter of the key, mouse, selecttext and selectgraphic messages. This restricts the accepted keywords to those actually valid for each message.
2015-04-27 13:09:27 -05:00
!getTokenKeyword(tokens[1], "type",
{{"start", LOK_SETGRAPHICSELECTION_START},
{"end", LOK_SETGRAPHICSELECTION_END}},
type) ||
Start on load testing Add a new program, loadtest, that runs a requested number of client sessions in parallel to a loolwsd server. A client session loads one of a list of test documents, and does some operations on it. Move the getTokenInteger() and getTokenString() functions out from LOOLSession into a new namespace LOOLProtocol, as they are neeeded also in the loadtest program. Add, also in LOOLProtocol, functions to parse some of the messages from the server. (In general that is done in client JavaScript code, of course; only for testing purposes needed in C++ code.)
2015-03-26 09:49:07 -05:00
!getTokenInteger(tokens[2], "x", x) ||
!getTokenInteger(tokens[3], "y", y))
Add key and mouse event handling, uno command, and selection handling Not "handled" here of course, just pass them on to LibreOfficeKit.
2015-03-19 07:38:04 -05:00
{
sendTextFrame("error: cmd=selectghraphic kind=syntax");
return false;
}
_loKitDocument->pClass->setGraphicSelection(_loKitDocument, type, x, y);
return true;
}
Be more consistent in using 'using'
2015-05-29 00:49:49 -05:00
bool ChildProcessSession::resetSelection(const char *buffer, int length, StringTokenizer& tokens)
Add key and mouse event handling, uno command, and selection handling Not "handled" here of course, just pass them on to LibreOfficeKit.
2015-03-19 07:38:04 -05:00
{
Obviously need to handle input events etc in the child process I need to re-factor this stuff, too much copypasta.
2015-03-20 07:56:37 -05:00
if (tokens.count() != 1)
{
sendTextFrame("error: cmd=resetselection kind=syntax");
return false;
}
Add key and mouse event handling, uno command, and selection handling Not "handled" here of course, just pass them on to LibreOfficeKit.
2015-03-19 07:38:04 -05:00
_loKitDocument->pClass->resetSelection(_loKitDocument);
Obviously need to handle input events etc in the child process I need to re-factor this stuff, too much copypasta.
2015-03-20 07:56:37 -05:00
return true;
Add key and mouse event handling, uno command, and selection handling Not "handled" here of course, just pass them on to LibreOfficeKit.
2015-03-19 07:38:04 -05:00
}
Be more consistent in using 'using'
2015-05-29 00:49:49 -05:00
bool ChildProcessSession::saveAs(const char *buffer, int length, StringTokenizer& tokens)
Add 'saveas'
2015-03-23 15:13:57 -05:00
{
std::string url, format, filterOptions;
if (tokens.count() < 4 ||
!getTokenString(tokens[1], "url", url) ||
!getTokenString(tokens[2], "format", format) ||
!getTokenString(tokens[3], "options", filterOptions))
{
sendTextFrame("error: cmd=saveas kind=syntax");
return false;
}
URI::decode(url, url, true);
URI::decode(format, format, true);
if (tokens.count() > 4)
filterOptions += Poco::cat(std::string(" "), tokens.begin() + 4, tokens.end());
_loKitDocument->pClass->saveAs(_loKitDocument, url.c_str(), format.c_str(), filterOptions.c_str());
return true;
}
Initial commit of loolwsd See loolwsd/README for some notes.
2015-03-04 17:14:04 -06:00
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue Copy permalink