3pp-mirror/snapcast
1
0
Fork 0
mirror of https://github.com/badaix/snapcast.git synced 2025-06-26 06:27:05 +02:00
Code Issues Projects Releases Packages Wiki Activity

basic telnet like control server

Browse source
This commit is contained in:
badaix 2015-08-27 23:20:10 +02:00
parent 635daabd8c
commit 504884feb9
14 changed files with 7887 additions and 119 deletions
Download patch file Download diff file Expand all files Collapse all files

86
server/controlServer.cpp
View file

@ -27,18 +27,18 @@
using namespace std;
ControlServer::ControlServer(const ControlServerSettings& controlServerSettings) : settings_(controlServerSettings), sampleFormat_(controlServerSettings.sampleFormat)
ControlServer::ControlServer(size_t port) : port_(port)
{
serverSettings_.bufferMs = settings_.bufferMs;
}
ControlServer::~ControlServer()
{
stop();
}
void ControlServer::send(const msg::BaseMessage* message)
void ControlServer::send(const std::string& message)
{
std::unique_lock<std::mutex> mlock(mutex_);
for (auto it = sessions_.begin(); it != sessions_.end(); )
@ -47,7 +47,7 @@ void ControlServer::send(const msg::BaseMessage* message)
{
logS(kLogErr) << "Session inactive. Removing\n";
// don't block: remove ServerSession in a thread
auto func = [](shared_ptr<ServerSession> s)->void{s->stop();};
auto func = [](shared_ptr<ControlSession> s)->void{s->stop();};
std::thread t(func, *it);
t.detach();
sessions_.erase(it++);
@ -56,73 +56,27 @@ void ControlServer::send(const msg::BaseMessage* message)
++it;
}
std::shared_ptr<const msg::BaseMessage> shared_message(message);
for (auto s : sessions_)
s->add(shared_message);
s->add(message);
}
void ControlServer::onChunkRead(const PipeReader* pipeReader, const msg::PcmChunk* chunk, double duration)
void ControlServer::onMessageReceived(ControlSession* connection, const std::string& message)
{
// logO << "onChunkRead " << duration << "ms\n";
send(chunk);
}
void ControlServer::onResync(const PipeReader* pipeReader, double ms)
{
logO << "onResync " << ms << "ms\n";
}
void ControlServer::onMessageReceived(ServerSession* connection, const msg::BaseMessage& baseMessage, char* buffer)
{
// logO << "getNextMessage: " << baseMessage.type << ", size: " << baseMessage.size << ", id: " << baseMessage.id << ", refers: " << baseMessage.refersTo << ", sent: " << baseMessage.sent.sec << "," << baseMessage.sent.usec << ", recv: " << baseMessage.received.sec << "," << baseMessage.received.usec << "\n";
if (baseMessage.type == message_type::kRequest)
logO << "received: " << message << "\n";
if (message == "quit")
{
msg::Request requestMsg;
requestMsg.deserialize(baseMessage, buffer);
// logO << "request: " << requestMsg.request << "\n";
if (requestMsg.request == kTime)
for (auto it = sessions_.begin(); it != sessions_.end(); ++it)
{
msg::Time timeMsg;
timeMsg.refersTo = requestMsg.id;
timeMsg.latency = (requestMsg.received.sec - requestMsg.sent.sec) + (requestMsg.received.usec - requestMsg.sent.usec) / 1000000.;
// logD << "Latency: " << timeMsg.latency << ", refers to: " << timeMsg.refersTo << "\n";
connection->send(&timeMsg);
}
else if (requestMsg.request == kServerSettings)
{
std::unique_lock<std::mutex> mlock(mutex_);
serverSettings_.refersTo = requestMsg.id;
connection->send(&serverSettings_);
}
else if (requestMsg.request == kSampleFormat)
{
std::unique_lock<std::mutex> mlock(mutex_);
sampleFormat_.refersTo = requestMsg.id;
connection->send(&sampleFormat_);
}
else if (requestMsg.request == kHeader)
{
std::unique_lock<std::mutex> mlock(mutex_);
msg::Header* headerChunk = pipeReader_->getHeader();
headerChunk->refersTo = requestMsg.id;
connection->send(headerChunk);
}
}
else if (baseMessage.type == message_type::kCommand)
{
msg::Command commandMsg;
commandMsg.deserialize(baseMessage, buffer);
if (commandMsg.command == "startStream")
{
msg::Ack ackMsg;
ackMsg.refersTo = commandMsg.id;
connection->send(&ackMsg);
connection->setStreamActive(true);
if (it->get() == connection)
{
sessions_.erase(it);
break;
}
}
}
else
connection->send("echo " + message);
}
@ -142,10 +96,9 @@ void ControlServer::handleAccept(socket_ptr socket)
setsockopt(socket->native(), SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
setsockopt(socket->native(), SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
logS(kLogNotice) << "ControlServer::NewConnection: " << socket->remote_endpoint().address().to_string() << endl;
shared_ptr<ServerSession> session = make_shared<ServerSession>(this, socket);
shared_ptr<ControlSession> session = make_shared<ControlSession>(this, socket);
{
std::unique_lock<std::mutex> mlock(mutex_);
session->setBufferMs(settings_.bufferMs);
session->start();
sessions_.insert(session);
}
@ -155,9 +108,7 @@ void ControlServer::handleAccept(socket_ptr socket)
void ControlServer::start()
{
pipeReader_ = new PipeReader(this, settings_.sampleFormat, settings_.codec, settings_.fifoName, settings_.pipeReadMs);
pipeReader_->start();
acceptor_ = make_shared<tcp::acceptor>(io_service_, tcp::endpoint(tcp::v4(), settings_.port));
acceptor_ = make_shared<tcp::acceptor>(io_service_, tcp::endpoint(tcp::v4(), port_));
startAccept();
acceptThread_ = thread(&ControlServer::acceptor, this);
}
@ -168,7 +119,6 @@ void ControlServer::stop()
acceptor_->cancel();
io_service_.stop();
acceptThread_.join();
pipeReader_->stop();
std::unique_lock<std::mutex> mlock(mutex_);
for (auto it = sessions_.begin(); it != sessions_.end(); ++it)
(*it)->stop();