add: version.h

fix: refactor

src/models/controller.c

@@ -0,0 +1,72 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <uuid/uuid.h>
+
+#include <models/controller.h>
+#include <macros.h>
+#include <config.h>
+#include <constants.h>
+
+controller_t*
+controller_create(void)
+{
+    controller_t *new_controller = malloc(sizeof(*new_controller));
+    uuid_generate(new_controller->id);
+
+    strncpy(new_controller->name, global_config.name, MAX_NAME_LENGTH);
+    new_controller->name[MAX_NAME_LENGTH] = '\0';
+
+    new_controller->command_port = 0;
+    new_controller->discovery_port = global_config.discovery_port;
+    new_controller->relay_count = global_config.relay_count;
+
+    new_controller->relays = malloc(sizeof(relay_t) * new_controller->relay_count);
+    uint8_t i;
+    for(i = 0; i < new_controller->relay_count; ++i)
+    {
+        new_controller->relays[i] = relay_create(i);
+    }
+
+    return new_controller;
+}
+
+void
+controller_set_name(controller_t *controller, const char *name)
+{
+    strncpy(controller->name, name, MAX_NAME_LENGTH);
+    controller->name[MAX_NAME_LENGTH] = '\0';
+}
+
+void
+controller_free(controller_t *controller)
+{
+    for(int i = 0; i < controller->relay_count; ++i)
+    {
+        relay_free(controller->relays[i]);
+    }
+    free(controller->relays);
+    free(controller);
+}
+
+void
+controller_debug(controller_t *controller)
+{
+    if(controller == NULL)
+    {
+        LOG_DEBUG("controller is NULL\n");
+        return;
+    }
+    char uuid_str[37];
+    uuid_unparse(controller->id, uuid_str);
+    LOG_DEBUG("(1/5) %s @ %p\n", uuid_str, (void*)controller);
+    LOG_DEBUG("(2/5) name: %s\n", controller->name);
+    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(int i = 0; i < controller->relay_count; ++i)
+    {
+        relay_debug(controller->relays[i]);
+    }
+}

src/models/controller_load.c

@@ -0,0 +1,85 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <uuid/uuid.h>
+
+#include <models/controller.h>
+#include <macros.h>
+
+static void
+controller_load_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, db_key_controller_e key_controller, MDB_val *value)
+{
+    int err;
+    MDB_val key;
+
+    key.mv_size = sizeof(db_key_controller_e);
+    key.mv_data = &key_controller;
+
+    if((err = mdb_get(mdb_txn, mdb_dbi, &key, value)) != 0)
+    {
+        LOG_ERROR("mdb_get error %s\n", mdb_strerror(err));
+        exit(1);
+    }
+}
+
+controller_t*
+controller_load(MDB_env *mdb_env)
+{
+    int err;
+    MDB_txn *mdb_txn;
+    MDB_dbi mdb_dbi;
+    
+    controller_t *new_controller;
+
+    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 NULL;
+    }
+    if((err = mdb_dbi_open(mdb_txn, "controller", 0, &mdb_dbi)) != 0)
+    {
+        switch(err)
+        {
+            case MDB_NOTFOUND:
+                LOG_INFO("no controller found in db. creating new one\n");
+                mdb_txn_abort(mdb_txn);
+                new_controller = controller_create();
+                controller_save(new_controller, mdb_env);
+                return new_controller;
+            default:
+                LOG_ERROR("mdb_txn_begin error %s\n", mdb_strerror(err));
+                return NULL;
+        }
+    }
+
+    new_controller = malloc(sizeof(controller_t));
+
+    MDB_val value;
+
+    controller_load_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_ID, &value);
+    memmove(new_controller->id, (uuid_t*)value.mv_data, sizeof(uuid_t));
+
+    controller_load_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_NAME, &value);
+    strncpy(new_controller->name, (char*)value.mv_data, MAX_NAME_LENGTH);
+    new_controller->name[MAX_NAME_LENGTH] = '\0';
+
+    controller_load_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_COMMAND_PORT, &value);
+    new_controller->command_port = ((uint16_t*)value.mv_data)[0];
+
+    controller_load_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_DISCOVERY_PORT, &value);
+    new_controller->discovery_port = ((uint16_t*)value.mv_data)[0];
+
+    new_controller->relay_count = global_config.relay_count;
+
+    mdb_txn_abort(mdb_txn); // transaction is read only
+
+    new_controller->relays = malloc(sizeof(relay_t*) * new_controller->relay_count);
+    for(uint8_t i = 0; i < new_controller->relay_count; i++)
+    {
+        LOG_TRACE("loading relay %d\n", i);
+        new_controller->relays[i] = relay_load(mdb_env, i);
+    }
+    
+    return new_controller;
+}

src/models/controller_save.c

@@ -0,0 +1,90 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <uuid/uuid.h>
+
+#include <models/controller.h>
+#include <macros.h>
+
+int
+controller_save_single(MDB_txn *mdb_txn, MDB_dbi mdb_dbi, db_key_controller_e key_controller, MDB_val value)
+{
+    int err;
+
+    MDB_val key;
+    key.mv_size = sizeof(db_key_controller_e);
+    key.mv_data = &key_controller;
+
+    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);
+        return 1;
+    }
+    return 0;
+}
+
+int
+controller_save(controller_t *controller, MDB_env *mdb_env)
+{
+    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, "controller", 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 = controller->id;
+    if(controller_save_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_ID, value))
+    {
+        LOG_ERROR("failed to save ID\n");
+        return 1;
+    }
+
+    value.mv_size = sizeof(char) * (strlen(controller->name) + 1);
+    value.mv_data = controller->name;
+    if(controller_save_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_NAME, value))
+    {
+        LOG_ERROR("failed to save name\n");
+        return 1;
+    }
+
+    value.mv_size = sizeof(controller->command_port);
+    value.mv_data = &controller->command_port;
+    if(controller_save_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_COMMAND_PORT, value))
+    {
+        LOG_ERROR("failed to save command port\n");
+        return 1;
+    }
+
+    value.mv_size = sizeof(controller->discovery_port);
+    value.mv_data = &controller->discovery_port;
+    if(controller_save_single(mdb_txn, mdb_dbi, DB_KEY_CONTROLLER_DISCOVERY_PORT, value))
+    {
+        LOG_ERROR("failed to save discovery port\n");
+        return 1;
+    }
+
+    mdb_txn_commit(mdb_txn);
+
+    for(uint8_t i = 0; i < controller->relay_count; ++i)
+    {
+        LOG_TRACE("saving relays[%d/%d]\n", i, controller->relay_count);
+        relay_save(controller->relays[i], mdb_env);
+    }
+
+    return 0;
+}

src/models/period.c

@@ -0,0 +1,47 @@
+#include <stdlib.h>
+
+#include <logger.h>
+#include <constants.h>
+#include <models/period.h>
+
+period_t*
+period_create(uint16_t start, uint16_t end)
+{
+    period_t *new_period = malloc(sizeof(period_t));
+    new_period->start = start;
+    new_period->end = end;
+
+    return new_period;
+}
+
+int
+period_includes_time(period_t *period, struct tm *time_struct)
+{
+    uint16_t start = period->start;
+    uint16_t end = period->end;
+
+    time_t timestamp = time_struct->tm_hour * 60;
+    timestamp += time_struct->tm_min;
+
+    // "normal" timespan
+    if(start < end)
+    {
+        if(start <= timestamp && end > timestamp)
+        {
+            return 1;
+        }
+        return 0;
+    }
+
+    // timespan goes through 00:00
+    if(end < start)
+    {
+        if(start >= timestamp && end < timestamp)
+        {
+            return 1;
+        }
+        return 0;
+    }
+
+    return 0;
+}

src/models/relay.c

@@ -0,0 +1,80 @@
+#include <stdlib.h>
+#include <string.h>
+#include <uuid/uuid.h>
+
+#include <logger.h>
+#include <helpers.h>
+#include <models/relay.h>
+
+relay_t*
+relay_create(uint8_t number)
+{
+    relay_t *new_relay = malloc(sizeof(relay_t));
+
+    new_relay->number = number;
+    new_relay->name[0] = '\0';
+
+    uuid_t off_id;
+    memset(off_id, 0, sizeof(uuid_t));
+    memcpy(off_id, "off", 3);
+
+    for(int i = 0; i < 7; ++i)
+    {
+        new_relay->schedules[i] = schedule_create(off_id, i, 0, NULL);
+    }
+
+    return new_relay;
+}
+
+void
+relay_set_name(relay_t *relay, const char *name)
+{
+    strncpy(relay->name, name, MAX_NAME_LENGTH);
+    relay->name[MAX_NAME_LENGTH] = '\0';
+}
+
+int
+relay_is_active(relay_t *relay, struct tm *time_struct)
+{
+    schedule_t *schedule = relay->schedules[helper_get_weekday(time_struct)];
+    if(schedule->length == 0)
+    {
+        return 0;
+    }
+
+    for(uint16_t i = 0; i < schedule->length; ++i)
+    {
+        if(period_includes_time(schedule->periods[i], time_struct))
+        {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+void
+relay_debug(relay_t *relay)
+{
+    if(relay == NULL)
+    {
+        LOG_DEBUG("relay is NULL\n");
+        return;
+    }
+    LOG_DEBUG("(1/3) %d @ %p\n", relay->number, (void*)relay);
+    LOG_DEBUG("(2/3) name: %s\n", relay->name);
+    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)
+{
+    for(int i = 0; i < 7; ++i)
+    {
+        schedule_free(relay->schedules[i]);
+    }
+    free(relay);
+}

src/models/relay_load.c

@@ -0,0 +1,88 @@
+#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
+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); 
+    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;
+    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;
+}
+
+relay_t*
+relay_load(MDB_env *mdb_env, uint8_t num)
+{
+    int err;
+    MDB_txn *mdb_txn;
+    MDB_dbi mdb_dbi;
+    
+    relay_t *new_relay;
+
+    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 relay_create(num);
+    }
+
+    if((err = mdb_dbi_open(mdb_txn, "relays", 0, &mdb_dbi)) != 0)
+    {
+        switch(err)
+        {
+            case MDB_NOTFOUND:
+                LOG_INFO("no relay for num %d found in db. returning new one (no relays db)\n", num);
+                mdb_txn_abort(mdb_txn);
+                return relay_create(num);
+            default:
+                LOG_ERROR("mdb_txn_begin error %s\n", mdb_strerror(err));
+                return relay_create(num);
+        }
+    }
+
+    new_relay = malloc(sizeof(relay_t));
+    new_relay->number = num;
+
+    MDB_val value;
+
+    if((err = relay_load_single(mdb_txn, mdb_dbi, DB_KEY_RELAY_NAME, 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);
+    }
+    strncpy(new_relay->name, (char*)value.mv_data, MAX_NAME_LENGTH);
+    new_relay->name[MAX_NAME_LENGTH] = '\0';
+
+    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;
+}

src/models/relay_save.c

@@ -0,0 +1,75 @@
+#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
+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); 
+    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;
+    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
+relay_save(relay_t *relay, MDB_env *mdb_env)
+{
+    LOG_TRACE("saving relay %d @ %p\n", relay->number, relay);
+    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, "relays", MDB_CREATE, &mdb_dbi)) != 0)
+    {
+        LOG_ERROR("mdb_dbi_open error %s\n", mdb_strerror(err));
+        exit(1);
+    }
+
+    value.mv_size = sizeof(char) * (strlen(relay->name) + 1);
+    value.mv_data = relay->name;
+    if(relay_save_single(mdb_txn, mdb_dbi, DB_KEY_RELAY_NAME, relay->number, value))
+    {
+        LOG_ERROR("failed to save name\n");
+        return 1;
+    }
+
+    mdb_txn_commit(mdb_txn);
+
+    for(int i = 0; i < 7; ++i)
+    {
+        schedule_save(relay->schedules[i], relay->number, mdb_env);
+    }
+
+    return 0;
+}

src/models/schedule.c

@@ -0,0 +1,94 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include <logger.h>
+#include <models/schedule.h>
+
+schedule_t*
+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;
+
+    if(length)
+    {
+        new_schedule->periods = malloc(sizeof(period_t*) * length);
+
+        for(uint16_t i = 0; i < length; ++i)
+        {
+            uint16_t start = periods_blob[0 + (i * 2)];
+            uint16_t   end = periods_blob[1 + (i * 2)];
+            new_schedule->periods[i] = period_create(start, end);
+        }
+    }
+
+    return new_schedule;
+}
+
+uint16_t*
+schedule_periods_to_blob(schedule_t *schedule)
+{
+    uint16_t *periods_blob = malloc(sizeof(uint16_t) * ((2 * schedule->length) + 1));
+    periods_blob[0] = schedule->length;
+
+    for(uint16_t i = 0; i < schedule->length; ++i)
+    {
+
+        periods_blob[1 + (i * 2)] = schedule->periods[i]->start;
+        periods_blob[2 + (i * 2)] = schedule->periods[i]->end;
+    }
+
+    return periods_blob;
+}
+
+void
+schedule_free(schedule_t *schedule)
+{
+    for(uint16_t i = 0; i < schedule->length; ++i)
+    {
+        free(schedule->periods[i]);
+    }
+    free(schedule->periods);
+    free(schedule);
+}
+
+void
+schedule_debug(schedule_t *schedule)
+{
+    if(schedule == NULL)
+    {
+        LOG_DEBUG("schedule is NULL\n");
+        return;
+    }
+    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/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));
+    periods_debug_str[0] = '\0';
+
+    for(uint16_t i = 0; i < schedule->length; ++i)
+    {
+        sprintf(
+            periods_debug_str + (13 * i),
+            "%02d:%02d-%02d:%02d, ",
+            schedule->periods[i]->start / 60,
+            schedule->periods[i]->start % 60,
+            schedule->periods[i]->end / 60,
+            schedule->periods[i]->end % 60
+        );
+    }
+
+    LOG_DEBUG("(4/4) periods: %s\n", periods_debug_str);
+
+    free(periods_debug_str);
+}

src/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;
+}

src/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;
+}