xroad_node.h

Go to the documentation of this file.

 
#pragma once
 
#include "xroad_system.h"
#include "xroad_node_types.h"
#include <cache/xroad_cache.h>
#include <cache/xroad_objects.h>
#include <cache/xroad_cache.h>
#include <cache/xroad_storage_fwd.h>
#include <common/xroad_xml.h>
#include <common/xroad_string.h>
#include <common/xroad_aux.h>
#include <stdint.h>
#include <stdbool.h>
#include <sys/epoll.h>
 
#define xroad_node_is_offline() \
   (xroad_node_get_data()->status == xroad_node_status_offline || \
    xroad_node_get_data()->status == xroad_node_status_sleep)
 
#ifdef __cplusplus
extern "C"
{
#endif
 
typedef struct
{
   void* ctx;
   void (*on_object)(void*, xroad_node_id_t, void*);
} xroad_node_callback_t;
 
typedef struct
{
   void* ctx;
   int32_t fd;
   void (*on_event)(const struct epoll_event*);
} xroad_node_epoll_callback_t;
 
 
typedef struct 
{
   tsc_t wake;
   tsc_t before_event_cb;
} xroad_epoll_timestamps;
 
xroad_errno_t xroad_node_create(
      xroad_str_t node_name,
      uint32_t major_version,
      uint32_t minor_version,
      xroad_str_t git_hash,
      xroad_node_callback_t callback);
 
void xroad_node_destroy(void);
 
xroad_errno_t xroad_node_reconfig(void);
 
xroad_xml_doc_t* xroad_node_get_config(void);
 
const xroad_epoll_timestamps* xroad_node_get_epoll_timestamps(void);
 
int32_t xroad_node_receive(void);
 
int32_t xroad_node_receive_ex(int32_t timeout);
xroad_errno_t xroad_node_add_epoll(uint32_t events, xroad_node_epoll_callback_t* cback);
 
xroad_errno_t xroad_node_mod_epoll(uint32_t events, xroad_node_epoll_callback_t* cback);
 
xroad_errno_t xroad_node_del_epoll(xroad_node_epoll_callback_t* cback);
 
int32_t xroad_node_get_epoll_fd(void);
 
void* xroad_node_create_object(xroad_object_type_t type);
 
void* xroad_node_clone_object(const void* obj);
 
xroad_errno_t xroad_node_send_object(void* obj, xroad_node_id_t id);
 
xroad_errno_t xroad_node_route_object(void* obj, ...);
 
xroad_errno_t xroad_node_route_object_va(void* obj, va_list ap);
 
void* xroad_node_get_fun(xroad_str_t fname);
 
void* xroad_node_get_object(xroad_object_type_t type, xroad_object_id_t id);
 
xroad_lock_by_pid_t* xroad_node_get_used_lock(void);
 
xroad_node_data_t* xroad_node_get_data(void);
 
void xroad_node_reset_statistic(void);
 
xroad_str_t xroad_node_get_working_dir(void);
 
void xroad_node_set_flags(uint32_t flags);
 
int32_t xroad_node_get_link_descriptor(void);
 
xroad_cursor_t* xroad_node_create_cursor(xroad_object_type_t type);
 
void xroad_node_destroy_cursor(xroad_cursor_t* cursor);
 
void* xroad_node_cursor_get_next(xroad_cursor_t* cursor);
 
void* xroad_node_cursor_get_prev(xroad_cursor_t* cursor);
 
void* xroad_node_cursor_get_first(xroad_cursor_t* cursor);
 
void* xroad_node_cursor_get_last(xroad_cursor_t* cursor);
 
void* xroad_node_cursor_offset(xroad_cursor_t* cursor, int64_t offset);
 
xroad_errno_t xroad_node_clear_cache(xroad_object_type_t type, bool force);
 
xroad_cache_t* xroad_node_get_cache();
 
size_t xroad_node_get_object_count(xroad_object_type_t type);
 
const xroad_version_t* xroad_node_get_version(void);
 
bool xroad_node_is_initialized(void);
 
xroad_errno_t xroad_node_subscribe(xroad_domain_t group, xroad_node_callback_t cback);
 
xroad_errno_t xroad_node_unsubscribe(xroad_domain_t group, xroad_node_callback_t cback);
 
xroad_str_t xroad_node_get_env_param(xroad_str_t param);
 
void xroad_node_renamed();
 
#define xroad_node_find_object(type, fun, ...)                                   \
({                                                                               \
   xroad_cursor_t* cur __xroad_cursor_dtor__ = xroad_node_create_cursor(type);   \
   void* obj = xroad_node_cursor_get_first(cur);                                 \
   while(obj)                                                                    \
   {                                                                             \
      if (fun(obj, __VA_ARGS__))                                                 \
      {                                                                          \
         break;                                                                  \
      }                                                                          \
      obj = xroad_node_cursor_get_next(cur);                                     \
   }                                                                             \
   obj;                                                                          \
})
 
#ifdef __cplusplus
}
#endif