vanja/yabridge
1
0
Fork 0
mirror of https://github.com/robbert-vdh/yabridge.git synced 2026-05-08 04:20:13 +02:00
Code Issues Packages Projects Releases Wiki Activity

Encapsulate individual/group handling differences

Browse Source 
This cleans up the PluginBridge significantly by getting rid of all
fields and handling that was only needed for connecting to plugin
groups. This was also the last thing I wanted to refactor before
releasing the plugin groups feature with yabridge 1.2.
This commit is contained in:
Robbert van der Helm
2020-05-29 18:08:44 +02:00
parent d462421490
commit b379708b21
6 changed files with 493 additions and 274 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/plugin/host-process.cpp
+254
View File
@@ -0,0 +1,254 @@
// yabridge: a Wine VST bridge
// Copyright (C) 2020 Robbert van der Helm
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
#include "host-process.h"
#include <boost/asio/read_until.hpp>
#include <boost/process/env.hpp>
#include <boost/process/io.hpp>
#include <boost/process/start_dir.hpp>
#include "../common/communication.h"
namespace bp = boost::process;
namespace fs = boost::filesystem;
/**
* Simple helper function around `boost::process::child` that launches the host
* application (`*.exe`) wrapped in winedbg if compiling with
* `-Duse-winedbg=true`. Keep in mind that winedbg does not handle arguments
* containing spaces, so most Windows paths will be split up into multiple
* arugments.
*/
template <typename... Args>
bp::child launch_host(fs::path host_path, Args&&... args) {
return bp::child(
#ifdef USE_WINEDBG
// This is set up for KDE Plasma. Other desktop environments and
// window managers require some slight modifications to spawn a
// detached terminal emulator.
"/usr/bin/kstart5", "konsole", "--", "-e", "winedbg", "--gdb",
host_path.string() + ".so",
#else
host_path,
#endif
std::forward<Args>(args)...);
}
HostProcess::HostProcess(boost::asio::io_context& io_context, Logger& logger)
: stdout_pipe(io_context), stderr_pipe(io_context), logger(logger) {
// Print the Wine host's STDOUT and STDERR streams to the log file. This
// should be done before trying to accept the sockets as otherwise we will
// miss all output.
async_log_pipe_lines(stdout_pipe, stdout_buffer, "[Wine STDOUT] ");
async_log_pipe_lines(stderr_pipe, stderr_buffer, "[Wine STDERR] ");
}
void HostProcess::async_log_pipe_lines(patched_async_pipe& pipe,
boost::asio::streambuf& buffer,
std::string prefix) {
boost::asio::async_read_until(
pipe, buffer, '\n',
[&, prefix](const boost::system::error_code& error, size_t) {
// When we get an error code then that likely means that the pipe
// has been clsoed and we have reached the end of the file
if (error.failed()) {
return;
}
std::string line;
std::getline(std::istream(&buffer), line);
logger.log(prefix + line);
async_log_pipe_lines(pipe, buffer, prefix);
});
}
IndividualHost::IndividualHost(boost::asio::io_context& io_context,
Logger& logger,
fs::path plugin_path,
fs::path socket_endpoint)
: HostProcess(io_context, logger),
plugin_arch(find_vst_architecture(plugin_path)),
host_path(find_vst_host(plugin_arch, false)),
host(launch_host(host_path,
#ifdef USE_WINEDBG
plugin_path.filename(),
#else
plugin_path,
#endif
socket_endpoint,
bp::env = set_wineprefix(),
bp::std_out = stdout_pipe,
bp::std_err = stderr_pipe
#ifdef USE_WINEDBG
, // winedbg has no reliable way to escape spaces, so
// we'll start the process in the plugin's directory
bp::start_dir = plugin_path.parent_path()
#endif
)) {
#ifdef USE_WINEDBG
if (plugin_path.string().find(' ') != std::string::npos) {
logger.log("Warning: winedbg does not support paths containing spaces");
}
#endif
}
PluginArchitecture IndividualHost::architecture() {
return plugin_arch;
}
fs::path IndividualHost::path() {
return host_path;
}
bool IndividualHost::running() {
return host.running();
}
void IndividualHost::terminate() {
host.terminate();
host.wait();
}
GroupHost::GroupHost(
boost::asio::io_context& io_context,
Logger& logger,
fs::path plugin_path,
fs::path socket_endpoint,
std::string group_name,
boost::asio::local::stream_protocol::socket& host_vst_dispatch)
: HostProcess(io_context, logger),
plugin_arch(find_vst_architecture(plugin_path)),
host_path(find_vst_host(plugin_arch, true)),
host_vst_dispatch(host_vst_dispatch) {
#ifdef USE_WINEDBG
if (plugin_path.string().find(' ') != std::string::npos) {
logger.log("Warning: winedbg does not support paths containing spaces");
}
#endif
// When using plugin groups, we'll first try to connect to an existing group
// host process and ask it to host our plugin. If no such process exists,
// then we'll start a new process. In the event that two yabridge instances
// simultaneously try to start a new group process for the same group, then
// the last process to connect to the socket will terminate gracefully and
// the first process will handle the connections for both yabridge
// instances.
const bp::environment host_env = set_wineprefix();
fs::path wine_prefix = host_env.at("WINEPREFIX").to_string();
if (host_env.at("WINEPREFIX").empty()) {
// Fall back to `~/.wine` if this has not been set or detected. This
// would happen if the plugin's .dll file is not inside of a Wine
// prefix. If this happens, then the Wine instance will be launched in
// the default Wine prefix, so we should reflect that here.
wine_prefix = fs::path(host_env.at("HOME").to_string()) / ".wine";
}
const fs::path group_socket_path =
generate_group_endpoint(group_name, wine_prefix, plugin_arch);
try {
// Request the existing group host process to host our plugin, and store
// the PID of that process so we'll know if it has crashed
boost::asio::local::stream_protocol::socket group_socket(io_context);
group_socket.connect(group_socket_path.string());
write_object(group_socket, GroupRequest{plugin_path.string(),
socket_endpoint.string()});
const auto response = read_object<GroupResponse>(group_socket);
host_pid = response.pid;
} catch (const boost::system::system_error&) {
// In case we could not connect to the socket, then we'll start a
// new group host process. This process is detached immediately
// because it should run independently of this yabridge instance as
// it will likely outlive it.
bp::child group_host =
launch_host(host_path, group_socket_path, bp::env = host_env,
bp::std_out = stdout_pipe, bp::std_err = stderr_pipe);
host_pid = group_host.id();
group_host.detach();
// We now want to connect to the socket the in the exact same way as
// above. The only problem is that it may take some time for the
// process to start depending on Wine's current state. We'll defer
// this to a thread so we can finish the rest of the startup in the
// meantime.
group_host_connect_handler = std::thread([&, group_socket_path,
plugin_path,
socket_endpoint]() {
using namespace std::literals::chrono_literals;
// TODO: Replace this polling with inotify
while (running()) {
std::this_thread::sleep_for(20ms);
try {
// This is the exact same connection sequence as above
boost::asio::local::stream_protocol::socket group_socket(
io_context);
group_socket.connect(group_socket_path.string());
write_object(group_socket,
GroupRequest{plugin_path.string(),
socket_endpoint.string()});
const auto response =
read_object<GroupResponse>(group_socket);
// If two group processes started at the same time, than the
// first one will be the one to respond to the host request
host_pid = response.pid;
return;
} catch (const boost::system::system_error&) {
// Keep trying to connect until either connection gets
// accepted or the group host crashes
}
}
});
}
}
GroupHost::~GroupHost() {
// This thread was briefly used to issue the host request if we had to start
// a new group host process
if (group_host_connect_handler.joinable()) {
group_host_connect_handler.join();
}
}
PluginArchitecture GroupHost::architecture() {
return plugin_arch;
}
fs::path GroupHost::path() {
return host_path;
}
bool GroupHost::running() {
// With regular individually hosted plugins we can simply check whether the
// process is still running, however Boost.Process does not allow you to do
// the same thing for a process that's not a direct child if this process.
// When using plugin groups we'll have to manually check whether the PID
// returned by the group host process is still active.
return kill(host_pid, 0) == 0;
}
void GroupHost::terminate() {
// There's no need to manually terminate group host processes as they will
// shut down automatically after all plugins have exited. Manually closing
// the dispatch socket will cause the associated plugin to exit.
host_vst_dispatch.close();
}