void TriggerAltimeter::blockUntilActive(ExecutionState* state)
{
DataModelLogger* RUNLOG = state->getLogger();
SensorHandler* sensor = SensorHandler::setupSensor(SENSOR_TYPE_ALTIMETER, state,
isValueTrue(getParameter("HIGH_PRECISION", state)));
if (!sensor)
throw ExecutionAbortedException();
sensor_event_t* event;
std::vector<std::string>* values;
for (;;) {
// Check if we are still running
if (!state->isRunning())
throw ExecutionAbortedException();
// Retrieve event with values
event = sensor->retrieveEvent();
// Check if event was successfully retrieved
if (NULL == event)
continue;
// Check returned values
values = new std::vector<std::string>();
RUNLOG->debug(SSTR("Retrieved: ALT=" << event->altitude_s.altitude));
values->push_back(/*ALTITUDE*/SSTR(event->altitude_s.altitude));
delete event;
if (checkRequirements(state, values))
break;
}
delete sensor;
}
bool TriggerTimeRange::isActive(ExecutionState* state)
{
QTime startTime = QTime::fromString(
QString::fromStdString(getParameter("TIME_START", state)));
if (!startTime.isValid()) {
state->getLogger()->error("Cannot parse start time, aborting");
throw ExecutionAbortedException();
}
QTime duration = QTime::fromString(QString::fromStdString(getParameter("DURATION", state)));
if (!duration.isValid()) {
state->getLogger()->error("Cannot parse duration, aborting");
throw ExecutionAbortedException();
}
QDateTime now = QDateTime::currentDateTime();
return isActive(startTime, duration, now, state);
}
void TriggerTimeRange::blockUntilActive(ExecutionState* state)
{
QTime startTime = QTime::fromString(
QString::fromStdString(getParameter("TIME_START", state)));
if (!startTime.isValid()) {
state->getLogger()->error("Cannot parse start time, aborting");
throw ExecutionAbortedException();
}
QTime duration = QTime::fromString(QString::fromStdString(getParameter("DURATION", state)));
if (!duration.isValid()) {
state->getLogger()->error("Cannot parse duration, aborting");
throw ExecutionAbortedException();
}
QDateTime now = QDateTime::currentDateTime();
// Check if already active
if (isActive(startTime, duration, now, state)) {
return;
}
// Wait until active
blockUntilActive(startTime, now, state);
return;
}
// Does not check spill overs from previous day. This should have already been checked with isActive()
void TriggerTimeRange::blockUntilActive(QTime startTime, QDateTime now, ExecutionState* state)
{
DataModelLogger* USERLOG = state->getLogger();
int secsToAlarm = now.time().secsTo(startTime);
int alarmDayCount = 0;
// If the alarm already passed today or is very close to now, push alarm for tomorrow
QDate alarmDate = now.date();
if (secsToAlarm < 2) {
alarmDate = alarmDate.addDays(1);
secsToAlarm += ONE_DAY_IN_SEC;
alarmDayCount++;
}
// Continuously loop over all the days to determine how long to sleep for.
while (!isValueTrue(getParameter(alarmDate.toString("dddd").toStdString(), state))) {
// Break out of infinite loop in case no recurring days were set
if (alarmDayCount == 7) {
USERLOG->error("No days are selected, aborting");
throw ExecutionAbortedException();
}
alarmDate = alarmDate.addDays(1);
secsToAlarm += ONE_DAY_IN_SEC;
alarmDayCount++;
}
LOG->trace(SSTR("secsToAlarm: " << secsToAlarm));
int seconds = secsToAlarm % 60;
int minutes = (secsToAlarm / 60) % 60;
int hours = secsToAlarm / 3600;
USERLOG->debug(
SSTR(
"Will go off in " << hours << ":" << std::setfill('0') << std::setw(2)
<< minutes << ":" << std::setfill('0') << std::setw(2) << seconds));
if (state->getRuntimeResources()->sleepSafe(((unsigned long) secsToAlarm * 1000))) {
LOG->trace("Forcefully woken up");
}
return;
}
void Utility::throwException(int rc, const std::string& addErrMsg)
{
switch (rc)
{
case SQLITE_OK:
break;
case SQLITE_ERROR:
throw InvalidSQLStatementException(std::string("SQL error or missing database"), addErrMsg);
case SQLITE_INTERNAL:
throw InternalDBErrorException(std::string("An internal logic error in SQLite"), addErrMsg);
case SQLITE_PERM:
throw DBAccessDeniedException(std::string("Access permission denied"), addErrMsg);
case SQLITE_ABORT:
throw ExecutionAbortedException(std::string("Callback routine requested an abort"), addErrMsg);
case SQLITE_BUSY:
throw DBLockedException(std::string("The database file is locked"), addErrMsg);
case SQLITE_LOCKED:
throw TableLockedException(std::string("A table in the database is locked"), addErrMsg);
case SQLITE_NOMEM:
throw NoMemoryException(std::string("A malloc() failed"), addErrMsg);
case SQLITE_READONLY:
throw ReadOnlyException(std::string("Attempt to write a readonly database"), addErrMsg);
case SQLITE_INTERRUPT:
throw InterruptException(std::string("Operation terminated by sqlite_interrupt()"), addErrMsg);
case SQLITE_IOERR:
throw IOErrorException(std::string("Some kind of disk I/O error occurred"), addErrMsg);
case SQLITE_CORRUPT:
throw CorruptImageException(std::string("The database disk image is malformed"), addErrMsg);
case SQLITE_NOTFOUND:
throw TableNotFoundException(std::string("Table or record not found"), addErrMsg);
case SQLITE_FULL:
throw DatabaseFullException(std::string("Insertion failed because database is full"), addErrMsg);
case SQLITE_CANTOPEN:
throw CantOpenDBFileException(std::string("Unable to open the database file"), addErrMsg);
case SQLITE_PROTOCOL:
throw LockProtocolException(std::string("Database lock protocol error"), addErrMsg);
case SQLITE_EMPTY:
throw InternalDBErrorException(std::string("(Internal Only) Database table is empty"), addErrMsg);
case SQLITE_SCHEMA:
throw SchemaDiffersException(std::string("The database schema changed"), addErrMsg);
case SQLITE_TOOBIG:
throw RowTooBigException(std::string("Too much data for one row of a table"), addErrMsg);
case SQLITE_CONSTRAINT:
throw ConstraintViolationException(std::string("Abort due to constraint violation"), addErrMsg);
case SQLITE_MISMATCH:
throw DataTypeMismatchException(std::string("Data type mismatch"), addErrMsg);
case SQLITE_MISUSE:
throw InvalidLibraryUseException(std::string("Library used incorrectly"), addErrMsg);
case SQLITE_NOLFS:
throw OSFeaturesMissingException(std::string("Uses OS features not supported on host"), addErrMsg);
case SQLITE_AUTH:
throw AuthorizationDeniedException(std::string("Authorization denied"), addErrMsg);
case SQLITE_FORMAT:
throw CorruptImageException(std::string("Auxiliary database format error"), addErrMsg);
case SQLITE_NOTADB:
throw CorruptImageException(std::string("File opened that is not a database file"), addErrMsg);
case SQLITE_RANGE:
throw InvalidSQLStatementException(std::string("Bind Parameter out of range (Access of invalid position 0? bind starts with 1!)"), addErrMsg);
case SQLITE_ROW:
break; // sqlite_step() has another row ready
case SQLITE_DONE:
break; // sqlite_step() has finished executing
default:
throw SQLiteException(std::string("Unknown error code: ") + Poco::NumberFormatter::format(rc), addErrMsg);
}
}
void Utility::throwException(int rc, const std::string& addErrMsg)
{
switch (rc)
{
case SQLITE_OK:
break;
case SQLITE_ERROR:
throw InvalidSQLStatementException(addErrMsg);
case SQLITE_INTERNAL:
throw InternalDBErrorException(addErrMsg);
case SQLITE_PERM:
throw DBAccessDeniedException(addErrMsg);
case SQLITE_ABORT:
throw ExecutionAbortedException(addErrMsg);
case SQLITE_BUSY:
throw DBLockedException(addErrMsg);
case SQLITE_LOCKED:
case SQLITE_LOCKED_SHAREDCACHE:
throw TableLockedException(addErrMsg);
case SQLITE_NOMEM:
throw NoMemoryException(addErrMsg);
case SQLITE_READONLY:
throw ReadOnlyException(addErrMsg);
case SQLITE_INTERRUPT:
throw InterruptException(addErrMsg);
case SQLITE_IOERR:
throw IOErrorException(addErrMsg);
case SQLITE_CORRUPT:
throw CorruptImageException(addErrMsg);
case SQLITE_NOTFOUND:
throw TableNotFoundException(addErrMsg);
case SQLITE_FULL:
throw DatabaseFullException(addErrMsg);
case SQLITE_CANTOPEN:
throw CantOpenDBFileException(addErrMsg);
case SQLITE_PROTOCOL:
throw LockProtocolException(addErrMsg);
case SQLITE_EMPTY:
throw InternalDBErrorException(addErrMsg);
case SQLITE_SCHEMA:
throw SchemaDiffersException(addErrMsg);
case SQLITE_TOOBIG:
throw RowTooBigException(addErrMsg);
case SQLITE_CONSTRAINT:
throw ConstraintViolationException(addErrMsg);
case SQLITE_MISMATCH:
throw DataTypeMismatchException(addErrMsg);
case SQLITE_MISUSE:
throw InvalidLibraryUseException(addErrMsg);
case SQLITE_NOLFS:
throw OSFeaturesMissingException(addErrMsg);
case SQLITE_AUTH:
throw AuthorizationDeniedException(addErrMsg);
case SQLITE_FORMAT:
throw CorruptImageException(addErrMsg);
case SQLITE_NOTADB:
throw CorruptImageException(addErrMsg);
case SQLITE_RANGE:
throw InvalidSQLStatementException(std::string("Bind parameter out of range (Access of invalid position 0? Bind starts with 1!)"), addErrMsg);
case SQLITE_ROW:
break; // sqlite_step() has another row ready
case SQLITE_DONE:
break; // sqlite_step() has finished executing
default:
throw SQLiteException(std::string("Unknown error code: ") + Poco::NumberFormatter::format(rc), addErrMsg);
}
}
