void EventManager::setTransport(EventTransport *transport)
{
eventTransport_ = transport;
if (eventTransport_) {
bool needSync = false;
{
KAA_MUTEX_LOCKING("pendingEventsGuard_");
KAA_MUTEX_UNIQUE_DECLARE(eventsLock, pendingEventsGuard_);
KAA_MUTEX_LOCKED("pendingEventsGuard_");
needSync = !pendingEvents_.empty();
KAA_MUTEX_UNLOCKED("pendingEventsGuard_");
}
if (!needSync) {
KAA_MUTEX_LOCKING("eventListenersGuard_");
KAA_MUTEX_UNIQUE_DECLARE(eventListenersLock, eventListenersGuard_);
KAA_MUTEX_LOCKED("eventListenersGuard_");
needSync = !eventListenersRequests_.empty();
KAA_MUTEX_UNLOCKED("eventListenersGuard_");
}
if (needSync) {
doSync();
}
}
}
bool MFileDataStore::createValue(const QString &key, const QVariant &value)
{
Q_D(MFileDataStore);
bool returnValue = false;
// QSettings has some kind of a cache so we'll prevent any temporary writes
// by checking if the data can be actually stored before doing anything
if (isWritable()) {
bool originalValueSet = d->settings.contains(key);
QVariant originalValue = d->settings.value(key);
d->settings.setValue(key, value);
bool syncOk = doSync(d->settings, d->watcher);
if (syncOk) {
returnValue = true;
// Emit valueChanged signal when value is changed or a new key is added
if ((originalValueSet && originalValue != value)
|| !originalValueSet) {
d->settingsSnapshot[key] = value;
emit valueChanged(key, value);
}
} else if (originalValueSet) {
// if sync fails, make sure the value in memory is the original
d->settings.setValue(key, originalValue);
} else {
d->settings.remove(key);
}
}
return returnValue;
}
std::int32_t EventManager::findEventListeners(const std::list<std::string>& eventFQNs, IFetchEventListenersPtr listener)
{
if (eventFQNs.empty() || !listener) {
KAA_LOG_WARN("Failed to add event listeners request: bad input data");
throw KaaException("Bad event listeners data");
}
std::int32_t requestId = UuidGenerator::generateRandomInt();
std::shared_ptr<EventListenersInfo> info(new EventListenersInfo);
info->eventFQNs_ = eventFQNs;
info->listener_ = listener;
{
KAA_MUTEX_LOCKING("eventListenersGuard_");
KAA_MUTEX_UNIQUE_DECLARE(eventListenersLock, eventListenersGuard_);
KAA_MUTEX_LOCKED("eventListenersGuard_");
eventListenersRequests_.insert(std::make_pair(requestId, info));
KAA_MUTEX_UNLOCKED("eventListenersGuard_");
}
KAA_LOG_TRACE("Added event listeners resolving request");
doSync();
return requestId;
}
int sync()
{
// write any data in the put buffer
doSync();
// flush file
doFlush();
return 0; // no error, -1 for error
}
void checkWriteBuffer()
{
// if write buffer is not empty, then flush it
if ( pptr() != pbase() )
{
doSync();
// get write position
assert ( static_cast<off_t>(writepos) == doSeek(0,SEEK_CUR) );
}
}
int_type overflow(int_type c = traits_type::eof())
{
if ( c != traits_type::eof() )
{
*pptr() = c;
pbump(1);
doSync();
}
return c;
}
void LogCollector::processLogUploadDecision(LogUploadStrategyDecision decision)
{
switch (decision) {
case LogUploadStrategyDecision::UPLOAD: {
KAA_LOG_DEBUG("Going to upload logs");
doSync();
break;
}
case LogUploadStrategyDecision::NOOP:
KAA_LOG_TRACE("Nothing to do now");
if (storage_->getStatus().getRecordsCount() > 0) {
startLogUploadCheckTimer();
}
break;
default:
KAA_LOG_WARN("Unknown log upload decision");
break;
}
}
void EventManager::commit(TransactionIdPtr trxId, IKaaClientContext &context_)
{
auto it = transactions_.find(trxId);
if (it != transactions_.end()) {
KAA_MUTEX_LOCKING("pendingEventsGuard_");
KAA_MUTEX_UNIQUE_DECLARE(eventsLock, pendingEventsGuard_);
KAA_MUTEX_LOCKED("pendingEventsGuard_");
std::list<Event> & events = it->second;
for (Event &e : events) {
pendingEvents_.insert(std::make_pair(currentEventIndex_++, std::move(e)));
}
transactions_.erase(it);
KAA_MUTEX_UNLOCKING("pendingEventsGuard_");
KAA_UNLOCK(eventsLock);
KAA_MUTEX_UNLOCKED("pendingEventsGuard_");
doSync();
}
}
void EventManager::produceEvent(const std::string& fqn, const std::vector<std::uint8_t>& data,
const std::string& target, TransactionIdPtr trxId)
{
if (fqn.empty()) {
KAA_LOG_WARN("Failed to process outgoing event: bad input data");
return;
}
KAA_LOG_DEBUG(boost::format("Going to produce Event [FQN: %1%, target: %2%, data_size = %3%]") % fqn
% (target.empty() ? "broadcast" : target) % data.size());
Event event;
event.eventClassFQN = fqn;
event.eventData.assign(data.begin(), data.end());
if (target.empty()) {
event.target.set_null();
} else {
event.target.set_string(target);
}
if (trxId) {
getContainerByTrxId(trxId, context_).push_back(event);
return;
}
KAA_LOG_TRACE(boost::format("New event %1% is produced for %2%") % fqn % target);
{
KAA_MUTEX_LOCKING("pendingEventsGuard_");
KAA_MUTEX_UNIQUE_DECLARE(eventsLock, pendingEventsGuard_);
KAA_MUTEX_LOCKED("pendingEventsGuard_");
pendingEvents_.insert(std::make_pair(currentEventIndex_++, event));
KAA_MUTEX_UNLOCKED("pendingEventsGuard_");
}
doSync();
}
void MFileDataStore::remove(const QString &key)
{
Q_D(MFileDataStore);
// QSettings has some kind of a cache so we'll prevent any temporary writes
// by checking if the data can be actually stored before doing anything
if (isWritable()) {
bool originalValueSet = d->settings.contains(key);
if (!originalValueSet) {
return;
}
QVariant originalValue = d->settings.value(key);
d->settings.remove(key);
bool syncOk = doSync(d->settings, d->watcher);
if (!syncOk) {
if (originalValueSet) {
// if sync fails, make sure the value in memory is the original
d->settings.setValue(key, originalValue);
}
} else {
d->settingsSnapshot.remove(key);
emit valueChanged(key, QVariant());
}
}
}
void LogCollector::retryLogUpload(std::size_t delay)
{
KAA_LOG_INFO(boost::format("Schedule log upload with %u second(s) delay ...") % delay);
scheduledUploadTimer_.stop();
scheduledUploadTimer_.start(delay, [&] { doSync(); });
}
void LogCollector::retryLogUpload()
{
KAA_LOG_INFO("Going to retry log upload...");
doSync();
}
void Call::tryToWrite(bool flush) {
//debug(QString("Situation: %3, %4").arg(bufferLocal.size()).arg(bufferRemote.size()));
long samples; // number of samples to write
if (flush) {
// when flushing, we pad the shorter buffer, so that all
// available data is written. this shouldn't usually be a
// significant amount, but it might be if there was an audio
// I/O error in Skype.
samples = padBuffers();
} else {
long l = bufferLocal.size() / 2;
long r = bufferRemote.size() / 2;
sync.add(r - l);
long syncAmount = sync.getSync();
syncAmount = (syncAmount / 160) * 160;
if (syncAmount) {
doSync(syncAmount);
sync.reset();
l = bufferLocal.size() / 2;
r = bufferRemote.size() / 2;
}
if (syncFile.isOpen())
syncFile.write(QString("%1 %2 %3\n").arg(syncTime.elapsed()).arg(r - l).arg(syncAmount).toAscii().constData());
if (std::labs(r - l) > skypeSamplingRate * 20) {
// more than 20 seconds out of sync, something went
// wrong. avoid eating memory by accumulating data
long s = (r - l) / skypeSamplingRate;
debug(QString("Call %1: WARNING: seriously out of sync by %2s; padding").arg(id).arg(s));
samples = padBuffers();
sync.reset();
} else {
samples = l < r ? l : r;
// skype usually sends new PCM data every 10ms (160
// samples at 16kHz). let's accumulate at least 100ms
// of data before bothering to write it to disk
if (samples < skypeSamplingRate / 10)
return;
}
}
// got new samples to write to file, or have to flush. note that we
// have to flush even if samples == 0
bool success;
if (!stereo) {
// mono
mixToMono(samples);
QByteArray dummy;
success = writer->write(bufferLocal, dummy, samples, flush);
bufferRemote.remove(0, samples * 2);
} else if (stereoMix == 0) {
// local left, remote right
success = writer->write(bufferLocal, bufferRemote, samples, flush);
} else if (stereoMix == 100) {
// local right, remote left
success = writer->write(bufferRemote, bufferLocal, samples, flush);
} else {
mixToStereo(samples, stereoMix);
success = writer->write(bufferLocal, bufferRemote, samples, flush);
}
if (!success) {
QMessageBox *box = new QMessageBox(QMessageBox::Critical, PROGRAM_NAME " - Error",
QString(PROGRAM_NAME " encountered an error while writing this call to disk. Recording terminated."));
box->setWindowModality(Qt::NonModal);
box->setAttribute(Qt::WA_DeleteOnClose);
box->show();
stopRecording(false);
return;
}
// the writer will remove the samples from the buffers
//debug(QString("Call %1: wrote %2 samples").arg(id).arg(samples));
// TODO: handle the case where the two streams get out of sync (buffers
// not equally fulled by a significant amount). does skype document
// whether we always get two nice, equal, in-sync streams, even if
// there have been transmission errors? perl-script behavior: if out
// of sync by more than 6.4ms, then remove 1ms from the stream that's
// ahead.
}
void ClusterServer::render(RenderActionBase *action)
{
doSync (false );
doRender(action);
doSwap ( );
}
bool PodSync::OnDriveInserted( char drive )
{
rInfo( "Media detected %c", drive );
return doSync();
}
Sync::Sync(QObject *parent) : QObject(parent)
{
syncTimer = new QTimer(this);
connect(syncTimer, SIGNAL(timeout()), this, SLOT(doSync()));
}
int sync()
{
doSync();
doFlush();
return 0; // no error, -1 for error
}
int sync()
{
doSync();
BgzfDeflateWrapper<std::ostream>::object.flush();
return 0; // no error, -1 for error
}
