Added TTL column to PublishedSensors Cassandra table

- Also renamed "frequency" column to "interval", can be used for all sensors

lib/include/dcdb/sensorconfig.h

@@ -70,8 +70,9 @@ public:
   std::string expression;       /**< For virtual sensors, this field holds the expression through which the virtual sensor's value is calculated. */
   std::string v_sensorid;       /**< For virtual sensors, this field holds a SensorID used for storing cached values in the database. (FIXME: Cache to be implemented) */
   uint64_t    t_zero;           /**< For virtual sensors, this field holds the first point in time at which the sensor carries a value. */
-  uint64_t    frequency;        /**< For virtual sensors, this field holds the interval at which the sensor evaluates (in nanoseconds). */
-  std::string operations;     /**< Defines the operations on the sensor, e.g. avg, std deviation, etc. */
+  uint64_t    interval;        /**< This field holds the interval at which the sensor evaluates (in nanoseconds). */
+  std::string operations;       /**< Defines the operations on the sensor, e.g. avg, std deviation, etc. */
+  uint64_t    ttl;              /**< Defines the time to live (in nanoseconds) for the readings of this sensor. */
     
   PublicSensor();
   PublicSensor(const PublicSensor &copy);
@@ -123,17 +124,25 @@ public:
    */
   SCError publishSensor(const char* publicName, const char* sensorPattern);
 
+   /**
+   * @brief Makes a physical sensor public, and publish its metadata as well.
+   *
+   * @param sensor         Sensor to be published.
+   * @return               See SCError.
+   */
+    SCError publishSensor(const PublicSensor& sensor);
+
   /**
    * @brief Creates a new virtual sensor.
    *
-   * @param publicName          Name under which the sensor becomes publicly available
+   * @param publicName          Name under which the sensor becomes publicly available.
    * @param vSensorExpression   Arithmetic expression describing how to evaluate the virtual sensor.
    * @param vSensorId           SensorID under which previously evaluated values may be cached (FIXME: cache to be implemented).
    * @param tZero               Point in time at which the sensor evaluates for the first time.
-   * @param frequency           Interval at which the sensor will evaluate (starting from tZero) in nanoseconds.
+   * @param interval           Interval at which the sensor will evaluate (starting from tZero) in nanoseconds.
    * @return                    See SCError.
    */
-  SCError publishVirtualSensor(const char* publicName, const char* vSensorExpression, const char * vSensorId, TimeStamp tZero, uint64_t frequency);
+  SCError publishVirtualSensor(const char* publicName, const char* vSensorExpression, const char * vSensorId, TimeStamp tZero, uint64_t interval);
 
   /**
    * @brief Removes a (virtual or non-virtual) sensor from the list of public sensors.
@@ -265,6 +274,24 @@ public:
     */
     SCError setOperations(std::string publicName, std::string operations);
 
+    /**
+    * @brief Set a new sensor expression for a virtual sensor.
+    *
+    * @param publicName          Name of the sensor.
+    * @param ttl                 Time to live value in nanoseconds.
+    * @return                    See SCError.
+    */
+    SCError setTimeToLive(std::string publicName, uint64_t ttl);
+
+    /**
+   * @brief Set the evaluation interval for a sensor.
+   *
+   * @param publicName          Name of the sensor.
+   * @param interval            New evaluation interval for the sensor in nanoseconds.
+   * @return                    See SCError.
+   */
+    SCError setSensorInterval(std::string publicName, uint64_t interval);
+    
   /**
    * @brief Set a new sensor expression for a virtual sensor.
    *
@@ -273,7 +300,7 @@ public:
    * @return                    See SCError.
    */
   SCError setVirtualSensorExpression(std::string publicName, std::string expression);
-
+  
   /**
    * @brief Set the t0 for a virtual sensor.
    *
@@ -282,16 +309,7 @@ public:
    * @return                    See SCError.
    */
   SCError setVirtualSensorTZero(std::string publicName, TimeStamp tZero);
-
-  /**
-   * @brief Set the frequency (evaluation interval) for a virtual sensor.
-   *
-   * @param publicName          Name of the sensor.
-   * @param frequency           New evaluation interval for the sensor in nanoseconds.
-   * @return                    See SCError.
-   */
-  SCError setVirtualSensorFrequency(std::string publicName, uint64_t frequency);
-
+  
   /**
    * @brief Constructor for the SensorConfig class.
    *

lib/include_internal/sensorconfig_internal.h

@@ -60,7 +60,8 @@ protected:
 public:
   SCError loadCache();
   SCError publishSensor(std::string publicName, std::string sensorPattern);
-  SCError publishVirtualSensor(std::string publicName, std::string vSensorExpression, std::string vSensorId, TimeStamp tZero, uint64_t frequency);
+  SCError publishSensor(const PublicSensor& sensor);
+  SCError publishVirtualSensor(std::string publicName, std::string vSensorExpression, std::string vSensorId, TimeStamp tZero, uint64_t interval);
   SCError unPublishSensor(std::string publicName);
   SCError getPublicSensorNames(std::list<std::string>& publicSensors);
   SCError getPublicSensorsVerbose(std::list<PublicSensor>& publicSensors);
@@ -79,10 +80,11 @@ public:
   SCError setSensorUnit(std::string publicName, std::string unit);
   SCError setSensorMask(std::string publicName, uint64_t mask);
   SCError setOperations(std::string publicName, std::string operations);
+  SCError setTimeToLive(std::string publicName, uint64_t ttl);
+  SCError setSensorInterval(std::string publicName, uint64_t interval);
 
   SCError setVirtualSensorExpression(std::string publicName, std::string expression);
   SCError setVirtualSensorTZero(std::string publicName, TimeStamp tZero);
-  SCError setVirtualSensorFrequency(std::string publicName, uint64_t frequency);
 
   SensorConfigImpl(Connection* conn);
   virtual ~SensorConfigImpl();

lib/src/connection.cpp

@@ -460,11 +460,12 @@ bool ConnectionImpl::initSchema() {
           "sensor_mask bigint, "        /* Bit mask that specifies sensor properties. Currently defined ones are:
                                            Integrable: indicates whether the sensor is integrable over time;
                                            Monotonic : indicates whether the collected sensor data is monotonic. */
-          "operations varchar, "   /* Operations for the sensor (e.g., avg, stdev,...). */
+          "operations varchar, "        /* Operations for the sensor (e.g., avg, stdev,...). */
           "expression varchar, "        /* For virtual sensors: arithmetic expression to derive the virtual sensor's value */
           "vsensorid varchar, "         /* For virtual sensors: Unique sensorId for the sensor in the virtualsensors table */
           "tzero bigint, "              /* For virtual sensors: time of the first reading */
-          "frequency bigint",           /* For virtual sensors: frequency at which this virtual sensor provides readings */
+          "interval bigint,"             /* Interval in nanoseconds at which this virtual sensor provides readings */
+          "ttl bigint",                 /* Time to live in nanoseconds for readings of this sensor */
 
           "name",                       /* Make the "name" column the primary key */
           "COMPACT STORAGE AND CACHING = {'keys' : 'all'} "); /* Enable compact storage and maximum caching */

lib/src/sensorconfig.cpp

@@ -57,8 +57,9 @@ PublicSensor::PublicSensor()
     expression = "";
     v_sensorid = "";
     t_zero = 0;
-    frequency = 0;
+    interval = 0;
     operations = "";
+    ttl = 0;
 }
 
 PublicSensor::PublicSensor (const PublicSensor &copy)
@@ -72,8 +73,9 @@ PublicSensor::PublicSensor (const PublicSensor &copy)
     expression = copy.expression;
     v_sensorid = copy.v_sensorid;
     t_zero = copy.t_zero;
-    frequency = copy.frequency;
+    interval = copy.interval;
     operations = copy.operations;
+    ttl = copy.ttl;
 }
 
 
@@ -91,9 +93,9 @@ SCError SensorConfig::publishSensor(const char* publicName, const char* sensorPa
     return impl->publishSensor(publicName, sensorPattern);
 }
 
-SCError SensorConfig::publishVirtualSensor(const char* publicName, const char* vSensorExpression, const char* vSensorId, TimeStamp tZero, uint64_t frequency)
+SCError SensorConfig::publishVirtualSensor(const char* publicName, const char* vSensorExpression, const char* vSensorId, TimeStamp tZero, uint64_t interval)
 {
-    return impl->publishVirtualSensor(publicName, vSensorExpression, vSensorId, tZero, frequency);
+    return impl->publishVirtualSensor(publicName, vSensorExpression, vSensorId, tZero, interval);
 }
 
 SCError SensorConfig::unPublishSensor(const char* publicName)
@@ -165,6 +167,11 @@ SCError SensorConfig::setOperations(std::string publicName, std::string operatio
     return impl->setOperations(publicName,operations);
 }
 
+SCError SensorConfig::setTimeToLive(std::string publicName, uint64_t ttl)
+{
+    return impl->setTimeToLive(publicName, ttl);
+}
+
 SCError SensorConfig::setVirtualSensorExpression(std::string publicName, std::string expression)
 {
     return impl->setVirtualSensorExpression(publicName, expression);
@@ -175,9 +182,9 @@ SCError SensorConfig::setVirtualSensorTZero(std::string publicName, TimeStamp tZ
     return impl->setVirtualSensorTZero(publicName, tZero);
 }
 
-SCError SensorConfig::setVirtualSensorFrequency(std::string publicName, uint64_t frequency)
+SCError SensorConfig::setSensorInterval(std::string publicName, uint64_t interval)
 {
-    return impl->setVirtualSensorFrequency(publicName, frequency);
+    return impl->setSensorInterval(publicName, interval);
 }
 
 SensorConfig::SensorConfig(Connection* conn)
@@ -329,7 +336,7 @@ SCError SensorConfigImpl::publishSensor(std::string publicName, std::string sens
     return SC_OK;
 }
 
-SCError SensorConfigImpl::publishVirtualSensor(std::string publicName, std::string vSensorExpression, std::string vSensorId, TimeStamp tZero, uint64_t frequency)
+SCError SensorConfigImpl::publishVirtualSensor(std::string publicName, std::string vSensorExpression, std::string vSensorId, TimeStamp tZero, uint64_t interval)
 {
     /* Check if the publicName is valid */
     if (!validateSensorPublicName(publicName.c_str())) {
@@ -369,7 +376,7 @@ SCError SensorConfigImpl::publishVirtualSensor(std::string publicName, std::stri
     CassStatement* statement = nullptr;
     CassFuture* future = nullptr;
     const CassPrepared* prepared = nullptr;
-    const char* query = "INSERT INTO " CONFIG_KEYSPACE_NAME "." CF_PUBLISHEDSENSORS " (name, expression, vsensorid, tzero, frequency, virtual) VALUES (?,?,?,?,?,TRUE);";
+    const char* query = "INSERT INTO " CONFIG_KEYSPACE_NAME "." CF_PUBLISHEDSENSORS " (name, expression, vsensorid, tzero, interval, virtual) VALUES (?,?,?,?,?,TRUE);";
 
     future = cass_session_prepare(session, query);
     cass_future_wait(future);
@@ -391,7 +398,7 @@ SCError SensorConfigImpl::publishVirtualSensor(std::string publicName, std::stri
     cass_statement_bind_string_by_name(statement, "expression", vSensorExpression.c_str());
     cass_statement_bind_string_by_name(statement, "vsensorid", vSensorId.c_str());
     cass_statement_bind_int64_by_name(statement, "tzero", tZero.getRaw());
-    cass_statement_bind_int64_by_name(statement, "frequency", frequency);
+    cass_statement_bind_int64_by_name(statement, "interval", interval);
 
     future = cass_session_execute(session, statement);
     cass_future_wait(future);
@@ -566,7 +573,8 @@ SCError SensorConfigImpl::getPublicSensorsVerbose(std::list<PublicSensor>& publi
             const char* vsensorid;
             size_t      vsensorid_len;
             int64_t     tzero;
-            int64_t     frequency;
+            int64_t     interval;
+            int64_t     ttl;
             const char* operations;
             size_t      operations_len;
             PublicSensor sensor;
@@ -600,8 +608,11 @@ SCError SensorConfigImpl::getPublicSensorsVerbose(std::list<PublicSensor>& publi
             if (cass_value_get_int64(cass_row_get_column_by_name(row, "tzero"), &tzero) != CASS_OK) {
                 tzero = 0;
             }
-            if (cass_value_get_int64(cass_row_get_column_by_name(row, "frequency"), &frequency) != CASS_OK) {
-                frequency = 0;
+            if (cass_value_get_int64(cass_row_get_column_by_name(row, "interval"), &interval) != CASS_OK) {
+                interval = 0;
+            }
+            if (cass_value_get_int64(cass_row_get_column_by_name(row, "ttl"), &ttl) != CASS_OK) {
+                ttl = 0;
             }
             if (cass_value_get_string(cass_row_get_column_by_name(row, "operations"), &operations, &operations_len) != CASS_OK) {
                 operations = ""; operations_len = 0;
@@ -616,7 +627,8 @@ SCError SensorConfigImpl::getPublicSensorsVerbose(std::list<PublicSensor>& publi
             sensor.expression = std::string(expression, expression_len);
             sensor.v_sensorid = std::string(vsensorid, vsensorid_len);
             sensor.t_zero = tzero;
-            sensor.frequency = frequency;
+            sensor.interval = interval;
+            sensor.ttl = ttl;
             sensor.operations = operations;
 
             publicSensors.push_back(sensor);
@@ -696,7 +708,8 @@ SCError SensorConfigImpl::getPublicSensorByName(PublicSensor& sensor, const char
             const char* vsensorid;
             size_t      vsensorid_len;
             int64_t     tzero;
-            int64_t     frequency;
+            int64_t     interval;
+            int64_t     ttl;
             const char* operations;
             size_t      operations_len;
 
@@ -729,8 +742,11 @@ SCError SensorConfigImpl::getPublicSensorByName(PublicSensor& sensor, const char
             if (cass_value_get_int64(cass_row_get_column_by_name(row, "tzero"), &tzero) != CASS_OK) {
                 tzero = 0;
             }
-            if (cass_value_get_int64(cass_row_get_column_by_name(row, "frequency"), &frequency) != CASS_OK) {
-                frequency = 0;
+            if (cass_value_get_int64(cass_row_get_column_by_name(row, "interval"), &interval) != CASS_OK) {
+                interval = 0;
+            }
+            if (cass_value_get_int64(cass_row_get_column_by_name(row, "ttl"), &ttl) != CASS_OK) {
+                ttl = 0;
             }
             if (cass_value_get_string(cass_row_get_column_by_name(row, "operations"), &operations, &operations_len) != CASS_OK) {
                 operations = ""; operations_len = 0;
@@ -745,7 +761,8 @@ SCError SensorConfigImpl::getPublicSensorByName(PublicSensor& sensor, const char
             sensor.expression = std::string(expression, expression_len);
             sensor.v_sensorid = std::string(vsensorid, vsensorid_len);
             sensor.t_zero = tzero;
-            sensor.frequency = frequency;
+            sensor.interval = interval;
+            sensor.ttl = ttl;
             sensor.operations = operations;
 
             /* Add to sensorPropertyCache for later use */
@@ -1276,6 +1293,51 @@ SCError SensorConfigImpl::setOperations(std::string publicName, std::string oper
     
     return error;
 }
+
+SCError SensorConfigImpl::setTimeToLive(std::string publicName, uint64_t ttl)
+{
+    SCError error = SC_UNKNOWNERROR;
+
+    CassError rc = CASS_OK;
+    CassStatement* statement = nullptr;
+    CassFuture* future = nullptr;
+    const CassPrepared* prepared = nullptr;
+    const char* query = "UPDATE " CONFIG_KEYSPACE_NAME "." CF_PUBLISHEDSENSORS " SET ttl = ? WHERE name = ? ;";
+
+    future = cass_session_prepare(session, query);
+    cass_future_wait(future);
+
+    rc = cass_future_error_code(future);
+    if (rc != CASS_OK) {
+        connection->printError(future);
+        return SC_UNKNOWNERROR;
+    }
+
+    prepared = cass_future_get_prepared(future);
+    cass_future_free(future);
+
+    statement = cass_prepared_bind(prepared);
+
+    cass_statement_bind_int64(statement, 0, ttl);
+    cass_statement_bind_string(statement, 1, publicName.c_str());
+
+    future = cass_session_execute(session, statement);
+    cass_future_wait(future);
+
+    rc = cass_future_error_code(future);
+    if (rc != CASS_OK) {
+        connection->printError(future);
+        error = SC_UNKNOWNERROR;
+    }
+    else {
+        error = SC_OK;
+    }
+
+    cass_statement_free(statement);
+    cass_prepared_free(prepared);
+
+    return error;
+}
                                                   
 SCError SensorConfigImpl::setVirtualSensorExpression(std::string publicName, std::string expression)
 {
@@ -1401,7 +1463,7 @@ SCError SensorConfigImpl::setVirtualSensorTZero(std::string publicName, TimeStam
     return error;
 }
 
-SCError SensorConfigImpl::setVirtualSensorFrequency(std::string publicName, uint64_t frequency)
+SCError SensorConfigImpl::setSensorInterval(std::string publicName, uint64_t interval)
 {
     /* Check if the session is valid */
     if (!session) {
@@ -1409,14 +1471,14 @@ SCError SensorConfigImpl::setVirtualSensorFrequency(std::string publicName, uint
     }
 
     /* Ensure that the public sensor is virtual */
-    bool virt;
-    SCError err = isVirtual(virt, publicName);
-    if (err != SC_OK) {
-        return err;
-    }
-    if (!virt) {
-        return SC_WRONGTYPE;
-    }
+    //bool virt;
+    //SCError err = isVirtual(virt, publicName);
+    //if (err != SC_OK) {
+    //    return err;
+    //}
+    //if (!virt) {
+    //    return SC_WRONGTYPE;
+    //}
 
     /* Update the database with the new expression */
     SCError error = SC_UNKNOWNERROR;
@@ -1425,7 +1487,7 @@ SCError SensorConfigImpl::setVirtualSensorFrequency(std::string publicName, uint
     CassStatement* statement = nullptr;
     CassFuture* future = nullptr;
     const CassPrepared* prepared = nullptr;
-    const char* query = "UPDATE " CONFIG_KEYSPACE_NAME "." CF_PUBLISHEDSENSORS " SET frequency = ? WHERE name = ? ;";
+    const char* query = "UPDATE " CONFIG_KEYSPACE_NAME "." CF_PUBLISHEDSENSORS " SET interval = ? WHERE name = ? ;";
 
     future = cass_session_prepare(session, query);
     cass_future_wait(future);
@@ -1441,7 +1503,7 @@ SCError SensorConfigImpl::setVirtualSensorFrequency(std::string publicName, uint
 
     statement = cass_prepared_bind(prepared);
 
-    cass_statement_bind_int64(statement, 0, frequency);
+    cass_statement_bind_int64(statement, 0, interval);
     cass_statement_bind_string(statement, 1, publicName.c_str());
 
     future = cass_session_execute(session, statement);

lib/src/virtualsensor.cpp

@@ -777,7 +777,7 @@ VSensorImpl::VSensorImpl(Connection *conn, PublicSensor sensor)
   expression = new VSensorExpressionImpl(connection, sensor.expression);
   vsensorid = new SensorId(sensor.v_sensorid);
   tzero = sensor.t_zero;
-  frequency = sensor.frequency;
+  frequency = sensor.interval;
 }
 
 VSensorImpl::~VSensorImpl()

tools/dcdbconfig/sensoraction.cpp

@@ -65,7 +65,8 @@ void SensorAction::printHelp(int argc, char* argv[])
   std::cout << "                                              'integrable' and 'monotonic'." << std::endl;
   std::cout << "   EXPRESSION <public name> <expr>          - Change expression of virt sensor." << std::endl;
   std::cout << "   TZERO <public name> <t0>                 - Change t0 of virt sensor." << std::endl;
-  std::cout << "   FREQUENCY <public name> <freq>           - Change frequency of virt sensor." << std::endl;
+  std::cout << "   INTERVAL <public name> <inter>           - Change interval of a sensor." << std::endl;
+  std::cout << "   TTL <public name> <ttl>                  - Change time to live of a sensor." << std::endl;
   std::cout << "   OPERATIONS <public name> <operation>,<operation>,..." << std::endl;
   std::cout << "                                            - Set operations for the sensor (e.g., avg, stddev,...)." << std::endl;
   std::cout << "   UNPUBLISH <public name>                  - Unpublish a sensor." << std::endl;
@@ -161,13 +162,21 @@ int SensorAction::executeCommand(int argc, char* argv[], int argvidx, const char
       }
       doTZero(argv[argvidx+1], argv[argvidx+2]);
   }
-  else if (strcasecmp(argv[argvidx], "FREQUENCY") == 0) {
-      /* FREQUENCY needs two more parameters */
+  else if (strcasecmp(argv[argvidx], "INTERVAL") == 0) {
+      /* INTERVAL needs two more parameters */
       if (argvidx+2 >= argc) {
-          std::cout << "FREQUENCY needs two more parameters!" << std::endl;
+          std::cout << "INTERVAL needs two more parameters!" << std::endl;
           goto executeCommandError;
       }
-      doFrequency(argv[argvidx+1], argv[argvidx+2]);
+      doInterval(argv[argvidx+1], argv[argvidx+2]);
+  }
+  else if (strcasecmp(argv[argvidx], "TTL") == 0) {
+      /* TTL needs two more parameters */
+      if (argvidx+2 >= argc) {
+          std::cout << "TTL needs two more parameters!" << std::endl;
+          goto executeCommandError;
+      }
+      doTTL(argv[argvidx+1], argv[argvidx+2]);
   }
   else if (strcasecmp(argv[argvidx], "OPERATIONS") == 0) {
       /* OPERATIONS needs two more parameters */
@@ -230,15 +239,15 @@ void SensorAction::doPublishSensor(const char* publicName, const char* sensorPat
 /*
  * Create a virtual sensor
  */
-void SensorAction::doVCreateSensor(const char* publicName, const char* expression, const char* vSensorId, const char* tZero, const char* frequency)
+void SensorAction::doVCreateSensor(const char* publicName, const char* expression, const char* vSensorId, const char* tZero, const char* interval)
 {
   /* Convert tZero to TimeStamp */
   DCDB::TimeStamp tz(tZero);
 
-  /* Convert frequency to int64_t - sadly, there's no real C++ way of doing this */
+  /* Convert interval to int64_t - sadly, there's no real C++ way of doing this */
   int64_t freq;
-  if (sscanf(frequency, "%" SCNd64, &freq) != 1) {
-      std::cout << frequency << " is not a valid number." << std::endl;
+  if (sscanf(interval, "%" SCNd64, &freq) != 1) {
+      std::cout << interval << " is not a valid number." << std::endl;
       return;
   }
 
@@ -326,11 +335,12 @@ void SensorAction::doShow(const char* publicName)
         std::cout << "vSensorId: " << publicSensor.v_sensorid << std::endl;
         DCDB::TimeStamp tz(publicSensor.t_zero);
         std::cout << "T-Zero: " << tz.getString() << " (" << tz.getRaw() << ")" << std::endl;
-        std::cout << "Frequency: " << publicSensor.frequency << std::endl;
     }
     std::cout << "Unit: " << publicSensor.unit << std::endl;
     std::cout << "Scaling factor: " << publicSensor.scaling_factor << std::endl;
     std::cout << "Operations: " << publicSensor.operations << std::endl;
+    std::cout << "Interval: " << publicSensor.interval << std::endl;
+    std::cout << "TTL: " << publicSensor.ttl << std::endl;
     std::cout << "Sensor Properties: ";
     if((publicSensor.sensor_mask & INTEGRABLE) == INTEGRABLE)
         std::cout << "Integrable ";
@@ -494,19 +504,19 @@ void SensorAction::doTZero(const char* publicName, const char* tZero)
 }
 
 /*
- * Set the frequency for a virtual sensor
+ * Set the interval for a sensor
  */
-void SensorAction::doFrequency(const char* publicName, const char *frequency)
+void SensorAction::doInterval(const char* publicName, const char *interval)
 {
-  /* Convert frequency to int64_t - sadly, there's no real C++ way of doing this */
+  /* Convert interval to int64_t - sadly, there's no real C++ way of doing this */
   int64_t freq;
-  if (sscanf(frequency, "%" SCNd64, &freq) != 1) {
-      std::cout << frequency << " is not a valid number." << std::endl;
+  if (sscanf(interval, "%" SCNd64, &freq) != 1) {
+      std::cout << interval << " is not a valid number." << std::endl;
       return;
   }
 
   DCDB::SensorConfig sensorConfig(connection);
-  DCDB::SCError err = sensorConfig.setVirtualSensorFrequency(publicName, freq);
+  DCDB::SCError err = sensorConfig.setSensorInterval(publicName, freq);
 
   switch (err) {
   case DCDB::SC_OK:
@@ -517,14 +527,36 @@ void SensorAction::doFrequency(const char* publicName, const char *frequency)
   case DCDB::SC_INVALIDSESSION:
     std::cout << "Invalid session!" << std::endl;
     break;
-  case DCDB::SC_WRONGTYPE:
-    std::cout << "Sensor " << publicName << " is not virtual!" << std::endl;
-    break;
   default:
     std::cout << "Internal error." << std::endl;
   }
 }
 
+void SensorAction::doTTL(const char* publicName, const char *ttl) {
+    /* Convert ttl to int64_t - sadly, there's no real C++ way of doing this */
+    int64_t ttl_int;
+    if (sscanf(ttl, "%" SCNd64, &ttl_int) != 1) {
+        std::cout << ttl << " is not a valid number." << std::endl;
+        return;
+    }
+
+    DCDB::SensorConfig sensorConfig(connection);
+    DCDB::SCError err = sensorConfig.setTimeToLive(publicName, ttl_int);
+
+    switch (err) {
+        case DCDB::SC_OK:
+            break;
+        case DCDB::SC_UNKNOWNSENSOR:
+            std::cout << "Unknown sensor name: " << publicName << std::endl;
+            break;
+        case DCDB::SC_INVALIDSESSION:
+            std::cout << "Invalid session!" << std::endl;
+            break;
+        default:
+            std::cout << "Internal error." << std::endl;
+    }
+}
+
 void SensorAction::doOperations(const char* publicName, const char *operations)
 {
     

tools/dcdbconfig/sensoraction.h

@@ -46,7 +46,7 @@ public:
 protected:
   DCDB::Connection* connection;
   void doPublishSensor(const char* publicName, const char* sensorPattern);
-  void doVCreateSensor(const char* publicName, const char* expression, const char* vSensorId, const char* tZero, const char* frequency);
+  void doVCreateSensor(const char* publicName, const char* expression, const char* vSensorId, const char* tZero, const char* interval);
   void doList();
   void doListPublicSensors();
   void doShow(const char* publicName);
@@ -55,8 +55,9 @@ protected:
   void doSensorProperty(const char* publicName, const char* cmd);
   void doExpression(const char* publicName, const char* expression);
   void doTZero(const char* publicName, const char* tZero);
-  void doFrequency(const char* publicName, const char *frequency);
-    void doOperations(const char* publicName, const char *operations);
+  void doInterval(const char* publicName, const char *interval);
+  void doTTL(const char* publicName, const char *ttl);
+  void doOperations(const char* publicName, const char *operations);
   void doUnPublishSensor(const char* publicName);
 };