Inventory (Hawkular Inventory API 0.0.9 API)

All Superinterfaces:

AutoCloseable

All Known Subinterfaces:

Inventory.Mixin.AutoTenant, Inventory.Mixin.AutoTenantAndObservable, Inventory.Mixin.Observable

All Known Implementing Classes:

EmptyInventory
```
public interface Inventory
extends AutoCloseable
```
Inventory stores "resources" which are groupings of measurements and other data. Inventory also stores metadata about the measurements and resources to give them meaning.
The resources are organized by tenant (your company) and environments (i.e. testing, development, staging, production, ...).
Despite their name, tenants are not completely separated and one can easily create relationships between them or between entities underneath different tenants. This is because there are situations where such relationships might make sense but more importantly because at the API level, inventory does not mandate any security model. It is assumed that the true multi-tenancy in the common sense of the word is implemented by a layer on top of the inventory API that also understands some security model to separate the tenants. To help with multi-tenancy support, the API provides "mixins" to modify the default behavior of the inventory, see the Inventory.Mixin class and the augment(Inventory) method.
Resources are hierarchical - meaning that one can be a parent of others, recursively. One can also say that a resource can contain other resources. Resources can have other kinds of relationships that are not necessarily tree-like.
Resources can have a "resource type" (but they don't have to) which prescribes what kind of data a resource contains. Most prominently a resource can have a list of metrics and a resource type can define what those metrics should be by specifying the set of "metric types".
This interface offers a fluent API to compose a "traversal" over the graph of entities stored in the inventory in a strongly typed fashion.
The inventory implementations are not required to be thread-safe. Instances should therefore be accessed only by a single thread or serially.
Note to implementers:
The interfaces composing the inventory API are of 2 kinds:
1. CRUD interfaces that provide manipulation of the entities as well as the retrieval of the actual entity instances (various Read, ReadWrite or ReadRelate interfaces, e.g. Environments.ReadWrite),
2. browse interfaces that offer further navigation methods to "hop" onto other entities somehow related to the one(s) in the current position in the inventory traversal. These interfaces are further divided into 2 groups:
  - Single interfaces that provide methods for navigating from a single entity. These interfaces generally contain methods that enable modification of the entity or its relationships. See Environments.Single for an example.
  - Multiple interfaces that provide methods for navigating from multiple entities at once. These interfaces strictly offer only read-only access to the entities, because the semantics of what should be done when modifying or relating multiple entities at once is not uniformly defined on all types of entities and therefore would make the API more confusing than necessary. See Environments.Multiple for example.
Since:

0.0.1

Author:

Lukas Krejci

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`Inventory.Mixin` A class for producing mixins of inventory and the `Inventory.Mixin.Observable` or `Inventory.Mixin.AutoTenant` interfaces.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`static Inventory.Mixin.AutoTenantMixin`	`augment(Inventory.Mixin.AutoTenant inventory)`
`static Inventory.Mixin.ObservableMixin`	`augment(Inventory.Mixin.Observable inventory)`
`static Inventory.Mixin`	`augment(Inventory inventory)` Returns an object with which one can modify the behavior of or add features to the provided inventory.
`void`	`initialize(Configuration configuration)` Initializes the inventory from the provided configuration object.
`default <E extends Entity<?,?>,Single extends ResolvableToSingle<E>> Single`	`inspect(E entity, Class<Single> accessInterface)` A generic version of the `inspect` methods that accepts an entity and returns the access interface to it.
`default Environments.Single`	`inspect(Environment environment)` Provides an access interface for inspecting given environment.
`default Feeds.Single`	`inspect(Feed feed)` Provides an access interface for inspecting given feed.
`default Metrics.Single`	`inspect(Metric metric)` Provides an access interface for inspecting given metric.
`default MetricTypes.Single`	`inspect(MetricType metricType)` Provides an access interface for inspecting given metric type.
`default Resources.Single`	`inspect(Resource resource)` Provides an access interface for inspecting given resource.
`default ResourceTypes.Single`	`inspect(ResourceType resourceType)` Provides an access interface for inspecting given resource type.
`default Tenants.Single`	`inspect(Tenant tenant)` Provides an access interface for inspecting given tenant.
`Tenants.ReadWrite`	`tenants()` Entry point into the inventory.

Methods inherited from interface java.lang.AutoCloseable
close

- Method Detail
  - augment
```
static Inventory.Mixin augment(Inventory inventory)
```
    Returns an object with which one can modify the behavior of or add features to the provided inventory.
    
    Parameters:
    
    inventory - the inventory to augment
    
    Returns:
    
    a mixin object to modify the inventory with
  - augment
```
static Inventory.Mixin.ObservableMixin augment(Inventory.Mixin.Observable inventory)
```
  - augment
```
static Inventory.Mixin.AutoTenantMixin augment(Inventory.Mixin.AutoTenant inventory)
```
  - initialize
```
void initialize(Configuration configuration)
```
    Initializes the inventory from the provided configuration object.
    
    Parameters:
    
    configuration - the configuration to use.
  - tenants
```
Tenants.ReadWrite tenants()
```
    Entry point into the inventory. Select one (ResolvingToSingle.get(String)) or more (ResolvingToMultiple.getAll(org.hawkular.inventory.api.filters.Filter...)) tenants and navigate further to the entities of interest.
    
    Returns:
    
    full CRUD and navigation interface to tenants
  - inspect
```
default Tenants.Single inspect(Tenant tenant)
                        throws EntityNotFoundException
```
    Provides an access interface for inspecting given tenant.
    
    Parameters:
    
    tenant - the tenant to steer to.
    
    Returns:
    
    the access interface to the tenant
    
    Throws:
    
    EntityNotFoundException
  - inspect
```
default Environments.Single inspect(Environment environment)
                             throws EntityNotFoundException
```
    Provides an access interface for inspecting given environment.
    
    Parameters:
    
    environment - the environment to steer to.
    
    Returns:
    
    the access interface to the environment
    
    Throws:
    
    EntityNotFoundException
  - inspect
```
default Feeds.Single inspect(Feed feed)
                      throws EntityNotFoundException
```
    Provides an access interface for inspecting given feed.
    
    Parameters:
    
    feed - the feed to steer to.
    
    Returns:
    
    the access interface to the feed
    
    Throws:
    
    EntityNotFoundException
  - inspect
```
default Metrics.Single inspect(Metric metric)
                        throws EntityNotFoundException
```
    Provides an access interface for inspecting given metric.
    
    Parameters:
    
    metric - the metric to steer to.
    
    Returns:
    
    the access interface to the metric
    
    Throws:
    
    EntityNotFoundException
  - inspect
```
default MetricTypes.Single inspect(MetricType metricType)
                            throws EntityNotFoundException
```
    Provides an access interface for inspecting given metric type.
    
    Parameters:
    
    metricType - the metric type to steer to.
    
    Returns:
    
    the access interface to the metric type
    
    Throws:
    
    EntityNotFoundException
  - inspect
```
default Resources.Single inspect(Resource resource)
                          throws EntityNotFoundException
```
    Provides an access interface for inspecting given resource.
    
    Parameters:
    
    resource - the resource to steer to.
    
    Returns:
    
    the access interface to the resource
    
    Throws:
    
    EntityNotFoundException
  - inspect
```
default ResourceTypes.Single inspect(ResourceType resourceType)
                              throws EntityNotFoundException
```
    Provides an access interface for inspecting given resource type.
    
    Parameters:
    
    resourceType - the resource type to steer to.
    
    Returns:
    
    the access interface to the resource type
    
    Throws:
    
    EntityNotFoundException
  - inspect
```
default <E extends Entity<?,?>,Single extends ResolvableToSingle<E>> Single inspect(E entity,
                                                                                    Class<Single> accessInterface)
```
    A generic version of the inspect methods that accepts an entity and returns the access interface to it.
    If you don't know the type of entity (and therefore cannot deduce access interface type) you can always use ResolvableToSingle type which is guaranteed to be the super interface of all access interfaces returned from this method (which makes it almost useless but at least you can get the instance of it).
    
    Type Parameters:
    
    E - the type of the entity
    
    Single - the type of the access interface
    
    Parameters:
    
    entity - the entity to inspect
    
    accessInterface - the expected access interface
    
    Returns:
    
    the access interface instance
    
    Throws:
    
    ClassCastException - if the provided access interface doesn't match the entity

Interface Inventory

Nested Class Summary

Method Summary

Methods inherited from interface java.lang.AutoCloseable

Method Detail

augment

augment

augment

initialize

tenants

inspect

inspect

inspect

inspect

inspect

inspect

inspect

inspect