received LyX will inform the client that it's listening its
messages, and 'bye' will inform that lyx is closing.
- See development/server_monitor.c for an example client.
+ See development/lyxserver/server_monitor.cpp for an example client.
Purpose: implement a client/server lib for LyX
*/
#include "DispatchResult.h"
#include "FuncRequest.h"
+#include "LyX.h"
#include "LyXAction.h"
-#include "LyXFunc.h"
#include "frontends/Application.h"
#include "support/debug.h"
#include "support/FileName.h"
+#include "support/filetools.h"
#include "support/lassert.h"
#include "support/lstrings.h"
#include "support/os.h"
+#include "support/signals.h"
-#include <boost/bind.hpp>
+#include <iostream>
#ifdef _WIN32
+#include <io.h>
#include <QCoreApplication>
#endif
+#include <QThread>
#include <cerrno>
#ifdef HAVE_SYS_STAT_H
return message;
}
-} // namespace anon
+} // namespace
DWORD WINAPI pipeServerWrapper(void * arg)
LyXComm::LyXComm(string const & pip, Server * cli, ClientCallbackfct ccb)
- : pipename_(pip), client_(cli), clientcb_(ccb), stopserver_(0)
+ : stopserver_(0),
+ ready_(false), pipename_(pip), client_(cli), clientcb_(ccb),
+ deferred_loading_(false)
{
for (int i = 0; i < MAX_PIPES; ++i) {
event_[i] = 0;
pipe_[i].handle = INVALID_HANDLE_VALUE;
}
- ready_ = false;
openConnection();
}
// Determine which pipe instance completed the operation.
i = wait - WAIT_OBJECT_0;
- LASSERT(i >= 0 && i <= MAX_PIPES, /**/);
+ LASSERT(i <= MAX_PIPES, /**/);
// Check whether we were waked up for stopping the pipe server.
if (i == MAX_PIPES)
return;
}
- // Check whether the pipe name is being used by some other program.
+ // Check whether the pipe name is being used by some other instance.
if (!stopserver_ && WaitNamedPipe(inPipeName().c_str(), 0)) {
+ // Tell the running instance to load the files
+ if (run_mode == USE_REMOTE && loadFilesInOtherInstance()) {
+ deferred_loading_ = true;
+ pipename_.erase();
+ return;
+ }
lyxerr << "LyXComm: Pipe " << external_path(inPipeName())
<< " already exists.\nMaybe another instance of LyX"
" is using it." << endl;
LyXComm::LyXComm(string const &, Server *, ClientCallbackfct)
{}
+
void LyXComm::openConnection()
{}
void LyXComm::emergencyCleanup()
{}
+
void LyXComm::read_ready()
{}
#else // defined (HAVE_MKFIFO)
-
LyXComm::LyXComm(string const & pip, Server * cli, ClientCallbackfct ccb)
- : pipename_(pip), client_(cli), clientcb_(ccb)
+ : infd_(-1), outfd_(-1),
+ ready_(false), pipename_(pip), client_(cli), clientcb_(ccb),
+ deferred_loading_(false)
{
- ready_ = false;
openConnection();
}
if (fd >= 0) {
// Another LyX instance is using it.
::close(fd);
+ // Tell the running instance to load the files
+ if (run_mode == USE_REMOTE && loadFilesInOtherInstance()) {
+ deferred_loading_ = true;
+ pipename_.erase();
+ return -1;
+ }
} else if (errno == ENXIO) {
// No process is reading from the other end.
stalepipe = true;
}
if (!write) {
- theApp()->registerSocketCallback(fd,
- boost::bind(&LyXComm::read_ready, this));
+ // Make sure not to call read_ready after destruction.
+ weak_ptr<void> tracker = tracker_.p();
+ theApp()->registerSocketCallback(fd, [=](){
+ if (!tracker.expired())
+ read_ready();
+ });
}
return fd;
<< '\n' << strerror(errno) << endl;
}
- if (FileName(filename).removeFile() < 0) {
+ if (!FileName(filename).removeFile()) {
lyxerr << "LyXComm: Could not remove pipe " << filename
<< '\n' << strerror(errno) << endl;
}
int status;
// the single = is intended here.
while ((status = ::read(infd_, charbuf, charbuf_size - 1))) {
-
if (status > 0) {
charbuf[status] = '\0'; // turn it into a c string
read_buffer_ += rtrim(charbuf, "\r");
LYXERR(Debug::LYXSERVER, "LyXComm: Sending '" << msg << '\'');
- if (pipename_.empty()) return;
+ if (pipename_.empty())
+ return;
if (!ready_) {
LYXERR0("LyXComm: Pipes are closed. Could not send " << msg);
#endif // defined (HAVE_MKFIFO)
+namespace {
+
+struct Sleep : QThread
+{
+ static void millisec(unsigned long ms)
+ {
+ QThread::usleep(ms * 1000);
+ }
+};
+
+} // namespace
+
+
+bool LyXComm::loadFilesInOtherInstance()
+{
+ int pipefd;
+ int loaded_files = 0;
+ FileName const pipe(inPipeName());
+ vector<string>::iterator it = theFilesToLoad().begin();
+ while (it != theFilesToLoad().end()) {
+ FileName fname = fileSearch(string(), os::internal_path(*it),
+ "lyx", may_not_exist);
+ if (fname.empty()) {
+ ++it;
+ continue;
+ }
+ // Wait a while to allow time for the other
+ // instance to reset the connection
+ Sleep::millisec(200);
+ pipefd = ::open(pipe.toFilesystemEncoding().c_str(), O_WRONLY);
+ if (pipefd < 0)
+ break;
+ string const cmd = "LYXCMD:pipe:file-open:" +
+ fname.absFileName() + '\n';
+ if (::write(pipefd, cmd.c_str(), cmd.length()) < 0)
+ LYXERR0("Cannot write to pipe!");
+ ::close(pipefd);
+ ++loaded_files;
+ it = theFilesToLoad().erase(it);
+ }
+ return loaded_files > 0;
+}
+
string const LyXComm::inPipeName() const
{
server->callback(msg);
}
-Server::Server(LyXFunc * f, string const & pipes)
- : numclients_(0), func_(f), pipes_(pipes, this, &ServerCallback)
+Server::Server(string const & pipes)
+ : numclients_(0), pipes_(pipes, this, &ServerCallback)
{}
int compare(char const * a, char const * b, unsigned int len)
{
- using namespace std;
return strncmp(a, b, len);
}
<< client << " said goodbye");
} else {
LYXERR(Debug::LYXSERVER,
- "Server: ignoring bye messge from unregistered client" << client);
+ "Server: ignoring bye message from unregistered client" << client);
}
} else {
LYXERR0("Server: Undefined server command " << cmd << '.');
// The correct solution would be to have a
// specialized (non-gui) BufferView. But how do
// we do it now? Probably we should just let it
- // connect to the lyxfunc in the single LyXView we
+ // connect to the lyxfunc in the single GuiView we
// support currently. (Lgb)
- FuncRequest const fr(lyxaction.lookupFunc(cmd), arg);
+ FuncRequest fr(lyxaction.lookupFunc(cmd), from_ascii(arg));
+ fr.setOrigin(FuncRequest::LYXSERVER);
DispatchResult dr;
- func_->dispatch(fr, dr);
+ theApp()->dispatch(fr, dr);
string const rval = to_utf8(dr.message());
// all commands produce an INFO or ERROR message