add: weekly schedules support

models/controller.c

@@ -65,7 +65,7 @@ controller_debug(controller_t *controller)
     LOG_DEBUG("(3/5) command_port: %5d discovery_port: %5d\n", controller->command_port, controller->discovery_port);
     LOG_DEBUG("(4/5) relay count: %3d\n", controller->relay_count);
     LOG_DEBUG("(5/5) relays @ %p:\n", (void*)controller->relays);
-    for(uint8_t i = 0; i < controller->relay_count; ++i)
+    for(int i = 0; i < controller->relay_count; ++i)
     {
         relay_debug(controller->relays[i]);
     }

models/relay.c

@@ -3,6 +3,7 @@
 #include <uuid/uuid.h>
 
 #include <logger.h>
+#include <helpers.h>
 #include <models/relay.h>
 
 relay_t*
@@ -17,7 +18,10 @@ relay_create(uint8_t number)
     memset(off_id, 0, sizeof(uuid_t));
     memcpy(off_id, "off", 3);
 
-    new_relay->schedule = schedule_create(off_id, 0, NULL);
+    for(int i = 0; i < 7; ++i)
+    {
+        new_relay->schedules[i] = schedule_create(off_id, i, 0, NULL);
+    }
 
     return new_relay;
 }
@@ -32,7 +36,8 @@ relay_set_name(relay_t *relay, const char *name)
 int
 relay_is_active(relay_t *relay, time_t timestamp_now)
 {
-    if(relay->schedule->length == 0)
+    schedule_t *schedule = relay->schedules[helper_get_weekday(timestamp_now)];
+    if(schedule->length == 0)
     {
         return 0;
     }
@@ -42,9 +47,9 @@ relay_is_active(relay_t *relay, time_t timestamp_now)
     // finally remove seconds
     timestamp_now /= SECONDS_PER_MINUTE;
 
-    for(uint16_t i = 0; i < relay->schedule->length; ++i)
+    for(uint16_t i = 0; i < schedule->length; ++i)
     {
-        if(period_includes_time(relay->schedule->periods[i], timestamp_now))
+        if(period_includes_time(schedule->periods[i], timestamp_now))
         {
             return 1;
         }
@@ -62,16 +67,19 @@ relay_debug(relay_t *relay)
     }
     LOG_DEBUG("(1/3) %d @ %p\n", relay->number, (void*)relay);
     LOG_DEBUG("(2/3) name: %s\n", relay->name);
-    LOG_DEBUG("(3/3) schedule:\n");
-    schedule_debug(relay->schedule);
+    LOG_DEBUG("(3/3) schedules @ %p:\n", (void*)relay->schedules);
+    for(int i = 0; i < 7; ++i)
+    {
+        schedule_debug(relay->schedules[i]);
+    }
 }
 
 void
 relay_free(relay_t *relay)
 {
-    if(relay->schedule)
+    for(int i = 0; i < 7; ++i)
     {
-        schedule_free(relay->schedule);
+        schedule_free(relay->schedules[i]);
     }
     free(relay);
 }

models/relay_load.c

@@ -8,14 +8,16 @@
 #include <macros.h>
 
 static int
-relay_load_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, db_key_relay_e key_relay, uint8_t num, MDB_val *value)
+relay_load_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, db_key_relay_e key_relay, uint8_t relay_num, MDB_val *value)
 {
     int err;
 
     size_t key_size = sizeof(db_key_relay_e) + sizeof(uint8_t); 
-    void *key_data = malloc(key_size);
-    memmove((uint8_t*)key_data, &key_relay, sizeof(db_key_relay_e));
-    memmove((uint8_t*)key_data + sizeof(db_key_relay_e), &num, sizeof(uint8_t));
+    uint8_t *key_data = malloc(key_size);
+    uint8_t *key_data_writer = key_data;
+    memmove(key_data_writer, &relay_num, sizeof(uint8_t));
+    key_data_writer += sizeof(uint8_t);
+    memmove(key_data_writer, &key_relay, sizeof(db_key_relay_e));
 
     MDB_val key;
     key.mv_size = key_size;
@@ -75,26 +77,12 @@ relay_load(MDB_env *mdb_env, uint8_t num)
     strncpy(new_relay->name, (char*)value.mv_data, MAX_NAME_LENGTH);
     new_relay->name[MAX_NAME_LENGTH] = '\0';
 
-    if((err = relay_load_single(mdb_txn, mdb_dbi, DB_KEY_RELAY_SCHEDULE_ID, num, &value)) != 0)
-    {
-        LOG_INFO("no relay for num %d found in db. returning new one\n", num);
-        mdb_txn_abort(mdb_txn); // transaction is read only
-        return relay_create(num);
-    }
-    uuid_t *schedule_id = (uuid_t*)value.mv_data;
-
-    if((err = relay_load_single(mdb_txn, mdb_dbi, DB_KEY_RELAY_SCHEDULE_PERIODS, num, &value)) != 0)
-    {
-        LOG_INFO("no relay for num %d found in db. returning new one\n", num);
-        mdb_txn_abort(mdb_txn); // transaction is read only
-        return relay_create(num);
-    }
-    uint16_t schedule_periods_length = ((uint16_t*)value.mv_data)[0];
-    uint16_t *schedule_periods = ((uint16_t*)value.mv_data) + 1;
-
-    new_relay->schedule = schedule_create(*schedule_id, schedule_periods_length, schedule_periods);
-
     mdb_txn_abort(mdb_txn); // transaction is read only
+
+    for(int i = 0; i < 7; ++i)
+    {
+        new_relay->schedules[i] = schedule_load(mdb_env, num, i);
+    }
     
     return new_relay;
 }

models/relay_save.c

@@ -8,14 +8,16 @@
 #include <macros.h>
 
 static int
-relay_save_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, db_key_relay_e key_relay, uint8_t num, MDB_val value)
+relay_save_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, db_key_relay_e key_relay, uint8_t relay_num, MDB_val value)
 {
     int err;
 
     size_t key_size = sizeof(db_key_relay_e) + sizeof(uint8_t); 
-    void *key_data = malloc(key_size);
-    memmove((uint8_t*)key_data, &key_relay, sizeof(db_key_relay_e));
-    memmove((uint8_t*)key_data + sizeof(db_key_relay_e), &num, sizeof(uint8_t));
+    uint8_t *key_data = malloc(key_size);
+    uint8_t *key_data_writer = key_data;
+    memmove(key_data_writer, &relay_num, sizeof(uint8_t));
+    key_data_writer += sizeof(uint8_t);
+    memmove(key_data_writer, &key_relay, sizeof(db_key_relay_e));
 
     MDB_val key;
     key.mv_size = key_size;
@@ -62,27 +64,12 @@ relay_save(relay_t *relay, MDB_env *mdb_env)
         return 1;
     }
 
-    value.mv_size = sizeof(uuid_t);
-    value.mv_data = relay->schedule->id;
-    if(relay_save_single(mdb_txn, mdb_dbi, DB_KEY_RELAY_SCHEDULE_ID, relay->number, value))
-    {
-        LOG_ERROR("failed to save ID\n");
-        return 1;
-    }
-
-    // save periods blob
-    uint16_t *periods_blob = schedule_periods_to_blob(relay->schedule);
-    value.mv_size = sizeof(uint16_t) * ((periods_blob[0] * 2) + 1);
-    value.mv_data = periods_blob;
-    if(relay_save_single(mdb_txn, mdb_dbi, DB_KEY_RELAY_SCHEDULE_PERIODS, relay->number, value))
-    {
-        free(periods_blob);
-        LOG_ERROR("failed to save periods\n");
-        return 1;
-    }
-    free(periods_blob);
-
     mdb_txn_commit(mdb_txn);
 
+    for(int i = 0; i < 7; ++i)
+    {
+        schedule_save(relay->schedules[i], relay->number, mdb_env);
+    }
+
     return 0;
 }

models/schedule.c

@@ -5,12 +5,14 @@
 #include <models/schedule.h>
 
 schedule_t*
-schedule_create(uuid_t id, uint16_t length, uint16_t *periods_blob)
+schedule_create(uuid_t id, uint8_t weekday, uint16_t length, uint16_t *periods_blob)
 {
     schedule_t *new_schedule = malloc(sizeof(schedule_t));
 
     memmove(new_schedule->id, id, sizeof(uuid_t));
 
+    new_schedule->weekday = weekday;
+
     new_schedule->length = length;
     new_schedule->periods = NULL;
 
@@ -64,10 +66,11 @@ schedule_debug(schedule_t *schedule)
         LOG_DEBUG("schedule is NULL\n");
         return;
     }
-    char uuid_str[37];
+    char uuid_str[UUID_STR_LEN];
     uuid_unparse(schedule->id, uuid_str);
     LOG_DEBUG("(1/3) %s @ %p\n", uuid_str, (void*)schedule);
-    LOG_DEBUG("(2/3) period count: %3d\n", schedule->length);
+    LOG_DEBUG("(2/4) period count: %3d\n", schedule->length);
+    LOG_DEBUG("(3/4) weekday: %3d\n", schedule->weekday);
 
     // one block: "HH:MM-HH:MM, " --> size: 13 (14 with '\0')
     char *periods_debug_str = malloc(sizeof(char) * ((schedule->length * 13) + 1));
@@ -85,5 +88,7 @@ schedule_debug(schedule_t *schedule)
         );
     }
 
-    LOG_DEBUG("(3/3) periods: %s\n", periods_debug_str);
+    LOG_DEBUG("(4/4) periods: %s\n", periods_debug_str);
+
+    free(periods_debug_str);
 }

models/schedule_load.c

@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <uuid/uuid.h>
+
+#include <models/relay.h>
+#include <macros.h>
+
+static int
+schedule_load_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, db_key_schedule_e key_schedule, uint8_t relay_num, uint8_t weekday, MDB_val *value)
+{
+    int err;
+
+    size_t key_size = sizeof(db_key_schedule_e) + (2 * sizeof(uint8_t)); 
+    uint8_t *key_data = malloc(key_size);
+    uint8_t *key_data_writer = key_data;
+    memmove(key_data_writer, &relay_num, sizeof(uint8_t));
+    key_data_writer += sizeof(uint8_t);
+    memmove(key_data_writer, &weekday, sizeof(uint8_t));
+    key_data_writer += sizeof(uint8_t);
+    memmove(key_data_writer, &key_schedule, sizeof(db_key_schedule_e));
+
+    MDB_val key;
+    key.mv_size = key_size;
+    key.mv_data = key_data;
+
+    if((err = mdb_get(mdb_txn, mdb_dbi, &key, value)) != 0)
+    {
+        LOG_ERROR("mdb_get error %s\n", mdb_strerror(err));
+        mdb_txn_abort(mdb_txn);
+        free(key_data);
+        return 1;
+    }
+    free(key_data);
+    return 0;
+}
+
+schedule_t*
+schedule_load(MDB_env *mdb_env, uint8_t relay_num, uint8_t weekday)
+{
+    int err;
+    MDB_txn *mdb_txn;
+    MDB_dbi mdb_dbi;
+    
+    schedule_t *new_schedule;
+
+    uuid_t off_id;
+    memset(off_id, 0, sizeof(uuid_t));
+    memcpy(off_id, "off", 3);
+
+    if((err = mdb_txn_begin(mdb_env, NULL, MDB_RDONLY, &mdb_txn)) != 0)
+    {
+        LOG_ERROR("mdb_txn_begin error %s\n", mdb_strerror(err));
+        return schedule_create(off_id, weekday, 0, NULL);
+    }
+
+    if((err = mdb_dbi_open(mdb_txn, "schedules", 0, &mdb_dbi)) != 0)
+    {
+        switch(err)
+        {
+            case MDB_NOTFOUND:
+                LOG_INFO("no schedule db found in db. returning new one (no schedules db)\n");
+                mdb_txn_abort(mdb_txn);
+                break;
+            default:
+                LOG_ERROR("mdb_txn_begin error %s\n", mdb_strerror(err));
+        }
+        return schedule_create(off_id, weekday, 0, NULL);
+    }
+
+    MDB_val value;
+
+    if((err = schedule_load_single(mdb_txn, mdb_dbi, DB_KEY_SCHEDULE_ID, relay_num, weekday, &value)) != 0)
+    {
+        LOG_INFO("no schedule for relay %d and weekday %d found in db. returning new one\n", relay_num, weekday);
+        mdb_txn_abort(mdb_txn); // transaction is read only
+        return schedule_create(off_id, weekday, 0, NULL);
+    }
+    uuid_t *schedule_id = (uuid_t*)value.mv_data;
+
+    if((err = schedule_load_single(mdb_txn, mdb_dbi, DB_KEY_SCHEDULE_PERIODS, relay_num, weekday, &value)) != 0)
+    {
+        LOG_INFO("no schedule for relay %d and weekday %d found in db. returning new one\n", relay_num, weekday);
+        mdb_txn_abort(mdb_txn); // transaction is read only
+        return schedule_create(off_id, weekday, 0, NULL);
+    }
+    uint16_t schedule_periods_length = ((uint16_t*)value.mv_data)[0];
+    uint16_t *schedule_periods = ((uint16_t*)value.mv_data) + 1;
+
+    new_schedule = schedule_create(*schedule_id, weekday, schedule_periods_length, schedule_periods);
+
+    mdb_txn_abort(mdb_txn); // transaction is read only
+    
+    return new_schedule;
+}

models/schedule_save.c

@@ -0,0 +1,87 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <uuid/uuid.h>
+
+#include <models/schedule.h>
+#include <models/relay.h>
+#include <macros.h>
+
+static int
+schedule_save_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, db_key_schedule_e key_schedule, uint8_t relay_num, uint8_t weekday, MDB_val value)
+{
+    int err;
+
+    size_t key_size = sizeof(db_key_schedule_e) + (2 * sizeof(uint8_t)); 
+    uint8_t *key_data = malloc(key_size);
+    uint8_t *key_data_writer = key_data;
+    memmove(key_data_writer, &relay_num, sizeof(uint8_t));
+    key_data_writer += sizeof(uint8_t);
+    memmove(key_data_writer, &weekday, sizeof(uint8_t));
+    key_data_writer += sizeof(uint8_t);
+    memmove(key_data_writer, &key_schedule, sizeof(db_key_schedule_e));
+
+    MDB_val key;
+    key.mv_size = key_size;
+    key.mv_data = key_data;
+
+    if((err = mdb_put(mdb_txn, mdb_dbi, &key, &value, 0)) != 0)
+    {
+        LOG_ERROR("mdb_put error %s\n", mdb_strerror(err));
+        mdb_txn_abort(mdb_txn);
+        free(key_data);
+        return 1;
+    }
+    free(key_data);
+    return 0;
+}
+
+int
+schedule_save(schedule_t *schedule, uint8_t relay_num, MDB_env *mdb_env)
+{
+    char uuid_str[37];
+    uuid_unparse(schedule->id, uuid_str);
+    LOG_TRACE("saving schedule %s @ %p\n", uuid_str, schedule);
+    int err;
+
+    MDB_txn *mdb_txn;
+    MDB_dbi mdb_dbi;
+    MDB_val value;
+
+    if((err = mdb_txn_begin(mdb_env, NULL, 0, &mdb_txn)) != 0)
+    {
+        LOG_ERROR("mdb_txn_begin error %s\n", mdb_strerror(err));
+        exit(1);
+    }
+
+    if((err = mdb_dbi_open(mdb_txn, "schedules", MDB_CREATE, &mdb_dbi)) != 0)
+    {
+        LOG_ERROR("mdb_dbi_open error %s\n", mdb_strerror(err));
+        exit(1);
+    }
+
+    value.mv_size = sizeof(uuid_t);
+    value.mv_data = schedule->id;
+    if(schedule_save_single(mdb_txn, mdb_dbi, DB_KEY_SCHEDULE_ID, relay_num, schedule->weekday, value))
+    {
+        LOG_ERROR("failed to save ID\n");
+        return 1;
+    }
+
+    // save periods blob
+    uint16_t *periods_blob = schedule_periods_to_blob(schedule);
+    value.mv_size = sizeof(uint16_t) * ((periods_blob[0] * 2) + 1);
+    value.mv_data = periods_blob;
+    if(schedule_save_single(mdb_txn, mdb_dbi, DB_KEY_SCHEDULE_PERIODS, relay_num, schedule->weekday, value))
+    {
+        free(periods_blob);
+        LOG_ERROR("failed to save periods\n");
+        return 1;
+    }
+    free(periods_blob);
+
+    mdb_txn_commit(mdb_txn);
+
+    return 0;
+}