Index

Symbols

"USER" "wrapped" provider example in C++ LN services

%(CURDIR) variable quickstart example (C++) quickstart example (Python)

_

__init__() (links_and_nodes.service_provider method) (links_and_nodes.services_wrapper method)

A

accessing data from lnrecorder user guide logging actor adding or extending environment variables address sanitizer aliasing host names American Standard Code for Information Interchange API API summary C++ module LN clients, [1] message definitions, [1] Python module tutorial (C++) tutorial (Python)

Application Programming Interface arrays message definitions ASCII atomic augmented assignment authentication starting processes avoiding repetitions in the LNM configuration file

B

basics of sending and receiving messages tutorial (C++) bisection bisection method debugging (C++) blocking blocking calls, [1] boilerplate code bottom-level handler for service requests tutorial (C++)

breakpoint debugging (C++) by predecessor process start-up synchronization by terminal output process start-up synchronization by time process start-up synchronization

C

C API fork() calls thread safety, [1] C language standard support C++ supported versions C++ API fork() calls thread safety, [1] C++ API summary client objects client.publish() ln::inport.read() ln::outport::write() service calls service client class service provider class (wrapped API) C++ client example using LN services c++ example tutorial tutorial (C++) C++ module API summary C++11 C++11 support C++14 support C++98 call handler for service requests, example() tutorial (C++) call() tutorial (C++), [1] call() (links_and_nodes.service method) calling an LN service quickstart (Python) tutorial (C++) calling services using the "wrapped" API quickstart (Python) changing message definitions changing the current working directory of a process tutorial (C++) Cissy workspace example tutorial (C++) CLI client (class in links_and_nodes) client example using LN services client object overview on communication, [1] client objects C++ API summary creating, [1] Python API summary client processes (summary) tutorial (C++) client.get_service() Python API summary client.publish() C++ API summary Python API summary tutorial (C++) client.subscribe() tutorial (C++) client::get_service() tutorial (C++) client::publish() (example) tutorial (C++) client::subscribe() (example) tutorial (C++) client::wait_and_handle_service_group_requests() (example) tutorial (C++), [1] CLIENT_CLASS::SVMDEF_NAME (C++ function) clock_gettime()

closing the LN manager; tutorial (LNM) cmake code generation for include headers, tutorial (C++) CMakeLists.txt example tutorial (C++) code generation using cmake example code generation for C++ clients using ln_generate tutorial (C++) code generation for include headers tutorial (C++) cmake code generation using ln_generate tutorial (C++) Command-Line Interface communication tutorial Communication in Links and Nodes comparison lnrecorder vs ln daemon logger user guide logging compatibility with C++ / Python versions compatibility between LN versions quickstart (Python) tutorial (Python) Conan Conan configuration tutorial (C++) concurrency bugs conditional evaluation LNM configuration file configuration LN daemon public-key authentication, [1] process dependencies process dependencies, LN Manager configuration file LN manager process dependencies, LN manager see LNM configuration file configuration of private key file reference, LN daemon configuration of public key file reference, LN daemon configuring services in LN quickstart (Python) configuring the LN manager quickstart (C++) message definitions quickstart (Python) message definitions convert data into hdf5 format user guide logging core dump cpp using publish/subscribe communication CPPFLAGS CPU-bound CPU-bound processes creating client objects, [1] creating LN client instances tutorial (C++) creating port objects (summary) tutorial (C++) cross-compatibility between languages service clients, [1] current directory of a config file tutorial (C++) current working directory of the LN manager tutorial current working directory of a process tutorial (C++) CWD see current working directory CXXFLAGS, [1]

D

deadlock debugging (C++) bisection method breakpoint edge cases white-box testing example fixing a segfault gdb commands getting debug information git bisect LN clients written in C++ methodology reverse-time debugging running code backwards from an error stack trace starting a process in LN with GDB undefined behavior sanitizer using address sanitizer using compiler warnings using GDB using the compiler using unit tests using unit tests example using unit tests how to do using unit tests technical outline watchpoint debugging access violations debugging and restarting LN clients tutorial (C++) debugging LN clients introduction debugging LN processes tutorial (C++) debugging non-deterministic behavior debugging system components by swapping out modules defining host aliases node_map

defining and storing message definitions tutorial defining messages dependency dependency management introduction depends-on directive tutorial (C++) tutorial (Python) depends_on flag, explanation tutorial depends_on_restart flag, explanation tutorial determinism diagnosing missing processes, [1] difference between message definition and topic names tutorial differences between ln recorder and ln daemon logger user guide logging differences in length of recorded data logging different clocks distributed system do_register() (links_and_nodes.service_provider method) do_register() example tutorial (C++), [1] Documentation quick overview quickstart sections tutorials user guide where to find specific things documentation bugs how to report don't repeat yourself DRY DRY principle

E

edge cases white-box testing, debugging (C++) elevator::request::elevator_call_base tutorial (C++), [1] embedded system endianness environment environment setup tutorial (C++) environment variable "USER" CPPFLAGS CXXFLAGS, [1] DEBUG_GETSTATE DISPLAY EDITOR HOME, [1] HOSTNAME LDFLAGS LN_ARBITER_PORT LN_BUILD_SUBDIR LN_CHECK_CB LN_CONFIG LN_DAEMON_NO_HIDE LN_DAEMON_START, [1] LN_DEBUG, [1], [2], [3] LN_DEBUG_TO_FTRACE LN_FTRACE LN_MANAGER, [1], [2], [3], [4], [5], [6], [7], [8], [9], [10] LN_MANAGER_ASK_SHUTDOWN LN_MANAGER_CONDITIONS_CHECK_FOR_LONG_WAITERS LN_MESSAGE_DEFINITION_DIRS, [1], [2], [3], [4], [5], [6], [7], [8], [9] LN_OPEN_SCOPE_ON_PARAMETER_DOUBLE_CLICK, [1] LN_PROGRAM_NAME, [1], [2], [3], [4], [5], [6] LN_PYTHON LN_PYTHONPATH LN_SCOPE_DEFAULT_DISPLAY_RATE LN_SRC_TREE_DAEMON_START LN_TERM_COLOR LN_TERM_DEBUG LN_USE_OLD_PYSCOPE LNM_TOPICS_DISPLAY_FLAT PATH, [1], [2], [3] PYTHONPATH, [1], [2] TMPDIR USER XAUTHORITY

environment variables adding or extending tutorial error codes Reference (C API) error handling LN services wrapped API for Python, [1] error handling in C++, authoritative guidance error handling in python using exceptions error messages and exceptions in service responses tutorial (Python) essential configuration tutorial, LNM configuration file example code generation using cmake debugging (C++) using unit tests fixing a segfault, debugging (C++) process definitions tutorial publish/subscribe communication, [1] example handling sensor messages tutorial (C++) example LN daemon logger user guide logging exceptions LN services wrapped API for Python exceptions (example how to handle) exchanging C++ implementation with Python code executing a service call quickstart (Python) exit status checking exiting with running processes LNM GUI explanation

F

falsy faq logging required versions for LN manager and lnrecorder logging time stamps and data synchronization finding include C/C++ headers installation of LN finding message definitions tutorial (C++) finding programs in PATH quickstart example fixing a segfault debugging (C++) example

floating point accuracy and semantics for services tutorial, message definition fork() (C library function) fork() calls C API C++ API function LN daemon functions and variables LNM configuration file

G

gdb commands debugging (C++) generating include files on the fly LNM configuration file get_service() (links_and_nodes.client method) get_service_provider() (links_and_nodes.client method) get_service_provider() example tutorial (C++), [1]

getting debug information debugging (C++) git bisect debugging (C++) Graphical User Interface grouping LN Manager, processes GUI LN manager GUI managing processes see also graphical user interface

H

handle_service_group_in_thread_pool (example) tutorial (C++), [1] handle_service_group_in_thread_pool() (links_and_nodes.client method) handle_service_group_requests() introduction handle_service_group_requests() (links_and_nodes.service_provider method) handler_t (C++ type) handling error messages in a language-independent way tutorial (C++) handling exceptions has_publisher() (links_and_nodes.inport method) has_subscriber() (links_and_nodes.outport method) HDF5 hdf5 format logging HOME host host aliases node_map, defining

host name host name aliases how to define stable interfaces tutorial (C++), [1] how to do debugging (C++) using unit tests how to find message definitions LN manager how to handle exceptions tutorial (C++) how to implement a service method tutorial (C++) how to implement service calls tutorial (C++) how to inspect error messages LN manager, [1] how to set PATH variable how to use the GUI tutorial

I

I/O using ports tutorial (C++) IEEE-754 floating point implementing a handler quickstart (Python) service provider implementing a service provider method tutorial (C++), [1] importing LN include headers fails troubleshooting include headers for using LN client API in C++ including other files LNM configuration file initialization quickstart (Python) service provider initializing a service request buffer tutorial (C++) initializing an LN client quickstart (Python) initializing clients timing and performance considerations, [1] inport (C++ class) (class in links_and_nodes) inport.read() tutorial (C++) tutorial overview on communication inport::read() (example and summary) tutorial (C++) inport::read() (example) tutorial (C++)

inspecting topics LNM GUI installation of LN finding include C/C++ headers instance name tutorial inter-process communication overview, tutorial (C++) on overview, tutorial (Python) tutorial inter-process communication in LN overview, [1] interface interface definition interface definition (for services) see service message definition introduction debugging LN clients dependency management handle_service_group_requests() ln.service_provider network transparency process management wrap_service_provider() IPC see also inter-process communication isolation from user environment

L

latency, [1] LDFLAGS LED LED Button life time Links and Nodes features and main principles main components main functions, [1] overview on central components what it is what problems does it solve? Links and Nodes instance links_and_nodes module links_and_nodes (Python module) (python module) links_and_nodes.client see client object LN see also Links and Nodes ln see also links_and_nodes (python module) see also links_and_nodes (Python module) LN API LN arbiter LN client LN clients API summary, [1] introduction LN clients written in C++ debugging (C++) LN daemon arbiter authentication configuration of keys configuration of private key file reference configuration of public key file reference default location of DSA keys function how to start introduction location of DSA keys, [1] path to secure shell binary ssh possible causes for failure to start public key authentication public-key authentication configuration, [1] starting via remote ssh command user guide why authentication is needed LN daemon access safety security LN daemon startup secure shell access LN instance LN library LN Manager configuration process dependencies processes grouping LN manager closing configuration file configuration file process dependencies how to find message definitions how to inspect error messages, [1] introduction minimal configuration file report bug starting and stopping processes LN Manager configuration LN manager configuration LN services, [1] quickstart (C++) message definitions quickstart (Python) message definitions tutorial (C++) LN manager GUI managing processes GUI LN message communication security of LN parameter LN parameters overview what they are LN publisher ln recorder description user guide logging LN service LN service client LN service provider LN services "wrapped" provider example in C++ client example in python, [1] client example in Python example, [1] LN manager configuration, [1] main principle message definitions, [1] message definitions, quickstart (C++) motivation provider example in C++ provider example in Python provider example in python quickstart (C++) wrapped API for Python wrapped API for Python error handling, [1] wrapped API for Python exceptions wrapped API for Python post-processing of requests wrapped API for Python pre-processing of requests LN services (Python tutorial) quickstart LN services(Python tutorial) motivation LN state LN states LN subscriber LN topic ln.client see client object ln.client.wrap_service() ln.service_provider introduction ln.services_wrapper see see services_wrapper ln.wrap_service_provider() see overview on communication ln::client see client object (tutorial) ln::client (C++ class) ln::client.publish(), tutorial overview ln::client.write(), tutorial overview ln::client::client (C++ function), [1], [2], [3] ln::client::get_service (C++ function) ln::client::get_service() (summary and example) tutorial (C++) ln::client::get_service_provider (C++ function) ln::client::handle_service_group_in_thread_pool (C++ function) ln::client::handle_service_group_in_thread_pool() tutorial (C++), [1] ln::client::publish (C++ function) ln::client::release_service (C++ function) ln::client::service::call() (summary and example) tutorial (C++) ln::client::set_max_threads (C++ function) ln::client::subscribe (C++ function) ln::client::wait_and_handle_service_group_requests (C++ function) ln::client::wait_and_handle_service_group_requests() tutorial (C++), [1] ln::inport.read() C++ API summary ln::inport::read (C++ function), [1] ln::outport::write (C++ function), [1] ln::outport::write() C++ API summary ln::parameters::parameter_block (C++ function) ln::parameters::parameter_block::register_parameters (C++ function) ln::parameters::parameter_block::update (C++ function) ln::parameters::port_description (C++ struct) ln::parameters::port_description::after_update_callback (C++ member) ln::parameters::port_description::before_update_callback (C++ member) ln::service (C++ class) ln::service::call (C++ function), [1]

ln::service::do_register (C++ function) ln::service::set_handler (C++ function) ln::service_request (C++ class) ln::service_request::abort (C++ function) ln::service_request::finished (C++ function) ln::service_request::is_aborted (C++ function) ln::service_request::respond (C++ function) ln::service_request::respond() tutorial (C++) ln::service_request::set_data (C++ function) ln_client (C type) ln_daemon LN_DAEMON_START LN_DEBUG, [1], [2] ln_describe_message_definition (C function) ln_generate tutorial ln_get_error_message (C function) ln_get_message_definition_for_topic_v17 (C function) ln_get_message_definition_v21 (C function) ln_handle_service_group_in_thread_pool (C function) ln_init (C function) ln_init_to_manager (C function) ln_inport (C type) LN_MANAGER, [1], [2], [3], [4], [5], [6], [7], [8], [9] ln_manager LN_MESSAGE_DEFINITION_DIRS, [1], [2], [3], [4], [5], [6], [7], [8] ln_messages.h how to generate via make LN_OPEN_SCOPE_ON_PARAMETER_DOUBLE_CLICK ln_outport (C type) ln_packet (C type) LN_PROGRAM_NAME, [1], [2], [3], [4], [5], [6] ln_publish (C function) ln_publish_with_buffers (C function) ln_put_message_definition (C function) LN_PYTHON LN_PYTHONPATH ln_read (C function) ln_read_timeout (C function) ln_scope user guide LN_SCOPE_DEFAULT_DISPLAY_RATE ln_service (C type) ln_service_call (C function) ln_service_deinit (C function) ln_service_handler (C type) ln_service_init (C function) ln_service_provider_register (C function) ln_service_provider_set_handler (C function) ln_service_request (C type) ln_service_request_respond (C function) ln_service_request_set_data (C function) ln_set_max_threads (C function) ln_subscribe (C function) ln_subscribe_with_buffers (C function) ln_unpublish (C function) ln_unsubscribe (C function) ln_wait_and_handle_service_group_requests (C function) ln_write (C function) LNE_CHECK_ERRNO LNE_CLIENT_NOT_INITIALIZED LNE_ERROR_GETTING_SHM_FD LNE_FIELD_NOT_IN_HEADER LNE_GOT_INVALID_RESPONSE LNE_HOST_WRONG_NET LNE_INTERNAL_ERROR LNE_INVALID_DSA_SIGNATURE LNE_INVALID_HOSTNAME LNE_INVALID_MANAGER_ADDRESS LNE_INVALID_PARAMETER LNE_INVALID_PORT_OBJECT LNE_INVALID_REQ_FIELD_FORMAT LNE_INVALID_SHM_MAGIC LNE_INVALID_SIGNATURE LNE_LOG_FILE_TOO_NEW LNE_LOST_CONNECTION LNE_MANAGER_TOO_OLD LNE_NO_LOGGER_TOPICS LNE_NO_MANAGER_ADDRESS LNE_NO_MEM LNE_NO_PROVIDER_FOUND LNE_NOT_ON_THIS_OS LNE_NOT_YET_IMPLEMENTED LNE_PACKET_TOO_LARGE LNE_PORT_NOT_FOUND LNE_PORT_UNBLOCKED LNE_REGISTER_DENIED LNE_REGISTER_FAILED LNE_REQUEST_FAILED LNE_SHM_DOES_NOT_EXIT LNE_SHM_IS_TOO_BIG LNE_SHM_IS_TOO_SMALL LNE_SHM_NAME_TOO_LONG LNE_SHM_READ_ERROR LNE_SHM_VERSION_TOO_NEW LNE_START_PROVIDER_FAILED LNE_STRING_LENGTH_SPEC_MISSING LNE_SVC_ALREADY_REGISTERED LNE_SVC_GRP_UNKNOWN LNE_SVC_HANDLER_EXC LNE_SVC_HANDLER_MULTI_RESP LNE_SVC_HANDLER_NO_RESP LNE_SVC_IS_CLIENT LNE_SVC_IS_PROVIDER LNE_SVC_NO_HANDLER LNE_SVC_NOT_REGISTERED LNE_SVC_RECV_REQ LNE_SVC_RECV_REQ_MEM LNE_SVC_RECV_RESP LNE_SVC_RECV_RESP_MEM LNE_SVC_REQ_ABORTED LNE_SVC_REQ_NOT_RUNNING LNE_SVC_REQ_RUNNING LNE_SVC_REQ_SET_DATA_WRONG LNE_SVC_RESP_LATER LNE_THREADP_INIT LNE_TOPIC_ID_OUT_OF_RANGE LNE_UNKNOWN_HOSTNAME LNE_UNKNOWN_PARAMETER LNE_USER_DEFINED_ERROR LNE_WRONG_BYTE_ORDER LNE_WRONG_SHM_SIZE LNM see LN manager LNM configuration see LN manager configuration LNM configuration file avoiding repetitions in the conditional evaluation essential configuration tutorial functions and variables generating include files on the fly including other files more functions; tutorial process work directory LNM GUI exiting with running processes how to use inspecting topics re-connect to processes after exiting the GUI re-connecting to running processes lnrecorder example user guide logging logging accessing data from lnrecorder, user guide comparison lnrecorder vs ln daemon logger, user guide convert data into hdf5 format, user guide differences between ln recorder and ln daemon logger, user guide differences in length of recorded data example LN daemon logger, user guide hdf5 format ln recorder description, user guide lnrecorder example, user guide network time protocol reading lnrecorder data into Matlab, user guide required versions for LN manager and lnrecorder, faq time stamps and data synchronization, faq time stamps and data synchronization, user guide troubleshooting missing metadata, user guide user guide

M

main components Links and Nodes main functions Links and Nodes main principle LN services Makefile for generating ln_messages.h tutorial (C++) managing processes GUI, LN manager GUI managing system configuration using LN states memory protection introduction message message buffer type tutorial (C++) message definition for services tutorial message definitions API summary, [1] arrays basics configuring the LN manager, quickstart (C++) configuring the LN manager, quickstart (Python) defining search path for LN services, [1] introduction LN manager configuration, quickstart (C++) LN manager configuration, quickstart (Python) LN services, [1] names tutorial quickstart (C++) LN services recommendations simple example (C++) simple example (Python) storage as text files strings strings and setting their length correctly variable-length arrays variable-length fields

message definitions (summary) tutorial (C++) message definitions for error messages quickstart (C++) message element types message passing why? MESSAGE_DEF_NAMESPACE::MDEF_NAME_t (C++ class) MESSAGE_DEF_NAMESPACE::SVMDEF_NAME::req (C++ member) MESSAGE_DEF_NAMESPACE::SVMDEF_NAME::resp (C++ member) MESSAGE_DEF_NAMESPACE::SVMDEF_NAME_base (C++ class) (example in tutorial), [1] MESSAGE_DEF_NAMESPACE::SVMDEF_NAME_base::register_SVMDEF_NAME (C++ function) MESSAGE_DEF_NAMESPACE::SVMDEF_NAME_t (C++ type) methodology debugging (C++) middleware minimal configuration file LN manager module links_and_nodes modules monotic clocks motivation LN services LN services(Python tutorial) multi-threaded service handlers (C++) multi-threading quickstart (C++) quickstart (Python) multi-user and multi-instance capability mutex

N

name of message buffer type name space names tutorial, message definitions tutorial, services tutorial, topics naming of LN clients nanosecond network Network Time Protocol network time protocol logging network transparency introduction nice value

node node field tutorial node_map defining host aliases nodes of a distributed system introduction non-blocking non-blocking calls, [1] non-deterministic non-deterministic errors, how to debug NTP NTP (Network Time Protocol) when to use null-terminated strings in message definitions

O

of messages exchanged by read() and write() synchronization, [1], [2], [3] on_elevator_call() tutorial (C++) order tutorial process start-up synchronization order of dependencies tutorial (C++) tutorial (Python) os.fork() (Python library function) os.fork() calls Python API outport (C++ class) (class in links_and_nodes) outport.write() tutorial (C++) outport::write() tutorial overview on communication outport::write() (example and summary) tutorial (C++) outport::write() (example) tutorial (C++)

override (explanation in C++ tutorial) overview tutorial (C++) on inter-process communication tutorial (Python) inter-process communication overview on central components Links and Nodes overview on communication client object, [1] port object, [1] port.packet port.read() port.write() publish(), [1] service.call(), [1] service.req, [1] service.response, [1] services_wrapper subscribe(), [1] wrap_service() wrap_service_provider() overview on topics, services, and clients tutorial (C++)

P

packet see port.packet packet (links_and_nodes.port attribute) pair LNM configuration file including generated files or a set of files parameter parameters see LN parameters passing environment variables quickstart example, [1] PATH, [1], [2], [3] path to secure shell binary ssh, LN daemon PATH variable how to set persistence Plain Old Data POD port tutorial port (class in links_and_nodes) port number port object overview on communication, [1] port objects python API summary Python API summary port.packet overview on communication port.packet() Python API summary port.read() example, [1] overview on communication Python API summary time stamps of logged messages time-out, [1] port.read() return values tutorial (C++) port.write() example, [1] overview on communication Python API summary time stamps of logged messages port::read() time stamps of logged messages port::write() time stamps of logged messages port_base (C++ class) (class in links_and_nodes) port_base::message_size (C++ member) POSIX post-processing of requests LN services wrapped API for Python postprocessor keyword argument to wrap_service Python API postprocessors keyword argument to wrap_service Python API pre-processing of requests LN services wrapped API for Python precondition preprocessor keyword argument to wrap_service Python API prerequisites starting processes over the network priority management introduction process work directory, LNM configuration file process definitions tutorial example process dependencies between TCP servers and clients configuration depends_on depends_on_restart different modes introduction LN Manager configuration LN manager configuration file process environment tutorial process group process management introduction quickstart (C++) quickstart (Python) quickstart section tutorial, [1] process management in Links and Nodes process management; by LN manager quickstart (C++) quickstart (Python)

process management; manual quickstart (C++) quickstart (Python) process name process priorities tutorial process start-up and synchronization tutorial process start-up synchronization by predecessor by terminal output by time order, tutorial ready-regex, tutorial ready-time, tutorial process stopped unexpectedly cause process synchronization terminal output tutorial tutorial, ready-regexp processes grouping LN Manager how to control them interactively introduction start-up dependencies ready-regexp processes which terminate tutorial prototyping service implementations provider example using ln services provider example in C++ using ln services, [1] PROVIDER_CLASS::on_SVMDEF_NAME (C++ function) PROVIDER_CLASS::run (C++ function) pthreads public-key authentication configuration, LN daemon, [1] public-key cryptography publish() overview on communication, [1] publish() (links_and_nodes.client method) publish/subscribe tutorial (C++) tutorial (Python) using timeouts tutorial (C++) using timeouts tutorial (Python) publish/subscribe communication example, [1] time-out, [1] tutorial (C++) publish/subscribe messaging pattern tutorial publish/subscribe or topic message definitions; example tutorial (C++) publisher Python using publish/subscribe communication python supported versions Python 2 Python 2 support Python 3 Python API os.fork() calls postprocessor keyword argument to wrap_service postprocessors keyword argument to wrap_service preprocessor keyword argument to wrap_service thread safety, [1] throw_on_these_error_indicators kwarg Python API summary client objects client.get_service() client.publish() port objects port.packet() port.read() port.write() service client class service provider class service.call service.req service.response python API summary port objects Python API summary() service client handle Python implementation as draft for a C++ implementation Python module API summary PYTHONPATH, [1], [2]

Q

quick overview Documentation quickstart LN services (Python tutorial) quickstart (C++) LN services LN services message definitions message definitions configuring the LN manager message definitions for error messages message definitions LN manager configuration multi-threading process management process management; by LN manager process management; manual running multi-threaded handlers running service handlers service group testing service clients and providers quickstart (Python) calling an LN service calling services using the "wrapped" API compatibility between LN versions configuring services in LN executing a service call initializing an LN client message definitions configuring the LN manager message definitions LN manager configuration multi-threading process management process management; by LN manager process management; manual running service handler running service handlers in parallel threads service client example service group, [1] service provider implementing a handler service provider initialization simple example services testing service clients and providers

quickstart example finding programs in PATH passing environment variables, [1] service client wrap_service, [1], [2] use_execvpe flag quickstart example (C++) %(CURDIR) variable quickstart example (Python) %(CURDIR) variable quickstart section process management quickstart sections Documentation overview

R

race condition RAII rate limit re-connect to processes after exiting the GUI LNM GUI re-connecting to running processes LNM GUI re-starting processes tutorial (LNM) re-starting TCP servers read() see port.read() read() (C++) see inport::read() read() (links_and_nodes.inport method) (links_and_nodes.port method) reading lnrecorder data into Matlab user guide logging reading messages tutorial (C++) ready-regex tutorial process start-up synchronization ready-regexp process synchronization tutorial processes start-up dependencies tutorial (C++), [1] ready-time tutorial process start-up synchronization real-time real-time scheduling further reading tutorial reference LN daemon configuration of private key file LN daemon configuration of public key file Reference (C API) error codes regexp register_elevator_call tutorial (C++) registering a service provider tutorial (C++), [1] registering service handlers in a service provider tutorial (C++) regression

regular expression reliable transport reloading the configuration tutorial (LN manager) reloading the LNM configuration tutorial (C++) remote procedure call remote procedure call example tutorial (C++) remote procedure calls and services replacing C++ implementation with Python code report bug LN manager reproducibility, [1] req (links_and_nodes.service attribute) required versions for LN manager and lnrecorder faq logging resource acquisition is initialization resp (links_and_nodes.service attribute) respond() tutorial (C++) respond() (links_and_nodes.connection method) respond() method, explanation tutorial (C++) responding to service requests tutorial (C++), [1] return error messages from service call tutorial (C++) reverse-time debugging debugging (C++) RPC service running a service handler tutorial (C++) running code backwards from an error debugging (C++) running multi-threaded handlers quickstart (C++) running service handler quickstart (Python) running service handlers quickstart (C++) running service handlers in parallel threads quickstart (Python) running service requests tutorial (C++), [1]

S

safety security, LN daemon access SCHED_FIFO tutorial scheduling policy tutorial scheduling priorities secure shell secure shell access LN daemon startup security LN daemon access safety security of LN message communication segfault how to fix segmentation fault how to debug sending command messages tutorial (C++) sensor sentinel value sentinel values in message definitions ser_handler() example tutorial (C++) service (class in links_and_nodes) service call() method service calls C++ API summary service client tutorial (C++), [1] wrap_service quickstart example, [1], [2] wrap_service tutorial (Python) service client class C++ API summary Python API summary service client example quickstart (Python) service client handle Python API summary() service client initialization tutorial (C++) service clients cross-compatibility between languages, [1] tutorial (C++), [1] service group quickstart (C++) quickstart (Python), [1] service groups tutorial (C++), [1], [2] service handler service handler implementation tutorial (C++) service message definition tutorial service message definitions strings tutorial example variable-length arrays tutorial example service message definitions; example tutorial (C++) service provide base class tutorial (C++), [1] service provider implementing a handler, quickstart (Python) initialization, quickstart (Python) service provider (summary and code example) tutorial (C++) service provider class Python API summary service provider class (wrapped API) C++ API summary service providers tutorial (C++) service request service.call Python API summary service.call() overview on communication, [1]

service.req overview on communication, [1] Python API summary service.response overview on communication, [1] Python API summary service_provider (class in links_and_nodes) ServiceErrorResponse (class in links_and_nodes) services advantages and disadvantages function and rationale inspecting them in LNM GUI introduction names tutorial see LN services services_wrapper overview on communication services_wrapper (class in links_and_nodes) set_handler() (links_and_nodes.service_provider method) set_handler() example tutorial (C++) set_max_threads() (links_and_nodes.client method) setting process parameters setting time-outs see time-out shared memory SIGSEGV simple example services quickstart (Python) ssh LN daemon path to secure shell binary stack trace debugging (C++) start-up dependencies ready-regexp, processes see process dependencies start-up dependency starting a process in LN with GDB debugging (C++) starting process on other nodes tutorial (LNM) starting processes authentication tutorial (LNM) starting processes over the network prerequisites state objects overview stopping processes tutorial (LNM) storage as text files message definitions strings message definitions tutorial example, service message definitions strings and setting their length correctly message definitions strings in message definitions tutorial struct subscribe() overview on communication, [1] subscribe() (links_and_nodes.client method) subscriber Summary of LN client API tutorial (C++) Summary on how to use service calls tutorial (C++) support of language standards supported language standards and versions supported versions C++ python swapping out C++ and Python implementation tutorial (C++) synchronization of logged messages of messages exchanged by read() and write(), [1], [2], [3], [4], [5] sys.argv

T

TCP servers managing process dependencies technical outline debugging (C++) using unit tests templates tutorial terminal terminal output tutorial, process synchronization testing individual system components testing service clients and providers quickstart (C++) quickstart (Python) thread configuration for LN services (in the provider process) tutorial (C++), [1] thread safety C API C++ API Python API thread-safe thread-safety of APIs user guide threads threads programming throw_on_these_error_indicators kwarg Python API time stamps of logged messages, [1], [2] time stamps and data synchronization faq logging user guide logging time stamps of logged messages port.read() port.write() port::read() port::write() time synchronization time-out port.read(), [1] port.write(), [1] publish/subscribe communication, [1] time-outs introduction introduction in C++ tutorial timing and performance considerations initializing clients, [1] TMPDIR topic topic communication example (C++) example (Python) topic publisher quickstart example (C++) quickstart example (Python) topic subscriber quickstart example (C++) quickstart example (Python) topics connecting clients, [1] function & rationale introduction names tutorial publishing data, [1] tutorial (C++) tutorial (Python) troubleshooting importing LN include headers fails troubleshooting missing metadata user guide logging truthy tutorial c++ example current working directory defining and storing message definitions depends_on flag, explanation depends_on_restart flag, explanation difference between message definition and topic names environment variables example, process definitions how to use the GUI instance name LNM configuration file essential configuration message definition for services message definitions names node field port process environment process management process priorities process start-up and synchronization process start-up synchronization order process start-up synchronization ready-regex process start-up synchronization ready-time process synchronization terminal output processes which terminate publish/subscribe messaging pattern ready-regexp process synchronization real-time scheduling SCHED_FIFO scheduling policy service message definition services names strings in message definitions templates topics names Unicode strings in message definitions UTF-8 strings in message definitions tutorial (C++) API summary basics of sending and receiving messages bottom-level handler for service requests c++ example call handler for service requests, example() call(), [1] calling an LN service changing the current working directory of a process Cissy workspace example client processes (summary) client.publish() client.subscribe() client::get_service() client::publish() (example) client::subscribe() (example) client::wait_and_handle_service_group_requests() (example), [1] cmake code generation for include headers CMakeLists.txt example code generation for C++ clients using ln_generate code generation using ln_generate Conan configuration creating LN client instances creating port objects (summary) current directory of a config file current working directory of a process debugging and restarting LN clients debugging LN processes depends-on directive do_register() example, [1] elevator::request::elevator_call_base, [1] environment setup example handling sensor messages finding message definitions get_service_provider() example, [1] handle_service_group_in_thread_pool (example), [1] handling error messages in a language-independent way how to define stable interfaces, [1] how to handle exceptions how to implement a service method how to implement service calls I/O using ports implementing a service provider method, [1] initializing a service request buffer inport.read() inport::read() (example and summary) inport::read() (example) LN manager configuration ln::client::get_service() (summary and example) ln::client::handle_service_group_in_thread_pool(), [1] ln::client::service::call() (summary and example) ln::client::wait_and_handle_service_group_requests(), [1] ln::service_request::respond() Makefile for generating ln_messages.h message buffer type message definitions (summary) on_elevator_call() order of dependencies outport.write() outport::write() (example and summary) outport::write() (example) overview on topics, services, and clients port.read() return values publish/subscribe communication publish/subscribe or topic message definitions; example publish/subscribe using timeouts reading messages ready-regexp, [1] register_elevator_call registering a service provider, [1] registering service handlers in a service provider reloading the LNM configuration remote procedure call example respond() respond() method, explanation responding to service requests, [1] return error messages from service call running a service handler running service requests, [1] sending command messages ser_handler() example service client, [1] service client initialization service clients, [1] service groups, [1], [2] service handler implementation service message definitions; example service provide base class, [1] service provider (summary and code example) service providers set_handler() example Summary of LN client API Summary on how to use service calls swapping out C++ and Python implementation thread configuration for LN services (in the provider process), [1] topics using cmake using libln library using ln_generate

tutorial (C++) on inter-process communication overview tutorial (LN manager) reloading the configuration tutorial (LNM) closing the LN manager; LN states re-starting processes starting process on other nodes starting processes stopping processes tutorial (Python) API summary compatibility between LN versions depends-on directive error messages and exceptions in service responses inter-process communication overview order of dependencies publish/subscribe using timeouts service client wrap_service topics tutorial example service message definitions strings service message definitions variable-length arrays tutorial overview on communication inport.read() outport::write() tutorials Documentation

U

ubsan see undefined behavior sanitizer unblock() (links_and_nodes.inport method) undefined behavior how to debug undefined behavior sanitizer debugging (C++) Unicode strings in message definitions tutorial unit test unit tests example (C++) UNIX signal use_execvpe flag quickstart example USER user environment why it can cause trouble user guide Documentation LN daemon ln_scope logging logging accessing data from lnrecorder logging comparison lnrecorder vs ln daemon logger logging convert data into hdf5 format logging differences between ln recorder and ln daemon logger logging example LN daemon logger logging ln recorder description logging lnrecorder example logging reading lnrecorder data into Matlab logging time stamps and data synchronization logging troubleshooting missing metadata thread-safety of APIs

USER_SERVICE_HANDLER (C++ function) using address sanitizer debugging (C++) using cmake example, code generation tutorial (C++) using compiler warnings debugging (C++) using GDB debugging (C++) using libln library tutorial (C++) using LN services C++ client example client example using ln services provider example provider example in C++, [1] using multiple LN clients in one process using non-blocking calls using publish/subscribe communication cpp Python using the compiler debugging (C++) using timeouts tutorial (C++), publish/subscribe tutorial (Python), publish/subscribe using unit tests debugging (C++) example, debugging (C++) how to do, debugging (C++) technical outline, debugging (C++) UTF-8 strings in message definitions tutorial

V

variable-length arrays message definitions tutorial example, service message definitions

variable-length fields message definitions version control

W

wait_and_handle_service_group_requests() (example), [1] (links_and_nodes.client method) watchpoint debugging (C++) where to find specific things Documentation white-box testing debugging (C++) edge cases work directory LNM configuration file process wrap_service quickstart example, service client, [1], [2] tutorial (Python), service client wrap_service() overview on communication wrap_service() (links_and_nodes.services_wrapper method)

wrap_service_provider() introduction overview on communication wrap_service_provider() (links_and_nodes.service_provider method) wrapped API for Python error handling, LN services, [1] exceptions, LN services LN services post-processing of requests, LN services pre-processing of requests, LN services write() see port.write() write() (C++) see outport::write() write() (links_and_nodes.outport method) (links_and_nodes.port method)

Y

YAML