Allow multiple servers in the same network (#900)

Co-authored-by: Erimel <[email protected]>
This commit is contained in:
UrielandErimel authored and GitHub committed 2024-03-14 21:42:49 -03:00
1 parent a8557474cb
commit f402b22d74
14 files changed
+367 -13

No files matched your search

@@ -15,6 +15,7 @@ import dev.slimevr.reset.ResetHandler
import dev.slimevr.serial.ProvisioningHandler
import dev.slimevr.serial.SerialHandler
import dev.slimevr.serial.SerialHandlerStub
import dev.slimevr.setup.HandshakeHandler
import dev.slimevr.setup.TapSetupHandler
import dev.slimevr.status.StatusSystem
import dev.slimevr.tracking.processor.HumanPoseManager
@@ -48,7 +49,6 @@ class VRServer @JvmOverloads constructor(
driverBridgeProvider: SteamBridgeProvider = { _, _ -> null },
feederBridgeProvider: (VRServer) -> ISteamVRBridge? = { _ -> null },
serialHandlerProvider: (VRServer) -> SerialHandler = { _ -> SerialHandlerStub() },
// configPath is used by VRWorkout, do not remove!
configPath: String,
) : Thread("VRServer") {
@JvmField
@@ -97,6 +97,9 @@ class VRServer @JvmOverloads constructor(
@JvmField
val statusSystem = StatusSystem()
@JvmField
val handshakeHandler = HandshakeHandler()
init {
// UwU
configManager = ConfigManager(configPath)
@@ -8,6 +8,7 @@ import dev.slimevr.tracking.trackers.TrackerPosition;
import io.eiren.util.logging.LogManager;
import java.util.Map;
import java.util.regex.Pattern;
public class CurrentVRConfigConverter implements VersionedModelConverter {
@@ -285,6 +286,24 @@ public class CurrentVRConfigConverter implements VersionedModelConverter {
}
}
}
if (version < 13) {
ObjectNode oldTrackersNode = (ObjectNode) modelData.get("trackers");
if (oldTrackersNode != null) {
var fieldNamesIter = oldTrackersNode.fieldNames();
String trackerId;
final String macAddressRegex = "udp://((?:[a-zA-Z\\d]{2}:){5}[a-zA-Z\\d]{2})/0";
final Pattern pattern = Pattern.compile(macAddressRegex);
while (fieldNamesIter.hasNext()) {
trackerId = fieldNamesIter.next();
var matcher = pattern.matcher(trackerId);
if (!matcher.find())
continue;
modelData.withArray("knownDevices").add(matcher.group(1));
}
}
}
} catch (Exception e) {
LogManager.severe("Error during config migration: " + e);
}
@@ -10,11 +10,13 @@ import dev.slimevr.tracking.trackers.Tracker;
import dev.slimevr.tracking.trackers.TrackerRole;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
@JsonVersionedModel(
currentVersion = "12", defaultDeserializeToVersion = "12", toCurrentConverterClass = CurrentVRConfigConverter.class
currentVersion = "13", defaultDeserializeToVersion = "13", toCurrentConverterClass = CurrentVRConfigConverter.class
)
public class VRConfig {
@@ -50,6 +52,8 @@ public class VRConfig {
@JsonSerialize(keyUsing = StdKeySerializers.StringKeySerializer.class)
private final Map<String, BridgeConfig> bridges = new HashMap<>();
private final Set<String> knownDevices = new HashSet<>();
private final OverlayConfig overlay = new OverlayConfig();
public VRConfig() {
@@ -142,6 +146,14 @@ public class VRConfig {
return overlay;
}
public Set<String> getKnownDevices() {
return knownDevices;
}
public boolean hasTrackerByName(String name) {
return trackers.containsKey(name);
}
public TrackerConfig getTracker(Tracker tracker) {
TrackerConfig config = trackers.get(tracker.getName());
if (config == null) {
@@ -181,5 +193,17 @@ public class VRConfig {
}
return config;
}
public boolean isKnownDevice(String mac) {
return knownDevices.contains(mac);
}
public boolean addKnownDevice(String mac) {
return knownDevices.add(mac);
}
public boolean forgetKnownDevice(String mac) {
return knownDevices.remove(mac);
}
}
@@ -11,6 +11,7 @@ import dev.slimevr.protocol.rpc.reset.RPCResetHandler;
import dev.slimevr.protocol.rpc.serial.RPCProvisioningHandler;
import dev.slimevr.protocol.rpc.serial.RPCSerialHandler;
import dev.slimevr.protocol.rpc.settings.RPCSettingsHandler;
import dev.slimevr.protocol.rpc.setup.RPCHandshakeHandler;
import dev.slimevr.protocol.rpc.setup.RPCTapSetupHandler;
import dev.slimevr.protocol.rpc.setup.RPCUtil;
import dev.slimevr.protocol.rpc.status.RPCStatusHandler;
@@ -47,6 +48,7 @@ public class RPCHandler extends ProtocolHandler<RpcMessageHeader> {
new RPCTapSetupHandler(this, api);
new RPCStatusHandler(this, api);
new RPCAutoBoneHandler(this, api);
new RPCHandshakeHandler(this, api);
new RPCTrackingPause(this, api);
registerPacketListener(RpcMessage.ResetRequest, this::onResetRequest);
@@ -0,0 +1,86 @@
package dev.slimevr.protocol.rpc.setup
import com.google.flatbuffers.FlatBufferBuilder
import dev.slimevr.protocol.GenericConnection
import dev.slimevr.protocol.ProtocolAPI
import dev.slimevr.protocol.rpc.RPCHandler
import dev.slimevr.setup.HandshakeListener
import dev.slimevr.tracking.trackers.udp.UDPDevice
import solarxr_protocol.rpc.AddUnknownDeviceRequest
import solarxr_protocol.rpc.ForgetDeviceRequest
import solarxr_protocol.rpc.RpcMessage
import solarxr_protocol.rpc.RpcMessageHeader
import solarxr_protocol.rpc.UnknownDeviceHandshakeNotification
class RPCHandshakeHandler(
private val rpcHandler: RPCHandler,
val api: ProtocolAPI,
) : HandshakeListener {
init {
rpcHandler.registerPacketListener(
RpcMessage.AddUnknownDeviceRequest,
::onAddUnknownDevice,
)
rpcHandler.registerPacketListener(
RpcMessage.ForgetDeviceRequest,
::onForgetDevice,
)
this.api.server.handshakeHandler.addListener(this)
}
override fun onUnknownHandshake(macAddress: String) {
val fbb = FlatBufferBuilder(32)
val string = fbb.createString(macAddress)
val update =
UnknownDeviceHandshakeNotification.createUnknownDeviceHandshakeNotification(
fbb,
string,
)
val outbound = rpcHandler.createRPCMessage(
fbb,
RpcMessage.UnknownDeviceHandshakeNotification,
update,
)
fbb.finish(outbound)
api.apiServers.forEach { apiServer ->
apiServer.apiConnections.forEach {
it.send(fbb.dataBuffer())
}
}
}
fun onAddUnknownDevice(
conn: GenericConnection,
messageHeader: RpcMessageHeader,
) {
val req =
messageHeader.message(AddUnknownDeviceRequest()) as AddUnknownDeviceRequest?
?: return
this.api.server.configManager.vrConfig.addKnownDevice(
req.macAddress() ?: return,
)
this.api.server.configManager.saveConfig()
}
fun onForgetDevice(
conn: GenericConnection,
messageHeader: RpcMessageHeader,
) {
val req = messageHeader.message(ForgetDeviceRequest()) as ForgetDeviceRequest?
?: return
this.api.server.configManager.vrConfig.forgetKnownDevice(
req.macAddress() ?: return,
)
val device =
this.api.server.deviceManager.devices.find { it.hardwareIdentifier == req.macAddress() }
if (device != null && device is UDPDevice) {
this.api.server.trackersServer.disconnectDevice(device)
}
this.api.server.configManager.saveConfig()
}
}
@@ -0,0 +1,23 @@
package dev.slimevr.setup
import java.util.concurrent.CopyOnWriteArrayList
class HandshakeHandler {
private val listeners: MutableList<HandshakeListener> = CopyOnWriteArrayList()
fun addListener(listener: HandshakeListener) {
listeners.add(listener)
}
fun removeListener(listener: HandshakeListener) {
listeners.remove(listener)
}
fun sendUnknownHandshake(macAddress: String) {
listeners.forEach { it.onUnknownHandshake(macAddress) }
}
}
interface HandshakeListener {
fun onUnknownHandshake(macAddress: String)
}
@@ -58,6 +58,15 @@ class TrackersUDPServer(private val port: Int, name: String, private val tracker
val addr = handshakePacket.address
val socketAddr = handshakePacket.socketAddress
// Check if it's a known device
VRServer.instance.configManager.vrConfig.let { vrConfig ->
if (vrConfig.isKnownDevice(handshake.macString)) return@let
val mac = handshake.macString ?: return@let
VRServer.instance.handshakeHandler.sendUnknownHandshake(mac)
return
}
// Get a connection either by an existing one, or by creating a new one
val connection: UDPDevice = synchronized(connections) {
connectionsByMAC[handshake.macString]?.apply {
@@ -108,6 +117,7 @@ class TrackersUDPServer(private val port: Int, name: String, private val tracker
}
} ?: run {
// No existing connection could be found, create a new one
val connection = UDPDevice(
socketAddr,
addr,
@@ -456,6 +466,25 @@ class TrackersUDPServer(private val port: Int, name: String, private val tracker
fun getConnections(): List<UDPDevice?> = connections
// FIXME: for some reason it ends up disconnecting after 30 seconds have passed instead of immediately
fun disconnectDevice(device: UDPDevice) {
synchronized(connections) {
connections.remove(device)
}
synchronized(connectionsByAddress) {
connectionsByAddress.filter { (_, dev) -> dev.id == device.id }.keys.forEach(
connectionsByAddress::remove,
)
}
device.trackers.forEach { (_, tracker) ->
tracker.status = TrackerStatus.DISCONNECTED
}
LogManager.info(
"[TrackerServer] Forcefully disconnected ${device.hardwareIdentifier} device.",
)
}
companion object {
/**
* Change between IMU axes and OpenGL/SteamVR axes