MODULE: Make a module with a rust implementation for repo_rs

src/module/module_repo_rs.c

@@ -7,7 +7,15 @@
  * Function from RUST *
  **********************/
 
-struct module_repo_rs_internal;
+struct repo_rs_intern;
+
+extern size_t lkt_module_repo_rs_get_struct_size(void);
+extern int32_t lkt_module_repo_rs_init(struct repo_rs_intern*, struct queue*, lkt_db*);
+extern int32_t lkt_module_repo_rs_free(struct repo_rs_intern*);
+extern int32_t lkt_module_repo_rs_update(struct repo_rs_intern*, struct lkt_uri *);
+extern int32_t lkt_module_repo_rs_dry_update(struct repo_rs_intern*);
+extern int32_t lkt_module_repo_rs_rescan(struct repo_rs_intern*);
+extern int32_t lkt_module_repo_rs_import(struct repo_rs_intern*);
 
 /********************
  * Export functions *
@@ -17,24 +25,35 @@ PRIVATE_FUNCTION int
 mod_new(va_list *va)
 {
     va_list copy;
-    struct module_repo_rs_internal **UNUSED repo;
     va_copy(copy, *va);
-    repo = (struct module_repo_rs_internal **)va_arg(copy, void **);
+    struct repo_rs_intern **repo = (struct repo_rs_intern **)va_arg(copy, void **);
+    struct queue *queue = va_arg(copy, struct queue *);
+    lkt_db *db          = va_arg(copy, lkt_db *);
 
-    va_end(copy);
+    if (NULL != *repo) {
+        LOG_ERROR("REPO", "Can't init two times the module");
         return 1;
     }
+    *repo = safe_malloc(lkt_module_repo_rs_get_struct_size());
+
+    const int32_t ret = lkt_module_repo_rs_init(*repo, queue, db);
+    lkt_queue_make_available(queue, LKT_EVENT_DB_UPDATING);
+
+    va_end(copy);
+    LOG_ERROR_IF(ret, "REPO", "Failed to create the module");
+    return ret;
+}
 
 PRIVATE_FUNCTION int
 mod_free(va_list *va)
 {
     va_list copy;
-    struct module_repo_rs_internal **UNUSED repo;
+    struct repo_rs_intern **repo;
     va_copy(copy, *va);
-    repo = (struct module_repo_rs_internal **)va_arg(copy, void **);
-
+    repo = (struct repo_rs_intern **)va_arg(copy, void **);
+    const int32_t ret = lkt_module_repo_rs_free(*repo);
     va_end(copy);
-    return 1;
+    return ret;
 }
 
 PRIVATE_FUNCTION int
@@ -44,7 +63,6 @@ mod_close(va_list *va)
     struct module_repo_rs_internal **UNUSED repo;
     va_copy(copy, *va);
     repo = (struct module_repo_rs_internal **)va_arg(copy, void **);
-
     va_end(copy);
     return 1;
 }
@@ -53,48 +71,50 @@ PRIVATE_FUNCTION int
 mod_update(va_list *va)
 {
     va_list copy;
-    struct module_repo_rs_internal **UNUSED repo;
+    struct repo_rs_intern **repo;
+    struct lkt_uri *uri_ptr;
     va_copy(copy, *va);
-    repo = (struct module_repo_rs_internal **)va_arg(copy, void **);
-
+    repo    = (struct repo_rs_intern **)va_arg(copy, void **);
+    uri_ptr = (struct lkt_uri *)va_arg(copy, struct lkt_uri *);
+    const int32_t ret = lkt_module_repo_rs_update(*repo, uri_ptr);
     va_end(copy);
-    return 1;
+    return ret;
 }
 
 PRIVATE_FUNCTION int
 mod_dry_update(va_list *va)
 {
     va_list copy;
-    struct module_repo_rs_internal **UNUSED repo;
+    struct repo_rs_intern **repo;
     va_copy(copy, *va);
-    repo = (struct module_repo_rs_internal **)va_arg(copy, void **);
-
+    repo = (struct repo_rs_intern **)va_arg(copy, void **);
+    const int32_t ret = lkt_module_repo_rs_dry_update(*repo);
     va_end(copy);
-    return 1;
+    return ret;
 }
 
 PRIVATE_FUNCTION int
 mod_rescan(va_list *va)
 {
     va_list copy;
-    struct module_repo_rs_internal **UNUSED repo;
+    struct repo_rs_intern **repo;
     va_copy(copy, *va);
-    repo = (struct module_repo_rs_internal **)va_arg(copy, void **);
-
+    repo = (struct repo_rs_intern **)va_arg(copy, void **);
+    const int32_t ret = lkt_module_repo_rs_rescan(*repo);
     va_end(copy);
-    return 1;
+    return ret;
 }
 
 PRIVATE_FUNCTION int
 mod_import(va_list *va)
 {
     va_list copy;
-    struct module_repo_rs_internal **UNUSED repo;
+    struct repo_rs_intern **repo;
     va_copy(copy, *va);
-    repo = (struct module_repo_rs_internal **)va_arg(copy, void **);
-
+    repo = (struct repo_rs_intern **)va_arg(copy, void **);
+    const int32_t ret = lkt_module_repo_rs_import(*repo);
     va_end(copy);
-    return 1;
+    return ret;
 }
 
 REG_BEGIN(repo_rs_reg)

src/rust/liblektor-rs/src/compat.rs

+pub const LEKTOR_TAG_MAX: usize = 256;
+
+pub struct LktQueue;
+pub struct LktDb;
+pub struct LktUri;
+
+pub type LktQueuePtr = *mut LktQueue;
+pub type LktDbPtr = *mut LktDb;
+pub type LktUriPtr = *mut LktUri;

src/rust/liblektor-rs/src/lib.rs

 #![allow(dead_code)]
 
-mod module;
+mod compat;
 mod database;
 mod mkv;
+mod module;
 
+pub(crate) use compat::*;
 pub(crate) use libc::{c_char, c_int, c_long, c_void, size_t};
-
-pub const LEKTOR_TAG_MAX: usize = 256;

src/rust/liblektor-rs/src/module/repo_rs.rs

+use crate::*;
+
+type LktModuleRepoRsPtr = *mut LktModuleRepoRs;
+struct LktModuleRepoRs {
+    queue: LktQueuePtr,
+}
+
+#[no_mangle]
+extern "C" fn lkt_module_repo_rs_get_struct_size() -> size_t {
+    std::mem::size_of::<LktModuleRepoRs>()
+}
+
+#[no_mangle]
+extern "C" fn lkt_module_repo_rs_init(
+    repo: LktModuleRepoRsPtr,
+    queue: LktQueuePtr,
+    db: LktDbPtr,
+) -> i32 {
+    let _repo: &mut LktModuleRepoRs = unsafe { std::mem::transmute(repo) };
+    1
+}
+
+#[no_mangle]
+extern "C" fn lkt_module_repo_rs_free(repo: LktModuleRepoRsPtr) -> i32 {
+    let _repo: &mut LktModuleRepoRs = unsafe { std::mem::transmute(repo) };
+    1
+}
+
+#[no_mangle]
+extern "C" fn lkt_module_repo_rs_update(repo: LktModuleRepoRsPtr, uri: LktUriPtr) -> i32 {
+    1
+}
+
+#[no_mangle]
+extern "C" fn lkt_module_repo_rs_dry_update(repo: LktModuleRepoRsPtr) -> i32 {
+    1
+}
+
+#[no_mangle]
+extern "C" fn lkt_module_repo_rs_rescan(repo: LktModuleRepoRsPtr) -> i32 {
+    1
+}
+
+#[no_mangle]
+extern "C" fn lkt_module_repo_rs_import(repo: LktModuleRepoRsPtr) -> i32 {
+    1
+}