This package contains the functionality to bring the system to a running state.
Once either of the public methods on the static BootStrapper class completes,
the system is up and running and ready for requests.
The component package contains the classes that handle the life and death of
components and are the source of references to components while they are still
living.
Contains the supporting interface and class for sending events to components
that are configured to handle event sending. This mechanism is designed to
be a lightweight event system notification layer and not a robust messaging
layer. The expected usage is to have functional implementations and interceptors
send messages through JMX notifications that are handled by a
ManagementInterceptor.
Provides for the construction of live Carbon Components in the form specified
by their template configuration. These classes instantiate each part of a
component (the functional implementation, the set of assistants and the
proxy that ties them all together) and then coordinates their assembly
into a live component.
The lifecycle package contains the interfaces describing lifecycle functionality
for components. Lifecycle functionality exists primarily to support configuration
and management.
This package contains the Component Proxy implementation in the form of
a DynamicProxyInvocationHandler. This is the glue
that ties a Carbon Component together and will contain the functionality of
the service as well as any assistants that are assigned to this component.
This package contains the definition of the component that starts other
components as part of the bootstrap sequence. It also contains the default
implementation.
The configuration package provides the core infrastructure and the service
interfaces for the configuration of components and non-component clients. This
service provides type-safe access to values that may be stored in any number
of external stores and the automated control and persistance of that data. The
core config package is delivered default with the capability to store data into
XML files on a file system.
This service is designed in such a way that their is two plug points for
alteration. The repository and persistence engine can each be replaced seperate
of each other.
Contains supporting classes to implement a caching layer to speed up
configuration document retrievals. This package does not support the internal
value caching that is implemented by the format service. It is strictly supplied
to support the caching of full document files. In order for the cache to stay
synchronized with the backing store, the supplied implementation supports the
NodeListener functionality to be notified of file changes that happen within
the system.
This package contains the default implementor of configuration objects in
the Carbon Core Configuration Subsystem. This system is designed to implement
interfaces that represent configuration data and to support their connection
to an underlying storage and management mechanism.
This default implementation utilizes the JDOM document management objects of
the open source JDOM project as its underlying datastructure. This allowes the
system to read directly from XML into the system native data format and then
to provide an JavaBean syntax view into that data.
Contains the interface and implementation for the default configuration support
for components. This interceptor provides general configuration support for
a component such as tracking live and working copies of its configuration and
exposing the configuration interface up through the component facade. The live
instance of a configuration interceptor actually exposes the main configuration
interface along with the configuration interceptor interface.
The node package contains the data structure used to hold configuration within
the ConfigurationService. The data structure is a graph
of Nodes. Each Node has some basic functionality
described by the Node interface. There are 3 sub-types of
Node, Folder, LinkNode and
ConfigurationDocument, described by their own interfaces.
Folder objects are responsible for the hierachy of the data
structure. They contain other Nodes.
LinkNodes link to other Nodes either within the
same data store or in a different one.
ConfigurationDocuments contain the configuration data.
There is an abstract class for each of these interfaces. These classes
implement all the required functionality that is not specific to the
underlying data store. They provide method signatures for extending classes
to implement to provide access to specific data sources.
Nodes should only be constructed using a NodeFactory
or a LinkNodeFactory.
This package contains the file-based implementation of the Configuration
nodes interfaces. These interfaces provide a tree-like view into configuration
documents stored in a hierarchical directory structure on any standard
filesystem. This package supports both the reading and writing of
configurations.
This package contains interfaces and classes used to implement link nodes.
Link nodes are used to create links between nodes within an existing
node structure or to mount new node structures.
The config type package is designed to provide a simple, but extensible type
formatting service for use by the configuration subsystem.
This system is
designed to format objects into their String representations and
from those Strings construct their object representation. It is
designed to encapsulate the data constitution from the raw stream of the
configuration store.
The exception package contains the basis of framework exception handling
and provides a base class and a delegate to support the development of
new exceptions.
The classify utility class is designed to create a standard classification
system used by the Carbon Core and its dependent services for a common
understanding of events.
This commonality includes the management the severity of an event as well
as its source and is used between both the exception handling subsytem and the
standard logging system. This allows developers to create classes of exceptions
and classify their severity as well as where they came from code wise. This
will allow the logging system to automatically log them as well as filter the
exceptions into groups, as configured by the user, so that they only see the
messages and exceptions that they choose to see.
This package provides the basic service of type-safe enumerations to the
core framework. This enumerations packages provides a base class to support
easy extension into subclasses and is used in the core to provide enumerated
types.
The utility reflection package contains general utilities that are utilized to
accomplish reflective tasks. These classes are just helpers to make reflection
and dynamic proxy code simpler.
The Cache Service is designed to cache frequently used data in a refreshable,
high performance, thread-safe fashion. There are 2 main implementaions of
the cache system, total cache and most recently used (MRU) cache. The former
is used for caching entire sets of data and the latter is used for caching
only a portion of the entire set of data using a most recently used algorithm
to decide which data to keep (the most recently used data is kept in the cache).
This package contains the classloader based implementation of the Configuration
nodes interfaces. These interfaces provide a tree-like view into configuration
documents stored in a hierarchical directory structure within the classloader.
This package supports both the reading from classloader resources
and writing to in-memory configuration objects.
This package contains the jar-file based implementation of the Configuration
nodes interfaces. These interfaces provide a tree-like view into configuration
documents stored in a hierarchical directory structure within a jar.
This package supports both the reading and writing of configurations to jars.
Contains a JNDI-backed implementation of carbon configuration nodes that support
the storage of configuration data in directory servers. Any JNDI supported
directory server can be used.
This package contains a graphical user interface for the Carbon Component
Model. It provides a tree structure view into configuration and component
information.
The DeploymentService is designed to help manage differences
in configurations between application deployments.
This service service allows configurations for
all environments and all instances within each environment to be stored
separately and chooses the right configuration at runtime for each
environment/instance. This allows all configurations to reside
under source control and alleviates the error prone task of maintaining
manually modified files on each deployment.
For example, a project may have a development team of 15 engineers,
2 test instances, 2 staging instances and
4 instances in production. Each instance within each environment must
be configured with its host and port. Without this service, each
of the 23 deployed instances would have a configuration file that
would be manually modified to contain the correct data. Historically,
this kind of process is error prone, difficult to manage, and a
constant headache for project teams.
This service allows all 23 configurations to reside
in the source code repository and managed as code.
The EJB service facilitates Enterprise Java Bean lookup via a variety of factory methods.
Presently, the EJB service consists of two "home factory" components;
one is dedicated to locally deployed EJBs, while the other provides similar
functionality for remotely deployed EJBs. These components are encapsulated
into two sub-packages:
org.sape.carbon.services.ejb.local
LocalHomeFactory - the functional interface of the local home factory component
LocalHomeFactoryImpl - the implementation of the local home factory functional interface
org.sape.carbon.services.ejb.remote
RemoteHomeFactory - the functional interface of the remote home factory component
RemoteHomeFactoryImpl - the implementation of the remote home factory functional interface
The EJB service also provides EJB home interface caching functionality
and a generic exception handling strategy that applies to both the local
and remote home factories.
This package contains a component that acts as the controller for an JMX
MBeanServer. This component manages the starting and registering of the Server
as well as giving component clients access to it.
This package contains a graphical user interface for viewing log messages. This
is implemented through a LogService implementing adapator and a GUI Frame Window
in Swing, that can display, filter and search log messages.
The Carbon Unique ID Service solves the problem of generating unique IDs for data that
are independent of the data representation itself. It can be used to get unique
id numbers which serve as key values for database tables before the data is
inserted into the table. Using generated or surrogate keys for business data
allows changes to the underlying data to not effect the nature or identity of
the data so that it can continue to be tracked.