emgauwa/controller-legacy
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

remove: lmdb

Browse source 
add: sqlite
add: new commands
This commit is contained in:
Tobias Reisinger 2020-08-24 16:00:08 +02:00
parent a37bdc4870
commit 9602e6e937
33 changed files with 1403 additions and 752 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
CMakeLists.txt
View file

@ -1,13 +1,13 @@
cmake_minimum_required (VERSION 3.7) cmake_minimum_required (VERSION 3.7)
project(controller project(controller
VERSION 0.2.10 VERSION 0.3.0
LANGUAGES C) LANGUAGES C)
add_executable(controller src/main.c) add_executable(controller src/main.c)
target_link_libraries(controller -lwiringPi) target_link_libraries(controller -lwiringPi)
target_link_libraries(controller -lwiringPiDev) target_link_libraries(controller -lwiringPiDev)
target_link_libraries(controller -llmdb) target_link_libraries(controller -lsqlite3)
target_link_libraries(controller -luuid) target_link_libraries(controller -luuid)
option(WIRING_PI_DEBUG "Use WiringPi Debugging Tool (OFF)" OFF) option(WIRING_PI_DEBUG "Use WiringPi Debugging Tool (OFF)" OFF)
@ -30,14 +30,22 @@ aux_source_directory(src/drivers DRIVERS_SRC)
aux_source_directory(src/runners RUNNERS_SRC) aux_source_directory(src/runners RUNNERS_SRC)
aux_source_directory(vendor VENDOR_SRC) aux_source_directory(vendor VENDOR_SRC)
add_dependencies(controller sql)
configure_file("controller.ini" "controller.ini" COPYONLY) configure_file("controller.ini" "controller.ini" COPYONLY)
configure_file("version.h.in" "version.h" @ONLY) configure_file("version.h.in" "version.h" @ONLY)
target_sources(controller PRIVATE ${SRC_DIR} ${MODELS_SRC} ${HELPERS_SRC} ${HANDLERS_SRC} ${DRIVERS_SRC} ${RUNNERS_SRC} ${VENDOR_SRC}) target_sources(controller PRIVATE ${SRC_DIR} ${MODELS_SRC} ${HELPERS_SRC} ${HANDLERS_SRC} ${DRIVERS_SRC} ${RUNNERS_SRC} ${VENDOR_SRC})
target_include_directories(controller PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include) target_include_directories(controller PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
target_include_directories(controller PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/vendor) target_include_directories(controller PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/vendor)
target_include_directories(controller PRIVATE ${CMAKE_BINARY_DIR}) target_include_directories(controller PRIVATE ${CMAKE_BINARY_DIR})
add_custom_target(sql
COMMAND ./compile_sql.sh
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
add_custom_target(run add_custom_target(run
COMMAND ./controller start COMMAND ./controller start
DEPENDS controller DEPENDS controller

33
compile_sql.sh Executable file
View file

@ -0,0 +1,33 @@
#!/usr/bin/env sh
to_header () {
if [ -f ./include/sql/$1.h ]
then
if [ -z $(find ./sql/$1.sql -newer ./include/sql/$1.h -print) ]
then
return
fi
fi
echo "Compiling $1"
xxd -i sql/$1.sql | sed 's/\([0-9a-f]\)$/\0, 0x00/' > ./include/sql/$1.h
}
cd "$(dirname "$0")";
migration_num=0;
while [ -f ./sql/migration_$migration_num.sql ]
do
if [ -f ./include/migrations/$migration_num.sql.h ]
then
if [ -z $(find ./sql/migration_$migration_num.sql -newer ./include/sql/migration_$migration_num.h -print) ]
then
migration_num=$((migration_num+1))
continue
fi
fi
to_header "migration_$migration_num"
migration_num=$((migration_num+1))
done
cd $PWD;

2
controller.ini
View file

@ -10,7 +10,7 @@ mqtt-host = localhost
relay-count = 10 relay-count = 10
relays-init = 1 relays-init = 1
database = controller_db.lmdb database = controller.sqlite
log-level = debug log-level = debug
log-file = stdout log-file = stdout

43
include/database.h
View file

@ -1,19 +1,40 @@
#ifndef CONTROLLER_DATABASE_H #ifndef CONTROLLER_DATABASE_H
#define CONTROLLER_DATABASE_H #define CONTROLLER_DATABASE_H
#include <lmdb.h> #include <sqlite3.h>
extern sqlite3 *global_database;
/**
* @brief Setup lmdb database enviroment
*
* Creates, sets max dbs and opens an MDB_env instance.
* Will return on success, but exit program on failure.
*
* @param mdb_env Source variable will be set to new MDB_env
*/
void void
database_setup(MDB_env **mdb_env, config_t *config); database_init();
extern MDB_env *global_mdb_env; void
database_free();
void
database_migrate();
int
database_transaction_begin();
void
database_transaction_commit();
void
database_transaction_rollback();
int
database_helper_get_id(sqlite3_stmt *stmt);
int*
database_helper_get_ids(sqlite3_stmt *stmt);
char*
database_helper_get_string(sqlite3_stmt *stmt);
char**
database_helper_get_strings(sqlite3_stmt *stmt);
#endif /* CONTROLLER_DATABASE_H */ #endif /* CONTROLLER_DATABASE_H */

25
include/enums.h
View file

@ -15,31 +15,6 @@ typedef enum
DISCOVERY_MAPPING_RELAY_COUNT = 3, DISCOVERY_MAPPING_RELAY_COUNT = 3,
} discovery_mapping_t; } discovery_mapping_t;
typedef enum
{
COMMAND_MAPPING_CODE = 0,
COMMAND_MAPPING_NAME = 1,
COMMAND_MAPPING_RELAY_NUM = 2,
COMMAND_MAPPING_SCHEDULES_ARRAY = 3,
COMMAND_MAPPING_SCHEDULE_ID = 4,
COMMAND_MAPPING_PERIODS_COUNT = 5,
COMMAND_MAPPING_PERIODS_BLOB = 6,
COMMAND_MAPPING_PULSE_DURATION = 7,
} control_mapping_t;
typedef enum
{
COMMAND_CODE_GET_TIME = 1,
COMMAND_CODE_GET_ID = 2,
COMMAND_CODE_SET_NAME = 100,
COMMAND_CODE_GET_NAME = 101,
COMMAND_CODE_SET_SCHEDULE = 102,
COMMAND_CODE_GET_SCHEDULE = 103,
COMMAND_CODE_SET_RELAY_NAME = 104,
COMMAND_CODE_GET_RELAY_NAME = 105,
COMMAND_CODE_PULSE = 200,
} command_code_t;
typedef enum typedef enum
{ {
RELAY_DRIVER_NONE, RELAY_DRIVER_NONE,

11
include/macros.h
View file

@ -1,13 +1,6 @@
#ifndef CONTROLLER_MACROS_H #ifndef CONTROLLER_MACROS_H
#define CONTROLLER_MACROS_H #define CONTROLLER_MACROS_H
#include <colors.h> #define STRLEN(s) ((sizeof(s)/sizeof(s[0])) - sizeof(s[0]))
#include <logger.h>
#ifndef SOURCE_PATH_SIZE #endif /* CONTROLLER_MACROS_H */
#define SOURCE_PATH_SIZE 0
#endif
#define __FILENAME__ (__FILE__ + SOURCE_PATH_SIZE)
#endif //CONTROLLER_MACROS_H

17
include/models/controller.h
View file

@ -13,10 +13,12 @@
*/ */
typedef struct typedef struct
{ {
int id;
/** /**
* @brief A unique UUID for this controller * @brief A unique UUID for this controller
*/ */
uuid_t id; uuid_t uid;
/** /**
* @brief The name of this controller * @brief The name of this controller
* *
@ -27,14 +29,7 @@ typedef struct
* @brief The command port the controller was bound to * @brief The command port the controller was bound to
*/ */
uint16_t command_port; uint16_t command_port;
/**
* @brief The discovery port the controller receives broadcasts on
*/
uint16_t discovery_port;
/**
* @brief Amount of relays available to this controller
*/
uint8_t relay_count;
relay_t **relays; relay_t **relays;
} controller_t; } controller_t;
@ -71,7 +66,7 @@ controller_create(void);
* @return A loaded or new instance of controller or NULL on database error * @return A loaded or new instance of controller or NULL on database error
*/ */
controller_t* controller_t*
controller_load(MDB_env *mdb_env); controller_load();
/** /**
* @brief Save a controller to the database * @brief Save a controller to the database
@ -82,7 +77,7 @@ controller_load(MDB_env *mdb_env);
* @return Indicator to show success (0) or failure (!0) * @return Indicator to show success (0) or failure (!0)
*/ */
int int
controller_save(controller_t *controller, MDB_env *mdb_env); controller_save();
/** /**
* @brief Sets a name to a controller. * @brief Sets a name to a controller.

13
include/models/junction_relay_schedule.h Normal file
View file

@ -0,0 +1,13 @@
#ifndef CONTROLLER_MODELS_JUNCTION_RELAY_SCHEDULE_H
#define CONTROLLER_MODELS_JUNCTION_RELAY_SCHEDULE_H
int
junction_relay_schedule_insert(uint8_t weekday, int relay_id, int schedule_id);
int
junction_relay_schedule_remove_for_relay(int relay_id);
int
junction_relay_schedule_insert_weekdays(int relay_id, int *schedule_ids);
#endif /* CONTROLLER_MODELS_JUNCTION_RELAY_SCHEDULE_H */

5
include/models/period.h
View file

@ -10,10 +10,7 @@ typedef struct
uint16_t end; uint16_t end;
} period_t; } period_t;
period_t*
period_create(uint16_t start, uint16_t end);
int int
period_includes_time(period_t *period, struct tm *time_struct); period_includes_time(period_t period, struct tm *time_struct);
#endif /* CONTROLLER_PERIOD_H */ #endif /* CONTROLLER_PERIOD_H */

23
include/models/relay.h
View file

@ -10,6 +10,7 @@
typedef struct typedef struct
{ {
int id;
uint8_t number; uint8_t number;
int is_on; int is_on;
int is_on_schedule; int is_on_schedule;
@ -33,26 +34,14 @@ relay_create(uint8_t number);
void void
relay_set_name(relay_t *relay, const char *name); relay_set_name(relay_t *relay, const char *name);
/**
* @brief Load a relay for database or create a new one
*
* @param mdb_env An opened MDB_env to load from
*
* @return A loaded or new instance of relay
*/
relay_t* relay_t*
relay_load(MDB_env *mdb_env, uint8_t num); relay_load(uint8_t number);
/**
* @brief Save a relay to the database
*
* @param relay Instance of a relay
* @param mdb_env Already created MDB_env
*
* @return Indicator to show success (0) or failure (!0)
*/
int int
relay_save(relay_t *relay, MDB_env *mdb_env); relay_save(relay_t *relay);
void
relay_reload_schedules(relay_t *relay);
int int
relay_is_on_schedule(relay_t *relay, struct tm *time_struct); relay_is_on_schedule(relay_t *relay, struct tm *time_struct);

27
include/models/schedule.h
View file

@ -9,10 +9,11 @@
typedef struct typedef struct
{ {
uuid_t id; int id;
uuid_t uid;
uint8_t weekday; uint8_t weekday;
uint16_t length; uint16_t length;
period_t **periods; period_t *periods;
} schedule_t; } schedule_t;
/** /**
@ -25,13 +26,16 @@ typedef enum
} db_key_schedule_e; } db_key_schedule_e;
schedule_t* schedule_t*
schedule_create(uuid_t id, uint8_t weekday, uint16_t length, uint16_t *periods_blob); schedule_create(uuid_t uid, uint16_t length, uint16_t *periods_blob);
schedule_t*
schedule_load(MDB_env *mdb_env, uint8_t relay_num, uint8_t weekday);
int int
schedule_save(schedule_t *schedule, uint8_t relay_num, MDB_env *mdb_env); schedule_save(schedule_t *schedule);
schedule_t*
schedule_get_by_uid(uuid_t uid);
schedule_t**
schedule_get_relay_weekdays(int relay_id);
uint16_t* uint16_t*
schedule_periods_to_blob(schedule_t *schedule); schedule_periods_to_blob(schedule_t *schedule);
@ -39,7 +43,16 @@ schedule_periods_to_blob(schedule_t *schedule);
void void
schedule_free(schedule_t *schedule); schedule_free(schedule_t *schedule);
void
schedule_free_list(schedule_t **schedules_list);
void void
schedule_debug(schedule_t *schedule); schedule_debug(schedule_t *schedule);
int
schedule_uid_parse(const char *uid_str, uuid_t result);
void
schedule_uid_unparse(const uuid_t uid, char *result);
#endif /* CONTROLLER_SCHEDULE_H */ #endif /* CONTROLLER_SCHEDULE_H */

2
include/runners.h
View file

@ -6,6 +6,6 @@
#include <models/controller.h> #include <models/controller.h>
void void
runner_test(controller_t *controller); runner_test();
#endif /* CONTROLLER_RUNNERS_H */ #endif /* CONTROLLER_RUNNERS_H */

0
include/sql/.gitkeep Normal file
View file

96
include/sql/migration_0.h Normal file
View file

@ -0,0 +1,96 @@
unsigned char sql_migration_0_sql[] = {
0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6c, 0x65,
0x20, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x72, 0x73,
0x0a, 0x28, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x64, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x0a, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x50,
0x52, 0x49, 0x4d, 0x41, 0x52, 0x59, 0x20, 0x4b, 0x45, 0x59, 0x0a, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x41,
0x55, 0x54, 0x4f, 0x49, 0x4e, 0x43, 0x52, 0x45, 0x4d, 0x45, 0x4e, 0x54,
0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x75, 0x69, 0x64, 0x20, 0x20, 0x20,
0x20, 0x20, 0x42, 0x4c, 0x4f, 0x42, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e,
0x55, 0x4c, 0x4c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x55, 0x4e, 0x49, 0x51, 0x55, 0x45, 0x2c, 0x0a,
0x20, 0x20, 0x20, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x56, 0x41, 0x52, 0x43,
0x48, 0x41, 0x52, 0x28, 0x31, 0x32, 0x38, 0x29, 0x2c, 0x0a, 0x20, 0x20,
0x20, 0x20, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x5f, 0x70, 0x6f,
0x72, 0x74, 0x20, 0x20, 0x20, 0x20, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45,
0x52, 0x0a, 0x29, 0x3b, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65,
0x20, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x79,
0x73, 0x0a, 0x28, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6e, 0x75, 0x6d, 0x62,
0x65, 0x72, 0x20, 0x20, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x0a,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x50, 0x52, 0x49, 0x4d, 0x41, 0x52, 0x59, 0x20, 0x4b, 0x45, 0x59, 0x0a,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c, 0x2c, 0x0a, 0x20, 0x20,
0x20, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x20, 0x20, 0x20, 0x56, 0x41,
0x52, 0x43, 0x48, 0x41, 0x52, 0x28, 0x31, 0x32, 0x38, 0x29, 0x0a, 0x29,
0x3b, 0x0a, 0x0a, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x74, 0x61,
0x62, 0x6c, 0x65, 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65,
0x73, 0x0a, 0x28, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x64, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x0a,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x50, 0x52, 0x49, 0x4d, 0x41, 0x52, 0x59, 0x20, 0x4b, 0x45, 0x59, 0x0a,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x41, 0x55, 0x54, 0x4f, 0x49, 0x4e, 0x43, 0x52, 0x45, 0x4d, 0x45, 0x4e,
0x54, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x75, 0x69, 0x64, 0x20, 0x20,
0x20, 0x20, 0x20, 0x42, 0x4c, 0x4f, 0x42, 0x0a, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x4e, 0x4f, 0x54, 0x20,
0x4e, 0x55, 0x4c, 0x4c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x55, 0x4e, 0x49, 0x51, 0x55, 0x45, 0x2c,
0x0a, 0x20, 0x20, 0x20, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x20, 0x20,
0x20, 0x56, 0x41, 0x52, 0x43, 0x48, 0x41, 0x52, 0x28, 0x31, 0x32, 0x38,
0x29, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x70, 0x65, 0x72, 0x69, 0x6f,
0x64, 0x73, 0x20, 0x42, 0x4c, 0x4f, 0x42, 0x0a, 0x29, 0x3b, 0x0a, 0x0a,
0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x20, 0x74, 0x61, 0x62, 0x6c, 0x65,
0x20, 0x6a, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x65,
0x6c, 0x61, 0x79, 0x5f, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65,
0x0a, 0x28, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x77, 0x65, 0x65, 0x6b, 0x64,
0x61, 0x79, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x53,
0x4d, 0x41, 0x4c, 0x4c, 0x49, 0x4e, 0x54, 0x0a, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x4e, 0x55, 0x4c, 0x4c,
0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x5f,
0x69, 0x64, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x49, 0x4e,
0x54, 0x45, 0x47, 0x45, 0x52, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x52, 0x45, 0x46, 0x45, 0x52, 0x45, 0x4e, 0x43, 0x45, 0x53,
0x20, 0x72, 0x65, 0x6c, 0x61, 0x79, 0x73, 0x20, 0x28, 0x69, 0x64, 0x29,
0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x4f, 0x4e, 0x20,
0x44, 0x45, 0x4c, 0x45, 0x54, 0x45, 0x20, 0x43, 0x41, 0x53, 0x43, 0x41,
0x44, 0x45, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x73, 0x63, 0x68, 0x65,
0x64, 0x75, 0x6c, 0x65, 0x5f, 0x69, 0x64, 0x20, 0x20, 0x20, 0x20, 0x20,
0x49, 0x4e, 0x54, 0x45, 0x47, 0x45, 0x52, 0x0a, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x44, 0x45, 0x46, 0x41, 0x55, 0x4c, 0x54, 0x20,
0x31, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x52, 0x45,
0x46, 0x45, 0x52, 0x45, 0x4e, 0x43, 0x45, 0x53, 0x20, 0x73, 0x63, 0x68,
0x65, 0x64, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x28, 0x69, 0x64, 0x29, 0x0a,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x4f, 0x4e, 0x20, 0x44,
0x45, 0x4c, 0x45, 0x54, 0x45, 0x20, 0x53, 0x45, 0x54, 0x20, 0x44, 0x45,
0x46, 0x41, 0x55, 0x4c, 0x54, 0x0a, 0x29, 0x3b, 0x0a, 0x0a, 0x49, 0x4e,
0x53, 0x45, 0x52, 0x54, 0x20, 0x49, 0x4e, 0x54, 0x4f, 0x20, 0x73, 0x63,
0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x28, 0x75, 0x69, 0x64,
0x2c, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x20, 0x70, 0x65, 0x72, 0x69,
0x6f, 0x64, 0x73, 0x29, 0x20, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x53, 0x20,
0x28, 0x78, 0x27, 0x36, 0x66, 0x36, 0x36, 0x36, 0x36, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x27,
0x2c, 0x20, 0x27, 0x6f, 0x66, 0x66, 0x27, 0x2c, 0x20, 0x78, 0x27, 0x30,
0x30, 0x27, 0x29, 0x3b, 0x0a, 0x49, 0x4e, 0x53, 0x45, 0x52, 0x54, 0x20,
0x49, 0x4e, 0x54, 0x4f, 0x20, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c,
0x65, 0x73, 0x20, 0x28, 0x75, 0x69, 0x64, 0x2c, 0x20, 0x6e, 0x61, 0x6d,
0x65, 0x2c, 0x20, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x73, 0x29, 0x20,
0x56, 0x41, 0x4c, 0x55, 0x45, 0x53, 0x20, 0x28, 0x78, 0x27, 0x36, 0x66,
0x36, 0x65, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x27, 0x2c, 0x20, 0x20, 0x27, 0x6f,
0x6e, 0x27, 0x2c, 0x20, 0x78, 0x27, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x39, 0x46, 0x30, 0x35, 0x27, 0x29, 0x3b, 0x0a, 0x00
};
unsigned int sql_migration_0_sql_len = 1114;

47
sql/migration_0.sql Normal file
View file

@ -0,0 +1,47 @@
create table controllers
(
id INTEGER
PRIMARY KEY
AUTOINCREMENT,
uid BLOB
NOT NULL
UNIQUE,
name VARCHAR(128),
command_port INTEGER
);
create table relays
(
number INTEGER
PRIMARY KEY
NOT NULL,
name VARCHAR(128)
);
create table schedules
(
id INTEGER
PRIMARY KEY
AUTOINCREMENT,
uid BLOB
NOT NULL
UNIQUE,
name VARCHAR(128),
periods BLOB
);
create table junction_relay_schedule
(
weekday SMALLINT
NOT NULL,
relay_id INTEGER
REFERENCES relays (id)
ON DELETE CASCADE,
schedule_id INTEGER
DEFAULT 1
REFERENCES schedules (id)
ON DELETE SET DEFAULT
);
INSERT INTO schedules (uid, name, periods) VALUES (x'6f666600000000000000000000000000', 'off', x'00');
INSERT INTO schedules (uid, name, periods) VALUES (x'6f6e0000000000000000000000000000', 'on', x'010000009F05');

2
src/connections.c
View file

@ -11,7 +11,7 @@ struct mg_connection*
connection_discovery_bind(struct mg_mgr *mgr) connection_discovery_bind(struct mg_mgr *mgr)
{ {
char address[32]; char address[32];
sprintf(address, "udp://0.0.0.0:%u", global_controller->discovery_port); sprintf(address, "udp://0.0.0.0:%u", global_config.discovery_port);
struct mg_connection *c = mg_bind(mgr, address, handler_discovery); struct mg_connection *c = mg_bind(mgr, address, handler_discovery);
return c; return c;
} }

262
src/database.c
View file

@ -1,32 +1,264 @@
#include <stdlib.h> #include <stdint.h>
#include <stddef.h>
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdlib.h>
#include <lmdb.h>
#include <logger.h> #include <logger.h>
#include <config.h> #include <database.h>
#include <constants.h>
#include <sql/migration_0.h>
sqlite3 *global_database;
static int in_transaction;
void void
database_setup(MDB_env **mdb_env, config_t *config) database_init()
{ {
int err; int rc = sqlite3_open(global_config.database, &global_database);
if(mdb_env_create(mdb_env) != 0) if(rc)
{ {
LOGGER_CRIT("Can't create mdb handle"); LOGGER_CRIT("can't open database: %s\n", sqlite3_errmsg(global_database));
exit(1); exit(1);
} }
if((err = mdb_env_set_maxdbs(*mdb_env, MDB_MAXDBS)) != 0) database_migrate();
{
LOGGER_CRIT("mdb_env_set_maxdbs error %s\n", mdb_strerror(err)); sqlite3_exec(global_database, "PRAGMA foreign_keys = ON", 0, 0, 0);
exit(1); in_transaction = 0;
} }
if(mdb_env_open(*mdb_env, config->database, MDB_NOSUBDIR, 0700) != 0) void
database_free()
{ {
LOGGER_CRIT("Can't open mdb file"); sqlite3_close(global_database);
}
void
database_migrate()
{
uint16_t version_num = 0;
int s, rc;
sqlite3_stmt *stmt;
sqlite3_prepare_v2(global_database, "PRAGMA user_version;", -1, &stmt, NULL);
s = sqlite3_step(stmt);
if (s == SQLITE_ROW)
{
version_num = sqlite3_column_int(stmt, 0);
}
else
{
version_num = 0;
}
uint16_t new_version_num = version_num;
char* err_msg;
sqlite3_finalize(stmt);
switch(version_num)
{
case 0:
LOGGER_INFO("migrating LEVEL 0\n");
rc = sqlite3_exec(global_database, (const char *)sql_migration_0_sql, NULL, NULL, &err_msg);
if(rc)
{
LOGGER_CRIT("couldn't migrate LEVEL 0 (%s)\n", err_msg);
exit(1); exit(1);
} }
new_version_num = 1;
default:
break;
}
char pragma_query[32];
sprintf(pragma_query, "PRAGMA user_version=%d;", new_version_num);
sqlite3_exec(global_database, pragma_query, 0, 0, 0);
LOGGER_DEBUG("storing new user_version %d\n", new_version_num);
return;
}
int
database_transaction_begin()
{
if(!in_transaction)
{
LOGGER_DEBUG("beginning transaction\n");
sqlite3_exec(global_database, "BEGIN TRANSACTION;", NULL, NULL, NULL);
in_transaction = 1;
return 1;
}
return 0;
}
void
database_transaction_commit()
{
LOGGER_DEBUG("commiting transaction\n");
sqlite3_exec(global_database, "COMMIT TRANSACTION;", NULL, NULL, NULL);
in_transaction = 0;
}
void
database_transaction_rollback()
{
LOGGER_DEBUG("rolling back transaction\n");
sqlite3_exec(global_database, "ROLLBACK TRANSACTION;", NULL, NULL, NULL);
in_transaction = 0;
}
int
database_helper_get_id(sqlite3_stmt *stmt)
{
int result = 0;
for(;;)
{
int s;
s = sqlite3_step(stmt);
if (s == SQLITE_ROW)
{
result = sqlite3_column_int(stmt, 0);
}
else
{
if (s == SQLITE_DONE)
{
break;
}
else
{
LOGGER_ERR("error selecting id from database: %s\n", sqlite3_errstr(s));
sqlite3_finalize(stmt);
return 0;
}
}
}
sqlite3_finalize(stmt);
return result;
}
int*
database_helper_get_ids(sqlite3_stmt *stmt)
{
int *result = malloc(sizeof(int));
int new_id;
int row = 0;
for(;;)
{
int s;
s = sqlite3_step(stmt);
if (s == SQLITE_ROW)
{
new_id = sqlite3_column_int(stmt, 0);
if(new_id != 0) // found row for other target (relay <> schedule)
{
row++;
result = (int*)realloc(result, sizeof(int) * (row + 1));
result[row - 1] = new_id;
}
}
else
{
if (s == SQLITE_DONE)
{
break;
}
else
{
LOGGER_ERR("error selecting ids from database: %s\n", sqlite3_errstr(s));
sqlite3_finalize(stmt);
return NULL;
}
}
}
sqlite3_finalize(stmt);
result[row] = 0;
return result;
}
char*
database_helper_get_string(sqlite3_stmt *stmt)
{
char *result = NULL;
for(;;)
{
int s;
s = sqlite3_step(stmt);
if (s == SQLITE_ROW)
{
const char *found_string = (const char *)sqlite3_column_text(stmt, 0);
result = (char*)malloc(sizeof(char) * (strlen(found_string) + 1));
strcpy(result, found_string);
}
else
{
if (s == SQLITE_DONE)
{
break;
}
else
{
LOGGER_ERR("error selecting string from database: %s\n", sqlite3_errstr(s));
sqlite3_finalize(stmt);
return NULL;
}
}
}
sqlite3_finalize(stmt);
return result;
}
char**
database_helper_get_strings(sqlite3_stmt *stmt)
{
char **result = malloc(sizeof(char*));
int row = 0;
for(;;)
{
int s;
s = sqlite3_step(stmt);
if (s == SQLITE_ROW)
{
const char *new_string = (const char *)sqlite3_column_text(stmt, 0);
int new_string_len = strlen(new_string);
row++;
result = (char**)realloc(result, sizeof(char*) * (row + 1));
result[row - 1] = malloc(sizeof(char) * (new_string_len + 1));
strcpy(result[row - 1], new_string);
}
else
{
if(s == SQLITE_DONE)
{
break;
}
else
{
LOGGER_ERR("error selecting strings from database: %s\n", sqlite3_errstr(s));
break;
}
}
}
sqlite3_finalize(stmt);
result[row] = NULL;
return result;
} }

168
src/handlers/command.c
View file

@ -14,16 +14,52 @@
#include <database.h> #include <database.h>
#include <handlers.h> #include <handlers.h>
#include <helpers.h> #include <helpers.h>
#include <enums.h>
#include <mpack.h> #include <mpack.h>
#include <models/controller.h>
#include <models/relay.h>
#include <models/schedule.h> #include <models/schedule.h>
#include <models/junction_relay_schedule.h>
typedef enum
{
COMMAND_CODE_CONTROLLER_ID_GET = 0,
COMMAND_CODE_CONTROLLER_TIME_GET = 1,
COMMAND_CODE_CONTROLLER_NAME_SET = 2,
COMMAND_CODE_CONTROLLER_NAME_GET = 3,
COMMAND_CODE_RELAY_SCHEDULES_SET = 100,
COMMAND_CODE_RELAY_SCHEDULES_GET = 101,
COMMAND_CODE_RELAY_NAME_SET = 102,
COMMAND_CODE_RELAY_NAME_GET = 103,
COMMAND_CODE_RELAY_PULSE = 200,
COMMAND_CODE_SCHEDULE_UPDATE = 300
} command_code_t;
typedef enum
{
COMMAND_MAPPING_CODE = 0,
COMMAND_MAPPING_NAME = 1,
COMMAND_MAPPING_RELAY_NUM = 2,
COMMAND_MAPPING_SCHEDULES_ARRAY = 3,
COMMAND_MAPPING_SCHEDULE_ID = 4,
COMMAND_MAPPING_PERIODS_COUNT = 5,
COMMAND_MAPPING_PERIODS_BLOB = 6,
COMMAND_MAPPING_PULSE_DURATION = 7,
} control_mapping_t;
static void static void
handler_command_pulse(mpack_node_t map, controller_t *controller) handler_command_relay_pulse(mpack_node_t map)
{ {
int relay_num = mpack_node_u8(mpack_node_map_uint(map, COMMAND_MAPPING_RELAY_NUM)); uint8_t relay_num = mpack_node_u8(mpack_node_map_uint(map, COMMAND_MAPPING_RELAY_NUM));
relay_t *target_relay = controller->relays[relay_num]; if(relay_num > global_config.relay_count)
{
LOGGER_WARNING("relay %d is not available (relay count: %d\n", relay_num, global_config.relay_count);
return;
}
relay_t *target_relay = global_controller->relays[relay_num];
(void)target_relay; (void)target_relay;
int duration = mpack_node_u8(mpack_node_map_uint(map, COMMAND_MAPPING_PULSE_DURATION)); int duration = mpack_node_u8(mpack_node_map_uint(map, COMMAND_MAPPING_PULSE_DURATION));
@ -36,56 +72,92 @@ handler_command_pulse(mpack_node_t map, controller_t *controller)
} }
static void static void
handler_command_set_name(mpack_node_t map, controller_t *controller) handler_command_controller_name_set(mpack_node_t map)
{ {
char name_buffer[MAX_NAME_LENGTH + 1]; char name_buffer[MAX_NAME_LENGTH + 1];
mpack_node_copy_cstr(mpack_node_map_uint(map, COMMAND_MAPPING_NAME), name_buffer, MAX_NAME_LENGTH + 1); mpack_node_copy_cstr(mpack_node_map_uint(map, COMMAND_MAPPING_NAME), name_buffer, MAX_NAME_LENGTH + 1);
controller_set_name(controller, name_buffer); controller_set_name(global_controller, name_buffer);
LOGGER_DEBUG("setting new name %s for controller\n", name_buffer); LOGGER_DEBUG("setting new name %s for controller\n", name_buffer);
controller_save();
} }
static void static void
handler_command_set_schedule(mpack_node_t map, controller_t *controller) handler_command_relay_name_set(mpack_node_t map)
{ {
uint8_t relay_num = mpack_node_u8(mpack_node_map_uint(map, COMMAND_MAPPING_RELAY_NUM)); uint8_t relay_num = mpack_node_u8(mpack_node_map_uint(map, COMMAND_MAPPING_RELAY_NUM));
LOGGER_DEBUG("setting schedules for relay %d\n", relay_num); const char *relay_name = mpack_node_str(mpack_node_map_uint(map, COMMAND_MAPPING_NAME));
relay_t *target_relay = controller->relays[relay_num]; if(relay_num > global_config.relay_count)
{
LOGGER_WARNING("relay %d is not available (relay count: %d\n", relay_num, global_config.relay_count);
return;
}
relay_set_name(global_controller->relays[relay_num], relay_name);
relay_debug(global_controller->relays[relay_num]);
LOGGER_DEBUG("setting new name %s for relay %d\n", relay_name, relay_num);
relay_save(global_controller->relays[relay_num]);
}
static void
handler_command_schedule_update(mpack_node_t map)
{
uuid_t schedule_uid;
memcpy(schedule_uid, mpack_node_data(mpack_node_map_uint(map, COMMAND_MAPPING_SCHEDULE_ID)), sizeof(uuid_t));
uint16_t periods_count = mpack_node_u16(mpack_node_map_uint(map, COMMAND_MAPPING_PERIODS_COUNT));
uint16_t *periods = (uint16_t*)mpack_node_bin_data(mpack_node_map_uint(map, COMMAND_MAPPING_PERIODS_BLOB));
schedule_t *schedule = schedule_get_by_uid(schedule_uid);
schedule_t *new_schedule = schedule_create(schedule_uid, periods_count, periods);
if(schedule)
{
new_schedule->id = schedule->id;
}
schedule_save(new_schedule);
schedule_free(schedule);
schedule_free(new_schedule);
}
static void
handler_command_relay_schedules_set(mpack_node_t map)
{
uint8_t relay_num = mpack_node_u8(mpack_node_map_uint(map, COMMAND_MAPPING_RELAY_NUM));
if(relay_num > global_config.relay_count)
{
LOGGER_WARNING("relay %d is not available (relay count: %d\n", relay_num, global_config.relay_count);
return;
}
LOGGER_DEBUG("setting schedules for relay %d\n", relay_num);
relay_t *target_relay = global_controller->relays[relay_num];
database_transaction_begin();
junction_relay_schedule_remove_for_relay(target_relay->id);
mpack_node_t schedules_array = mpack_node_map_uint(map, COMMAND_MAPPING_SCHEDULES_ARRAY); mpack_node_t schedules_array = mpack_node_map_uint(map, COMMAND_MAPPING_SCHEDULES_ARRAY);
for(int i = 0; i < 7; ++i) for(int i = 0; i < 7; ++i)
{ {
mpack_node_t schedules_map = mpack_node_array_at(schedules_array, i); mpack_node_t schedule_map = mpack_node_array_at(schedules_array, i);
uuid_t schedule_id; handler_command_schedule_update(schedule_map);
memcpy(schedule_id, mpack_node_data(mpack_node_map_uint(schedules_map, COMMAND_MAPPING_SCHEDULE_ID)), sizeof(uuid_t));
uint16_t periods_count = mpack_node_u16(mpack_node_map_uint(schedules_map, COMMAND_MAPPING_PERIODS_COUNT)); uuid_t schedule_uid;
uint16_t *periods = (uint16_t*)mpack_node_bin_data(mpack_node_map_uint(schedules_map, COMMAND_MAPPING_PERIODS_BLOB)); memcpy(schedule_uid, mpack_node_data(mpack_node_map_uint(schedule_map, COMMAND_MAPPING_SCHEDULE_ID)), sizeof(uuid_t));
if(target_relay->schedules[i]) schedule_t *schedule = schedule_get_by_uid(schedule_uid);
{
schedule_free(target_relay->schedules[i]); junction_relay_schedule_insert(i, target_relay->id, schedule->id);
}
target_relay->schedules[i] = schedule_create(schedule_id, i, periods_count, periods);
} }
relay_reload_schedules(target_relay);
relay_debug(target_relay); relay_debug(target_relay);
}
static void database_transaction_commit();
handler_command_set_relay_name(mpack_node_t map, controller_t *controller)
{
uint8_t relay_num = mpack_node_u8(mpack_node_map_uint(map, COMMAND_MAPPING_RELAY_NUM));
const char *relay_name = mpack_node_str(mpack_node_map_uint(map, COMMAND_MAPPING_NAME));
if(relay_num < controller->relay_count)
{
relay_set_name(controller->relays[relay_num], relay_name);
}
relay_debug(controller->relays[relay_num]);
LOGGER_DEBUG("setting new name %s for relay %d\n", relay_name, relay_num);
} }
void void
@ -110,33 +182,36 @@ handler_command(struct mg_connection *c, int ev, void *ev_data)
mpack_tree_parse(&tree); mpack_tree_parse(&tree);
mpack_node_t root = mpack_tree_root(&tree); mpack_node_t root = mpack_tree_root(&tree);
uint8_t command_code = mpack_node_u8(mpack_node_map_uint(root, COMMAND_MAPPING_CODE)); uint16_t command_code = mpack_node_u8(mpack_node_map_uint(root, COMMAND_MAPPING_CODE));
LOGGER_DEBUG("received command %d\n", command_code); LOGGER_DEBUG("received command %d\n", command_code);
switch(command_code) switch(command_code)
{ {
case COMMAND_CODE_GET_TIME: case COMMAND_CODE_CONTROLLER_ID_GET:
break; break;
case COMMAND_CODE_GET_ID: case COMMAND_CODE_CONTROLLER_TIME_GET:
break; break;
case COMMAND_CODE_SET_NAME: case COMMAND_CODE_CONTROLLER_NAME_SET:
handler_command_set_name(root, global_controller); handler_command_controller_name_set(root);
break; break;
case COMMAND_CODE_GET_NAME: case COMMAND_CODE_CONTROLLER_NAME_GET:
break; break;
case COMMAND_CODE_SET_SCHEDULE: case COMMAND_CODE_RELAY_SCHEDULES_SET:
handler_command_set_schedule(root, global_controller); handler_command_relay_schedules_set(root);
break; break;
case COMMAND_CODE_GET_SCHEDULE: case COMMAND_CODE_RELAY_SCHEDULES_GET:
break; break;
case COMMAND_CODE_SET_RELAY_NAME: case COMMAND_CODE_RELAY_NAME_SET:
handler_command_set_relay_name(root, global_controller); handler_command_relay_name_set(root);
break; break;
case COMMAND_CODE_GET_RELAY_NAME: case COMMAND_CODE_RELAY_NAME_GET:
break; break;
case COMMAND_CODE_PULSE: case COMMAND_CODE_RELAY_PULSE:
handler_command_pulse(root, global_controller); handler_command_relay_pulse(root);
break;
case COMMAND_CODE_SCHEDULE_UPDATE:
handler_command_schedule_update(root);
break; break;
default: default:
LOGGER_ERR("received invalid command\n"); LOGGER_ERR("received invalid command\n");
@ -146,5 +221,4 @@ handler_command(struct mg_connection *c, int ev, void *ev_data)
{ {
LOGGER_WARNING("error when destroying mpack tree\n"); LOGGER_WARNING("error when destroying mpack tree\n");
} }
controller_save(global_controller, global_mdb_env);
} }

4
src/handlers/discovery.c
View file

@ -49,11 +49,11 @@ handler_discovery(struct mg_connection *c, int ev, void *ev_data)
mpack_start_map(&writer, 4); mpack_start_map(&writer, 4);
mpack_write_uint(&writer, DISCOVERY_MAPPING_ID); mpack_write_uint(&writer, DISCOVERY_MAPPING_ID);
mpack_write_bin(&writer, (char*)global_controller->id, sizeof(uuid_t)); mpack_write_bin(&writer, (char*)global_controller->uid, sizeof(uuid_t));
mpack_write_uint(&writer, DISCOVERY_MAPPING_COMMAND_PORT); mpack_write_uint(&writer, DISCOVERY_MAPPING_COMMAND_PORT);
mpack_write_u16(&writer, global_controller->command_port); mpack_write_u16(&writer, global_controller->command_port);
mpack_write_uint(&writer, DISCOVERY_MAPPING_RELAY_COUNT); mpack_write_uint(&writer, DISCOVERY_MAPPING_RELAY_COUNT);
mpack_write_u8(&writer, global_controller->relay_count); mpack_write_u8(&writer, global_config.relay_count);
mpack_write_uint(&writer, DISCOVERY_MAPPING_NAME); mpack_write_uint(&writer, DISCOVERY_MAPPING_NAME);
mpack_write_cstr(&writer, global_controller->name); mpack_write_cstr(&writer, global_controller->name);
mpack_finish_map(&writer); mpack_finish_map(&writer);

4
src/handlers/loop.c
View file

@ -19,7 +19,7 @@ handler_loop(struct mg_connection *c_mqtt)
char topic_buf[100]; char topic_buf[100];
char payload_buf[2]; char payload_buf[2];
char controller_uid[UUID_STR_LEN]; char controller_uid[UUID_STR_LEN];
uuid_unparse(global_controller->id, controller_uid); uuid_unparse(global_controller->uid, controller_uid);
struct tm time_last, time_now; struct tm time_last, time_now;
time_t timestamp; time_t timestamp;
@ -28,7 +28,7 @@ handler_loop(struct mg_connection *c_mqtt)
localtime_r(&timestamp, &time_last); localtime_r(&timestamp, &time_last);
timestamp = time(NULL); timestamp = time(NULL);
localtime_r(&timestamp, &time_now); localtime_r(&timestamp, &time_now);
for(uint_fast8_t i = 0; i < global_controller->relay_count; ++i) for(uint_fast8_t i = 0; i < global_config.relay_count; ++i)
{ {
relay_t *relay = global_controller->relays[i]; relay_t *relay = global_controller->relays[i];
int is_on = 0; int is_on = 0;

20
src/main.c
View file

@ -24,8 +24,6 @@
#include <confini.h> #include <confini.h>
config_t global_config; config_t global_config;
controller_t *global_controller;
MDB_env *global_mdb_env;
static struct mg_mgr mgr; static struct mg_mgr mgr;
@ -39,7 +37,7 @@ terminate(int signum)
//mg_mgr_free(&mgr); //mg_mgr_free(&mgr);
LOGGER_DEBUG("closing database\n"); LOGGER_DEBUG("closing database\n");
mdb_env_close(global_mdb_env); database_free();
LOGGER_DEBUG("freeing global controller\n"); LOGGER_DEBUG("freeing global controller\n");
controller_free(global_controller); controller_free(global_controller);
@ -114,13 +112,19 @@ main(int argc, const char** argv)
} }
/******************** SETUP DATABASE, SOCKETS AND THIS CONTROLLER ********************/ /******************** INIT DATABASE, SOCKETS AND THIS CONTROLLER ********************/
mg_mgr_init(&mgr, NULL); mg_mgr_init(&mgr, NULL);
database_setup(&global_mdb_env, &global_config); database_init();
global_controller = controller_load(global_mdb_env); global_controller = controller_load();
if(!global_controller)
{
global_controller = controller_create();
controller_save();
}
connection_discovery_bind(&mgr); connection_discovery_bind(&mgr);
connection_mqtt_connect(&mgr); connection_mqtt_connect(&mgr);
@ -128,7 +132,7 @@ main(int argc, const char** argv)
global_controller->command_port = helper_get_port(c_command->sock); global_controller->command_port = helper_get_port(c_command->sock);
controller_save(global_controller, global_mdb_env); controller_save();
helper_drop_privileges(); helper_drop_privileges();
@ -139,7 +143,7 @@ main(int argc, const char** argv)
int piface_setup = 0; int piface_setup = 0;
for(uint_fast8_t i = 0; i < global_controller->relay_count; ++i) for(uint_fast8_t i = 0; i < global_config.relay_count; ++i)
{ {
int relay_default = global_config.relay_configs[i].init; int relay_default = global_config.relay_configs[i].init;
if(relay_default == -1) if(relay_default == -1)

210
src/models/controller.c
View file

@ -4,30 +4,214 @@
#include <string.h> #include <string.h>
#include <uuid/uuid.h> #include <uuid/uuid.h>
#include <sqlite3.h>
#include <models/controller.h> #include <models/controller.h>
#include <macros.h> #include <logger.h>
#include <config.h> #include <config.h>
#include <constants.h> #include <constants.h>
#include <database.h>
controller_t *global_controller;
static int
db_update_insert(controller_t *controller, sqlite3_stmt *stmt)
{
LOGGER_DEBUG("saving controller '%s' into database (id: %d)\n", controller->name, controller->id);
int rc;
sqlite3_bind_int(stmt, 1, controller->id);
sqlite3_bind_blob(stmt, 2, controller->uid, sizeof(uuid_t), SQLITE_STATIC);
sqlite3_bind_text(stmt, 3, controller->name, -1, SQLITE_STATIC);
sqlite3_bind_int(stmt, 4, controller->command_port);
rc = sqlite3_step(stmt);
sqlite3_finalize(stmt);
return rc != SQLITE_DONE;
}
static controller_t*
controller_db_select_mapper(sqlite3_stmt *stmt)
{
controller_t *new_controller = malloc(sizeof(controller_t));
for(int i = 0; i < sqlite3_column_count(stmt); i++)
{
const char *name = sqlite3_column_name(stmt, i);
switch(name[0])
{
case 'i': // id
new_controller->id = sqlite3_column_int(stmt, i);
break;
case 'c': // command_port
new_controller->command_port = sqlite3_column_int(stmt, i);
break;
case 'n': // name
strncpy(new_controller->name, (const char*)sqlite3_column_text(stmt, i), 127);
break;
case 'u': // uid
uuid_copy(new_controller->uid, (const unsigned char*)sqlite3_column_blob(stmt, i));
break;
default: // ignore columns not implemented
break;
}
}
new_controller->relays = malloc(sizeof(relay_t) * global_config.relay_count);
uint8_t i;
for(i = 0; i < global_config.relay_count; ++i)
{
new_controller->relays[i] = relay_load(new_controller->id);
if(!new_controller->relays[i])
{
new_controller->relays[i] = relay_create(i);
}
}
return new_controller;
}
static controller_t**
controller_db_select(sqlite3_stmt *stmt)
{
controller_t **all_controllers = malloc(sizeof(controller_t*));
int row = 0;
for(;;)
{
int s;
s = sqlite3_step(stmt);
if (s == SQLITE_ROW)
{
controller_t *new_controller = controller_db_select_mapper(stmt);
row++;
all_controllers = (controller_t**)realloc(all_controllers, sizeof(controller_t*) * (row + 1));
all_controllers[row - 1] = new_controller;
}
else
{
if(s == SQLITE_DONE)
{
break;
}
else
{
LOGGER_ERR("error selecting controllers from database: %s\n", sqlite3_errstr(s));
break;
}
}
}
sqlite3_finalize(stmt);
all_controllers[row] = NULL;
return all_controllers;
}
int
controller_save()
{
int opened_transaction = database_transaction_begin();
sqlite3_stmt *stmt;
if(global_controller->id)
{
sqlite3_prepare_v2(global_database, "UPDATE controllers set uid = ?2, name = ?3, command_port = ?4 WHERE id = ?1;", -1, &stmt, NULL);
}
else
{
sqlite3_prepare_v2(global_database, "INSERT INTO controllers(uid, name, command_port) values (?2, ?3, ?4);", -1, &stmt, NULL);
}
int result = db_update_insert(global_controller, stmt);
if(result)
{
if(global_controller->id)
{
LOGGER_ERR("error inserting data: %s\n", sqlite3_errmsg(global_database));
}
else
{
LOGGER_ERR("error updating data: %s\n", sqlite3_errmsg(global_database));
}
if(opened_transaction)
{
database_transaction_rollback();
}
}
else
{
if(!global_controller->id)
{
global_controller->id = sqlite3_last_insert_rowid(global_database);
}
if(opened_transaction)
{
database_transaction_commit();
}
}
return result;
}
controller_t*
controller_load()
{
LOGGER_DEBUG("getting controller from database\n");
sqlite3_stmt *stmt;
sqlite3_prepare_v2(global_database, "SELECT * FROM controllers LIMIT 1;", -1, &stmt, NULL);
controller_t **sql_result = controller_db_select(stmt);
controller_t *result = sql_result[0];
free(sql_result);
return result;
}
int
controller_remove(controller_t *controller)
{
sqlite3_stmt *stmt;
if(!controller->id)
{
return 0;
}
sqlite3_prepare_v2(global_database, "DELETE FROM controllers WHERE id=?1;", -1, &stmt, NULL);
sqlite3_bind_int(stmt, 1, controller->id);
int rc = sqlite3_step(stmt);
sqlite3_finalize(stmt);
return rc != SQLITE_DONE;
}
controller_t* controller_t*
controller_create(void) controller_create(void)
{ {
controller_t *new_controller = malloc(sizeof(*new_controller)); controller_t *new_controller = malloc(sizeof(*new_controller));
uuid_generate(new_controller->id); new_controller->id = 0;
uuid_generate(new_controller->uid);
strncpy(new_controller->name, global_config.name, MAX_NAME_LENGTH); strncpy(new_controller->name, global_config.name, MAX_NAME_LENGTH);
new_controller->name[MAX_NAME_LENGTH] = '\0'; new_controller->name[MAX_NAME_LENGTH] = '\0';
new_controller->command_port = 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); new_controller->relays = malloc(sizeof(relay_t) * global_config.relay_count);
uint8_t i; uint8_t i;
for(i = 0; i < new_controller->relay_count; ++i) for(i = 0; i < global_config.relay_count; ++i)
{
new_controller->relays[i] = relay_load(new_controller->id);
if(!new_controller->relays[i])
{ {
new_controller->relays[i] = relay_create(i); new_controller->relays[i] = relay_create(i);
} }
}
return new_controller; return new_controller;
} }
@ -42,7 +226,7 @@ controller_set_name(controller_t *controller, const char *name)
void void
controller_free(controller_t *controller) controller_free(controller_t *controller)
{ {
for(int i = 0; i < controller->relay_count; ++i) for(int i = 0; i < global_config.relay_count; ++i)
{ {
relay_free(controller->relays[i]); relay_free(controller->relays[i]);
} }
@ -59,13 +243,11 @@ controller_debug(controller_t *controller)
return; return;
} }
char uuid_str[37]; char uuid_str[37];
uuid_unparse(controller->id, uuid_str); uuid_unparse(controller->uid, uuid_str);
LOGGER_DEBUG("(1/5) %s @ %p\n", uuid_str, (void*)controller); LOGGER_DEBUG("(1/3) %s @ %p\n", uuid_str, (void*)controller);
LOGGER_DEBUG("(2/5) name: %s\n", controller->name); LOGGER_DEBUG("(2/3) name: %s\n", controller->name);
LOGGER_DEBUG("(3/5) command_port: %5d discovery_port: %5d\n", controller->command_port, controller->discovery_port); LOGGER_DEBUG("(3/3) relays @ %p:\n", (void*)controller->relays);
LOGGER_DEBUG("(4/5) relay count: %3d\n", controller->relay_count); for(int i = 0; i < global_config.relay_count; ++i)
LOGGER_DEBUG("(5/5) relays @ %p:\n", (void*)controller->relays);
for(int i = 0; i < controller->relay_count; ++i)
{ {
relay_debug(controller->relays[i]); relay_debug(controller->relays[i]);
} }

86
src/models/controller_load.c
View file

@ -1,86 +0,0 @@
#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)
{
LOGGER_ERR("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;
LOGGER_DEBUG("loading controller\n");
if((err = mdb_txn_begin(mdb_env, NULL, MDB_RDONLY, &mdb_txn)) != 0)
{
LOGGER_ERR("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:
LOGGER_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:
LOGGER_ERR("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++)
{
new_controller->relays[i] = relay_load(mdb_env, i);
}
return new_controller;
}

91
src/models/controller_save.c
View file

@ -1,91 +0,0 @@
#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)
{
LOGGER_ERR("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;
LOGGER_DEBUG("saving controller\n");
if((err = mdb_txn_begin(mdb_env, NULL, 0, &mdb_txn)) != 0)
{
LOGGER_ERR("mdb_txn_begin error %s\n", mdb_strerror(err));
exit(1);
}
if((err = mdb_dbi_open(mdb_txn, "controller", MDB_CREATE, &mdb_dbi)) != 0)
{
LOGGER_ERR("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))
{
LOGGER_ERR("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))
{
LOGGER_ERR("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))
{
LOGGER_ERR("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))
{
LOGGER_ERR("failed to save discovery port\n");
return 1;
}
mdb_txn_commit(mdb_txn);
for(uint8_t i = 0; i < controller->relay_count; ++i)
{
relay_save(controller->relays[i], mdb_env);
}
return 0;
}

90
src/models/junction_relay_schedule.c Normal file
View file

@ -0,0 +1,90 @@
#include <stdlib.h>
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include <models/junction_relay_schedule.h>
#include <logger.h>
#include <macros.h>
#include <database.h>
int
junction_relay_schedule_insert(uint8_t weekday, int relay_id, int schedule_id)
{
int rc;
sqlite3_stmt *stmt;
sqlite3_prepare_v2(global_database, "INSERT INTO junction_relay_schedule(weekday, schedule_id, relay_id) values (?1, ?2, ?3);", -1, &stmt, NULL);
sqlite3_bind_int(stmt, 1, weekday);
sqlite3_bind_int(stmt, 2, schedule_id);
sqlite3_bind_int(stmt, 3, relay_id);
rc = sqlite3_step(stmt);
if (rc != SQLITE_DONE)
{
LOGGER_ERR("error inserting data: %s", sqlite3_errmsg(global_database));
return false;
}
sqlite3_finalize(stmt);
return true;
}
int
junction_relay_schedule_insert_weekdays(int relay_id, int *schedule_ids)
{
int rc;
sqlite3_stmt *stmt;
static const char query_base[] = "INSERT INTO junction_relay_schedule (weekday, schedule_id, relay_id) VALUES";
static const char query_extender[] = " (?, ?, ?)";
size_t query_len = STRLEN(query_base) + (7 * (STRLEN(query_extender) + 1)) + 1;
char *query = malloc(sizeof(char) * query_len + 1);
strncpy(query, query_base, query_len);
query_len -= STRLEN(query_base);
for(int i = 0; i < 7; ++i)
{
strncat(query, query_extender, query_len);
query_len -= STRLEN(query_extender);
char *query_divider = (i < 7 - 1) ? "," : ";";
strncat(query, query_divider, query_len);
query_len -= 1;
}
sqlite3_prepare_v2(global_database, query, -1, &stmt, NULL);
for(int i = 0; i < 7; ++i)
{
sqlite3_bind_int(stmt, i * 3 + 1, i);
sqlite3_bind_int(stmt, i * 3 + 2, schedule_ids[i]);
sqlite3_bind_int(stmt, i * 3 + 3, relay_id);
}
rc = sqlite3_step(stmt);
if (rc != SQLITE_DONE)
{
LOGGER_ERR("error inserting data: %s", sqlite3_errmsg(global_database));
return false;
}
sqlite3_finalize(stmt);
return true;
}
int
junction_relay_schedule_remove_for_relay(int relay_id)
{
sqlite3_stmt *stmt;
int rc;
sqlite3_prepare_v2(global_database, "DELETE FROM junction_relay_schedule WHERE relay_id=?1;", -1, &stmt, NULL);
sqlite3_bind_int(stmt, 1, relay_id);
rc = sqlite3_step(stmt);
sqlite3_finalize(stmt);
return rc == SQLITE_DONE;
}

16
src/models/period.c
View file

@ -4,21 +4,11 @@
#include <constants.h> #include <constants.h>
#include <models/period.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 int
period_includes_time(period_t *period, struct tm *time_struct) period_includes_time(period_t period, struct tm *time_struct)
{ {
uint16_t start = period->start; uint16_t start = period.start;
uint16_t end = period->end; uint16_t end = period.end;
time_t timestamp = time_struct->tm_hour * 60; time_t timestamp = time_struct->tm_hour * 60;
timestamp += time_struct->tm_min; timestamp += time_struct->tm_min;

208
src/models/relay.c
View file

@ -4,7 +4,173 @@
#include <logger.h> #include <logger.h>
#include <helpers.h> #include <helpers.h>
#include <database.h>
#include <models/relay.h> #include <models/relay.h>
#include <models/junction_relay_schedule.h>
static int
db_update_insert(relay_t *relay, sqlite3_stmt *stmt)
{
LOGGER_DEBUG("saving relay '%s' into database (id: %d)\n", relay->name, relay->id);
int rc;
sqlite3_bind_int(stmt, 1, relay->id);
sqlite3_bind_int(stmt, 2, relay->number);
sqlite3_bind_text(stmt, 3, relay->name, -1, SQLITE_STATIC);
rc = sqlite3_step(stmt);
sqlite3_finalize(stmt);
return rc != SQLITE_DONE;
}
static relay_t*
relay_db_select_mapper(sqlite3_stmt *stmt)
{
relay_t *new_relay = malloc(sizeof(relay_t));
new_relay->is_on = 0;
for(int i = 0; i < sqlite3_column_count(stmt); i++)
{
const char *name = sqlite3_column_name(stmt, i);
switch(name[0])
{
case 'i':
new_relay->id = sqlite3_column_int(stmt, i);
break;
case 'n':
switch(name[1])
{
case 'a': // name
strncpy(new_relay->name, (const char*)sqlite3_column_text(stmt, i), 127);
break;
case 'u': // number
new_relay->number = sqlite3_column_int(stmt, i);
break;
default:
break;
}
break;
default: // ignore columns not implemented
break;
}
}
schedule_t **schedules = schedule_get_relay_weekdays(new_relay->id);
for(int i = 0; i < 7; ++i)
{
if(schedules[i] == NULL)
{
LOGGER_ERR("got only %d/7 schedules for relay_id %d\n", i, new_relay->id);
relay_free(new_relay);
free(schedules);
return NULL;
}
new_relay->schedules[i] = schedules[i];
}
free(schedules); // don't free list, because contents are kept in relay->schedules
return new_relay;
}
static relay_t**
relay_db_select(sqlite3_stmt *stmt)
{
relay_t **all_relays = malloc(sizeof(relay_t*));
int row = 0;
while(true)
{
int s;
s = sqlite3_step(stmt);
if (s == SQLITE_ROW)
{
relay_t *new_relay = relay_db_select_mapper(stmt);
row++;
all_relays = (relay_t**)realloc(all_relays, sizeof(relay_t*) * (row + 1));
all_relays[row - 1] = new_relay;
}
else
{
if(s == SQLITE_DONE)
{
break;
}
else
{
LOGGER_ERR("error selecting relays from database: %s\n", sqlite3_errstr(s));
break;
}
}
}
sqlite3_finalize(stmt);
all_relays[row] = NULL;
return all_relays;
}
int
relay_save(relay_t *relay)
{
int opened_transaction = database_transaction_begin();
sqlite3_stmt *stmt;
if(relay->id)
{
sqlite3_prepare_v2(global_database, "UPDATE relays set number = ?2, name = ?3, controller_id = ?4 WHERE id = ?1;", -1, &stmt, NULL);
}
else
{
sqlite3_prepare_v2(global_database, "INSERT INTO relays(number, name, controller_id) values (?2, ?3, ?4);", -1, &stmt, NULL);
}
int result = db_update_insert(relay, stmt);
if(result)
{
if(relay->id)
{
LOGGER_ERR("error inserting data: %s\n", sqlite3_errmsg(global_database));
}
else
{
LOGGER_ERR("error updating data: %s\n", sqlite3_errmsg(global_database));
}
if(opened_transaction)
{
database_transaction_rollback();
}
}
else
{
if(relay->id == 0)
{
relay->id = sqlite3_last_insert_rowid(global_database);
}
LOGGER_DEBUG("cleaning relay_schedule junction\n");
junction_relay_schedule_remove_for_relay(relay->id);
LOGGER_DEBUG("rebuilding relay_schedule junction\n");
int schedule_ids[7];
for(int i = 0; i < 7; ++i)
{
schedule_ids[i] = relay->schedules[i]->id;
}
junction_relay_schedule_insert_weekdays(relay->id, schedule_ids);
if(opened_transaction)
{
database_transaction_commit();
}
}
return result;
}
relay_t* relay_t*
relay_create(uint8_t number) relay_create(uint8_t number)
@ -25,12 +191,52 @@ relay_create(uint8_t number)
for(int i = 0; i < 7; ++i) for(int i = 0; i < 7; ++i)
{ {
new_relay->schedules[i] = schedule_create(off_id, i, 0, NULL); new_relay->schedules[i] = schedule_get_by_uid(off_id);
} }
return new_relay; return new_relay;
} }
relay_t*
relay_load(uint8_t number)
{
sqlite3_stmt *stmt;
sqlite3_prepare_v2(global_database, "SELECT * FROM relays WHERE number = ?1;", -1, &stmt, NULL);
sqlite3_bind_int(stmt, 1, number);
relay_t **sql_result = relay_db_select(stmt);
relay_t *result = sql_result[0];
free(sql_result);
return result;
}
void
relay_reload_schedules(relay_t *relay)
{
schedule_t **schedules = schedule_get_relay_weekdays(relay->id);
for(int i = 0; i < 7; ++i)
{
if(schedules[i] == NULL)
{
LOGGER_ERR("got only %d/7 schedules for relay_id %d\n", i, relay->id);
relay_free(relay);
schedule_free_list(schedules);
return;
}
}
for(int i = 0; i < 7; ++i)
{
schedule_free(relay->schedules[i]);
relay->schedules[i] = schedules[i];
}
free(schedules); // don't free list, because contents are kept in relay->schedules
}
void void
relay_set_name(relay_t *relay, const char *name) relay_set_name(relay_t *relay, const char *name)
{ {

95
src/models/relay_load.c
View file

@ -1,95 +0,0 @@
#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)
{
LOGGER_ERR("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;
LOGGER_DEBUG("loading relay %d\n", num);
if((err = mdb_txn_begin(mdb_env, NULL, MDB_RDONLY, &mdb_txn)) != 0)
{
LOGGER_ERR("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:
LOGGER_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:
LOGGER_ERR("mdb_txn_begin error %s\n", mdb_strerror(err));
return relay_create(num);
}
}
new_relay = malloc(sizeof(relay_t));
new_relay->number = num;
new_relay->is_on = -1;
new_relay->is_on_schedule = -1;
new_relay->pulse_timer = 0;
new_relay->sent_to_broker = 0;
MDB_val value;
if((err = relay_load_single(mdb_txn, mdb_dbi, DB_KEY_RELAY_NAME, num, &value)) != 0)
{
LOGGER_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;
}

76
src/models/relay_save.c
View file

@ -1,76 +0,0 @@
#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)
{
LOGGER_ERR("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)
{
int err;
MDB_txn *mdb_txn;
MDB_dbi mdb_dbi;
MDB_val value;
LOGGER_DEBUG("saving relay %d\n", relay->number);
if((err = mdb_txn_begin(mdb_env, NULL, 0, &mdb_txn)) != 0)
{
LOGGER_ERR("mdb_txn_begin error %s\n", mdb_strerror(err));
exit(1);
}
if((err = mdb_dbi_open(mdb_txn, "relays", MDB_CREATE, &mdb_dbi)) != 0)
{
LOGGER_ERR("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))
{
LOGGER_ERR("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;
}

265
src/models/schedule.c
View file

@ -2,29 +2,203 @@
#include <string.h> #include <string.h>
#include <logger.h> #include <logger.h>
#include <database.h>
#include <models/schedule.h> #include <models/schedule.h>
#include <models/junction_relay_schedule.h>
static int
db_update_insert(schedule_t *schedule, sqlite3_stmt *stmt)
{
char uuid_str[UUID_STR_LEN];
uuid_unparse(schedule->uid, uuid_str);
LOGGER_DEBUG("saving schedule '%s' into database (id: %d)\n", uuid_str, schedule->id);
int rc;
uint16_t *periods_blob = schedule_periods_to_blob(schedule);
int blob_size = (int)sizeof(uint16_t) * ((periods_blob[0] * 2) + 1);
sqlite3_bind_int(stmt, 1, schedule->id);
sqlite3_bind_blob(stmt, 2, schedule->uid, sizeof(uuid_t), SQLITE_STATIC);
sqlite3_bind_blob(stmt, 3, periods_blob, blob_size, SQLITE_STATIC);
rc = sqlite3_step(stmt);
sqlite3_finalize(stmt);
free(periods_blob);
return rc != SQLITE_DONE;
}
static schedule_t*
schedule_db_select_mapper(sqlite3_stmt *stmt)
{
const uint16_t *periods_blob;
schedule_t *new_schedule = malloc(sizeof(schedule_t));
for(int i = 0; i < sqlite3_column_count(stmt); i++)
{
const char *name = sqlite3_column_name(stmt, i);
switch(name[0])
{
case 'i': // id
new_schedule->id = sqlite3_column_int(stmt, i);
break;
case 'p': // periods
periods_blob = sqlite3_column_blob(stmt, i);
new_schedule->periods = malloc(sizeof(period_t) * periods_blob[0]);
for(int i = 0; i < periods_blob[0]; ++i)
{
new_schedule->periods[i].start = periods_blob[(i * 2) + 1];
new_schedule->periods[i].end = periods_blob[(i * 2) + 2];
}
break;
case 'u': // uid
uuid_copy(new_schedule->uid, (const unsigned char*)sqlite3_column_blob(stmt, i));
break;
default: // ignore columns not implemented
break;
}
}
return new_schedule;
}
static schedule_t**
schedule_db_select(sqlite3_stmt *stmt)
{
schedule_t **all_schedules = malloc(sizeof(schedule_t*));
int row = 0;
for(;;)
{
int s;
s = sqlite3_step(stmt);
if (s == SQLITE_ROW)
{
schedule_t *new_schedule = schedule_db_select_mapper(stmt);
row++;
all_schedules = (schedule_t**)realloc(all_schedules, sizeof(schedule_t*) * (row + 1));
all_schedules[row - 1] = new_schedule;
}
else
{
if(s == SQLITE_DONE)
{
break;
}
else
{
LOGGER_ERR("error selecting schedules from database: %s\n", sqlite3_errstr(s));
break;
}
}
}
sqlite3_finalize(stmt);
all_schedules[row] = NULL;
return all_schedules;
}
int
schedule_save(schedule_t *schedule)
{
int opened_transaction = database_transaction_begin();
sqlite3_stmt *stmt;
if(schedule->id)
{
sqlite3_prepare_v2(global_database, "UPDATE schedules SET uid = ?2, periods = ?3 WHERE id=?1;", -1, &stmt, NULL);
}
else
{
sqlite3_prepare_v2(global_database, "INSERT INTO schedules(uid, periods) values (?2, ?3);", -1, &stmt, NULL);
}
int result = db_update_insert(schedule, stmt);
if(result)
{
if(schedule->id)
{
LOGGER_ERR("error inserting data: %s\n", sqlite3_errmsg(global_database));
}
else
{
LOGGER_ERR("error updating data: %s\n", sqlite3_errmsg(global_database));
}
if(opened_transaction)
{
database_transaction_rollback();
}
}
else
{
if(!schedule->id)
{
schedule->id = sqlite3_last_insert_rowid(global_database);
}
if(opened_transaction)
{
database_transaction_commit();
}
}
return result;
}
schedule_t**
schedule_get_relay_weekdays(int relay_id)
{
LOGGER_DEBUG("getting schedules [relay_id=%d] from database\n", relay_id);
sqlite3_stmt *stmt;
sqlite3_prepare_v2(global_database, "SELECT schedules.* FROM schedules INNER JOIN junction_relay_schedule ON schedules.id == junction_relay_schedule.schedule_id WHERE junction_relay_schedule.relay_id = ?1 ORDER BY junction_relay_schedule.weekday ASC", -1, &stmt, NULL);
sqlite3_bind_int(stmt, 1, relay_id);
return schedule_db_select(stmt);
}
schedule_t* schedule_t*
schedule_create(uuid_t id, uint8_t weekday, uint16_t length, uint16_t *periods_blob) schedule_get_by_uid(uuid_t uid)
{
char uuid_str[UUID_STR_LEN];
schedule_uid_unparse(uid, uuid_str);
LOGGER_DEBUG("getting schedule [uid=%s] from database\n", uuid_str);
sqlite3_stmt *stmt;
sqlite3_prepare_v2(global_database, "SELECT * FROM schedules WHERE uid = ?1;", -1, &stmt, NULL);
sqlite3_bind_blob(stmt, 1, uid, sizeof(uuid_t), SQLITE_STATIC);
schedule_t **sql_result = schedule_db_select(stmt);
schedule_t *result = sql_result[0];
free(sql_result);
return result;
}
schedule_t*
schedule_create(uuid_t uid, uint16_t length, uint16_t *periods_blob)
{ {
schedule_t *new_schedule = malloc(sizeof(schedule_t)); schedule_t *new_schedule = malloc(sizeof(schedule_t));
memmove(new_schedule->id, id, sizeof(uuid_t)); memmove(new_schedule->uid, uid, sizeof(uuid_t));
new_schedule->weekday = weekday;
new_schedule->length = length; new_schedule->length = length;
new_schedule->periods = NULL; new_schedule->periods = NULL;
if(length) if(length)
{ {
new_schedule->periods = malloc(sizeof(period_t*) * length); new_schedule->periods = malloc(sizeof(period_t) * length);
for(uint16_t i = 0; i < length; ++i) for(uint16_t i = 0; i < length; ++i)
{ {
uint16_t start = periods_blob[0 + (i * 2)]; new_schedule->periods[i].start = periods_blob[0 + (i * 2)];
uint16_t end = periods_blob[1 + (i * 2)]; new_schedule->periods[i].end = periods_blob[1 + (i * 2)];
new_schedule->periods[i] = period_create(start, end);
} }
} }
@ -40,24 +214,77 @@ schedule_periods_to_blob(schedule_t *schedule)
for(uint16_t i = 0; i < schedule->length; ++i) for(uint16_t i = 0; i < schedule->length; ++i)
{ {
periods_blob[1 + (i * 2)] = schedule->periods[i]->start; periods_blob[1 + (i * 2)] = schedule->periods[i].start;
periods_blob[2 + (i * 2)] = schedule->periods[i]->end; periods_blob[2 + (i * 2)] = schedule->periods[i].end;
} }
return periods_blob; return periods_blob;
} }
int
schedule_uid_parse(const char *uid_str, uuid_t result)
{
if(strcmp("off", uid_str) == 0)
{
memset(result, 0, sizeof(uuid_t));
memcpy(result, "off", 3);
return 0;
}
if(strcmp("on", uid_str) == 0)
{
memset(result, 0, sizeof(uuid_t));
memcpy(result, "on", 2);
return 0;
}
if(uuid_parse(uid_str, result))
{
return 1;
}
return 0;
}
void
schedule_uid_unparse(const uuid_t uid, char *result)
{
uuid_t tmp_uuid;
memset(tmp_uuid, 0, sizeof(uuid_t));
memcpy(tmp_uuid, "off", 3);
if(uuid_compare(uid, tmp_uuid) == 0)
{
strcpy(result, "off");
return;
}
memset(tmp_uuid, 0, sizeof(uuid_t));
memcpy(tmp_uuid, "on", 2);
if(uuid_compare(uid, tmp_uuid) == 0)
{
strcpy(result, "on");
return;
}
uuid_unparse(uid, result);
}
void void
schedule_free(schedule_t *schedule) schedule_free(schedule_t *schedule)
{ {
for(uint16_t i = 0; i < schedule->length; ++i)
{
free(schedule->periods[i]);
}
free(schedule->periods); free(schedule->periods);
free(schedule); free(schedule);
} }
void
schedule_free_list(schedule_t **schedules)
{
for(int i = 0; schedules[i] != NULL; ++i)
{
schedule_free(schedules[i]);
}
free(schedules);
}
void void
schedule_debug(schedule_t *schedule) schedule_debug(schedule_t *schedule)
{ {
@ -67,7 +294,7 @@ schedule_debug(schedule_t *schedule)
return; return;
} }
char uuid_str[UUID_STR_LEN]; char uuid_str[UUID_STR_LEN];
uuid_unparse(schedule->id, uuid_str); uuid_unparse(schedule->uid, uuid_str);
LOGGER_DEBUG("(1/3) %s @ %p\n", uuid_str, (void*)schedule); LOGGER_DEBUG("(1/3) %s @ %p\n", uuid_str, (void*)schedule);
LOGGER_DEBUG("(2/4) period count: %3d\n", schedule->length); LOGGER_DEBUG("(2/4) period count: %3d\n", schedule->length);
LOGGER_DEBUG("(3/4) weekday: %3d\n", schedule->weekday); LOGGER_DEBUG("(3/4) weekday: %3d\n", schedule->weekday);
@ -81,10 +308,10 @@ schedule_debug(schedule_t *schedule)
sprintf( sprintf(
periods_debug_str + (13 * i), periods_debug_str + (13 * i),
"%02d:%02d-%02d:%02d, ", "%02d:%02d-%02d:%02d, ",
schedule->periods[i]->start / 60, schedule->periods[i].start / 60,
schedule->periods[i]->start % 60, schedule->periods[i].start % 60,
schedule->periods[i]->end / 60, schedule->periods[i].end / 60,
schedule->periods[i]->end % 60 schedule->periods[i].end % 60
); );
} }

98
src/models/schedule_load.c
View file

@ -1,98 +0,0 @@
#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)
{
LOGGER_ERR("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);
LOGGER_DEBUG("loading schedule %d for relay %d\n", weekday, relay_num);
if((err = mdb_txn_begin(mdb_env, NULL, MDB_RDONLY, &mdb_txn)) != 0)
{
LOGGER_ERR("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:
LOGGER_INFO("no schedule db found in db. returning new one (no schedules db)\n");
mdb_txn_abort(mdb_txn);
break;
default:
LOGGER_ERR("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)
{
LOGGER_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)
{
LOGGER_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;
}

88
src/models/schedule_save.c
View file

@ -1,88 +0,0 @@
#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)
{
LOGGER_ERR("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);
int err;
MDB_txn *mdb_txn;
MDB_dbi mdb_dbi;
MDB_val value;
LOGGER_DEBUG("saving schedule %d for relay %d\n", schedule->weekday, relay_num);
if((err = mdb_txn_begin(mdb_env, NULL, 0, &mdb_txn)) != 0)
{
LOGGER_ERR("mdb_txn_begin error %s\n", mdb_strerror(err));
exit(1);
}
if((err = mdb_dbi_open(mdb_txn, "schedules", MDB_CREATE, &mdb_dbi)) != 0)
{
LOGGER_ERR("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))
{
LOGGER_ERR("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);
LOGGER_ERR("failed to save periods\n");
return 1;
}
free(periods_blob);
mdb_txn_commit(mdb_txn);
return 0;
}

4
src/runners/test.c
View file

@ -6,10 +6,10 @@
#include <drivers.h> #include <drivers.h>
void void
runner_test(controller_t *controller) runner_test()
{ {
// from x down to 0 to turn all relays off in the end // from x down to 0 to turn all relays off in the end
for(uint_fast8_t i = 0; i < controller->relay_count; ++i) for(uint_fast8_t i = 0; i < global_config.relay_count; ++i)
{ {
for(int test_run = 2; test_run >= 0; --test_run) for(int test_run = 2; test_run >= 0; --test_run)
{ {