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.
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.
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 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.
Returns zero or more instances of the given property, deserialized
into instances of the given type. This method differs from
getResourceProperty(QName) in that it returns POJOs rather than XML.
Unlike getResourceProperty(QName), the values returned from this
method have been transformed from Elements to POJOs and do not
represent the values in the underlying DOM Document.
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).