Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-19 00:41:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

[sim] WebSockets: don't override HAL_Main

Browse Source 
Also clean up some other implementation aspects for cleaner shutdown and
reduce peak memory allocation.
This commit is contained in:
Peter Johnson
2020-09-04 10:57:05 -07:00
parent f1b1bdb121
commit f86a5f9b09
19 changed files with 780 additions and 851 deletions
Download Patch File Download Diff File Expand all files Collapse all files

175
simulation/halsim_ws_client/src/main/native/cpp/HALSimWS.cpp Normal file
View File

@@ -0,0 +1,175 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2020 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
/*----------------------------------------------------------------------------*/
#include "HALSimWS.h"
#include <wpi/SmallString.h>
#include <wpi/raw_ostream.h>
#include <wpi/uv/util.h>
#include "HALSimWSClientConnection.h"
static constexpr int kTcpConnectAttemptTimeout = 1000;
namespace uv = wpi::uv;
using namespace wpilibws;
HALSimWS::HALSimWS(wpi::uv::Loop& loop, ProviderContainer& providers,
HALSimWSProviderSimDevices& simDevicesProvider)
: m_loop(loop),
m_providers(providers),
m_simDevicesProvider(simDevicesProvider) {
m_loop.error.connect([](uv::Error err) {
wpi::errs() << "HALSim WS Client libuv Error: " << err.str() << "\n";
});
m_tcp_client = uv::Tcp::Create(m_loop);
m_exec = UvExecFunc::Create(m_loop);
if (m_exec) {
m_exec->wakeup.connect([](auto func) { func(); });
}
m_connect_timer = uv::Timer::Create(m_loop);
}
bool HALSimWS::Initialize() {
if (!m_tcp_client || !m_exec || !m_connect_timer) {
return false;
}
const char* host = std::getenv("HALSIMWS_HOST");
if (host != NULL) {
m_host = host;
} else {
m_host = "localhost";
}
const char* port = std::getenv("HALSIMWS_PORT");
if (port != NULL) {
try {
m_port = std::stoi(port);
} catch (const std::invalid_argument& err) {
wpi::errs() << "Error decoding HALSIMWS_PORT (" << err.what() << ")\n";
return false;
}
} else {
m_port = 8080;
}
const char* uri = std::getenv("HALSIMWS_URI");
if (uri != NULL) {
m_uri = uri;
} else {
m_uri = "/wpilibws";
}
return true;
}
void HALSimWS::Start() {
m_tcp_client->SetNoDelay(true);
// Hook up TCP client events
m_tcp_client->error.connect(
[this, socket = m_tcp_client.get()](wpi::uv::Error err) {
if (m_tcp_connected) {
m_tcp_connected = false;
m_connect_attempts = 0;
return;
}
// If we weren't previously connected, attempt a reconnection
m_connect_timer->Start(uv::Timer::Time(kTcpConnectAttemptTimeout));
});
m_tcp_client->closed.connect(
[]() { wpi::outs() << "TCP connection closed\n"; });
// Set up the connection timer
wpi::outs() << "HALSimWS Initialized\n";
wpi::outs() << "Will attempt to connect to ws://" << m_host << ":" << m_port
<< m_uri << "\n";
// Set up the timer to attempt connection
m_connect_timer->timeout.connect([this] { AttemptConnect(); });
// Run the initial connect immediately
m_connect_timer->Start(uv::Timer::Time(0));
m_connect_timer->Unreference();
}
void HALSimWS::AttemptConnect() {
m_connect_attempts++;
wpi::outs() << "Connection Attempt " << m_connect_attempts << "\n";
struct sockaddr_in dest;
uv::NameToAddr(m_host, m_port, &dest);
m_tcp_client->Connect(dest, [this, socket = m_tcp_client.get()]() {
m_tcp_connected = true;
auto wsConn = std::make_shared<HALSimWSClientConnection>(shared_from_this(),
m_tcp_client);
wsConn->Initialize();
});
}
bool HALSimWS::RegisterWebsocket(
std::shared_ptr<HALSimBaseWebSocketConnection> hws) {
if (m_hws.lock()) {
return false;
}
m_hws = hws;
m_simDevicesProvider.OnNetworkConnected(hws);
m_providers.ForEach([hws](std::shared_ptr<HALSimWSBaseProvider> provider) {
provider->OnNetworkConnected(hws);
});
return true;
}
void HALSimWS::CloseWebsocket(
std::shared_ptr<HALSimBaseWebSocketConnection> hws) {
// Inform the providers that they need to cancel callbacks
m_simDevicesProvider.OnNetworkDisconnected();
m_providers.ForEach([](std::shared_ptr<HALSimWSBaseProvider> provider) {
provider->OnNetworkDisconnected();
});
if (hws == m_hws.lock()) {
m_hws.reset();
}
}
void HALSimWS::OnNetValueChanged(const wpi::json& msg) {
// Look for "type" and "device" fields so that we can
// generate the key
try {
auto& type = msg.at("type").get_ref<const std::string&>();
auto& device = msg.at("device").get_ref<const std::string&>();
wpi::SmallString<64> key;
key.append(type);
if (!device.empty()) {
key.append("/");
key.append(device);
}
auto provider = m_providers.Get(key.str());
if (provider) {
provider->OnNetValueChanged(msg.at("data"));
}
} catch (wpi::json::exception& e) {
wpi::errs() << "Error with incoming message: " << e.what() << "\n";
}
}

222
simulation/halsim_ws_client/src/main/native/cpp/HALSimWSClient.cpp
View File

@@ -7,190 +7,50 @@
#include "HALSimWSClient.h"
#include <wpi/SmallString.h>
#include <wpi/raw_ostream.h>
#include <wpi/uv/util.h>
#include <WSProviderContainer.h>
#include <WSProvider_Analog.h>
#include <WSProvider_DIO.h>
#include <WSProvider_DriverStation.h>
#include <WSProvider_Encoder.h>
#include <WSProvider_Joystick.h>
#include <WSProvider_PWM.h>
#include <WSProvider_Relay.h>
#include <WSProvider_RoboRIO.h>
#include <WSProvider_SimDevice.h>
#include <WSProvider_dPWM.h>
#include <wpi/EventLoopRunner.h>
#include "HALSimWSClientConnection.h"
using namespace wpilibws;
static constexpr int kTcpConnectAttemptTimeout = 1000;
bool HALSimWSClient::Initialize() {
bool result = true;
runner.ExecSync([&](wpi::uv::Loop& loop) {
simws = std::make_shared<HALSimWS>(loop, providers, simDevices);
namespace uv = wpi::uv;
namespace wpilibws {
std::shared_ptr<HALSimWS> HALSimWS::g_instance;
bool HALSimWS::Initialize() {
const char* host = std::getenv("HALSIMWS_HOST");
if (host != NULL) {
m_host = host;
} else {
m_host = "localhost";
}
const char* port = std::getenv("HALSIMWS_PORT");
if (port != NULL) {
try {
m_port = std::stoi(port);
} catch (const std::invalid_argument& err) {
wpi::errs() << "Error decoding HALSIMWS_PORT (" << err.what() << ")\n";
return false;
}
} else {
m_port = 8080;
}
const char* uri = std::getenv("HALSIMWS_URI");
if (uri != NULL) {
m_uri = uri;
} else {
m_uri = "/wpilibws";
}
m_loop = uv::Loop::Create();
if (!m_loop) {
return false;
}
m_loop->error.connect([](uv::Error err) {
wpi::errs() << "HALSim WS Client libuv Error: " << err.str() << "\n";
});
m_tcp_client = uv::Tcp::Create(m_loop);
if (!m_tcp_client) {
return false;
}
m_tcp_client->SetNoDelay(true);
// Hook up TCP client events
m_tcp_client->error.connect(
[this, socket = m_tcp_client.get()](wpi::uv::Error err) {
if (m_tcp_connected) {
m_tcp_connected = false;
m_connect_attempts = 0;
m_loop->Stop();
return;
}
// If we weren't previously connected, attempt a reconnection
m_connect_timer->Start(uv::Timer::Time(kTcpConnectAttemptTimeout));
});
m_tcp_client->closed.connect(
[]() { wpi::outs() << "TCP connection closed\n"; });
// Set up the connection timer
m_connect_timer = uv::Timer::Create(m_loop);
if (!m_connect_timer) {
return false;
}
wpi::outs() << "HALSimWS Initialized\n";
wpi::outs() << "Will attempt to connect to: " << m_host << ":" << m_port
<< " " << m_uri << "\n";
return true;
}
void HALSimWS::Main(void* param) {
GetInstance()->MainLoop();
SetInstance(nullptr);
}
void HALSimWS::MainLoop() {
// Set up the timer to attempt connection
m_connect_timer->timeout.connect([this] { AttemptConnect(); });
// Run the initial connect immediately
m_connect_timer->Start(uv::Timer::Time(0));
m_loop->Run();
}
void HALSimWS::AttemptConnect() {
m_connect_attempts++;
wpi::outs() << "Connection Attempt " << m_connect_attempts << "\n";
struct sockaddr_in dest;
uv::NameToAddr(m_host, m_port, &dest);
m_tcp_client->Connect(dest, [this, socket = m_tcp_client.get()]() {
m_tcp_connected = true;
auto wsConn = std::make_shared<HALSimWSClientConnection>(m_tcp_client);
wsConn->Initialize();
});
}
void HALSimWS::Exit(void* param) {
auto inst = GetInstance();
if (!inst) {
return;
}
auto loop = inst->m_loop;
loop->Walk([](uv::Handle& h) {
h.SetLoopClosing(true);
h.Close();
});
}
bool HALSimWS::RegisterWebsocket(
std::shared_ptr<HALSimBaseWebSocketConnection> hws) {
if (m_hws.lock()) {
return false;
}
m_hws = hws;
m_simDevicesProvider.OnNetworkConnected(hws);
m_providers.ForEach([hws](std::shared_ptr<HALSimWSBaseProvider> provider) {
provider->OnNetworkConnected(hws);
});
return true;
}
void HALSimWS::CloseWebsocket(
std::shared_ptr<HALSimBaseWebSocketConnection> hws) {
// Inform the providers that they need to cancel callbacks
m_simDevicesProvider.OnNetworkDisconnected();
m_providers.ForEach([](std::shared_ptr<HALSimWSBaseProvider> provider) {
provider->OnNetworkDisconnected();
});
if (hws == m_hws.lock()) {
m_hws.reset();
}
}
void HALSimWS::OnNetValueChanged(const wpi::json& msg) {
// Look for "type" and "device" fields so that we can
// generate the key
try {
auto& type = msg.at("type").get_ref<const std::string&>();
auto& device = msg.at("device").get_ref<const std::string&>();
wpi::SmallString<64> key;
key.append(type);
if (!device.empty()) {
key.append("/");
key.append(device);
if (!simws->Initialize()) {
result = false;
return;
}
auto provider = m_providers.Get(key.str());
if (provider) {
provider->OnNetValueChanged(msg.at("data"));
}
} catch (wpi::json::exception& e) {
wpi::errs() << "Error with incoming message: " << e.what() << "\n";
}
}
WSRegisterFunc registerFunc = [&](auto key, auto provider) {
providers.Add(key, provider);
};
} // namespace wpilibws
HALSimWSProviderAnalogIn::Initialize(registerFunc);
HALSimWSProviderAnalogOut::Initialize(registerFunc);
HALSimWSProviderDIO::Initialize(registerFunc);
HALSimWSProviderDigitalPWM::Initialize(registerFunc);
HALSimWSProviderDriverStation::Initialize(registerFunc);
HALSimWSProviderEncoder::Initialize(registerFunc);
HALSimWSProviderJoystick::Initialize(registerFunc);
HALSimWSProviderPWM::Initialize(registerFunc);
HALSimWSProviderRelay::Initialize(registerFunc);
HALSimWSProviderRoboRIO::Initialize(registerFunc);
simDevices.Initialize(loop);
simws->Start();
});
return result;
}

65
simulation/halsim_ws_client/src/main/native/cpp/HALSimWSClientConnection.cpp
View File

@@ -10,22 +10,20 @@
#include <wpi/raw_ostream.h>
#include <wpi/raw_uv_ostream.h>
#include "HALSimWSClient.h"
#include "HALSimWS.h"
namespace uv = wpi::uv;
namespace wpilibws {
using namespace wpilibws;
void HALSimWSClientConnection::Initialize() {
// Get a shared pointer to ourselves
auto self = this->shared_from_this();
auto hws = HALSimWS::GetInstance();
std::string reqHost =
hws->GetTargetHost() + ":" + std::to_string(hws->GetTargetPort());
auto ws =
wpi::WebSocket::CreateClient(*m_stream, hws->GetTargetUri(), reqHost);
wpi::WebSocket::CreateClient(*m_stream, m_client->GetTargetUri(),
wpi::Twine{m_client->GetTargetHost()} + ":" +
wpi::Twine{m_client->GetTargetPort()});
ws->SetData(self);
@@ -35,21 +33,7 @@ void HALSimWSClientConnection::Initialize() {
m_websocket->open.connect_extended([this](auto conn, wpi::StringRef) {
conn.disconnect();
m_buffers = std::make_unique<BufferPool>();
m_exec =
UvExecFunc::Create(m_stream->GetLoop(), [](auto out, LoopFunc func) {
func();
out.set_value();
});
auto hws = HALSimWS::GetInstance();
if (!hws) {
wpi::errs() << "Unable to get hws instance\n";
return;
}
if (!hws->RegisterWebsocket(shared_from_this())) {
if (!m_client->RegisterWebsocket(shared_from_this())) {
wpi::errs() << "Unable to register websocket\n";
return;
}
@@ -59,8 +43,7 @@ void HALSimWSClientConnection::Initialize() {
});
m_websocket->text.connect([this](wpi::StringRef msg, bool) {
auto hws = HALSimWS::GetInstance();
if (!m_ws_connected || !hws) {
if (!m_ws_connected) {
return;
}
@@ -75,7 +58,7 @@ void HALSimWSClientConnection::Initialize() {
return;
}
hws->OnNetValueChanged(j);
m_client->OnNetValueChanged(j);
});
m_websocket->closed.connect([this](uint16_t, wpi::StringRef) {
@@ -83,10 +66,7 @@ void HALSimWSClientConnection::Initialize() {
wpi::outs() << "HALSimWS: Websocket Disconnected\n";
m_ws_connected = false;
auto hws = HALSimWS::GetInstance();
if (hws) {
hws->CloseWebsocket(shared_from_this());
}
m_client->CloseWebsocket(shared_from_this());
}
});
}
@@ -98,25 +78,24 @@ void HALSimWSClientConnection::OnSimValueChanged(const wpi::json& msg) {
wpi::SmallVector<uv::Buffer, 4> sendBufs;
wpi::raw_uv_ostream os{sendBufs, [this]() -> uv::Buffer {
std::lock_guard lock(m_buffers_mutex);
return m_buffers->Allocate();
return m_buffers.Allocate();
}};
os << msg;
// Call the websocket send function on the uv loop
m_exec->Call([this, sendBufs]() mutable {
m_websocket->SendText(sendBufs, [this](auto bufs, wpi::uv::Error err) {
{
std::lock_guard lock(m_buffers_mutex);
m_buffers->Release(bufs);
}
m_client->GetExec().Send([self = shared_from_this(), sendBufs] {
self->m_websocket->SendText(sendBufs,
[self](auto bufs, wpi::uv::Error err) {
{
std::lock_guard lock(self->m_buffers_mutex);
self->m_buffers.Release(bufs);
}
if (err) {
wpi::errs() << err.str() << "\n";
wpi::errs().flush();
}
});
if (err) {
wpi::errs() << err.str() << "\n";
wpi::errs().flush();
}
});
});
}
} // namespace wpilibws

43
simulation/halsim_ws_client/src/main/native/cpp/main.cpp
View File

@@ -5,26 +5,16 @@
/* the project. */
/*----------------------------------------------------------------------------*/
#include <WSProviderContainer.h>
#include <WSProvider_Analog.h>
#include <WSProvider_DIO.h>
#include <WSProvider_DriverStation.h>
#include <WSProvider_Encoder.h>
#include <WSProvider_Joystick.h>
#include <WSProvider_PWM.h>
#include <WSProvider_Relay.h>
#include <WSProvider_RoboRIO.h>
#include <WSProvider_SimDevice.h>
#include <WSProvider_dPWM.h>
#include <hal/Main.h>
#include <memory>
#include <hal/Extensions.h>
#include <wpi/raw_ostream.h>
#include "HALSimWSClient.h"
using namespace wpilibws;
static ProviderContainer providers;
static HALSimWSProviderSimDevices simDevices(providers);
static std::unique_ptr<HALSimWSClient> gClient;
extern "C" {
#if defined(WIN32) || defined(_WIN32)
@@ -34,32 +24,13 @@ __declspec(dllexport)
int HALSIM_InitExtension(void) {
wpi::outs() << "HALSim WS Client Extension Initializing\n";
auto hws = std::make_shared<HALSimWS>(providers, simDevices);
HALSimWS::SetInstance(hws);
HAL_OnShutdown(nullptr, [](void*) { gClient.reset(); });
if (!hws->Initialize()) {
gClient = std::make_unique<HALSimWSClient>();
if (!gClient->Initialize()) {
return -1;
}
WSRegisterFunc registerFunc = [&](auto key, auto provider) {
providers.Add(key, provider);
};
HALSimWSProviderAnalogIn::Initialize(registerFunc);
HALSimWSProviderAnalogOut::Initialize(registerFunc);
HALSimWSProviderDIO::Initialize(registerFunc);
HALSimWSProviderDigitalPWM::Initialize(registerFunc);
HALSimWSProviderDriverStation::Initialize(registerFunc);
HALSimWSProviderEncoder::Initialize(registerFunc);
HALSimWSProviderJoystick::Initialize(registerFunc);
HALSimWSProviderPWM::Initialize(registerFunc);
HALSimWSProviderRelay::Initialize(registerFunc);
HALSimWSProviderRoboRIO::Initialize(registerFunc);
simDevices.Initialize(hws->GetLoop());
HAL_SetMain(nullptr, HALSimWS::Main, HALSimWS::Exit);
wpi::outs() << "HALSim WS Client Extension Initialized\n";
return 0;
}

75
simulation/halsim_ws_client/src/main/native/include/HALSimWS.h Normal file
View File

@@ -0,0 +1,75 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2020 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
/*----------------------------------------------------------------------------*/
#pragma once
#include <functional>
#include <memory>
#include <string>
#include <WSProviderContainer.h>
#include <WSProvider_SimDevice.h>
#include <wpi/uv/Async.h>
#include <wpi/uv/Loop.h>
#include <wpi/uv/Tcp.h>
#include <wpi/uv/Timer.h>
namespace wpi {
class json;
} // namespace wpi
namespace wpilibws {
class HALSimWSClientConnection;
class HALSimWS : public std::enable_shared_from_this<HALSimWS> {
public:
using LoopFunc = std::function<void(void)>;
using UvExecFunc = wpi::uv::Async<LoopFunc>;
HALSimWS(wpi::uv::Loop& loop, ProviderContainer& providers,
HALSimWSProviderSimDevices& simDevicesProvider);
HALSimWS(const HALSimWS&) = delete;
HALSimWS& operator=(const HALSimWS&) = delete;
bool Initialize();
void Start();
bool RegisterWebsocket(std::shared_ptr<HALSimBaseWebSocketConnection> hws);
void CloseWebsocket(std::shared_ptr<HALSimBaseWebSocketConnection> hws);
void OnNetValueChanged(const wpi::json& msg);
wpi::StringRef GetTargetHost() const { return m_host; }
wpi::StringRef GetTargetUri() const { return m_uri; }
int GetTargetPort() const { return m_port; }
wpi::uv::Loop& GetLoop() { return m_loop; }
UvExecFunc& GetExec() { return *m_exec; }
private:
void AttemptConnect();
bool m_tcp_connected = false;
std::shared_ptr<wpi::uv::Timer> m_connect_timer;
int m_connect_attempts = 0;
std::weak_ptr<HALSimBaseWebSocketConnection> m_hws;
wpi::uv::Loop& m_loop;
std::shared_ptr<wpi::uv::Tcp> m_tcp_client;
std::shared_ptr<UvExecFunc> m_exec;
ProviderContainer& m_providers;
HALSimWSProviderSimDevices& m_simDevicesProvider;
std::string m_host;
std::string m_uri;
int m_port;
};
} // namespace wpilibws

64
simulation/halsim_ws_client/src/main/native/include/HALSimWSClient.h
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2020 FIRST. All Rights Reserved. */
/* Copyright (c) 2017-2020 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
@@ -8,67 +8,27 @@
#pragma once
#include <memory>
#include <string>
#include <WSProviderContainer.h>
#include <WSProvider_SimDevice.h>
#include <wpi/json.h>
#include <wpi/uv/AsyncFunction.h>
#include <wpi/uv/Loop.h>
#include <wpi/uv/Tcp.h>
#include <wpi/uv/Timer.h>
#include <wpi/EventLoopRunner.h>
#include "HALSimWS.h"
namespace wpilibws {
class HALSimWSClientConnection;
class HALSimWS {
class HALSimWSClient {
public:
static std::shared_ptr<HALSimWS> GetInstance() { return g_instance; }
static void SetInstance(std::shared_ptr<HALSimWS> inst) { g_instance = inst; }
explicit HALSimWS(ProviderContainer& providers,
HALSimWSProviderSimDevices& simDevicesProvider)
: m_providers(providers), m_simDevicesProvider(simDevicesProvider) {}
HALSimWS(const HALSimWS&) = delete;
HALSimWS& operator=(const HALSimWS&) = delete;
HALSimWSClient() = default;
HALSimWSClient(const HALSimWSClient&) = delete;
HALSimWSClient& operator=(const HALSimWSClient&) = delete;
bool Initialize();
static void Main(void*);
static void Exit(void*);
bool RegisterWebsocket(std::shared_ptr<HALSimBaseWebSocketConnection> hws);
void CloseWebsocket(std::shared_ptr<HALSimBaseWebSocketConnection> hws);
void OnNetValueChanged(const wpi::json& msg);
std::string GetTargetHost() const { return m_host; }
std::string GetTargetUri() const { return m_uri; }
int GetTargetPort() { return m_port; }
std::shared_ptr<wpi::uv::Loop> GetLoop() { return m_loop; }
private:
static std::shared_ptr<HALSimWS> g_instance;
void MainLoop();
void AttemptConnect();
bool m_tcp_connected = false;
std::shared_ptr<wpi::uv::Timer> m_connect_timer;
int m_connect_attempts = 0;
std::weak_ptr<HALSimBaseWebSocketConnection> m_hws;
ProviderContainer& m_providers;
HALSimWSProviderSimDevices& m_simDevicesProvider;
std::shared_ptr<wpi::uv::Loop> m_loop;
std::shared_ptr<wpi::uv::Tcp> m_tcp_client;
std::string m_host;
std::string m_uri;
int m_port;
ProviderContainer providers;
HALSimWSProviderSimDevices simDevices{providers};
wpi::EventLoopRunner runner;
std::shared_ptr<HALSimWS> simws;
};
} // namespace wpilibws

24
simulation/halsim_ws_client/src/main/native/include/HALSimWSClientConnection.h
View File

@@ -8,15 +8,20 @@
#pragma once
#include <memory>
#include <utility>
#include <HALSimBaseWebSocketConnection.h>
#include <wpi/WebSocket.h>
#include <wpi/json.h>
#include <wpi/mutex.h>
#include <wpi/uv/AsyncFunction.h>
#include <wpi/uv/Buffer.h>
#include <wpi/uv/Stream.h>
#include "HALSimWS.h"
namespace wpi {
class json;
} // namespace wpi
namespace wpilibws {
class HALSimWS;
@@ -25,25 +30,24 @@ class HALSimWSClientConnection
: public HALSimBaseWebSocketConnection,
public std::enable_shared_from_this<HALSimWSClientConnection> {
public:
using BufferPool = wpi::uv::SimpleBufferPool<4>;
using LoopFunc = std::function<void(void)>;
using UvExecFunc = wpi::uv::AsyncFunction<void(LoopFunc)>;
explicit HALSimWSClientConnection(std::shared_ptr<wpi::uv::Stream> stream)
: m_stream(stream) {}
explicit HALSimWSClientConnection(std::shared_ptr<HALSimWS> client,
std::shared_ptr<wpi::uv::Stream> stream)
: m_client(std::move(client)),
m_stream(std::move(stream)),
m_buffers(128) {}
public:
void OnSimValueChanged(const wpi::json& msg) override;
void Initialize();
private:
std::shared_ptr<HALSimWS> m_client;
std::shared_ptr<wpi::uv::Stream> m_stream;
bool m_ws_connected = false;
wpi::WebSocket* m_websocket = nullptr;
std::shared_ptr<UvExecFunc> m_exec;
std::unique_ptr<BufferPool> m_buffers;
wpi::uv::SimpleBufferPool<4> m_buffers;
std::mutex m_buffers_mutex;
};

3
simulation/halsim_ws_core/src/main/native/cpp/WSProvider_SimDevice.cpp
View File

@@ -166,8 +166,7 @@ void HALSimWSProviderSimDevices::DeviceFreedCallback(
m_providers.Delete(name);
}
void HALSimWSProviderSimDevices::Initialize(
std::shared_ptr<wpi::uv::Loop> loop) {
void HALSimWSProviderSimDevices::Initialize(wpi::uv::Loop& loop) {
m_deviceCreatedCbKey = HALSIM_RegisterSimDeviceCreatedCallback(
"", this, HALSimWSProviderSimDevices::DeviceCreatedCallbackStatic, 1);
m_deviceFreedCbKey = HALSIM_RegisterSimDeviceFreedCallback(

2
simulation/halsim_ws_core/src/main/native/include/WSProvider_SimDevice.h
View File

@@ -90,7 +90,7 @@ class HALSimWSProviderSimDevices {
: m_providers(providers) {}
~HALSimWSProviderSimDevices();
void Initialize(std::shared_ptr<wpi::uv::Loop> loop);
void Initialize(wpi::uv::Loop& loop);
void OnNetworkConnected(std::shared_ptr<HALSimBaseWebSocketConnection> hws);
void OnNetworkDisconnected();

126
simulation/halsim_ws_server/src/main/native/cpp/HALSimHttpConnection.cpp
View File

@@ -19,15 +19,12 @@
#include <wpi/raw_uv_ostream.h>
#include <wpi/uv/Request.h>
#include "HALSimWSServer.h"
namespace uv = wpi::uv;
namespace wpilibws {
using namespace wpilibws;
bool HALSimHttpConnection::IsValidWsUpgrade(wpi::StringRef protocol) {
auto hws = HALSimWeb::GetInstance();
if (m_request.GetUrl() != hws->GetServerUri()) {
if (m_request.GetUrl() != m_server->GetServerUri()) {
MySendError(404, "invalid websocket address");
return false;
}
@@ -39,21 +36,7 @@ void HALSimHttpConnection::ProcessWsUpgrade() {
m_websocket->open.connect_extended([this](auto conn, wpi::StringRef) {
conn.disconnect(); // one-shot
m_buffers = std::make_unique<BufferPool>();
m_exec =
UvExecFunc::Create(m_stream.GetLoop(), [](auto out, LoopFunc func) {
func();
out.set_value();
});
auto hws = HALSimWeb::GetInstance();
if (!hws) {
Log(503);
m_websocket->Fail(503, "HALSimWeb unavailable");
return;
}
if (!hws->RegisterWebsocket(shared_from_this())) {
if (!m_server->RegisterWebsocket(shared_from_this())) {
Log(409);
m_websocket->Fail(409, "Only a single simulation websocket is allowed");
return;
@@ -66,8 +49,7 @@ void HALSimHttpConnection::ProcessWsUpgrade() {
// parse incoming JSON, dispatch to parent
m_websocket->text.connect([this](wpi::StringRef msg, bool) {
auto hws = HALSimWeb::GetInstance();
if (!m_isWsConnected || !hws) {
if (!m_isWsConnected) {
return;
}
@@ -80,7 +62,7 @@ void HALSimHttpConnection::ProcessWsUpgrade() {
m_websocket->Fail(400, err);
return;
}
hws->OnNetValueChanged(j);
m_server->OnNetValueChanged(j);
});
m_websocket->closed.connect([this](uint16_t, wpi::StringRef) {
@@ -89,10 +71,7 @@ void HALSimHttpConnection::ProcessWsUpgrade() {
wpi::errs() << "HALWebSim: websocket disconnected\n";
m_isWsConnected = false;
auto hws = HALSimWeb::GetInstance();
if (hws) {
hws->CloseWebsocket(shared_from_this());
}
m_server->CloseWebsocket(shared_from_this());
}
});
}
@@ -102,84 +81,27 @@ void HALSimHttpConnection::OnSimValueChanged(const wpi::json& msg) {
wpi::SmallVector<uv::Buffer, 4> sendBufs;
wpi::raw_uv_ostream os{sendBufs, [this]() -> uv::Buffer {
std::lock_guard lock(m_buffers_mutex);
return m_buffers->Allocate();
return m_buffers.Allocate();
}};
os << msg;
// call the websocket send function on the uv loop
m_exec->Call([this, sendBufs]() mutable {
m_websocket->SendText(sendBufs, [this](auto bufs, wpi::uv::Error err) {
{
std::lock_guard lock(m_buffers_mutex);
m_buffers->Release(bufs);
}
m_server->GetExec().Send([self = shared_from_this(), sendBufs] {
self->m_websocket->SendText(sendBufs,
[self](auto bufs, wpi::uv::Error err) {
{
std::lock_guard lock(self->m_buffers_mutex);
self->m_buffers.Release(bufs);
}
if (err) {
wpi::errs() << err.str() << "\n";
wpi::errs().flush();
}
});
if (err) {
wpi::errs() << err.str() << "\n";
wpi::errs().flush();
}
});
});
}
class SendfileReq : public uv::RequestImpl<SendfileReq, uv_fs_t> {
public:
SendfileReq(uv_file out, uv_file in, int64_t inOffset, size_t len)
: m_out(out), m_in(in), m_inOffset(inOffset), m_len(len) {
error = [this](uv::Error err) { GetLoop().error(err); };
}
uv::Loop& GetLoop() const {
return *static_cast<uv::Loop*>(GetRaw()->loop->data);
}
int Send(uv::Loop& loop) {
int err = uv_fs_sendfile(loop.GetRaw(), GetRaw(), m_out, m_in, m_inOffset,
m_len, [](uv_fs_t* req) {
auto& h = *static_cast<SendfileReq*>(req->data);
if (req->result < 0) {
h.ReportError(req->result);
h.complete();
h.Release();
return;
}
h.m_inOffset += req->result;
h.m_len -= req->result;
if (h.m_len == 0) {
// done
h.complete();
h.Release(); // this is always a one-shot
return;
}
// need to send more
h.Send(h.GetLoop());
});
if (err < 0) {
ReportError(err);
complete();
}
return err;
}
wpi::sig::Signal<> complete;
private:
uv_file m_out;
uv_file m_in;
int64_t m_inOffset;
size_t m_len;
};
void Sendfile(uv::Loop& loop, uv_file out, uv_file in, int64_t inOffset,
size_t len, std::function<void()> complete) {
auto req = std::make_shared<SendfileReq>(out, in, inOffset, len);
if (complete) req->complete.connect(complete);
int err = req->Send(loop);
if (err >= 0) req->Keep();
}
void HALSimHttpConnection::SendFileResponse(int code,
const wpi::Twine& codeText,
const wpi::Twine& contentType,
@@ -262,10 +184,12 @@ void HALSimHttpConnection::ProcessRequest() {
std::string prefix = (wpi::sys::path::get_separator() + "user" +
wpi::sys::path::get_separator())
.str();
wpi::sys::path::replace_path_prefix(nativePath, prefix, m_webroot_user);
wpi::sys::path::replace_path_prefix(nativePath, prefix,
m_server->GetWebrootUser());
} else {
wpi::sys::path::replace_path_prefix(
nativePath, wpi::sys::path::get_separator(), m_webroot_sys);
wpi::sys::path::replace_path_prefix(nativePath,
wpi::sys::path::get_separator(),
m_server->GetWebrootSys());
}
if (wpi::sys::fs::is_directory(nativePath)) {
@@ -295,5 +219,3 @@ void HALSimHttpConnection::Log(int code) {
<< m_request.GetMajor() << "." << m_request.GetMinor() << " "
<< code << "\n";
}
} // namespace wpilibws

213
simulation/halsim_ws_server/src/main/native/cpp/HALSimWSServer.cpp
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2017-2020 FIRST. All Rights Reserved. */
/* Copyright (c) 2020 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
@@ -7,180 +7,49 @@
#include "HALSimWSServer.h"
#include <wpi/FileSystem.h>
#include <wpi/Path.h>
#include <wpi/SmallString.h>
#include <wpi/Twine.h>
#include <wpi/UrlParser.h>
#include <wpi/WebSocketServer.h>
#include <wpi/raw_uv_ostream.h>
#include <wpi/uv/Loop.h>
#include <wpi/uv/Tcp.h>
#include <WSProviderContainer.h>
#include <WSProvider_Analog.h>
#include <WSProvider_DIO.h>
#include <WSProvider_DriverStation.h>
#include <WSProvider_Encoder.h>
#include <WSProvider_Joystick.h>
#include <WSProvider_PWM.h>
#include <WSProvider_Relay.h>
#include <WSProvider_RoboRIO.h>
#include <WSProvider_SimDevice.h>
#include <WSProvider_dPWM.h>
#include "HALSimHttpConnection.h"
using namespace wpilibws;
namespace uv = wpi::uv;
bool HALSimWSServer::Initialize() {
bool result = true;
runner.ExecSync([&](wpi::uv::Loop& loop) {
simWeb = std::make_shared<HALSimWeb>(loop, providers, simDevices);
namespace wpilibws {
std::shared_ptr<HALSimWeb> HALSimWeb::g_instance;
bool HALSimWeb::Initialize() {
// determine where to get static content from
// wpi::SmallVector<char, 64> tmp;
wpi::SmallString<64> tmp;
const char* webroot_sys = std::getenv("HALSIMWS_SYSROOT");
if (webroot_sys != NULL) {
wpi::StringRef tstr(webroot_sys);
tmp.append(tstr);
} else {
wpi::sys::fs::current_path(tmp);
wpi::sys::path::append(tmp, "sim");
}
wpi::sys::fs::make_absolute(tmp);
m_webroot_sys = wpi::Twine(tmp).str();
tmp.clear();
const char* webroot_user = std::getenv("HALSIMWS_USERROOT");
if (webroot_user != NULL) {
wpi::StringRef tstr(webroot_user);
tmp.append(tstr);
} else {
wpi::sys::fs::current_path(tmp);
wpi::sys::path::append(tmp, "sim", "user");
}
wpi::sys::fs::make_absolute(tmp);
m_webroot_user = wpi::Twine(tmp).str();
const char* uri = std::getenv("HALSIMWS_URI");
if (uri != NULL) {
m_uri = uri;
} else {
m_uri = "/wpilibws";
}
const char* port = std::getenv("HALSIMWS_PORT");
if (port != NULL) {
try {
m_port = std::stoi(port);
} catch (const std::invalid_argument& err) {
wpi::errs() << "Error decoding HALSIMWS_PORT (" << err.what() << ")\n";
return false;
}
} else {
m_port = 8080;
}
// create libuv things
m_loop = uv::Loop::Create();
if (!m_loop) {
return false;
}
m_loop->error.connect([](uv::Error err) {
wpi::errs() << "HALSim WS Server libuv ERROR: " << err.str() << '\n';
});
m_server = uv::Tcp::Create(m_loop);
if (!m_server) {
return false;
}
m_server->Bind("", m_port);
return true;
}
void HALSimWeb::Main(void* param) {
GetInstance()->MainLoop();
SetInstance(nullptr);
}
void HALSimWeb::MainLoop() {
// when we get a connection, accept it and start reading
m_server->connection.connect([this, srv = m_server.get()] {
auto tcp = srv->Accept();
if (!tcp) return;
tcp->SetNoDelay(true);
auto conn = std::make_shared<HALSimHttpConnection>(tcp, m_webroot_sys,
m_webroot_user);
tcp->SetData(conn);
});
// start listening for incoming connections
m_server->Listen();
wpi::outs() << "Listening at http://localhost:" << m_port << "\n";
wpi::outs() << "WebSocket URI: " << m_uri << "\n";
m_loop->Run();
}
void HALSimWeb::Exit(void* param) {
auto inst = GetInstance();
if (!inst) return;
auto loop = inst->m_loop;
loop->Walk([](uv::Handle& h) {
h.SetLoopClosing(true);
h.Close();
});
}
bool HALSimWeb::RegisterWebsocket(
std::shared_ptr<HALSimBaseWebSocketConnection> hws) {
if (m_hws.lock()) {
return false;
}
m_hws = hws;
m_simDevicesProvider.OnNetworkConnected(hws);
// notify all providers that they should use this new websocket instead
m_providers.ForEach([hws](std::shared_ptr<HALSimWSBaseProvider> provider) {
provider->OnNetworkConnected(hws);
});
return true;
}
void HALSimWeb::CloseWebsocket(
std::shared_ptr<HALSimBaseWebSocketConnection> hws) {
// Inform the providers that they need to cancel callbacks
m_simDevicesProvider.OnNetworkDisconnected();
m_providers.ForEach([](std::shared_ptr<HALSimWSBaseProvider> provider) {
provider->OnNetworkDisconnected();
});
if (hws == m_hws.lock()) {
m_hws.reset();
}
}
void HALSimWeb::OnNetValueChanged(const wpi::json& msg) {
// Look for "type" and "device" fields so that we can
// generate the key
try {
auto& type = msg.at("type").get_ref<const std::string&>();
auto& device = msg.at("device").get_ref<const std::string&>();
wpi::SmallString<64> key;
key.append(type);
if (!device.empty()) {
key.append("/");
key.append(device);
if (!simWeb->Initialize()) {
result = false;
return;
}
auto provider = m_providers.Get(key.str());
if (provider) {
provider->OnNetValueChanged(msg.at("data"));
}
} catch (wpi::json::exception& e) {
wpi::errs() << "Error with incoming message: " << e.what() << "\n";
}
}
WSRegisterFunc registerFunc = [&](auto key, auto provider) {
providers.Add(key, provider);
};
} // namespace wpilibws
HALSimWSProviderAnalogIn::Initialize(registerFunc);
HALSimWSProviderAnalogOut::Initialize(registerFunc);
HALSimWSProviderDIO::Initialize(registerFunc);
HALSimWSProviderDigitalPWM::Initialize(registerFunc);
HALSimWSProviderDriverStation::Initialize(registerFunc);
HALSimWSProviderEncoder::Initialize(registerFunc);
HALSimWSProviderJoystick::Initialize(registerFunc);
HALSimWSProviderPWM::Initialize(registerFunc);
HALSimWSProviderRelay::Initialize(registerFunc);
HALSimWSProviderRoboRIO::Initialize(registerFunc);
simDevices.Initialize(loop);
simWeb->Start();
});
return result;
}

170
simulation/halsim_ws_server/src/main/native/cpp/HALSimWeb.cpp Normal file
View File

@@ -0,0 +1,170 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2017-2020 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
/*----------------------------------------------------------------------------*/
#include "HALSimWeb.h"
#include <wpi/FileSystem.h>
#include <wpi/Path.h>
#include <wpi/SmallString.h>
#include <wpi/Twine.h>
#include <wpi/UrlParser.h>
#include <wpi/WebSocketServer.h>
#include <wpi/raw_uv_ostream.h>
#include <wpi/uv/Loop.h>
#include <wpi/uv/Tcp.h>
#include "HALSimHttpConnection.h"
namespace uv = wpi::uv;
using namespace wpilibws;
HALSimWeb::HALSimWeb(wpi::uv::Loop& loop, ProviderContainer& providers,
HALSimWSProviderSimDevices& simDevicesProvider)
: m_loop(loop),
m_providers(providers),
m_simDevicesProvider(simDevicesProvider) {
m_loop.error.connect([](uv::Error err) {
wpi::errs() << "HALSim WS Server libuv ERROR: " << err.str() << '\n';
});
m_server = uv::Tcp::Create(m_loop);
m_exec = UvExecFunc::Create(m_loop);
if (m_exec) {
m_exec->wakeup.connect([](auto func) { func(); });
}
}
bool HALSimWeb::Initialize() {
if (!m_server || !m_exec) {
return false;
}
// determine where to get static content from
// wpi::SmallVector<char, 64> tmp;
wpi::SmallString<64> tmp;
const char* webroot_sys = std::getenv("HALSIMWS_SYSROOT");
if (webroot_sys != NULL) {
wpi::StringRef tstr(webroot_sys);
tmp.append(tstr);
} else {
wpi::sys::fs::current_path(tmp);
wpi::sys::path::append(tmp, "sim");
}
wpi::sys::fs::make_absolute(tmp);
m_webroot_sys = wpi::Twine(tmp).str();
tmp.clear();
const char* webroot_user = std::getenv("HALSIMWS_USERROOT");
if (webroot_user != NULL) {
wpi::StringRef tstr(webroot_user);
tmp.append(tstr);
} else {
wpi::sys::fs::current_path(tmp);
wpi::sys::path::append(tmp, "sim", "user");
}
wpi::sys::fs::make_absolute(tmp);
m_webroot_user = wpi::Twine(tmp).str();
const char* uri = std::getenv("HALSIMWS_URI");
if (uri != NULL) {
m_uri = uri;
} else {
m_uri = "/wpilibws";
}
const char* port = std::getenv("HALSIMWS_PORT");
if (port != NULL) {
try {
m_port = std::stoi(port);
} catch (const std::invalid_argument& err) {
wpi::errs() << "Error decoding HALSIMWS_PORT (" << err.what() << ")\n";
return false;
}
} else {
m_port = 8080;
}
return true;
}
void HALSimWeb::Start() {
m_server->Bind("", m_port);
// when we get a connection, accept it and start reading
m_server->connection.connect([this, srv = m_server.get()] {
auto tcp = srv->Accept();
if (!tcp) return;
tcp->SetNoDelay(true);
auto conn = std::make_shared<HALSimHttpConnection>(shared_from_this(), tcp);
tcp->SetData(conn);
});
// start listening for incoming connections
m_server->Listen();
wpi::outs() << "Listening at http://localhost:" << m_port << "\n";
wpi::outs() << "WebSocket URI: " << m_uri << "\n";
}
bool HALSimWeb::RegisterWebsocket(
std::shared_ptr<HALSimBaseWebSocketConnection> hws) {
if (m_hws.lock()) {
return false;
}
m_hws = hws;
m_simDevicesProvider.OnNetworkConnected(hws);
// notify all providers that they should use this new websocket instead
m_providers.ForEach([hws](std::shared_ptr<HALSimWSBaseProvider> provider) {
provider->OnNetworkConnected(hws);
});
return true;
}
void HALSimWeb::CloseWebsocket(
std::shared_ptr<HALSimBaseWebSocketConnection> hws) {
// Inform the providers that they need to cancel callbacks
m_simDevicesProvider.OnNetworkDisconnected();
m_providers.ForEach([](std::shared_ptr<HALSimWSBaseProvider> provider) {
provider->OnNetworkDisconnected();
});
if (hws == m_hws.lock()) {
m_hws.reset();
}
}
void HALSimWeb::OnNetValueChanged(const wpi::json& msg) {
// Look for "type" and "device" fields so that we can
// generate the key
try {
auto& type = msg.at("type").get_ref<const std::string&>();
auto& device = msg.at("device").get_ref<const std::string&>();
wpi::SmallString<64> key;
key.append(type);
if (!device.empty()) {
key.append("/");
key.append(device);
}
auto provider = m_providers.Get(key.str());
if (provider) {
provider->OnNetValueChanged(msg.at("data"));
}
} catch (wpi::json::exception& e) {
wpi::errs() << "Error with incoming message: " << e.what() << "\n";
}
}

50
simulation/halsim_ws_server/src/main/native/cpp/main.cpp
View File

@@ -5,18 +5,9 @@
/* the project. */
/*----------------------------------------------------------------------------*/
#include <WSProviderContainer.h>
#include <WSProvider_Analog.h>
#include <WSProvider_DIO.h>
#include <WSProvider_DriverStation.h>
#include <WSProvider_Encoder.h>
#include <WSProvider_Joystick.h>
#include <WSProvider_PWM.h>
#include <WSProvider_Relay.h>
#include <WSProvider_RoboRIO.h>
#include <WSProvider_SimDevice.h>
#include <WSProvider_dPWM.h>
#include <hal/Main.h>
#include <memory>
#include <hal/Extensions.h>
#include <wpi/raw_ostream.h>
#include "HALSimWSServer.h"
@@ -24,44 +15,23 @@
using namespace std::placeholders;
using namespace wpilibws;
// Currently, robots never terminate, so we keep static objects that are
// never properly released or cleaned up.
static ProviderContainer providers;
static HALSimWSProviderSimDevices simDevices(providers);
static std::unique_ptr<HALSimWSServer> gServer;
extern "C" {
#if defined(WIN32) || defined(_WIN32)
__declspec(dllexport)
#endif
int HALSIM_InitExtension(void) {
wpi::outs() << "Websocket Simulator Initializing.\n";
auto hsw = std::make_shared<HALSimWeb>(providers, simDevices);
HALSimWeb::SetInstance(hsw);
wpi::outs() << "Websocket WS Server Initializing.\n";
if (!hsw->Initialize()) {
HAL_OnShutdown(nullptr, [](void*) { gServer.reset(); });
gServer = std::make_unique<HALSimWSServer>();
if (!gServer->Initialize()) {
return -1;
}
WSRegisterFunc registerFunc = [&](auto key, auto provider) {
providers.Add(key, provider);
};
HALSimWSProviderAnalogIn::Initialize(registerFunc);
HALSimWSProviderAnalogOut::Initialize(registerFunc);
HALSimWSProviderDIO::Initialize(registerFunc);
HALSimWSProviderDigitalPWM::Initialize(registerFunc);
HALSimWSProviderDriverStation::Initialize(registerFunc);
HALSimWSProviderEncoder::Initialize(registerFunc);
HALSimWSProviderJoystick::Initialize(registerFunc);
HALSimWSProviderPWM::Initialize(registerFunc);
HALSimWSProviderRelay::Initialize(registerFunc);
HALSimWSProviderRoboRIO::Initialize(registerFunc);
simDevices.Initialize(hsw->GetLoop());
HAL_SetMain(nullptr, HALSimWeb::Main, HALSimWeb::Exit);
wpi::outs() << "Websocket Simulator Initialized!\n";
wpi::outs() << "Websocket WS Server Initialized!\n";
return 0;
}
} // extern "C"

35
simulation/halsim_ws_server/src/main/native/include/HALSimHttpConnection.h
View File

@@ -9,35 +9,31 @@
#include <cinttypes>
#include <memory>
#include <string>
#include <vector>
#include <utility>
#include <HALSimBaseWebSocketConnection.h>
#include <wpi/HttpWebSocketServerConnection.h>
#include <wpi/json.h>
#include <wpi/mutex.h>
#include <wpi/uv/AsyncFunction.h>
#include <wpi/uv/Buffer.h>
namespace wpilibws {
#include "HALSimWeb.h"
class HALSimWeb;
namespace wpi {
class json;
} // namespace wpi
namespace wpilibws {
class HALSimHttpConnection
: public wpi::HttpWebSocketServerConnection<HALSimHttpConnection>,
public HALSimBaseWebSocketConnection {
public:
using BufferPool = wpi::uv::SimpleBufferPool<4>;
using LoopFunc = std::function<void(void)>;
using UvExecFunc = wpi::uv::AsyncFunction<void(LoopFunc)>;
explicit HALSimHttpConnection(std::shared_ptr<wpi::uv::Stream> stream,
wpi::StringRef webroot_sys,
wpi::StringRef webroot_user)
HALSimHttpConnection(std::shared_ptr<HALSimWeb> server,
std::shared_ptr<wpi::uv::Stream> stream)
: wpi::HttpWebSocketServerConnection<HALSimHttpConnection>(stream, {}),
m_webroot_sys(webroot_sys),
m_webroot_user(webroot_user) {}
m_server(std::move(server)),
m_buffers(128) {}
public:
// callable from any thread
@@ -56,18 +52,13 @@ class HALSimHttpConnection
void Log(int code);
private:
// Absolute paths of folders to retrieve data from
// -> /
std::string m_webroot_sys;
// -> /user
std::string m_webroot_user;
std::shared_ptr<HALSimWeb> m_server;
// is the websocket connected?
bool m_isWsConnected = false;
// these are only valid if the websocket is connected
std::shared_ptr<UvExecFunc> m_exec;
std::unique_ptr<BufferPool> m_buffers;
wpi::uv::SimpleBufferPool<4> m_buffers;
std::mutex m_buffers_mutex;
};

69
simulation/halsim_ws_server/src/main/native/include/HALSimWSServer.h
View File

@@ -8,74 +8,27 @@
#pragma once
#include <memory>
#include <string>
#include <WSBaseProvider.h>
#include <WSProviderContainer.h>
#include <WSProvider_SimDevice.h>
#include <wpi/StringMap.h>
#include <wpi/json.h>
#include <wpi/mutex.h>
#include <wpi/uv/AsyncFunction.h>
#include <wpi/uv/Buffer.h>
#include <wpi/uv/Loop.h>
#include <wpi/uv/Tcp.h>
#include <wpi/EventLoopRunner.h>
#include "HALSimWeb.h"
namespace wpilibws {
class HALSimHttpConnection;
class HALSimWeb {
class HALSimWSServer {
public:
static std::shared_ptr<HALSimWeb> GetInstance() { return g_instance; }
static void SetInstance(std::shared_ptr<HALSimWeb> inst) {
g_instance = inst;
}
explicit HALSimWeb(ProviderContainer& providers,
HALSimWSProviderSimDevices& simDevicesProvider)
: m_providers(providers), m_simDevicesProvider(simDevicesProvider) {}
HALSimWeb(const HALSimWeb&) = delete;
HALSimWeb& operator=(const HALSimWeb&) = delete;
HALSimWSServer() = default;
HALSimWSServer(const HALSimWSServer&) = delete;
HALSimWSServer& operator=(const HALSimWSServer&) = delete;
bool Initialize();
static void Main(void*);
static void Exit(void*);
bool RegisterWebsocket(std::shared_ptr<HALSimBaseWebSocketConnection> hws);
void CloseWebsocket(std::shared_ptr<HALSimBaseWebSocketConnection> hws);
// network -> sim
void OnNetValueChanged(const wpi::json& msg);
std::string GetServerUri() const { return m_uri; }
int GetServerPort() { return m_port; }
std::shared_ptr<wpi::uv::Loop> GetLoop() { return m_loop; }
private:
static std::shared_ptr<HALSimWeb> g_instance;
void MainLoop();
// connected http connection that contains active websocket
std::weak_ptr<HALSimBaseWebSocketConnection> m_hws;
// list of providers
ProviderContainer& m_providers;
HALSimWSProviderSimDevices& m_simDevicesProvider;
std::shared_ptr<wpi::uv::Loop> m_loop;
std::shared_ptr<wpi::uv::Tcp> m_server;
// Absolute paths of folders to retrieve data from
// -> /
std::string m_webroot_sys;
// -> /user
std::string m_webroot_user;
std::string m_uri;
int m_port;
ProviderContainer providers;
HALSimWSProviderSimDevices simDevices{providers};
wpi::EventLoopRunner runner;
std::shared_ptr<HALSimWeb> simWeb;
};
} // namespace wpilibws

78
simulation/halsim_ws_server/src/main/native/include/HALSimWeb.h Normal file
View File

@@ -0,0 +1,78 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2017-2020 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
/*----------------------------------------------------------------------------*/
#pragma once
#include <functional>
#include <memory>
#include <string>
#include <WSBaseProvider.h>
#include <WSProviderContainer.h>
#include <WSProvider_SimDevice.h>
#include <wpi/StringRef.h>
#include <wpi/uv/Async.h>
#include <wpi/uv/Loop.h>
#include <wpi/uv/Tcp.h>
namespace wpi {
class json;
} // namespace wpi
namespace wpilibws {
class HALSimWeb : public std::enable_shared_from_this<HALSimWeb> {
public:
using LoopFunc = std::function<void(void)>;
using UvExecFunc = wpi::uv::Async<LoopFunc>;
HALSimWeb(wpi::uv::Loop& loop, ProviderContainer& providers,
HALSimWSProviderSimDevices& simDevicesProvider);
HALSimWeb(const HALSimWeb&) = delete;
HALSimWeb& operator=(const HALSimWeb&) = delete;
bool Initialize();
void Start();
bool RegisterWebsocket(std::shared_ptr<HALSimBaseWebSocketConnection> hws);
void CloseWebsocket(std::shared_ptr<HALSimBaseWebSocketConnection> hws);
// network -> sim
void OnNetValueChanged(const wpi::json& msg);
wpi::StringRef GetWebrootSys() const { return m_webroot_sys; }
wpi::StringRef GetWebrootUser() const { return m_webroot_user; }
wpi::StringRef GetServerUri() const { return m_uri; }
int GetServerPort() const { return m_port; }
wpi::uv::Loop& GetLoop() { return m_loop; }
UvExecFunc& GetExec() { return *m_exec; }
private:
// connected http connection that contains active websocket
std::weak_ptr<HALSimBaseWebSocketConnection> m_hws;
wpi::uv::Loop& m_loop;
std::shared_ptr<wpi::uv::Tcp> m_server;
std::shared_ptr<UvExecFunc> m_exec;
// list of providers
ProviderContainer& m_providers;
HALSimWSProviderSimDevices& m_simDevicesProvider;
// Absolute paths of folders to retrieve data from
// -> /
std::string m_webroot_sys;
// -> /user
std::string m_webroot_user;
std::string m_uri;
int m_port;
};
} // namespace wpilibws

23
simulation/halsim_ws_server/src/test/native/cpp/WebServerClientTest.cpp
View File

@@ -20,8 +20,6 @@ namespace uv = wpi::uv;
namespace wpilibws {
std::shared_ptr<WebServerClientTest> WebServerClientTest::g_instance;
// Create Web Socket and specify event callbacks
void WebServerClientTest::InitializeWebSocket(const std::string& host, int port,
const std::string& uri) {
@@ -59,11 +57,6 @@ void WebServerClientTest::InitializeWebSocket(const std::string& host, int port,
}
// Save last message received
m_json = j;
// If terminate flag set, end loop after message received
if (m_terminateFlag) {
m_loop->Stop();
}
});
m_websocket->closed.connect([this](uint16_t, wpi::StringRef) {
@@ -75,9 +68,8 @@ void WebServerClientTest::InitializeWebSocket(const std::string& host, int port,
}
// Create tcp client, specify callbacks, and create timers for loop
bool WebServerClientTest::Initialize(std::shared_ptr<uv::Loop>& loop) {
m_loop = loop;
m_loop->error.connect(
bool WebServerClientTest::Initialize() {
m_loop.error.connect(
[](uv::Error err) { wpi::errs() << "uv Error: " << err.str() << "\n"; });
m_tcp_client = uv::Tcp::Create(m_loop);
@@ -92,7 +84,7 @@ bool WebServerClientTest::Initialize(std::shared_ptr<uv::Loop>& loop) {
if (m_tcp_connected) {
m_tcp_connected = false;
m_connect_attempts = 0;
m_loop->Stop();
m_loop.Stop();
return;
}
@@ -124,7 +116,7 @@ void WebServerClientTest::AttemptConnect() {
if (m_connect_attempts >= 5) {
wpi::errs() << "Test Client Timeout. Unable to connect\n";
Exit();
m_loop.Stop();
return;
}
@@ -136,13 +128,6 @@ void WebServerClientTest::AttemptConnect() {
});
}
void WebServerClientTest::Exit() {
m_loop->Walk([](uv::Handle& h) {
h.SetLoopClosing(true);
h.Close();
});
}
void WebServerClientTest::SendMessage(const wpi::json& msg) {
if (msg.empty()) {
wpi::errs() << "Message to send is empty\n";

175
simulation/halsim_ws_server/src/test/native/cpp/main.cpp
View File

@@ -5,6 +5,8 @@
/* the project. */
/*----------------------------------------------------------------------------*/
#include <thread>
#include <hal/DriverStation.h>
#include <hal/HALBase.h>
#include <hal/Main.h>
@@ -16,89 +18,66 @@
#include "WebServerClientTest.h"
#include "gtest/gtest.h"
namespace uv = wpi::uv;
using namespace wpilibws;
extern "C" int HALSIM_InitExtension(
void); // from simulation/halsim_ws_server/src/main/native/cpp/main.cpp
const int POLLING_SPEED = 10; // 10 ms polling
static const int POLLING_SPEED = 10; // 10 ms polling
class WebServerIntegrationTest : public ::testing::Test {
public:
WebServerIntegrationTest() {
const int MAX_TEST_TIME = 1000; // 1 second
// Initialize HAL layer including webserver
HALSIM_InitExtension();
// Initialize server
m_server.Initialize();
// Create and initialize client
m_webserver_client =
std::shared_ptr<WebServerClientTest>((new WebServerClientTest()));
WebServerClientTest::SetInstance(m_webserver_client);
auto webserver = HALSimWeb::GetInstance();
auto loop = webserver->GetLoop();
m_webserver_client->Initialize(loop);
// Create failover timer to prevent running forever
m_failoverTimer = wpi::uv::Timer::Create(loop);
m_failoverTimer->timeout.connect([loop] { loop->Stop(); });
m_failoverTimer->Start(uv::Timer::Time(MAX_TEST_TIME));
m_server.runner.ExecSync([=](auto& loop) {
m_webserverClient = std::make_shared<WebServerClientTest>(loop);
m_webserverClient->Initialize();
});
}
~WebServerIntegrationTest() {
// Exit HAL layer which exits webserver
HAL_ExitMain();
HALSimWeb::Exit(nullptr);
bool IsConnectedClientWS() { return m_webserverClient->IsConnectedWS(); }
// Exit client
m_webserver_client->Exit();
WebServerClientTest::SetInstance(nullptr);
// Unreference timers from loop
m_failoverTimer->Unreference();
}
bool IsConnectedClientWS() { return m_webserver_client->IsConnectedWS(); }
void TerminateOnNextMessage(bool flag) {
m_webserver_client->SetTerminateFlag(flag);
}
private:
std::shared_ptr<WebServerClientTest> m_webserver_client;
std::shared_ptr<wpi::uv::Timer> m_failoverTimer;
protected:
std::shared_ptr<WebServerClientTest> m_webserverClient;
HALSimWSServer m_server;
};
TEST_F(WebServerIntegrationTest, DigitalOutput) {
// Create expected results
const bool EXPECTED_VALUE = false;
const int PIN = 0;
bool done = false;
// Attach timer to loop for test function
auto ws = HALSimWeb::GetInstance();
auto loop = ws->GetLoop();
auto timer = wpi::uv::Timer::Create(loop);
timer->timeout.connect([&] {
if (IsConnectedClientWS()) {
wpi::outs() << "***** Setting DIO value for pin " << PIN << " to "
<< (EXPECTED_VALUE ? "true" : "false") << "\n";
HALSIM_SetDIOValue(PIN, EXPECTED_VALUE);
TerminateOnNextMessage(true);
} else {
// Recheck in POLLING_SPEED ms
timer->Start(uv::Timer::Time(POLLING_SPEED));
}
m_server.runner.ExecSync([&](auto& loop) {
auto timer = wpi::uv::Timer::Create(loop);
timer->timeout.connect([&] {
if (done) {
return;
}
if (IsConnectedClientWS()) {
wpi::outs() << "***** Setting DIO value for pin " << PIN << " to "
<< (EXPECTED_VALUE ? "true" : "false") << "\n";
HALSIM_SetDIOValue(PIN, EXPECTED_VALUE);
done = true;
}
});
timer->Start(uv::Timer::Time(POLLING_SPEED),
uv::Timer::Time(POLLING_SPEED));
timer->Unreference();
});
timer->Start(uv::Timer::Time(POLLING_SPEED));
HAL_RunMain();
timer->Unreference();
using namespace std::chrono_literals;
std::this_thread::sleep_for(1s);
// Get values from JSON message
std::string test_type;
std::string test_device;
bool test_value = true; // Default value from HAL initialization
try {
auto& msg = WebServerClientTest::GetInstance()->GetLastMessage();
auto& msg = m_webserverClient->GetLastMessage();
test_type = msg.at("type").get_ref<const std::string&>();
test_device = msg.at("device").get_ref<const std::string&>();
auto& data = msg.at("data");
@@ -120,28 +99,31 @@ TEST_F(WebServerIntegrationTest, DigitalInput) {
// Create expected results
const bool EXPECTED_VALUE = false;
const int PIN = 0;
bool done = false;
// Attach timer to loop for test function
auto ws = HALSimWeb::GetInstance();
auto loop = ws->GetLoop();
auto timer = wpi::uv::Timer::Create(loop);
timer->timeout.connect([&] {
if (IsConnectedClientWS()) {
wpi::json msg = {{"type", "DIO"},
{"device", std::to_string(PIN)},
{"data", {{"<>value", EXPECTED_VALUE}}}};
wpi::outs() << "***** Input JSON: " << msg.dump() << "\n";
WebServerClientTest::GetInstance()->SendMessage(msg);
loop->Stop();
} else {
// Recheck in POLLING_SPEED ms
timer->Start(uv::Timer::Time(POLLING_SPEED));
}
m_server.runner.ExecSync([&](auto& loop) {
auto timer = wpi::uv::Timer::Create(loop);
timer->timeout.connect([&] {
if (done) {
return;
}
if (IsConnectedClientWS()) {
wpi::json msg = {{"type", "DIO"},
{"device", std::to_string(PIN)},
{"data", {{"<>value", EXPECTED_VALUE}}}};
wpi::outs() << "***** Input JSON: " << msg.dump() << "\n";
m_webserverClient->SendMessage(msg);
done = true;
}
});
timer->Start(uv::Timer::Time(POLLING_SPEED),
uv::Timer::Time(POLLING_SPEED));
timer->Unreference();
});
timer->Start(uv::Timer::Time(POLLING_SPEED));
HAL_RunMain();
timer->Unreference();
using namespace std::chrono_literals;
std::this_thread::sleep_for(1s);
// Compare results
bool test_value = HALSIM_GetDIOValue(PIN);
@@ -151,33 +133,32 @@ TEST_F(WebServerIntegrationTest, DigitalInput) {
TEST_F(WebServerIntegrationTest, DriverStation) {
// Create expected results
const bool EXPECTED_VALUE = true;
bool done = false;
// Attach timer to loop for test function
auto ws = HALSimWeb::GetInstance();
auto loop = ws->GetLoop();
auto timer = wpi::uv::Timer::Create(loop);
bool done = false;
timer->timeout.connect([&] {
if (done) {
loop->Stop();
} else {
// Recheck in POLLING_SPEED ms
timer->Start(uv::Timer::Time(POLLING_SPEED));
}
if (IsConnectedClientWS()) {
wpi::json msg = {
{"type", "DriverStation"},
{"device", ""},
{"data", {{">enabled", EXPECTED_VALUE}, {">new_data", true}}}};
wpi::outs() << "***** Input JSON: " << msg.dump() << "\n";
WebServerClientTest::GetInstance()->SendMessage(msg);
done = true;
}
m_server.runner.ExecSync([&](auto& loop) {
auto timer = wpi::uv::Timer::Create(loop);
timer->timeout.connect([&] {
if (done) {
return;
}
if (IsConnectedClientWS()) {
wpi::json msg = {
{"type", "DriverStation"},
{"device", ""},
{"data", {{">enabled", EXPECTED_VALUE}, {">new_data", true}}}};
wpi::outs() << "***** Input JSON: " << msg.dump() << "\n";
m_webserverClient->SendMessage(msg);
done = true;
}
});
timer->Start(uv::Timer::Time(POLLING_SPEED),
uv::Timer::Time(POLLING_SPEED));
timer->Unreference();
});
timer->Start(uv::Timer::Time(POLLING_SPEED));
HAL_RunMain();
timer->Unreference();
using namespace std::chrono_literals;
std::this_thread::sleep_for(1s);
// Compare results
HAL_ControlWord cw;

19
simulation/halsim_ws_server/src/test/native/include/WebServerClientTest.h
View File

@@ -19,8 +19,6 @@
#include <wpi/uv/Tcp.h>
#include <wpi/uv/Timer.h>
namespace uv = wpi::uv;
namespace wpilibws {
class WebServerClientTest {
@@ -29,36 +27,25 @@ class WebServerClientTest {
using LoopFunc = std::function<void(void)>;
using UvExecFunc = wpi::uv::AsyncFunction<void(LoopFunc)>;
static std::shared_ptr<WebServerClientTest> GetInstance() {
return g_instance;
}
static void SetInstance(std::shared_ptr<WebServerClientTest> inst) {
g_instance = inst;
}
WebServerClientTest() {}
explicit WebServerClientTest(wpi::uv::Loop& loop) : m_loop(loop) {}
WebServerClientTest(const WebServerClientTest&) = delete;
WebServerClientTest& operator=(const WebServerClientTest&) = delete;
bool Initialize(std::shared_ptr<uv::Loop>& loop);
bool Initialize();
void AttemptConnect();
void Exit();
void SendMessage(const wpi::json& msg);
const wpi::json& GetLastMessage();
bool IsConnectedWS() { return m_ws_connected; }
void SetTerminateFlag(bool flag) { m_terminateFlag = flag; }
private:
void InitializeWebSocket(const std::string& host, int port,
const std::string& uri);
bool m_terminateFlag = false;
static std::shared_ptr<WebServerClientTest> g_instance;
bool m_tcp_connected = false;
std::shared_ptr<wpi::uv::Timer> m_connect_timer;
int m_connect_attempts = 0;
std::shared_ptr<wpi::uv::Loop> m_loop;
wpi::uv::Loop& m_loop;
std::shared_ptr<wpi::uv::Tcp> m_tcp_client;
wpi::json m_json;