Contains implementation of the inversion of control container, which creates objects and controls their lifecycle(*) using various configurations.
Using generic containers, we can create more specialized containers – one of which is the process container. It represents a system process, receives its configuration file via the command line, and creates a container, starts it, reads its configuration, recreates objects, runs them, and then, after pressing ctrl-c, turns off and destroys the objects.
Another example of containers are lambda functions, service fabric containers, and so on.
External configurations (stored as YAML or JSON) are passed to the container and define the structure of objects that need to be recreated in the container. Objects can be defined in two ways:
In addition, various configurations are stored for each object. The container recreates the objects and, if they implement the IConfigurable interface, passes them their configurations.
Once the objects of a container are configured, if they implement the IReferencable interface,
they are passed a set of references for recreating links between objects in the container. If
objects implement the IOpenable interface,
open() method is called and they
start to work. Connections to various services are made, after which the objects start, the
container starts running, and the objects carry out their tasks. When the container
starts to close, the objects that implement the ICloseable interface
are closed via their
close() method (which should make them stop working and disconnect from other services),
after which objects that implement the IUnreferencable interface delete various links between
objects, and, finally, the contains destroys all objects and turns off.
Generated using TypeDoc