AbstractCapability provides a foundation for user-defined capabilities
by allowing users to focus on their operations and capability-specific
logic without having to worry about maintaining Muse components and
other plumbing work.
AbstractFilePersistence is an abstract component that provides generic
resource-state-to-file utilities without specifying the format of the XML
that goes into the files.
AbstractManageabilityCapability is an extension of
AbstractWsResourceCapability that
provides one additional initialization step: if the resource uses
the ManageabilityCharacteristics
capability, then this capability's URI will be added to the
muws1:ManageabilityCapability property.
AbstractMessageHandler is a convenience class that implements all of the
accessor methods of MessageHandler, leaving
only the serialization methods (fromXML(Element) and toXML(Object)).
AbstractProxyHandler is a convenience class that implements all of the
accessor methods of ProxyHandler, leaving only
the serialization methods (fromXML(Element) and toXML(Object[])).
This is a convenience constructor that calls
this(EndpointReference, EndpointReference) with the WS-A
anonymous EPR as the second parameter (the source EPR).
This is a convenience constructor that calls
this(EndpointReference, EndpointReference, SoapClient) with
the SoapClient provided by the given Environment.
This method allows you to add message content in its XML form - the
element will be added as the last child under the wsnt:Message part
of the notification message.
Creates a new Relationship resource with the given values, adds it to
the ResourceManager and the participant resources' WS-RP container, and
returns it to the caller.
This method is for internal (service-side) code that wishes to add a
subscription that has already been created (perhaps from data residing
in a persistent data store) and does not require a call to subscribe().
Converts an object into its XML representation; this usually means
that the object's toString() method is called and the result used
to create a DOM Text object.
Users can override this method to provide a different implementation of
the WS-N client class without changing the implementation of subscription
management.
This method serializes the given descriptor into XML and then wraps
it in a wsrmd:Definitions element so it can be written or published
as a valid WSRMD document.
Users can override this method to provide an alternative implementation
of ChangeNotificationListenerFactory that wraps WS-RP change notifications
in a different set of XML content.
This method returns the concrete WSRP state model - this is not
the implementation of the WSRP capabilities (which map SOAP
requests to WSRP operations), but it does implement the actual
WSRP operations and does the delegation of read/write requests
to the capabilities defining the properties.
Finds the resource type definition associated with the given context
path (defined in muse.xml), instantiates an instance of the resource
class, and sets the basic values (EPR, initialization parameters, etc.)
and Muse components (Environment, log file, etc.) that it needs to
operate.
Creates the proper file name for the given resource instance and then
delegates creation of the file's contents to the abstract method of
the same name.
This method should be overridden by concrete file-based persistence
classes to create the given file and fill it with the appropriate
XML content. Classes that are only interested in the serialization of
a certain capability's data can use the Resource object to get access
to said capability.
This implementation serializes the EPR to XML, then writes the
wsa:ReferenceParameters element to the file.
This is a convenience constructor that is equivalent to calling the
EndpointReference(EndpointReference, QName) constructor with the
standard wsa:EndpointReference QName.
This is a convenience constructor that is the equivalent of calling
EndpointReference(URI, QName) constructor with the standard
wsa:EndpointReference QName.
Filter is a data structure used by the WS-Notification Subscribe operation
to allow clients to control how many and what type of messages they receive
from a resource.
FilterCollection is a set of WSN subscription filters that a notification
producer must evaluate when determining whether it should send a message
to a consumer or not.
Deserializes the given DOM Element into a set of POJOs that can be
used when invoking a Java method. Implementations should use Muse's
registered Serializers in order to deserialize the XML into objects of
the proper types.
This implementation uses the MessageHandler's java.lang.reflect.Method
to discover what parameter types can be expected in the given Element.
GetCapability allows resources to expose the "get" operations defined by
WS-RP - GetMultipleResourceProperties, GetResourceProperty, and
GetResourcePropertyDocument.
This implementation reads the content values on-the-fly, creating a
client to the member resource and using the WSRP GetMultipleResourceProperties
operation to discover the property values.
This method is useful if you are only expecting one instance of a given
SOAP header element and do not want to sort through a Collection or
Iterator just to get one item.
This is a convenience method that does the same task as
getMessageContent(QName) but deserializes the message content into
a POJO of the given type before returning it.
Most users will probably want to use the canDelete(), canInsert(), and
canUpdate() methods to test the permissions of a property; these methods
handle the Boolean logic between modifiability and mutability values so
you don't have to litter your code with messy if/else blocks.
Most users will probably want to use the canDelete(), canInsert(), and
canUpdate() methods to test the permissions of a property; these methods
handle the Boolean logic between modifiability and mutability values so
you don't have to litter your code with messy if/else blocks.
This is a convenience method that calls getResourceProperty() and then
parses the XML results into POJOs of the given type using the Muse
serializer framework.
This method converts the WsResource[] returned by getRelationship()
into an Element[] with muws2:Relationship XML that is compliant with
the MUWS Part 2 spec.
Returns the security token that can be used by users of the WS-RP
document to verify that they are internal callers with permission
to circumvent published restrictions on property changes, etc.
AbstractWsResourceCapability continues the initialization process
by inspecting the concrete class to find all of the getters (and,
if applicable, setters) for its resource properties.
The SimpleWsResource implementation takes the following steps:
Create WSRP state model - createPropertyCollection()
Create WSRP document schema and apply it to the collection.
Create WSRP metadata and apply it to the collection.
Call super.initialize() to initialize capabilities.
This is a convenience method that uses the given ProxyHandler to
serialize the parameters (and deserialize the response) before
calling invoke(String, Element).
This is a convenience method that uses the given ProxyHandler to
serialize the parameters (and deserialize the response) before
calling invoke(String, Element).
MetricsClient provides two convenience methods for reading WSRP resource
properties and their metrics without resorting to separate SOAP calls or
DOM APIs.
NotificationProducerPersistence is an extension of the basic
Persistence API to provide a link to the
NotificationProducer API and resource
lifecycle events.
This implementation spawns a thread to handle the passing of the message
to the message listeners so that the method can return immediately and
speed up the notification process for the reporter.
OpenPropertiesSchema is a ResourcePropertiesSchema
that has no restrictions on any of its properties - all operations are
allowed, and no values have limits.
Policy is a data structure used by the WS-Notification Subscribe operation
to allow clients to control how many and what type of messages they receive
from a resource, above and beyond the basic filtering
mechanism.
PropertyChangeApprover describes a type of property listener that is
invoked when a property change is about to occur (through the WS-RP
SetResourceProperties operation).
PropertyChangeListener describes a type of property listener that is
invoked after a property change has occurred (through the WS-RP
SetResourceProperties operation).
PropertyReadListener describes a type of property listener that is
invoked before a property read request is completed (through the WS-RP
GetResourceProperty and GetMultipleResourceProperties operations).
PullPointDataStore is an interface to a persistent data store that is used
by pullpoint resources to keep messages until they are retrieved using the
PullPoint.getMessages() method.
Receives the old and new value of the property after it has been
changed; there are no requirements on the actions taken in response
to a property change.
This is a convenience method that calls publish(QName, Element) after
the given content object has been serialized to XML using the Muse
serializer framework.
QueryExpressionFactory is a means of generating executable
QueryExpressions for a set of dialects
without having to reference specific dialects or language constructs
in the calling code.
This method is defined by MUWS Part 2 in order to optimize the
query of a resource property that will often have a large number
of instances (which would make XPath-like queries and catch-all Get
requests a performance bottleneck).
ResourceIdFactory is an interface for classes that provide a name-value
pair that is inserted into a WS-Addressing endpoint reference's set of
properties in order to distinguish it from other EPRs that target the
same endpoint (the implied resource pattern).
ResourceManager defines the interface for creating and storing resources
that can be targeted by other resources (internal and external to a
Muse-derived application).
ResourceManagerListener is an interface for components that want to
receive internal notifications about the addition/removal of resource
instances in the Muse ResourceManager.
ResourcePropertyListeners defines operations for WS-RP implementations
that allow users to monitor activity on the document and subscribe to
notifications about that activity.
RouterPersistence is an interface for components that will serialize and
deserialize the routing table (EPRs and resource types) to a persistence
layer during reboots.
This method should be overridden by concrete file-based persistence
classes to update a resource instance with the saved data from the
XML fragment. The resource instance may be created by this method, or
it may exist prior to invocation.
This implementation treats the XML fragment as a wsa:ReferenceParameters
element.
ScheduledTermination represents the WS-ResourceLifetime ScheduledResourceTermination
capability, which has two properties (wsrf-rl:CurrentTime and
wsrf-rl:TerminationTime) and one method (wsrf-rl:SetTerminationTime).
ServiceGroupClient is a WSRF-based web services client that provides an
implementation of the (optional) wsrf-sg:Add operation as well as a few
convenience methods that make reading through service groups easier.
ServiceGroupRegistration contains the optional wsrf-sg:Add operation, which
can be added to resource types that already include the WS-RF
ServiceGroup capability.
SetOperationFactory is a component that allows users to create executable
commands for a WSRP document by providing either the values of the command
or an XML fragment that represents it.
SetResourcePropertyPermissions defines a security mechanism that can be used
to limit the use of these methods to internal callers, and/or to differentiate
between internal and external callers so that internal requests can have
more freedom in their modifications.
SimpleGetCapability is Muse's default implementation of the WS-RP 'get'
operations - the implementation simply forwards these requests to the
equivalent methods in ResourcePropertyCollection.
SimpleNotificationConsumer is Muse's default implementation of the
WS-Notification NotificationConsumer port type and the listener API
that augments it.
The default constructor provides no initialization, allowing users
to create messages in an 'aseembly line' system, where pieces of
the messages are added by different components before being published.
SimpleServiceGroupRegistration is Muse's default implementation of the
WS-RF ServiceGroupRegistration capability - it simply forwards all
wsrf-sg:Add requests to the ServiceGroup.addEntry() method.
SimpleSetCapability is Muse's default implementation of the WS-RP 'set'
operations - the implementation simply forwards these requests to the
equivalent methods in ResourcePropertyCollection.
SimpleSetOperationFactory provides an API for constructing and parsing WS-RP
SetResourceProperties requests, including the Insert, Delete, and Update
operations.
StaticValuesApprover is a
PropertyChangeApprover that throws an
exception if a caller tries to delete a property instance whose value is
defined in the WS-RMD document's StaticValues section.
Maps the property to the capability so that users can later determine
which capability should be used for servicing read/write requests
against the property.
If the given Element has no text content, a new Text node added with
the given text; otherwise, the first Text node will have its value
changed to the given text.
This implementation double-checks to make sure the resource hasn't
already been destroyed and then nulls-out all references to internal
data structures (this will highlight bugs caused by stale references
and prevent "undefined behavior").
This is a convenience method that calls toFile(Node, File, boolean)
with the last parameter set to "true" (to add the standard XML
header to the new XML file).
This is a convenience method that serializes the given XML tree
with the XML header and indentation; it is the equivalent of
calling toString(Node, boolean) with the last parameter set to
"true".
Serializes the given object into a DOM Element. Implementations should
use Muse's registered Serializers in order to serialize the objects
into the proper formats.
This implementation uses the MessageHandler's java.lang.reflect.Method
to discover what return type can be expected in the given Element.
UuidFactory defines an interface for UUID generators.
update() -
Method in interface org.apache.muse.ws.dm.muws.Metric
Notifies the metric metadata container that an update to the resource
property occurred, so it should adjust the metadata values to reflect
this change.
ValidValuesApprover is a
PropertyChangeApprover that throws
an exception if a caller tries to insert or update a property instance
with a value that is not defined in the WS-RMD document's ValidValues
section.
Throws an exception if the second parameter is null (signifying a
deletion) and the current property value is one of the static values
defined in the RMD.
WefFactory defines methods needed to instantiate "blank" WEF events and
their sub-components, as well as events and sub-components that exist as
from XML fragments.
WsrfMetadataExchange is an extension of the default WS-MEx implementation,
SimpleMetadataExchange, which supports
the WS0RF WS-ResourceMetadataDescriptor dialect.
WsrfMetadataExchangeClient is an extension of Muse's
MetadataExchangeClient to include
a convenience method for retrieving the resource's metadata descriptor.