hydrar/mistserver
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rewrite of Comms

Browse source
This commit is contained in:
Thulinma 2020-10-30 22:38:29 +01:00
parent c6265f6659
commit 7297336e46
14 changed files with 173 additions and 303 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

317
lib/comms.cpp
View file

@ -27,35 +27,23 @@ namespace Comms{
sem.close(); sem.close();
} }
void Comms::addCommonFields(){ void Comms::addFields(){
dataAccX.addField("status", RAX_UINT); dataAccX.addField("status", RAX_UINT);
dataAccX.addField("command", RAX_64UINT); dataAccX.addField("pid", RAX_64UINT);
dataAccX.addField("timer", RAX_UINT);
dataAccX.addField("pid", RAX_32UINT);
dataAccX.addField("killtime", RAX_64UINT);
} }
void Comms::commonFieldAccess(){ void Comms::nullFields(){
setPid(getpid());
}
void Comms::fieldAccess(){
status = dataAccX.getFieldAccX("status"); status = dataAccX.getFieldAccX("status");
command = dataAccX.getFieldAccX("command");
timer = dataAccX.getFieldAccX("timer");
pid = dataAccX.getFieldAccX("pid"); pid = dataAccX.getFieldAccX("pid");
killTime = dataAccX.getFieldAccX("killtime");
} }
size_t Comms::firstValid() const{ size_t Comms::recordCount() const{
if (!master){return index;}
return dataAccX.getStartPos();
}
size_t Comms::endValid() const{
if (!master){return index + 1;} if (!master){return index + 1;}
return dataAccX.getEndPos(); return dataAccX.getRCount();
}
void Comms::deleteFirst(){
if (!master){return;}
dataAccX.deleteRecords(1);
} }
uint8_t Comms::getStatus() const{return status.uint(index);} uint8_t Comms::getStatus() const{return status.uint(index);}
@ -66,22 +54,6 @@ namespace Comms{
status.set(_status, idx); status.set(_status, idx);
} }
uint64_t Comms::getCommand() const{return command.uint(index);}
uint64_t Comms::getCommand(size_t idx) const{return (master ? command.uint(idx) : 0);}
void Comms::setCommand(uint64_t _cmd){command.set(_cmd, index);}
void Comms::setCommand(uint64_t _cmd, size_t idx){
if (!master){return;}
command.set(_cmd, idx);
}
uint8_t Comms::getTimer() const{return timer.uint(index);}
uint8_t Comms::getTimer(size_t idx) const{return (master ? timer.uint(idx) : 0);}
void Comms::setTimer(uint8_t _timer){timer.set(_timer, index);}
void Comms::setTimer(uint8_t _timer, size_t idx){
if (!master){return;}
timer.set(_timer, idx);
}
uint32_t Comms::getPid() const{return pid.uint(index);} uint32_t Comms::getPid() const{return pid.uint(index);}
uint32_t Comms::getPid(size_t idx) const{return (master ? pid.uint(idx) : 0);} uint32_t Comms::getPid(size_t idx) const{return (master ? pid.uint(idx) : 0);}
void Comms::setPid(uint32_t _pid){pid.set(_pid, index);} void Comms::setPid(uint32_t _pid){pid.set(_pid, index);}
@ -90,48 +62,28 @@ namespace Comms{
pid.set(_pid, idx); pid.set(_pid, idx);
} }
void Comms::kill(size_t idx, bool force){
if (!master){return;}
if (force){
Util::Procs::Murder(pid.uint(idx)); // hard kill
status.set(COMM_STATUS_INVALID, idx);
return;
}
uint64_t kTime = killTime.uint(idx);
uint64_t now = Util::bootSecs();
if (!kTime){
kTime = now;
killTime.set(kTime, idx);
}
if (now - kTime > 30){
Util::Procs::Murder(pid.uint(idx)); // hard kill
status.set(COMM_STATUS_INVALID, idx);
}else{
Util::Procs::Stop(pid.uint(idx)); // soft kill
}
}
void Comms::finishAll(){ void Comms::finishAll(){
if (!master){return;} if (!master){return;}
size_t c = 0; size_t c = 0;
bool keepGoing = true;
do{ do{
for (size_t i = firstValid(); i < endValid(); i++){ keepGoing = false;
if (getStatus(i) == COMM_STATUS_INVALID){continue;} for (size_t i = 0; i < recordCount(); i++){
if (getStatus(i) == COMM_STATUS_INVALID || getStatus(i) == COMM_STATUS_DISCONNECT){continue;}
uint64_t cPid = getPid(i);
if (cPid > 1){
Util::Procs::Stop(cPid); // soft kill
keepGoing = true;
}
setStatus(COMM_STATUS_REQDISCONNECT, i); setStatus(COMM_STATUS_REQDISCONNECT, i);
} }
while (getStatus(firstValid()) == COMM_STATUS_INVALID){deleteFirst();} if (keepGoing){Util::sleep(250);}
}while (firstValid() < endValid() && ++c < 10); }while (keepGoing && ++c < 8);
} }
void Comms::keepAlive(){ Comms::operator bool() const{
if (isAlive()){setTimer(0);} if (master){return dataPage;}
} return dataPage && (getStatus() != COMM_STATUS_INVALID) && (getStatus() != COMM_STATUS_DISCONNECT);
bool Comms::isAlive() const{
if (!*this){return false;}
if (getStatus() == COMM_STATUS_INVALID){return false;}
if (getStatus() == COMM_STATUS_DISCONNECT){return false;}
return getTimer() < 126;
} }
void Comms::setMaster(bool _master){ void Comms::setMaster(bool _master){
@ -139,6 +91,54 @@ namespace Comms{
dataPage.master = _master; dataPage.master = _master;
} }
void Comms::reload(const std::string & prefix, size_t baseSize, bool _master, bool reIssue){
master = _master;
if (!currentSize){currentSize = baseSize;}
if (master){
dataPage.init(prefix, currentSize, false, false);
if (dataPage){
dataPage.master = true;
dataAccX = Util::RelAccX(dataPage.mapped);
fieldAccess();
}else{
dataPage.init(prefix, currentSize, true);
dataAccX = Util::RelAccX(dataPage.mapped, false);
addFields();
fieldAccess();
size_t reqCount = (currentSize - dataAccX.getOffset()) / dataAccX.getRSize();
dataAccX.setRCount(reqCount);
dataAccX.setPresent(reqCount);
dataAccX.setReady();
}
return;
}
dataPage.init(prefix, currentSize, false);
if (!dataPage){
WARN_MSG("Unable to open page %s", prefix.c_str());
return;
}
dataAccX = Util::RelAccX(dataPage.mapped);
fieldAccess();
if (index == INVALID_RECORD_INDEX || reIssue){
size_t reqCount = dataAccX.getRCount();
for (index = 0; index < reqCount; ++index){
if (getStatus() == COMM_STATUS_INVALID){
IPC::semGuard G(&sem);
if (getStatus() != COMM_STATUS_INVALID){continue;}
nullFields();
setStatus(COMM_STATUS_ACTIVE);
break;
}
}
if (index >= reqCount){
FAIL_MSG("Could not register entry on comm page!");
dataPage.close();
}
}
}
Statistics::Statistics() : Comms(){sem.open(SEM_STATISTICS, O_CREAT | O_RDWR, ACCESSPERMS, 1);} Statistics::Statistics() : Comms(){sem.open(SEM_STATISTICS, O_CREAT | O_RDWR, ACCESSPERMS, 1);}
void Statistics::unload(){ void Statistics::unload(){
@ -147,76 +147,39 @@ namespace Comms{
} }
void Statistics::reload(bool _master, bool reIssue){ void Statistics::reload(bool _master, bool reIssue){
master = _master; Comms::reload(COMMS_STATISTICS, COMMS_STATISTICS_INITSIZE, _master, reIssue);
bool setFields = true; }
if (!currentSize){currentSize = COMMS_STATISTICS_INITSIZE;} void Statistics::addFields(){
dataPage.init(COMMS_STATISTICS, currentSize, false, false); Comms::addFields();
if (master){ dataAccX.addField("sync", RAX_UINT);
if (dataPage.mapped){ dataAccX.addField("now", RAX_64UINT);
setFields = false; dataAccX.addField("time", RAX_64UINT);
dataPage.master = true; dataAccX.addField("lastsecond", RAX_64UINT);
}else{ dataAccX.addField("down", RAX_64UINT);
dataPage.init(COMMS_STATISTICS, currentSize, true); dataAccX.addField("up", RAX_64UINT);
} dataAccX.addField("host", RAX_RAW, 16);
} dataAccX.addField("stream", RAX_STRING, 100);
if (!dataPage.mapped){ dataAccX.addField("connector", RAX_STRING, 20);
FAIL_MSG("Unable to open page " COMMS_STATISTICS); dataAccX.addField("crc", RAX_32UINT);
return; }
}
if (master){ void Statistics::nullFields(){
dataAccX = Util::RelAccX(dataPage.mapped, false); Comms::nullFields();
if (setFields){ setCRC(0);
addCommonFields(); setConnector("");
setStream("");
dataAccX.addField("sync", RAX_UINT); setHost("");
dataAccX.addField("now", RAX_64UINT); setUp(0);
dataAccX.addField("time", RAX_64UINT); setDown(0);
dataAccX.addField("lastsecond", RAX_64UINT); setLastSecond(0);
dataAccX.addField("down", RAX_64UINT); setTime(0);
dataAccX.addField("up", RAX_64UINT); setNow(0);
dataAccX.addField("host", RAX_RAW, 16); setSync(0);
dataAccX.addField("stream", RAX_STRING, 100); }
dataAccX.addField("connector", RAX_STRING, 20);
dataAccX.addField("crc", RAX_32UINT);
dataAccX.setRCount((currentSize - dataAccX.getOffset()) / dataAccX.getRSize());
dataAccX.setReady();
}
}else{
dataAccX = Util::RelAccX(dataPage.mapped);
if (index == INVALID_RECORD_INDEX || reIssue){
sem.wait();
for (index = 0; index < dataAccX.getEndPos(); ++index){
if (dataAccX.getInt("status", index) == COMM_STATUS_INVALID){
// Reverse! clear entry and claim it.
dataAccX.setInt("crc", 0, index);
dataAccX.setString("connector", "", index);
dataAccX.setString("stream", "", index);
dataAccX.setString("host", "", index);
dataAccX.setInt("up", 0, index);
dataAccX.setInt("down", 0, index);
dataAccX.setInt("lastsecond", 0, index);
dataAccX.setInt("time", 0, index);
dataAccX.setInt("now", 0, index);
dataAccX.setInt("sync", 0, index);
dataAccX.setInt("killtime", 0, index);
dataAccX.setInt("pid", 0, index);
dataAccX.setInt("timer", 0, index);
dataAccX.setInt("command", 0, index);
dataAccX.setInt("status", 0, index);
break;
}
}
if (index == dataAccX.getEndPos()){dataAccX.addRecords(1);}
sem.post();
}
}
commonFieldAccess();
void Statistics::fieldAccess(){
Comms::fieldAccess();
sync = dataAccX.getFieldAccX("sync"); sync = dataAccX.getFieldAccX("sync");
now = dataAccX.getFieldAccX("now"); now = dataAccX.getFieldAccX("now");
time = dataAccX.getFieldAccX("time"); time = dataAccX.getFieldAccX("time");
@ -336,7 +299,7 @@ namespace Comms{
Users::Users() : Comms(){} Users::Users() : Comms(){}
Users::Users(const Users &rhs) : Comms(){ Users::Users(const Users &rhs) : Comms(){
if (rhs && rhs.isAlive()){ if (rhs){
reload(rhs.streamName, (size_t)rhs.getTrack()); reload(rhs.streamName, (size_t)rhs.getTrack());
if (*this){ if (*this){
setKeyNum(rhs.getKeyNum()); setKeyNum(rhs.getKeyNum());
@ -352,79 +315,35 @@ namespace Comms{
snprintf(semName, NAME_BUFFER_SIZE, SEM_USERS, streamName.c_str()); snprintf(semName, NAME_BUFFER_SIZE, SEM_USERS, streamName.c_str());
sem.open(semName, O_CREAT | O_RDWR, ACCESSPERMS, 1); sem.open(semName, O_CREAT | O_RDWR, ACCESSPERMS, 1);
master = _master;
if (!currentSize){currentSize = COMMS_USERS_INITSIZE;}
char userPageName[NAME_BUFFER_SIZE]; char userPageName[NAME_BUFFER_SIZE];
snprintf(userPageName, NAME_BUFFER_SIZE, COMMS_USERS, streamName.c_str()); snprintf(userPageName, NAME_BUFFER_SIZE, COMMS_USERS, streamName.c_str());
bool newPage = false; Comms::reload(userPageName, COMMS_USERS_INITSIZE, _master, reIssue);
if (master){ }
dataPage.init(userPageName, currentSize, false, false);
if (dataPage){
dataPage.master = true;
}else{
dataPage.init(userPageName, currentSize, true);
newPage = true;
}
}else{
dataPage.init(userPageName, currentSize, false);
}
if (!dataPage.mapped){
HIGH_MSG("Unable to open page %s", userPageName);
return;
}
if (master){ void Users::addFields(){
if (newPage){ Comms::addFields();
dataAccX = Util::RelAccX(dataPage.mapped, false); dataAccX.addField("track", RAX_64UINT);
addCommonFields(); dataAccX.addField("keynum", RAX_64UINT);
}
dataAccX.addField("track", RAX_32UINT); void Users::nullFields(){
dataAccX.addField("keynum", RAX_32UINT); Comms::nullFields();
setTrack(0);
dataAccX.setRCount((currentSize - dataAccX.getOffset()) / dataAccX.getRSize()); setKeyNum(0);
dataAccX.setReady(); }
}else{
dataAccX = Util::RelAccX(dataPage.mapped);
}
}else{
dataAccX = Util::RelAccX(dataPage.mapped);
if (index == INVALID_RECORD_INDEX || reIssue){
sem.wait();
for (index = 0; index < dataAccX.getEndPos(); ++index){
if (dataAccX.getInt("status", index) == COMM_STATUS_INVALID){
// Reverse! clear entry and claim it.
dataAccX.setInt("keynum", 0, index);
dataAccX.setInt("track", 0, index);
dataAccX.setInt("killtime", 0, index);
dataAccX.setInt("pid", 0, index);
dataAccX.setInt("timer", 0, index);
dataAccX.setInt("command", 0, index);
dataAccX.setInt("status", 0, index);
break;
}
}
if (index == dataAccX.getEndPos()){dataAccX.addRecords(1);}
sem.post();
}
}
commonFieldAccess();
void Users::fieldAccess(){
Comms::fieldAccess();
track = dataAccX.getFieldAccX("track"); track = dataAccX.getFieldAccX("track");
keyNum = dataAccX.getFieldAccX("keynum"); keyNum = dataAccX.getFieldAccX("keynum");
setPid(getpid());
} }
void Users::reload(const std::string &_streamName, size_t idx, uint8_t initialState){ void Users::reload(const std::string &_streamName, size_t idx, uint8_t initialState){
reload(_streamName); reload(_streamName);
if (dataPage.mapped){ if (dataPage){
setTrack(idx); setTrack(idx);
setKeyNum(0);
setStatus(initialState); setStatus(initialState);
} }
} }

70
lib/comms.h
View file

@ -7,25 +7,21 @@
#define COMM_STATUS_SOURCE 0x80 #define COMM_STATUS_SOURCE 0x80
#define COMM_STATUS_REQDISCONNECT 0xFD #define COMM_STATUS_REQDISCONNECT 0xFD
#define COMM_STATUS_DISCONNECT 0xFE #define COMM_STATUS_DISCONNECT 0xFE
#define COMM_STATUS_INVALID 0xFF #define COMM_STATUS_INVALID 0x0
#define COMM_STATUS_ACTIVE 0x1
#define COMM_LOOP(comm, onActive, onDisconnect) \
#define COMM_LOOP(comm, onActive, onDisconnect) \
{\ {\
for (size_t id = comm.firstValid(); id != comm.endValid(); id++){\ for (size_t id = 0; id < comm.recordCount(); id++){\
if (comm.getStatus(id) == COMM_STATUS_INVALID){continue;}\ if (comm.getStatus(id) == COMM_STATUS_INVALID){continue;}\
onActive; \
if (!Util::Procs::isRunning(comm.getPid(id))){\ if (!Util::Procs::isRunning(comm.getPid(id))){\
comm.setStatus(COMM_STATUS_DISCONNECT, id); \ comm.setStatus(COMM_STATUS_DISCONNECT, id);\
}\ }\
if ((comm.getTimer(id) & 0x7F) >= 126 || comm.getStatus(id) == COMM_STATUS_DISCONNECT){\ onActive;\
onDisconnect; \ if (comm.getStatus(id) == COMM_STATUS_DISCONNECT){\
comm.setStatus(COMM_STATUS_INVALID, id); \ onDisconnect;\
}\ comm.setStatus(COMM_STATUS_INVALID, id);\
if ((comm.getTimer(id) & 0x7F) <= 124){\
if ((comm.getTimer(id) & 0x7F) == 124){\
HIGH_MSG("Timeout occurred for entry %zu, ignoring further timeout", id); \
}\
comm.setTimer(comm.getTimer(id) + 1, id); \
}\ }\
}\ }\
} }
@ -35,63 +31,37 @@ namespace Comms{
public: public:
Comms(); Comms();
~Comms(); ~Comms();
operator bool() const;
operator bool() const{return dataPage.mapped;} void reload(const std::string & prefix, size_t baseSize, bool _master = false, bool reIssue = false);
virtual void addFields();
void addCommonFields(); virtual void nullFields();
void commonFieldAccess(); virtual void fieldAccess();
size_t recordCount() const;
size_t firstValid() const;
size_t endValid() const;
void deleteFirst();
uint8_t getStatus() const; uint8_t getStatus() const;
uint8_t getStatus(size_t idx) const; uint8_t getStatus(size_t idx) const;
void setStatus(uint8_t _status); void setStatus(uint8_t _status);
void setStatus(uint8_t _status, size_t idx); void setStatus(uint8_t _status, size_t idx);
uint64_t getCommand() const; uint64_t getCommand() const;
uint64_t getCommand(size_t idx) const; uint64_t getCommand(size_t idx) const;
void setCommand(uint64_t _cmd); void setCommand(uint64_t _cmd);
void setCommand(uint64_t _cmd, size_t idx); void setCommand(uint64_t _cmd, size_t idx);
uint8_t getTimer() const;
uint8_t getTimer(size_t idx) const;
void setTimer(uint8_t _timer);
void setTimer(uint8_t _timer, size_t idx);
uint32_t getPid() const; uint32_t getPid() const;
uint32_t getPid(size_t idx) const; uint32_t getPid(size_t idx) const;
void setPid(uint32_t _pid); void setPid(uint32_t _pid);
void setPid(uint32_t _pid, size_t idx); void setPid(uint32_t _pid, size_t idx);
void kill(size_t idx, bool force = false);
void finishAll(); void finishAll();
void keepAlive();
bool isAlive() const;
void setMaster(bool _master); void setMaster(bool _master);
const std::string &pageName() const{return dataPage.name;} const std::string &pageName() const{return dataPage.name;}
protected: protected:
bool master; bool master;
size_t index; size_t index;
size_t currentSize; size_t currentSize;
IPC::semaphore sem; IPC::semaphore sem;
IPC::sharedPage dataPage; IPC::sharedPage dataPage;
Util::RelAccX dataAccX; Util::RelAccX dataAccX;
Util::FieldAccX status; Util::FieldAccX status;
Util::FieldAccX command;
Util::FieldAccX timer;
Util::FieldAccX pid; Util::FieldAccX pid;
Util::FieldAccX killTime;
}; };
class Statistics : public Comms{ class Statistics : public Comms{
@ -100,6 +70,9 @@ namespace Comms{
operator bool() const{return dataPage.mapped && (master || index != INVALID_RECORD_INDEX);} operator bool() const{return dataPage.mapped && (master || index != INVALID_RECORD_INDEX);}
void unload(); void unload();
void reload(bool _master = false, bool reIssue = false); void reload(bool _master = false, bool reIssue = false);
virtual void addFields();
virtual void nullFields();
virtual void fieldAccess();
uint8_t getSync() const; uint8_t getSync() const;
uint8_t getSync(size_t idx) const; uint8_t getSync(size_t idx) const;
@ -172,7 +145,10 @@ namespace Comms{
Users(); Users();
Users(const Users &rhs); Users(const Users &rhs);
void reload(const std::string &_streamName = "", bool _master = false, bool reIssue = false); void reload(const std::string &_streamName = "", bool _master = false, bool reIssue = false);
void reload(const std::string &_streamName, size_t track, uint8_t initialState = 0x00); void reload(const std::string &_streamName, size_t track, uint8_t initialState = COMM_STATUS_ACTIVE);
virtual void addFields();
virtual void nullFields();
virtual void fieldAccess();
operator bool() const{return dataPage.mapped;} operator bool() const{return dataPage.mapped;}

2
lib/defines.h
View file

@ -198,7 +198,7 @@ static inline void show_stackframe(){}
#define COMMS_STATISTICS_INITSIZE 8 * 1024 * 1024 #define COMMS_STATISTICS_INITSIZE 8 * 1024 * 1024
#define COMMS_USERS "MstUser%s" //%s stream name #define COMMS_USERS "MstUser%s" //%s stream name
#define COMMS_USERS_INITSIZE 8 * 1024 * 1024 #define COMMS_USERS_INITSIZE 512 * 1024
#define SEM_STATISTICS "/MstStat" #define SEM_STATISTICS "/MstStat"
#define SEM_USERS "/MstUser%s" //%s stream name #define SEM_USERS "/MstUser%s" //%s stream name

5
src/controller/controller_statistics.cpp
View file

@ -490,10 +490,7 @@ void Controller::SharedMemStats(void *config){
}else{/*LTS-START*/ }else{/*LTS-START*/
if (Controller::killOnExit){ if (Controller::killOnExit){
WARN_MSG("Killing all connected clients to force full shutdown"); WARN_MSG("Killing all connected clients to force full shutdown");
for (uint32_t id = statComm.firstValid(); id != statComm.endValid(); id++){ statComm.finishAll();
if (statComm.getStatus(id) == COMM_STATUS_INVALID){continue;}
statComm.kill(id, true);
}
} }
/*LTS-END*/ /*LTS-END*/
} }

28
src/input/input.cpp
View file

@ -857,15 +857,14 @@ namespace Mist{
tid = thisPacket.getTrackId(); tid = thisPacket.getTrackId();
idx = M.trackIDToIndex(tid, getpid()); idx = M.trackIDToIndex(tid, getpid());
if (thisPacket && !userSelect.count(idx)){ if (thisPacket && !userSelect.count(idx)){
userSelect[idx].reload(streamName, idx, COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK); userSelect[idx].reload(streamName, idx, COMM_STATUS_ACTIVE | COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK);
} }
while (thisPacket && config->is_active && userSelect[idx].isAlive()){ while (thisPacket && config->is_active && userSelect[idx]){
if (userSelect[idx].getStatus() == COMM_STATUS_REQDISCONNECT){ if (userSelect[idx].getStatus() == COMM_STATUS_REQDISCONNECT){
Util::logExitReason("buffer requested shutdown"); Util::logExitReason("buffer requested shutdown");
break; break;
} }
bufferLivePacket(thisPacket); bufferLivePacket(thisPacket);
userSelect[idx].keepAlive();
getNext(); getNext();
if (!thisPacket){ if (!thisPacket){
Util::logExitReason("invalid packet from getNext"); Util::logExitReason("invalid packet from getNext");
@ -874,14 +873,14 @@ namespace Mist{
tid = thisPacket.getTrackId(); tid = thisPacket.getTrackId();
idx = M.trackIDToIndex(tid, getpid()); idx = M.trackIDToIndex(tid, getpid());
if (thisPacket && !userSelect.count(idx)){ if (thisPacket && !userSelect.count(idx)){
userSelect[idx].reload(streamName, idx, COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK); userSelect[idx].reload(streamName, idx, COMM_STATUS_ACTIVE | COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK);
} }
if (Util::bootSecs() - statTimer > 1){ if (Util::bootSecs() - statTimer > 1){
// Connect to stats for INPUT detection // Connect to stats for INPUT detection
if (!statComm){statComm.reload();} if (!statComm){statComm.reload();}
if (statComm){ if (statComm){
if (!statComm.isAlive()){ if (!statComm){
config->is_active = false; config->is_active = false;
Util::logExitReason("received shutdown request from controller"); Util::logExitReason("received shutdown request from controller");
return; return;
@ -896,7 +895,6 @@ namespace Mist{
statComm.setTime(now - startTime); statComm.setTime(now - startTime);
statComm.setLastSecond(0); statComm.setLastSecond(0);
statComm.setHost(getConnectedBinHost()); statComm.setHost(getConnectedBinHost());
statComm.keepAlive();
} }
statTimer = Util::bootSecs(); statTimer = Util::bootSecs();
@ -911,33 +909,31 @@ namespace Mist{
getNext(); getNext();
if (thisPacket && !userSelect.count(thisPacket.getTrackId())){ if (thisPacket && !userSelect.count(thisPacket.getTrackId())){
size_t tid = thisPacket.getTrackId(); size_t tid = thisPacket.getTrackId();
userSelect[tid].reload(streamName, tid, COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK); userSelect[tid].reload(streamName, tid, COMM_STATUS_ACTIVE | COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK);
} }
while (thisPacket && config->is_active && userSelect[thisPacket.getTrackId()].isAlive()){ while (thisPacket && config->is_active && userSelect[thisPacket.getTrackId()]){
thisPacket.nullMember("bpos"); thisPacket.nullMember("bpos");
while (config->is_active && userSelect[thisPacket.getTrackId()].isAlive() && while (config->is_active && userSelect[thisPacket.getTrackId()] &&
Util::bootMS() + SIMULATED_LIVE_BUFFER < (thisPacket.getTime() + timeOffset) + simStartTime){ Util::bootMS() + SIMULATED_LIVE_BUFFER < (thisPacket.getTime() + timeOffset) + simStartTime){
Util::sleep(std::min(((thisPacket.getTime() + timeOffset) + simStartTime) - (Util::getMS() + SIMULATED_LIVE_BUFFER), Util::sleep(std::min(((thisPacket.getTime() + timeOffset) + simStartTime) - (Util::getMS() + SIMULATED_LIVE_BUFFER),
(uint64_t)1000)); (uint64_t)1000));
userSelect[thisPacket.getTrackId()].keepAlive();
} }
uint64_t originalTime = thisPacket.getTime(); uint64_t originalTime = thisPacket.getTime();
thisPacket.setTime(originalTime + timeOffset); thisPacket.setTime(originalTime + timeOffset);
bufferLivePacket(thisPacket); bufferLivePacket(thisPacket);
thisPacket.setTime(originalTime); thisPacket.setTime(originalTime);
userSelect[thisPacket.getTrackId()].keepAlive();
getNext(); getNext();
if (thisPacket && !userSelect.count(thisPacket.getTrackId())){ if (thisPacket && !userSelect.count(thisPacket.getTrackId())){
size_t tid = thisPacket.getTrackId(); size_t tid = thisPacket.getTrackId();
userSelect[tid].reload(streamName, tid, COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK); userSelect[tid].reload(streamName, tid, COMM_STATUS_ACTIVE | COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK);
} }
if (Util::bootSecs() - statTimer > 1){ if (Util::bootSecs() - statTimer > 1){
// Connect to stats for INPUT detection // Connect to stats for INPUT detection
if (!statComm){statComm.reload();} if (!statComm){statComm.reload();}
if (statComm){ if (statComm){
if (!statComm.isAlive()){ if (statComm.getStatus() == COMM_STATUS_REQDISCONNECT){
config->is_active = false; config->is_active = false;
Util::logExitReason("received shutdown request from controller"); Util::logExitReason("received shutdown request from controller");
return; return;
@ -952,7 +948,6 @@ namespace Mist{
statComm.setTime(now - startTime); statComm.setTime(now - startTime);
statComm.setLastSecond(0); statComm.setLastSecond(0);
statComm.setHost(getConnectedBinHost()); statComm.setHost(getConnectedBinHost());
statComm.keepAlive();
} }
statTimer = Util::bootSecs(); statTimer = Util::bootSecs();
@ -961,7 +956,7 @@ namespace Mist{
if (!thisPacket){ if (!thisPacket){
Util::logExitReason("invalid packet from getNext"); Util::logExitReason("invalid packet from getNext");
} }
if (thisPacket && !userSelect[thisPacket.getTrackId()].isAlive()){ if (thisPacket && !userSelect[thisPacket.getTrackId()]){
Util::logExitReason("buffer shutdown"); Util::logExitReason("buffer shutdown");
} }
} }
@ -1411,8 +1406,7 @@ namespace Mist{
bool isAlive = false; bool isAlive = false;
for (std::map<size_t, Comms::Users>::iterator it = userSelect.begin(); it != userSelect.end(); it++){ for (std::map<size_t, Comms::Users>::iterator it = userSelect.begin(); it != userSelect.end(); it++){
if (it->second.isAlive()){isAlive = true;} if (it->second){isAlive = true;}
it->second.keepAlive();
} }
return isAlive && config->is_active; return isAlive && config->is_active;
} }

8
src/input/input_buffer.cpp
View file

@ -155,9 +155,7 @@ namespace Mist{
{ {
Comms::Users cleanUsers; Comms::Users cleanUsers;
cleanUsers.reload(streamName); cleanUsers.reload(streamName);
for (size_t i = cleanUsers.firstValid(); i < cleanUsers.endValid(); ++i){ cleanUsers.finishAll();
cleanUsers.setStatus(COMM_STATUS_INVALID, i);
}
cleanUsers.setMaster(true); cleanUsers.setMaster(true);
} }
// Delete the live stream semaphore, if any. // Delete the live stream semaphore, if any.
@ -389,8 +387,8 @@ namespace Mist{
} }
void inputBuffer::removeTrack(size_t tid){ void inputBuffer::removeTrack(size_t tid){
size_t lastUser = users.endValid(); size_t lastUser = users.recordCount();
for (size_t i = users.firstValid(); i < lastUser; ++i){ for (size_t i = 0; i < lastUser; ++i){
if (users.getStatus(i) == COMM_STATUS_INVALID){continue;} if (users.getStatus(i) == COMM_STATUS_INVALID){continue;}
if (!(users.getStatus(i) & COMM_STATUS_SOURCE)){continue;} if (!(users.getStatus(i) & COMM_STATUS_SOURCE)){continue;}
if (users.getTrack(i) != tid){continue;} if (users.getTrack(i) != tid){continue;}

2
src/input/input_dtsc.cpp
View file

@ -169,7 +169,7 @@ namespace Mist{
std::set<size_t> validTracks = M.getMySourceTracks(getpid()); std::set<size_t> validTracks = M.getMySourceTracks(getpid());
userSelect.clear(); userSelect.clear();
for (std::set<size_t>::iterator it = validTracks.begin(); it != validTracks.end(); ++it){ for (std::set<size_t>::iterator it = validTracks.begin(); it != validTracks.end(); ++it){
userSelect[*it].reload(streamName, *it, COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK); userSelect[*it].reload(streamName, *it, COMM_STATUS_ACTIVE | COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK);
} }
break; break;
} }

5
src/input/input_rtsp.cpp
View file

@ -212,7 +212,7 @@ namespace Mist{
// Connect to stats for INPUT detection // Connect to stats for INPUT detection
statComm.reload(); statComm.reload();
if (statComm){ if (statComm){
if (!statComm.isAlive()){ if (statComm.getStatus() == COMM_STATUS_REQDISCONNECT){
config->is_active = false; config->is_active = false;
Util::logExitReason("received shutdown request from controller"); Util::logExitReason("received shutdown request from controller");
return; return;
@ -227,7 +227,6 @@ namespace Mist{
statComm.setTime(now - startTime); statComm.setTime(now - startTime);
statComm.setLastSecond(0); statComm.setLastSecond(0);
statComm.setHost(getConnectedBinHost()); statComm.setHost(getConnectedBinHost());
statComm.keepAlive();
} }
} }
} }
@ -402,7 +401,7 @@ namespace Mist{
}else{ }else{
if (!userSelect.count(idx)){ if (!userSelect.count(idx)){
WARN_MSG("Reloading track %zu, index %zu", pkt.getTrackId(), idx); WARN_MSG("Reloading track %zu, index %zu", pkt.getTrackId(), idx);
userSelect[idx].reload(streamName, idx, COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK); userSelect[idx].reload(streamName, idx, COMM_STATUS_ACTIVE | COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK);
} }
if (userSelect[idx].getStatus() == COMM_STATUS_REQDISCONNECT){ if (userSelect[idx].getStatus() == COMM_STATUS_REQDISCONNECT){
Util::logExitReason("buffer requested shutdown"); Util::logExitReason("buffer requested shutdown");

10
src/input/input_ts.cpp
View file

@ -58,8 +58,7 @@ void parseThread(void *mistIn){
threadTimer[tid] = Util::bootSecs(); threadTimer[tid] = Util::bootSecs();
} }
while (Util::bootSecs() - threadTimer[tid] < THREAD_TIMEOUT && cfgPointer->is_active && while (Util::bootSecs() - threadTimer[tid] < THREAD_TIMEOUT && cfgPointer->is_active &&
(!dataTrack || (userConn ? userConn.isAlive() : true))){ (!dataTrack || (userConn ? userConn : true))){
if (dataTrack){userConn.keepAlive();}
liveStream.parse(tid); liveStream.parse(tid);
if (!liveStream.hasPacket(tid)){ if (!liveStream.hasPacket(tid)){
Util::sleep(100); Util::sleep(100);
@ -95,7 +94,7 @@ void parseThread(void *mistIn){
idx = meta.trackIDToIndex(tid, getpid()); idx = meta.trackIDToIndex(tid, getpid());
if (idx != INVALID_TRACK_ID){ if (idx != INVALID_TRACK_ID){
//Successfully assigned a track index! Inform the buffer we're pushing //Successfully assigned a track index! Inform the buffer we're pushing
userConn.reload(globalStreamName, idx, COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK); userConn.reload(globalStreamName, idx, COMM_STATUS_ACTIVE | COMM_STATUS_SOURCE | COMM_STATUS_DONOTTRACK);
} }
//Any kind of failure? Retry later. //Any kind of failure? Retry later.
if (idx == INVALID_TRACK_ID || !meta.trackValid(idx)){ if (idx == INVALID_TRACK_ID || !meta.trackValid(idx)){
@ -137,7 +136,7 @@ void parseThread(void *mistIn){
std::string reason = "unknown reason"; std::string reason = "unknown reason";
if (!(Util::bootSecs() - threadTimer[tid] < THREAD_TIMEOUT)){reason = "thread timeout";} if (!(Util::bootSecs() - threadTimer[tid] < THREAD_TIMEOUT)){reason = "thread timeout";}
if (!cfgPointer->is_active){reason = "input shutting down";} if (!cfgPointer->is_active){reason = "input shutting down";}
if (!(!liveStream.isDataTrack(tid) || userConn.isAlive())){ if (!(!liveStream.isDataTrack(tid) || userConn)){
reason = "buffer disconnect"; reason = "buffer disconnect";
cfgPointer->is_active = false; cfgPointer->is_active = false;
} }
@ -588,7 +587,7 @@ namespace Mist{
// Connect to stats for INPUT detection // Connect to stats for INPUT detection
statComm.reload(); statComm.reload();
if (statComm){ if (statComm){
if (!statComm.isAlive()){ if (statComm.getStatus() == COMM_STATUS_REQDISCONNECT){
config->is_active = false; config->is_active = false;
Util::logExitReason("received shutdown request from controller"); Util::logExitReason("received shutdown request from controller");
return; return;
@ -603,7 +602,6 @@ namespace Mist{
statComm.setTime(now - startTime); statComm.setTime(now - startTime);
statComm.setLastSecond(0); statComm.setLastSecond(0);
statComm.setHost(getConnectedBinHost()); statComm.setHost(getConnectedBinHost());
statComm.keepAlive();
} }
std::set<size_t> activeTracks = liveStream.getActiveTracks(); std::set<size_t> activeTracks = liveStream.getActiveTracks();

10
src/output/output.cpp
View file

@ -1605,7 +1605,7 @@ namespace Mist{
} }
emptyCount = 0; // valid packet - reset empty counter emptyCount = 0; // valid packet - reset empty counter
if (!userSelect[nxt.tid].isAlive()){ if (!userSelect[nxt.tid]){
INFO_MSG("Track %zu is not alive!", nxt.tid); INFO_MSG("Track %zu is not alive!", nxt.tid);
return false; return false;
} }
@ -1691,7 +1691,6 @@ namespace Mist{
statComm.setTime(now - myConn.connTime()); statComm.setTime(now - myConn.connTime());
statComm.setLastSecond(thisPacket ? thisPacket.getTime() : 0); statComm.setLastSecond(thisPacket ? thisPacket.getTime() : 0);
statComm.setPid(getpid()); statComm.setPid(getpid());
statComm.keepAlive();
/*LTS-START*/ /*LTS-START*/
// Tag the session with the user agent // Tag the session with the user agent
@ -1710,21 +1709,16 @@ namespace Mist{
if (isPushing()){ if (isPushing()){
for (std::map<size_t, Comms::Users>::iterator it = userSelect.begin(); it != userSelect.end(); it++){ for (std::map<size_t, Comms::Users>::iterator it = userSelect.begin(); it != userSelect.end(); it++){
it->second.keepAlive();
if (it->second.getStatus() == COMM_STATUS_REQDISCONNECT){ if (it->second.getStatus() == COMM_STATUS_REQDISCONNECT){
if (dropPushTrack(it->second.getTrack(), "disconnect request from buffer")){break;} if (dropPushTrack(it->second.getTrack(), "disconnect request from buffer")){break;}
} }
if (!it->second.isAlive()){ if (!it->second){
if (dropPushTrack(it->second.getTrack(), "track mapping no longer valid")){break;} if (dropPushTrack(it->second.getTrack(), "track mapping no longer valid")){break;}
} }
//if (Util::bootSecs() - M.getLastUpdated(it->first) > 5){ //if (Util::bootSecs() - M.getLastUpdated(it->first) > 5){
// if (dropPushTrack(it->second.getTrack(), "track updates being ignored by buffer")){break;} // if (dropPushTrack(it->second.getTrack(), "track updates being ignored by buffer")){break;}
//} //}
} }
}else{
for (std::map<size_t, Comms::Users>::iterator it = userSelect.begin(); it != userSelect.end(); it++){
it->second.keepAlive();
}
} }
} }

7
src/output/output_cmaf.cpp
View file

@ -811,12 +811,7 @@ namespace Mist{
} }
Util::wait(100); Util::wait(100);
//Make sure we don't accidentally timeout while waiting - runs approximately every second. //Make sure we don't accidentally timeout while waiting - runs approximately every second.
if (i % 10 == 0){ if (i % 10 == 0){stats();}
for (std::map<size_t, Comms::Users>::iterator it = userSelect.begin(); it != userSelect.end(); ++it){
it->second.keepAlive();
stats();
}
}
} }
return (keys.getEndValid() > currentKey + 1 && M.getLastms(thisIdx) > M.getTimeForKeyIndex(getMainSelectedTrack(), currentKey+1)); return (keys.getEndValid() > currentKey + 1 && M.getLastms(thisIdx) > M.getTimeForKeyIndex(getMainSelectedTrack(), currentKey+1));
} }

2
src/output/output_rtmp.cpp
View file

@ -1406,7 +1406,7 @@ namespace Mist{
} }
uint64_t idx = reTrackToID[reTrack]; uint64_t idx = reTrackToID[reTrack];
if (idx != INVALID_TRACK_ID && !userSelect.count(idx)){ if (idx != INVALID_TRACK_ID && !userSelect.count(idx)){
userSelect[idx].reload(streamName, idx, COMM_STATUS_SOURCE); userSelect[idx].reload(streamName, idx, COMM_STATUS_ACTIVE | COMM_STATUS_SOURCE);
} }
if (M.getCodec(idx) == "PCM" && M.getSize(idx) == 16){ if (M.getCodec(idx) == "PCM" && M.getSize(idx) == 16){
char *ptr = F.getData(); char *ptr = F.getData();

4
src/output/output_webrtc.cpp
View file

@ -812,7 +812,7 @@ namespace Mist{
videoTrack.rtpToDTSC.setCallbacks(onDTSCConverterHasPacketCallback, onDTSCConverterHasInitDataCallback); videoTrack.rtpToDTSC.setCallbacks(onDTSCConverterHasPacketCallback, onDTSCConverterHasInitDataCallback);
videoTrack.sorter.setCallback(M.getID(vIdx), onRTPSorterHasPacketCallback); videoTrack.sorter.setCallback(M.getID(vIdx), onRTPSorterHasPacketCallback);
userSelect[vIdx].reload(streamName, vIdx, COMM_STATUS_SOURCE); userSelect[vIdx].reload(streamName, vIdx, COMM_STATUS_ACTIVE | COMM_STATUS_SOURCE);
INFO_MSG("Video push received on track %zu", vIdx); INFO_MSG("Video push received on track %zu", vIdx);
} }
@ -834,7 +834,7 @@ namespace Mist{
audioTrack.rtpToDTSC.setCallbacks(onDTSCConverterHasPacketCallback, onDTSCConverterHasInitDataCallback); audioTrack.rtpToDTSC.setCallbacks(onDTSCConverterHasPacketCallback, onDTSCConverterHasInitDataCallback);
audioTrack.sorter.setCallback(M.getID(aIdx), onRTPSorterHasPacketCallback); audioTrack.sorter.setCallback(M.getID(aIdx), onRTPSorterHasPacketCallback);
userSelect[aIdx].reload(streamName, aIdx, COMM_STATUS_SOURCE); userSelect[aIdx].reload(streamName, aIdx, COMM_STATUS_ACTIVE | COMM_STATUS_SOURCE);
INFO_MSG("Audio push received on track %zu", aIdx); INFO_MSG("Audio push received on track %zu", aIdx);
} }

4
src/utils/util_nuke.cpp
View file

@ -135,10 +135,10 @@ int main(int argc, char **argv){
Comms::Users cleanUsers; Comms::Users cleanUsers;
cleanUsers.reload(Util::streamName, true); cleanUsers.reload(Util::streamName, true);
std::set<pid_t> checkPids; std::set<pid_t> checkPids;
for (size_t i = cleanUsers.firstValid(); i < cleanUsers.endValid(); ++i){ for (size_t i = 0; i < cleanUsers.recordCount(); ++i){
uint8_t status = cleanUsers.getStatus(i); uint8_t status = cleanUsers.getStatus(i);
cleanUsers.setStatus(COMM_STATUS_INVALID, i); cleanUsers.setStatus(COMM_STATUS_INVALID, i);
if (status != COMM_STATUS_INVALID && status != COMM_STATUS_DISCONNECT && cleanUsers.getTimer(i) < 126){ if (status != COMM_STATUS_INVALID && status != COMM_STATUS_DISCONNECT){
pid_t pid = cleanUsers.getPid(i); pid_t pid = cleanUsers.getPid(i);
if (pid > 1){ if (pid > 1){
Util::Procs::Stop(pid); Util::Procs::Stop(pid);