|
| | LoadApi (Kernel &kernel, impl::Runner *runner, const VarMap &config) noexcept |
| | ~LoadApi () 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 Result< LoggerSinkRegistration, ExecError > | addLoggerSink (std::shared_ptr< spdlog::sinks::sink > sink, TerminalOwnership terminal=TerminalOwnership::shared) |
| | Sends every logger's output to sink, including loggers made afterwards.
|
| static FuncResult | removeLoggerSink (const std::shared_ptr< spdlog::sinks::sink > &sink) |
| | Stops sending output to sink. Restores the console sinks if this was the last registered sink claiming the terminal. For a component being unloaded.
|
| static FuncResult | setAllLoggersLevel (spdlog::level::level_enum level) |
| | Sets the level on every logger the kernel knows and on every logger made afterwards.
|
| 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.
|
What can be done when loading a component.
The logger state below is per process, not per kernel. The relay sink and the record of what the console sinks were are statics in libkernel, so they outlive any Kernel and are shared by every kernel in the process. "Every logger" means every logger in libkernel's registry, which no kernel owns. configureSpdlog replaces the sink vector of every logger that already exists, so KernelImpl::configure re-attaches the relay straight afterwards, and a second kernel configured in the same process keeps working. A logger made by any route other than getOrCreateLogger, a direct spdlog factory for instance, is not reached at all.
spdlog appears in these signatures deliberately. It makes a component's ABI depend on being built against the same spdlog as the kernel, which is acceptable because Sen builds the kernel and its components from one source tree, and a component that renders logs wants spdlog's own formatting. Revisit it first if components ever ship separately from the kernel.
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.
Sends every logger's output to sink, including loggers made afterwards.
A component cannot do this by walking the registry itself: spdlog iterates a logger's sink vector without a lock and hands out a bare reference, so appending to a logger another thread is emitting through is a use-after-free. Appending earlier is no safer, because the kernel starts each group's threads before it loads the next group and logs between groups itself. The kernel therefore attaches one sink of its own to every logger, in the only window where attaching is safe, and this call registers sink behind it under a mutex. No logger's sink vector is touched here, so it may be called from any thread at any time.
sink keeps its own pattern: the relay hands on the unformatted message and each registered sink formats it.
The registration has no owner. Sinks are held until removed, so a component that is unloaded must call removeLoggerSink, and it must stop its sink reaching its own state first, because the sink can be running on another thread. Nothing here enforces that order: this is a static function with no api object, so the kernel cannot know which component registered what.
A sink left registered is a state hazard rather than a code one only because nothing dlcloses a component, so its code stays mapped. If unload is ever made to really unload, every un-removed sink becomes a jump into unmapped memory on the next log line.
Returns what the registration did, or an error if sink is null. Nothing else can fail.
| FuncResult sen::kernel::KernelApi::setAllLoggersLevel |
( |
spdlog::level::level_enum | level | ) |
|
|
staticnodiscardinherited |
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