All Classes and Interfaces
Class
Description
Basic class for a YAML-based component setup.
A
double value that may be updated atomically.Defines the usual builder interface.
Generic access to Bytecode manipulation.
Builds a dynamic class.
Sub-builder for type annotations.
Sub-builder for field annotations.
Sub-builder for annotations.
Sub-builder for type annotations.
Creating the Bytecode instance via JSL.
Defines the interface of a child class loader, mixed from
ClassLoader and
java.net.URLClassLoader.A delegating child-first classloader.
A delegating child-first classloader.
A delegating child classloader to make internal methods accessible.
Class loader helpers.
Loads a plugin from a given classpath file assuming that the referenced relative URLs are in a sibling folder.
Represents a clock.
Simple command line utilities.
Some useful additional collection methods.
Simple data collector for test performance/regression.
A CSV datapoint constructor.
A datapoint constructor.
A field descriptor.
Collector setup information.
Commons utility interface.
Creating the Commons instance via JSL.
A compound enumeration.
Represents a counter.
Builds a counter.
A default plugin setup descriptor taking the actual/parent classloader as actual one.
A default plugin setup descriptor taking the actual thread's context class loader or as fallback the specified
parent classloader as actual one.
Default plugin descriptor implementation.
Declares the plugin supplier type.
An input stream that delegates its operations to a given delegate input stream.
Enables setup merging.
Implements a reusable server endpoint.
Marker annotation for descriptor classes that shall be excluded in a first search round for JSL descriptors.
A file format just based on extensions.
A fallback logger to sysout/syserr.
Represents a file format, e.g., to indicate which formats are supported by an importer/exporter.
Basic file functionality, partly warpping/in style of
org.apache.commons.io.FileUtils.A to make internal methods accessible.
Default plugin setup descriptor based based on loading from a project folder containing jars and the
classpath in "classpath", in "target/jars/classpath", or in "target/classes/classpath".
Represents a classpath file and selected descriptive entries.
A simple resource resolver that takes a given folder into account.
Represents a gauge.
Builds a gauge.
Generic access to HTTP.
Represents an HTTP client.
Represents a POST request.
Creating the HTTP instance via JSL.
Represents an HTTP message.
Represents a HTTP response.
Classloader with deeper identification support.
The internal logger factory.
Provides access to installed dependencies on the actual resource, e.g., the location of a specific Java version
or of Python.
A consumer that may throw an
IOException.A simple (optional) function that may throw an
IOException.An iterator that can throw
IOException.A runnable that may throw an IO exception.
A supplier that may throw an
IOException.I/O utilities in the style of
org.apache.commons.io.IOUtils.A simple (optional) function that may throw an
IOException.Json interface.
Specifies the mapping of an enumeration for serialization/deserialization.
Represents a Json array.
Creates Json arrays.
Creates Json objects.
Simplified annotation to ignore properties.
Simplified annotation to ignore properties.
An iterable JSON structure.
Element/entry iterator.
JSON value types.
Represents a number.
Represents a Json object.
Creates Json objects.
Simplified annotation to specify properties.
Creating the JSON instance via JSL.
Uniform JSON way to represent results of operations that may fail.
A function that may throw an exception.
Allows to track operations.
Represents the result w/o exception.
Represents a String.
Some JSON utility methods, also reading/writing of specific types.
Property exclusion modifier to simulate
JsonIgnoreProperties.Renames properties.
Generic enum deserializer.
Specifies the mapping of an enumeration for serialization/deserialization.
A property naming strategy exactly using the given names as JSON and Java field/getter/setter names.
A handler for optional fields.
Represents a Json value.
A logger.
Finally emits the log message.
Creates loggers.
Creating the logger factory by JSL.
The log levels.
A resource resolver for typical Maven paths.
Represents a measurement.
Something that meters something.
A
Meter id.Custom meters may emit metrics like one of these types without implementing
the corresponding interface.
Represents a meter filter.
A meter registry akin to micrometer.
Represents the configuration of the registry.
Builder interface.
Generic access to Metering/Metrics.
Creating the Metering instance via JSL.
A delegating multi resource resolver.
Some network utilities.
A server that does nothing (sometimes a helpful fake class).
Object utilities.
A resource resolver for oktoflow resources.
Access to static operating system level information.
Process ID (PID) file abstraction that writes the current PID into a file and optionally
removes it on system exit.
Represents a plugin.
Loads a plugin based on the classloader of an already loaded plugin.
Represents a loaded plugin.
Basic JSL descriptor for alternative plugin instance loading via JSL.
Manages plugins to separate overlapping classpaths and dependencies of alternatives and optionals.
Allows to filter out plugins that shall not be loaded.
Collects information about a plugin.
Basic setup for plugins.
A descriptor to describe the presence of a plugin.
Generic access to process level information.
Represents a process and its accessible information.
Creating the REST instance via JSL.
Some generic Python process helper functions.
Default resource-based plugin setup descriptor, reading the required URLs from a classpath file.
Support for class loading also in FAT jars.
Resolves resources.
Generic access to Rest (server).
Represents an exception handler, can be used to uniformly handle exceptions.
Represents a route filter.
Request interface.
Response interface.
Represents a rest server.
Represents a route (function).
Creating the REST instance via JSL.
Represents a Web target for RESTful API access.
Represents a request invocation.
Represents a request.
Lists common relevant protocol schemas.
A generic server, something that can be started or stopped and, finally, disposed.
Represents a reusable server address.
Helper functions for Java Service Loading.
Represents a singleton plugin, i.e., a plugin holds and returns a singleton instance.
Singleton plugin descriptor implementation, creates
SingletonPlugin instances.Generic access to SSH.
Authenticates server accesses.
The SSH server with further setup options.
Creating the REST instance via JSL.
A description of the value contained in a measurement.
Simple process stream gobbler.
String utility functions, partially wrapping
org.apache.commons.text.Short prefix style with limited string output.
Represents a metrics tag.
Thread-based mechanism to track tasks (AAS, through UI).
Represents data associated to a task.
Constants to represent the task status.
Represents a timer.
Default implementation of
Timer.Sample based on micrometer.Maintains state on the clock's start position for a latency sample.
Builds a timer.
Test utilities.
An abstract basic date converter.
Plugin to extend the date time conversion.
Default URL-based plugin setup descriptor.
Artifact or service version.
Generic access to WebSockets.
Is called on status changes.
A web socket.
Creating the WebService instance via JSL.
Generic access to YAML.
Low-level YAML file support, specific functions for oktoflow.
Creating the YAML instance via JSL.
Basic JAR/ZIP utilities.
A delegating input stream that closes a given closable after closing this stream.