|
| | RegistrationApi (Kernel &kernel, impl::Runner *runner, const VarMap &config) noexcept |
| | ~RegistrationApi () noexcept=default |
| const VarMap & | getConfig () const noexcept |
| | Gets the configuration associated with this component.
|
| CustomTypeRegistry & | getTypes () noexcept |
| | The types registered into the kernel.
|
| void | requestKernelStop (int exitCode=0) |
| | Issues an asynchronous request to stop the kernel. The request is ignored if a previous stop request was issued.
|
| std::shared_ptr< ObjectSource > | getSource (const BusAddress &address) |
| | Gets an object source, where objects can be found and published.
|
| std::shared_ptr< ObjectSource > | getSource (const std::string &address) |
| | Gets an object source, where objects can be found and published. The address parameter must be given as <session-name>.<bus-name>.
|
| SessionsDiscoverer & | getSessionsDiscoverer () noexcept |
| | Object that allows discovering sessions and buses.
|
| const ProcessInfo * | fetchOwnerInfo (const Object *object) const noexcept |
| | Gets information about the process where an object is. Returns nullptr if the object resides in the current process.
|
| const std::string & | getAppName () const noexcept |
| | Gets the (optional) application name passed to the kernel as a configuration parameter.
|
| std::vector< BusAddress > | getConfiguredBusAddresses () const |
| | Gets configured non-local bus addresses.
|
| ::sen::impl::WorkQueue * | getWorkQueue () const noexcept |
| | The work queue of this runner.
|
| template<typename T, typename Bus> |
| std::shared_ptr< Subscription< T > > | selectAllFrom (const Bus &bus) |
| | Subscribe to every object of type T on bus. The returned Subscription owns the kernel-side wiring; destruct it to stop.
|
| template<typename T, typename Bus> |
| std::shared_ptr< Subscription< T > > | selectAllFrom (const Bus &bus, typename sen::ObjectList< T >::Callback onAdded, typename sen::ObjectList< T >::Callback onRemoved=nullptr) |
| | As above, plus addition/removal callbacks installed before subscribing so they fire for objects already present. Pass nullptr to skip either.
|
| template<typename T, typename Bus> |
| std::shared_ptr< Subscription< T > > | selectFrom (const Bus &bus, const std::string &query, typename sen::ObjectList< T >::Callback onAdded=nullptr, typename sen::ObjectList< T >::Callback onRemoved=nullptr) |
| | Subscription against an arbitrary Sen query (with WHERE conditions). Example: selectFrom<Shape>(bus, R"(SELECT Shape FROM local.bus WHERE color IN ("red"))"). Installs the callbacks before subscribing. Pass nullptr to skip either.
|
| std::filesystem::path | getConfigFilePath () const noexcept |
| | Gets the path to the configuration file used to construct the kernel. It might be empty if the kernel is programmatically configured.
|
|
| static std::shared_ptr< spdlog::logger > | getOrCreateLogger (const std::string &loggerName) |
| | Registers a new logger in the kernel if it does not exist, or returns the existing one by name. Used to propagate the logger configuration to other packages/components that use it.
|
| static void | applyToAllLoggers (std::function< void(std::shared_ptr< spdlog::logger >)> &&func) |
| | Applies the input function to all loggers kept in the logger registry. Used by the logmaster component.
|
| static FuncResult | setAllLoggersLevel (spdlog::level::level_enum level) |
| | The level below is the registry's, not a kernel's, and spdlog is one shared library with one registry per process. So it reaches every logger in that registry, including one a component made through spdlog's own factory. A logger constructed directly and never registered is not in it.
|
| static void | setCrashBannerDescriptor (int descriptor) noexcept |
| | Where the kernel writes the crash banner, the few lines naming what died and where the report went, for a component that has taken stderr over.
|
| static void | prepareCurrentThreadForCrashReports () noexcept |
| | Give the calling thread the alternate signal stack the crash handler needs.
|
| static spdlog::level::level_enum | getAllLoggersLevel () |
| | The level setAllLoggersLevel last set, which is also the level a new logger starts from.
|
API for objects when registered.
template<typename T, typename Bus>
| std::shared_ptr< Subscription< T > > sen::kernel::KernelApi::selectAllFrom |
( |
const Bus & | bus | ) |
|
|
inlinenodiscardinherited |
Subscribe to every object of type T on bus. The returned Subscription owns the kernel-side wiring; destruct it to stop.
Callback lifetime (this overload, the next, and selectFrom): onAdded / onRemoved fire on the kernel's run() thread between subscribe and the Subscription's destruction. References they capture must outlive the Subscription. Capture state by shared_ptr or via a component member.
| void sen::kernel::KernelApi::applyToAllLoggers |
( |
std::function< void(std::shared_ptr< spdlog::logger >)> && | func | ) |
|
|
staticinherited |
Applies the input function to all loggers kept in the logger registry. Used by the logmaster component.
func runs under spdlog's logger-map mutex, which is not recursive, so it must not do anything that reaches the registry again. getOrCreateLogger, spdlog::get, setAllLoggersLevel and logging through a logger looked up by name all take that mutex, and calling one from inside func deadlocks the calling thread. Emitting through a logger func was handed is fine.
| FuncResult sen::kernel::KernelApi::setAllLoggersLevel |
( |
spdlog::level::level_enum | level | ) |
|
|
staticnodiscardinherited |
The level below is the registry's, not a kernel's, and spdlog is one shared library with one registry per process. So it reaches every logger in that registry, including one a component made through spdlog's own factory. A logger constructed directly and never registered is not in it.
spdlog appears in these signatures by name: this header declares the types instead of including them, so compiling against the kernel does not compile spdlog or fmt. A caller that uses a logger includes spdlog itself and links the copy Sen ships, which holds the registry.
Sets the level on every logger the kernel knows and on every logger made afterwards.
Walking the registry with applyToAllLoggers reaches only the loggers that exist when it runs, so a level set that way stops applying as soon as another component makes a logger. This sets the registry's own level, which is what a new logger is initialised from.
It replaces the per-logger levels a configuration file asked for, and there is no way back to them: read one before you change it if you mean to restore it.
Errors on a level outside the enum. Nothing else can fail.
| void sen::kernel::KernelApi::setCrashBannerDescriptor |
( |
int | descriptor | ) |
|
|
staticnoexceptinherited |
Where the kernel writes the crash banner, the few lines naming what died and where the report went, for a component that has taken stderr over.
A component that draws a full-screen terminal captures stderr so a stray write cannot land on its display. That captures the crash banner too, and a fatal error would print the report's path into a pipe that dies with the process, leaving the user with a vanished UI and an exit status. Hand over the descriptor the component saved and the banner goes there. Pass -1 to restore stderr, which a component must do before the descriptor it gave is closed.
| void sen::kernel::KernelApi::prepareCurrentThreadForCrashReports |
( |
| ) |
|
|
staticnoexceptinherited |
Give the calling thread the alternate signal stack the crash handler needs.
Every thread the kernel creates gets this when it starts. A component that creates its own thread with std::thread does not, and a fatal signal on such a thread, a stack overflow in particular, can fault again inside the handler and produce no dump at all. Call it once, first thing, in any thread the component starts itself. Harmless if crash reporting is disabled or already armed.
1.17.0