Difference between revisions of "Adding State"
(→Building & Deploying) |
(→A Quick Test) |
||
Line 727: | Line 727: | ||
EndpointReferenceType resourceEpr = stub.logon(args[2]); | EndpointReferenceType resourceEpr = stub.logon(args[2]); | ||
− | logger.trace("created resource at endpoint "+ | + | logger.trace("created resource at endpoint " + resourceEpr); |
FileWriter writer = new FileWriter("/tmp/resource.epr"); | FileWriter writer = new FileWriter("/tmp/resource.epr"); |
Revision as of 17:34, 24 April 2009
Contents
Adding State
The service we defined in the first part of this tutorial was stateless: its responses to client requests depended solely on the requests. This is all well, but in practice services may need to maintain some form of state that pre-exists, persists, and - most importantly - changes as a result of client invocations. Many gCube services are indeed stateful.
In this second part of the tutorial we will learn how to add state to our SampleService
. In the spirit of a dumb service, the idea is to keep track of the number of visits of any client that has previously 'logged on' with the service.
The identity of logged clients and the number of their subsequent visits will then form the state of our augmented SampleService
. In particular, we will add two new port-types:
- a
Factory
port-type that allows clients to log on and thus creates state within the service . In particular, we plan a single operationlogon()
for this port-type.
- a
Stateful
port-type that allows clients to visit the service and thus consults and updates the state of the service. In particular, we plan a single operationaboutSF()
for this port-type which will behave similarly to the operationabout()
in theStateless
port-type whilst recognising visits from clients that have previously logged on.
(It will be clear soon why we prefer two port-types with a single operation each rather than a single port-type with two operations.)
For both port-types, we need to repeat the steps already shown for the Stateless
port-type: add the port-types descriptions to the service profile, define the WSDL interface of each port-type, and provide the Java implementation of the two port-types. Additional steps will then be required for state management.
WS-Resources and The Implied Resource Pattern
The overall state of our SampleService
will be comprised of many 'pieces', one per client that logs on and then visits. We refer to these pieces somewhat more technically as stateful resources.
How should we go about creating and accessing stateful resources? One approach could be as follows:
- take some credentials from clients when they invoke the
logon()
operation on theFactory
port-type. A simple name would surely do for our purposes. - create stateful resources as Java objects that contain the count of client visits, and identify such resources with the name of the associated client.
- when a client comes back to visit the service and invokes the
aboutSF()
operation on theStateful
port-type, ask it to provide his name so that we can identify the corresponding stateful resource and update the count of its visits.
In this approach, clients need to explicitly identify the state they wish to target. Unfortunately, identifiers are service-specific: here we need a name, elsewhere we may need something different. The use that we make of identifiers is also specific: here we hinted at one parameter in the aboutSF()
operation, elsewhere could be two or three parameters in one or more operations. This variability makes it impossible to build generic clients that can transparently access state across different services.
You may find this observation rather strange: what could a client do that does not require specific knowledge of the target service? Well, it turns out that if we find a general way to access stateful resources, then we can build enough conventions on how we describe them to enable a range of very useful and yet generic clients. For example, we can define clients that can query and change the stateful resources of any service that complies with the conventions. We can define clients that can uniformly destroy stateful resources, either immediately or based on some renewable expiry time. We can even define clients that allow others to subscribe for changes to the stateful resources. These are all key features in gCube, and we shall be directly concerned with some of them in this very Primer.
What we need to promote generic clients is then:
- a uniform pattern to identify and access stateful resources which does not change from service to service.
- a standard that codifies this pattern and builds useful conventions on top of it.
The Web Services Resource Framework (WSRF) is precisely one such standard, and gCube adopts it. When it comes to identifying and accessing stateful resources, WSRF says: forget passing identifiers explicitly in operations such as aboutSF()
, which vary from port-type to port-type and from service to service; let us pass them instead implicitly, as part of the address of the port-type that exposes those operations. An invocation of aboutSF()
would thus be addressed to the Stateful
port-type, but the address would include also the identifier of the stateful resource that is the target of the request. The port-type implementation would then extract such identifier and use it to locally access the stateful resource. No need to explicitly parameterise aboutSF()
with it. This is the access pattern that WSRF calls the implied resource pattern.
If you think about it, this annotated address - or more appropriately, this qualified endpoint reference - identifies a pair (port-type,stateful resource). This pairs WSRF calls a WS-Resource. We can then think of the qualified endpoint reference as the endpoint reference of the WS-resource itself. Similarly, we can think of the operations available at that endpoint as the operations of the WS-Resource. In this sense, the port-type becomes the uniform interface of potentially many WS-Resources.
With the implied resource pattern and the corresponding terminology, we can now describe our new port-types as follows:
- a
Factory
port-type that allows users to create WS-Resources. In particular, we plan a single operation for this port-type,logon()
, which takes the name of the client and returns the endpoint reference of a WS-Resource 'dedicated' to the client. - a
Stateful
port-type that defines the interface of the WS-Resources. We plan a single operation for this port-type too,aboutSF()
, which takes nothing but it is invoked with the endpoint reference of a WS-Resource.
A client may then invoke logon()
on the Factory
port-type and then use the resulting WS-Resource endpoint reference to invoke aboutSF()
on it. As we shall see, a client may also discover and use the endpoint of a WS-Resource of interest without having previously created. A couple of things to notice:
The client does not need to know about the stateful resource identifier embedded in the endpoint reference returned by the
Factory
, or otherwise 'found'. The endpoint reference identifies a WS-Resource but the inner structure of this WS-Resource as a pair (port-type,stateful resource) remains opaque to the client.
Placing
logon()
and aboutSF()
in different port-types makes sense. The first creates WS-Resources while the second defines their operations. Informally, we say that the Factory
is, like Stateless
, a stateless port-type because it does not serve as the interface of WS-Resources. For the opposite reason, we say that Stateful
is a stateful port-type.
Extending the Profile
We now enrich the service profile to reflect the existence of two new port-types.
<Resource xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <ID></ID> <Type>Service</Type> <Profile> <Description>A very simple gCube Service</Description> <Class>Samples</Class> <Name>SampleService</Name> <Packages> <Main> <Description>Describes port-types</Description> <Name>Main</Name> <Dependencies> <Dependency> <Service> <Class>Samples</Class> <Name>SampleService</Name> </Service> <Package>Stubs</Package> <Version>1.0</Version> <Scope level="GHN"/> <Optional>false</Optional> </Dependency> </Dependencies> <GARArchive>org.acme.sample.gar</GARArchive> <PortType> <Name>acme/sample/stateless</Name> <WSDL/> </PortType> <PortType> <Name>acme/sample/stateful</Name> <WSDL/> </PortType> <PortType> <Name>acme/sample/factory</Name> <WSDL/> </PortType> </Main> <Software> <Description>Describes port-type stubs</Description> <Name>Stubs</Name> <Files><File>org.acme.sample.stubs.jar</File></Files> </Software> </Packages> </Profile> </Resource>
Not much to comment about here, we just added two new PortType
elements in the description of the Main
package.
More Port-Type Interfaces
The WSDL that describes the interface of the Factory
port-type holds few surprises at this stage:
<definitions name="Factory" targetNamespace="http://acme.org/sample" xmlns:tns="http://acme.org/sample" xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:corefaults="http://gcube-system.org/namespaces/common/core/faults" xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/03/addressing" > <import namespace="http://gcube-system.org/namespaces/common/core/faults" location="../gcube/common/core/faults/GCUBEFaults.wsdl"/> <types> <xsd:schema targetNamespace="http://acme.org/sample"> <xsd:import namespace="http://schemas.xmlsoap.org/ws/2004/03/addressing" schemaLocation="../ws/addressing/WS-Addressing.xsd" /> <xsd:element name="logon" type="xsd:string" /> <xsd:element name="logonResponse" type="wsa:EndpointReferenceType"/> </xsd:schema> </types> <message name="logonInputMessage"> <part name="request" element="tns:logon"/> </message> <message name="logonOutputMessage"> <part name="response" element="tns:logonResponse"/> </message> <portType name="FactoryPortType"> <operation name="logon"> <input message="tns:logonInputMessage"/> <output message="tns:logonOutputMessage"/> <fault name="fault" message="corefaults:GCUBEFaultMessage"></fault> <fault name="fault" message="corefaults:GCUBEUnrecoverableFaultMessage"></fault> </operation> </portType> </definitions>
Just notice the following:
We use the
EndpointReferenceType
type to describe endpoint references of WS-Resources. This type is defined by the WS-Addressing standard to describe endpoint references (qualified or not), and we need to import its definition from a file that ships with gCore (WS-Addressing.xsd
); note in particular the import
directive and how it is resolved relatively to the location of the interface after service deployment (remember?).
At this stage, there is little point in looking into the schema definition of this type. gCore will offer Java objects to model and serialise qualified endpoint references, in accordance with the schema definition. We just notice here that the stateful resource identifier that qualifies an endpoint reference of a WS-Resource is an XML document with an arbitrary payload. In jargon, we speak of this element as the key of the stateful resource. In gCF, in particular, the payload of resource keys is always a plain string, such as the 'name' of clients we expect to use in the design of our
Sample
service.
The WSDL for the Stateful
port-type is also straightforward, at least for the time being.
<definitions name="Stateful" targetNamespace="http://acme.org/sample" xmlns:tns="http://acme.org/sample" xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:coretypes="http://gcube-system.org/namespaces/common/core/types" xmlns:corefaults="http://gcube-system.org/namespaces/common/core/faults"> <import namespace="http://gcube-system.org/namespaces/common/core/faults" location="../gcube/common/core/faults/GCUBEFaults.wsdl"/> <types> <xsd:schema targetNamespace="http://acme.org/sample"> <xsd:import namespace="http://gcube-system.org/namespaces/common/core/types" schemaLocation="../gcube/common/core/types/GCUBETypes.xsd"/> <xsd:element name="aboutSF" type="coretypes:VOID" /> <xsd:element name="aboutSFResponse" type="xsd:string" /> </xsd:schema> </types> <message name="aboutSFInputMessage"> <part name="request" element="tns:aboutSF"/> </message> <message name="aboutSFOutputMessage"> <part name="response" element="tns:aboutSFResponse"/> </message> <portType name="StatefulPortType"> <operation name="aboutSF"> <input message="tns:aboutSFInputMessage"/> <output message="tns:aboutSFOutputMessage"/> <fault name="fault" message="corefaults:GCUBEFaultMessage"></fault> </operation> </portType> </definitions>
Just notice the following:
The operation
aboutSF()
takes an instance of type VOID
as a way to say that it takes nothing of interest. In particular, notice how the operation does not need any explicit information to identify the stateful resource that corresponds to the requesting client; as discussed earlier the identifier will be implicitly carried by the request, in accordance with the implied resource access pattern. As to the type VOID
, this is imported from a schema document that ships with gCore (GCUBETypes.xsd
), again relatively to the location of the interface after service deployment. The schema defines VOID
and other common types, for your convenience and to promote uniform conventions in gCube.
Now store the new interfaces in the schema folder under the service location. Remember that file names and port-types must coincide:
|-SampleService |--etc |---profile.xml |---deploy-jndi-config.xml |---deploy-server.wsdd |---build.properties | |--src |---org |----acme |-----sample |------ServiceContext.java |------stateless |-------Stateless.java |------tests |-------StatelessTest.java | |--schema |---Stateless.wsdl |---Factory.wsdl [new] |---Stateful.wsdl [new] | | |--build.xml | |-Dependencies |--SampleService
Stateful Resources
Time to model stateful resources then. Inspiringly, we shall do this with objects of a Resource
class. The minimal requirements on this class are indeed minimal:
it must extend a class provided by gCF,
GCUBEWSResource
.
it must implement
initialise()
, the only abstract method of GCUBEWSResource
.
Here's a glorious Java class that does just that:
package org.acme.sample.stateful; import ... public class Resource extends GCUBEWSResource { /** Client visits.*/ private int visits; /** Client name. */ private String name; /**{@inheritDoc}*/ public void initialise(Object... args) throws Exception { if (args == null || args.length>1) throw new IllegalArgumentException(); this.setName((String) args[0]); } public String getName() {return name;} public void setName(String name) {this.name=name;} public synchronized int getVisits() {return visits;} protected synchronized void addVisit() {this.visits++;} }
As you can see, there is little that you have to do to extend GCUBEWSResource
. gCF will invoke initialise()
in the process of creating a new WS-Resource. The single parameter is an array of zero or more parameters that might be required to initialise a stateful resource (here modelled as an optional parameter for the convenience of clients that have no parameters to pass). Here we expect the name of the client associated with the resource (the client whose visits the resource will track). We perform some checks on the input parameters (there must be exactly one), and then use it to initialise the resource in the obvious way.
initialise()
works a bit like the main()
method of standard a Java application, except that it takes Object
s rather than String
s. In the latter case, the parameters are typically specified on the command line, here you will pass them in from some other part of the code, where the decision to create a WS-Resource is first made. Remember that according to our plans we will do it from the implementation of the Factory
port-type and in response to explicit client requests.
Resource
inherits far more state and behaviour than it declares. We will unveil a small part of this heirloom as we go along. For now, we only notice that the stateful resource inherits an identifier and that the inherited method getID()
is available to show it. The precise nature of this identifier depends on how the WS-Resource is created, and we will discuss it later when implementing the Factory
port-type.
Even the simplest of stateful resources must be ready for concurrent access. Although not exactly likely for our
Sample
service, many clients may target the same WS-Resource at the same time. Concurrent client visits will be assigned different threads by gCore and different threads might concurrently access the same stateful resource through the addVisit()
and getVisits()
methods. If we did not synchronise access to either of these methods our counter may then become inconsistent. Concurrency is of course a main concern when implementing a service and it is not something gCF can entirely abstract away for you.
Save Resource
in accordance with the suggested package:
|-SampleService |--etc |---profile.xml |---deploy-jndi-config.xml |---deploy-server.wsdd |---build.properties | |--src |---org |----acme |-----sample |------ServiceContext.java |------stateless |-------Stateless.java |------stateful |-------Resource.java [new] |------tests |-------StatelessTest.java | |--schema |---Stateless.wsdl |---Factory.wsdl |---Stateful.wsdl | | |--build.xml | |-Dependencies |--SampleService
Home Sweet Home
According to our plans, the Factory
port-type will create Resource
s and the Stateful
port-type will find them, use them, and change them.
Find them from where, exactly? We could hold a repository of Resource
s in the implementation of the Stateful
port-type, but a cleaner and more general approach is to have a dedicated manager of Resource
s that can be accessed from multiple port-types and for different purposes. In gCF, managers of stateful resources are called resource homes.
Writing a simple resource home is as simple as writing a simple stateful resource. However, we cannot do it as incrementally. Along with the resource home we have to introduce a context for the associated port-type, Stateful
in our case. Only so will gCF be able to link all the pieces required for state management on our behalf. In particular:
Stateful port-types must have an associated context in gCF.
Let us start from the home anyway:
package org.acme.sample.stateful; import ... public class Home extends GCUBEWSHome { /** {@inheritDoc} */ public GCUBEStatefulPortTypeContext getPortTypeContext() {return StatefulContext.getContext();} }
Notice the requirements:
The home implementation must extend a class provided by gCF,
GCUBEWSHome
.
The home implementation must implement
getPortTypeContext()
, the only abstract method of GCUBEWSHome
.
Here we return the singleton instance of StatefulContext
, where StatefulContext
is defined as follows:
package org.acme.sample.stateful; import ... public class StatefulContext extends GCUBEStatefulPortTypeContext { /** Singleton instance. */ private static GCUBEStatefulPortTypeContext cache = new StatefulContext(); /**Creates an instance, privately. */ private StatefulContext(){} /** Returns the singleton context. /* @return the context.*/ public static GCUBEStatefulPortTypeContext getContext() {return cache;} /** {@inheritDoc} */ public String getJNDIName() {return "acme/sample/stateful";} /** {@inheritDoc} */ public String getNamespace() {return "http://acme.org/sample";} /** {@inheritDoc} */ public GCUBEServiceContext getServiceContext() {return ServiceContext.getContext();} }
There is not much we have not already seen here:
- we follow the usual singleton pattern by returning always a single, eagerly created instance.
- we follow the usual template pattern to indicate the JNDI configuration entry-point for the associated port-type (
getJNDIName()
), the namespace in which the interface of the port-type was declared (getNamespace()
), and the context of the associated service (getServiceContext()
).
The only novel requirement is the following:
The contexts of stateful port-types must extend the
GCUBEStatefulPortTypeContext
, rather than the more general GCUBEPortTypeContext
. The latter gCF class will provide our context with the additional behaviour which is required by the underlying assumption of state.
Now gCF can link our home to our port-type. However, gCF will also need to do the opposite, i.e. identify the home from the port-type context. In fact, when Sample
will start up, gCF will look into the configuration of the port-type first and will need to find in it enough information to instantiate the home. We must then dedicate a new section of the JNDI file to the configuration of this port-type, as we have done earlier. In addition, we have to point to the associated resource home from there:
<service name="acme/sample/stateful"> <resource name="home" type="org.acme.sample.stateful.Home"> <resourceParams> <parameter> <name>factory</name> <value>org.globus.wsrf.jndi.BeanFactory</value> </parameter> <parameter> <name>resourceClass</name> <value>org.acme.sample.stateful.Resource</value> </parameter> </resourceParams> </resource> <environment name="frequentUserThreshold" value="3" type="java.lang.Integer" override="false" /> </service>
Notice the following:
The JNDI section contains a distinguished
resource
element that configures the resource home associated with the port-type. The terminology is a bit unfortunate here: this resource
is a 'JNDI resource', nothing to do with a stateful resource! Along with the environment
elements you have seen so far, it is one of the two modelling primitives that we can use to structure information within JNDI fields. Hopefully, this will not be too confusing.
The
resource
element must have a name
attribute with value home
. Only so, can this JNDI resource be identified as the configuration of the resource home associated with the port-type. Then it must have a type
that specifies the fully qualified name of the resource home implementation, org.acme.sample.stateful.Home
in our case;
The
resource
element must be configured with at least a small number of resourceParams
. The first resourceParam
specifies a factory
that can create an instance of the resource home we are configuring. The value of this resourceParam
is normally always the same, a pre-defined bean factory that ships with gCore. This factory expects the resource home implementation to expose setters for all the other resourceParam
s that occur under resourceParams
. The GCUBEWSHome
derived by our Home
guarantees that this is the case for all the parameters that are pre-defined in gCore (if you were to add ad-hoc configuration parameters in your resource home, then your home implementation would have to include setters for these too). In most cases, you will stick with this factory implementation. We will surely do in this Primer!
The
resourceParams
must include a resourceParam
called resourceClass
that indicates the fully qualified name of the class that implements the stateful resources managed by the resource home. This allows your home to create your stateful resource objects reflectively. Here we specify org.acme.sample.stateful.Resource
of course but we do not need to worry about using it directly. The GCUBEWSHome
we inherited from gCF will do it for us at the right time.
Since we are at it, we are throwing in some service-specific configuration, here a numeric threshold beyond which clients will belong to a Frequent User club. This is rather silly but reminds you that port-type contexts are there for your own configuration as well as the configuration required by gCF. We will use this configuration soon from the implementation of the
Stateful
port-type.
In conclusion, we have added two more pieces to the implementation of Sample
, a Home
to manage Resource
s and a StatefulContext
for the Stateful
. We have also added JNDI configuration for the Stateful
port-type, particularly information about the associated Home
. The implementation of Sample
now look as follows:
|-SampleService |--etc |---profile.xml |---deploy-jndi-config.xml [changed] |---deploy-server.wsdd |---build.properties | |--src |---org |----acme |-----sample |------ServiceContext.java |------stateless |-------Stateless.java |------stateful |-------Resource.java |-------Home.java [new] |-------StatefulContext.java [new] |------tests |-------StatelessTest.java | |--schema |---Stateless.wsdl |---Factory.wsdl |---Stateful.wsdl | | |--build.xml | |-Dependencies |--SampleService
The Factory Port-Type
With Resource
, ResourceHome
, and StatefulPortTypeContext
our back-end for state management is in place. What we are left with is now to make co-ordinate use of these classes in the implementation of the Factory
and Stateful
port-types.
Starting with the Factory
port-type:
package org.acme.sample.stateful; import... public class Factory extends GCUBEPortType { GCUBELog logger = new GCUBELog(this); /** {@inheritDoc} */ protected ServiceContext getServiceContext() {return ServiceContext.getContext();} public EndpointReferenceType logon(String name) throws GCUBEFault { try { GCUBEStatefulPortTypeContext ptcxt = StatefulContext.getContext(); GCUBEWSHome home = ptcxt.getWSHome(); GCUBEWSResourceKey key = ptcxt.makeKey(name); GCUBEWSResource resource = home.create(key,name); return resource.getEPR(); } catch (Exception e) { logger.error("unable to logon", e); throw new GCUBEUnrecoverableException(e).toFault(); } } }
As we have already seen for the Stateless
port-type, our Factory
implementation extends GCUBEPortType
and implements the getServiceContext()
method.
As to the method logon()
, notice what follows:
In accordance with its interface,
logon()
takes a String
and returns an EndpointReferenceType
, which is a Java model for the WS-Addressing's schema type mentioned in the WSDL of the port-type. EndpointReferenceType
Java type ships with gCore.
We obtain the singleton instance of the
StatefulContext
port-type and use it to retrieve the associated resource home. The method getHome()
is defined in GCUBEStatefulPortType
and our StatefulContext
has simply inherited it. The JNDI configuration of the port-type has provided enough information to gCF to implement that method on our behalf. Note also that since our Home
does not add any behaviour to the generic GCUBEWSHome
(nor would we need it here), we do not need to cast the return value of getWSHome()
to Home
but can work directly with the supertype GCUBEWSHome
.
We ask the home to create a stateful resource by invoking the method
create()
on it. This method is predefined in GCUBEWSHome
(and thus in our Home
that inherits from it). It appears to return a generic GCUBEWSResource
but there is a more specific Resource
underneath. The home has looked into the JNDI configuration of the port-type to know which class to instantiate reflectively (remember the resourceClass
configuration parameter?). In any case, we do not need to do anything specific with this resource, so we can again leave it at that without needing to cast down to the more specific Resource
.
We invoke
create()
with the identifier that we wish to give to the stateful resource and the parameters required to initialise it, here only the name of the client. This identifier is based on the name
parameter provided by the client but it's actually a GCUBEWSresourceKey
wrapper that we can ask the StatefulContext
to produce for us. The reason of wrapping our identifier into a 'key' is because we need to return it to the client and thus it needs to serialise on the wire in accordance with WS-Addressing requirements for endpoint reference qualifications. Notice that we have already introduced the notion of a WS-Resource key, check it out.
Finally, we invoke the method
getEPR()
on our resource. The method is predefined in GCUBEWSResource
and returns the endpoint reference of the WS-Resource that encapulates our resource. Then we simply return the endpoint reference to the client.
A couple of extra commonents on create()
:
create()
can accept an arbitrary number of resource initialisation parameters. If more were required, we would pass them all after the key, comma-separating them (or as an array). As we have seen earlier these parameters will end up into the initialise()
method of the Resource
class. Similarly, we could pass zero initialisation parameters (i.e. only the key) if the resource did not need any at all to initialise.
the
create()
could have also not taken a key at all (only parameters or absolutely nothing). In this case, the home would have automatically generated a key for the resource. The decision of whether to specify an identifier or not is our own to make. If we specify one, then the home will avoid creating a fresh resource if there is already one with that identifier. So, we specify a key any time we wish to reuse resources across 'semantically equivalent' requests. If this is not the required behaviour, i.e. we do not want reuse of stateful resources, then we do not pass a key to create()
. This depends of course on the semantics of our service; if reuse is a sensible option we should strive for it, as creating stateful resources might be in principle arbitrarily expensive processes. Here, rather artificially, we assume that the name is an unambiguous identifier for clients (...) and decide that if we receive many requests with the same name then we will associate all of them with the same WS-Resource.
The Stateful Port-Type
Finally we come to the consumption of WS-Resources and thus to the implementation of the Stateful
:
package org.acme.sample.stateful; import ... public class Stateful extends GCUBEPortType { private final String THRESHOLD_JNDI_NAME="frequentUserThreshold"; ... /** {@inheritDoc} */ protected ServiceContext getServiceContext() {return ServiceContext.getContext();} public String aboutSF(VOID voidType) throws GCUBEFault { ServiceContext sctx = ServiceContext.getContext(); StatefulContext pctx = StatefulContext.getContext(); try { Resource resource = this.getResource() String name = resource.getName(); StringBuilder output = new StringBuilder(); ...build output as in Stateless.about()... output.append("\nThis is your invocation N." + resource.getVisits() + "\n"); int threshold = (Integer) pctx.getProperty(THRESHOLD_JNDI_NAME); if (resource.getVisits() >= threshold) output.append("welcome in the frequent user club!"); resource.addVisit(); return output.toString(); } catch (GCUBEException e) {throw e.toFault();} catch (Exception e) {throw sctx.getDefaultException(e).toFault();} } private Resource getResource() throws ResourceException { return (Resource) StatefulContext.getContext().getWSHome().find(); } ... }
There are essentially two things to notice here:
the method
aboutSF()
behaves like about()
in the implementation of the Stateless
port-type (check any of the versions we have looked at before). The significant difference is that now we are acting in the context of a WS-Resource and thus upon an underlying stateful resource. We know by now that this resource will be implicitly identified in the endpoint reference use to call this WS-Resource, and we delegate the task to retrieve it to a private helper method getResource()
. Assuming we get one back, we increment its count of client visits and proceed with satisfying the client request. In particular, we append the current count of visits at the end of the message, consult port-type configuration via its context to decide whether we should also welcome the client to the frequent user club, and finally return the message to the client.
in
getResource()
, we delegate in turn the task to retrieve the stateful resource to the resource home, which we obtain from the context of the Stateful
port-type. We then ask the home to find the required resource, by invoking a method find()
that our Home
inherits from GCUBEWSHome
. As the invocation specifies no parameters, the home resolves it by automatically extracting the endpoint reference with which the current call was made by the client. It will then look into that reference and extract the stateful resource key and use the key to lookup the required resource. As this operation is a general one defined by GCUBEWSHome
, its return type is as generic as GCUBEWSResource
and, since we plan to invoke Resource
-specific methods, we need to down cast it before we can return a specific Resource
.
in the process of implied resource access, a few things could go wrong. The call may have been made with an unqualified endpoint reference, i.e. might have been addressed to the port-type rather than a WS-Resource that encapsulates the port-type. Even if the endpoint reference is qualified with a key, the home may still fail to find a resource with that key. This could be because one such resource never existed (the endpoint reference was somehow incorrectly built), or because it existed but it has somehow been removed. We will return later to this possibility.
With our two new port-type implementations, the service implementation ought to look as follows:
|-SampleService |--etc |---profile.xml |---deploy-jndi-config.xml |---deploy-server.wsdd |---build.properties | |--src |---org |----acme |-----sample |------ServiceContext.java |------stateless |-------Stateless.java |------stateful |-------Resource.java |-------Home.java |-------StatefulContext.java |-------Factory.java [new] |-------Stateful.java [new] |------tests |-------StatelessTest.java | |--schema |---Stateless.wsdl |---Factory.wsdl |---Stateful.wsdl | | |--build.xml | |-Dependencies |--SampleService
Building & Deploying
The service implementation is almost complete. What we are left with is to reflect the new port-types in the deployment descriptor and in the build properties.
In build.properties
we add two more wsdl
properties, though we don't need to add any namespace
property since we defined all the new interfaces in the same namespace as the first (http://acme.org/sample
):
package = org.acme.sample lib.dir = Dependencies/SampleService wsdl.1 = Stateless wsdl.2 = Stateful wsdl.3 = Factory namespace.1=http://acme.org/sample
In deploy-server.wsdd
we add two more service
sections, essentially following the same pattern used for the Stateless
port-type:
<?xml version="1.0" encoding="UTF-8"?> <deployment name="defaultServerConfig" xmlns="http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> <service name="acme/sample/stateless" provider="Handler" use="literal" style="document"> <parameter name="className" value="org.acme.sample.stateless.Stateless"/> <wsdlFile>share/schema/org.acme.sample/Stateless_service.wsdl</wsdlFile> <parameter name="allowedMethods" value="*"/> <parameter name="handlerClass" value="org.globus.axis.providers.RPCProvider"/> <parameter name="scope" value="Application"/> <parameter name="loadOnStartup" value="true"/> </service> <service name="acme/sample/factory" provider="Handler" use="literal" style="document"> <parameter name="className" value="org.acme.sample.stateful.Factory"/> <wsdlFile>share/schema/org.acme.sample/Factory_service.wsdl</wsdlFile> <parameter name="allowedMethods" value="*"/> <parameter name="handlerClass" value="org.globus.axis.providers.RPCProvider"/> <parameter name="scope" value="Application"/> <parameter name="loadOnStartup" value="true"/> </service> <service name="acme/sample/stateful" provider="Handler" use="literal" style="document"> <parameter name="className" value="org.acme.sample.stateful.Stateful"/> <wsdlFile>share/schema/org.acme.sample/Stateful_service.wsdl</wsdlFile> <parameter name="allowedMethods" value="*"/> <parameter name="handlerClass" value="org.globus.axis.providers.RPCProvider"/> <parameter name="scope" value="Application"/> <parameter name="loadOnStartup" value="true"/> </service> </deployment>
Now build and deploy service and stubs. As to the service implementation, the latest snapshot is as follows:
|-SampleService |--etc |---profile.xml |---deploy-jndi-config.xml |---deploy-server.wsdd [changed] |---build.properties [changed] | |--src |---org |----acme |-----sample |------ServiceContext.java |------stateless |-------Stateless.java |------stateful |-------Resource.java |-------Home.java |-------StatefulContext.java |-------Factory.java |-------Stateful.java |------tests |-------StatelessTest.java | |--schema |---Stateless.wsdl |---Factory.wsdl |---Stateful.wsdl | | |--build.xml | |-Dependencies |--SampleService
A Quick Test
Ok, it's time to make sure that all the pieces developed so far come together nicely. For this purpose, we will write a couple of simple test clients. The first client, CreateResource
, will invoke the logon()
operation of the Factory
port-type to create a WS-Resource. The second client, StatefulTest
will invoke the method aboutSF()
of that WS-Resource. The two clients will exchange the endpoint reference of the WS-Resource that the first creates and the second consumes. The exchange will be based on the file system: CreateResource
will serialise on file the endpoint reference of the WS-Resource it creates; StatefulTest
will deserialise the endpoint reference from that file and use it.
Starting with CreateResource
:
package org.acme.sample.tests; import ... public class CreateResource { static GCUBEClientLog logger = new GCUBEClientLog(CreateResource.class); public static void main(String[] args) throws Exception { logger.info("creating WS-Resource..."); try { EndpointReferenceType factoryEPR = new EndpointReferenceType(new AttributedURI(args[0])); FactoryPortType stub = new FactoryServiceAddressingLocator().getFactoryPortTypePort(endpoint); stub=GCUBERemotePortTypeContext.getProxy(stub,GCUBEScope.getScope(args[1])); EndpointReferenceType resourceEpr = stub.logon(args[2]); logger.trace("created resource at endpoint " + resourceEpr); FileWriter writer = new FileWriter("/tmp/resource.epr"); ObjectSerializer.serialize(writer,resourceEpr,new QName("http:/org.acme","statefulEPR")); writer.close(); } } }
The first part of the client has been already discussed when we tested the Stateless
port-type, including logging practices. We expect three
arguments: the endpoint reference of a running Factory
, a scope in which to make the call which is compatible with the targeted Factory
, and a name for the client.
We then invoke the logon()
operation and get back an endpoint reference to a WS-Resource. To store it, we invoke the serialize()
method of a utility class that ships with gCore, ObjectSerializer
, passing a FileWriter
'open' on a given file, the WS-Resource endpoint reference to serialise, and a QName
of our own invention that wraps the endpoint reference in well-formed XML.
Moving on to StatefulTest
:
package org.acme.sample.tests; import ... public class StatefulTest { static GCUBEClientLog logger = new GCUBEClientLog(StatefulTest.class); public static void main(String[] args) throws Exception { logger.info("visiting WS-Resource..."); try { FileReader reader = new FileReader("/tmp/resource.epr"); EndpointReferenceType resourceEPR= (EndpointReferenceType) ObjectDeserializer.deserialize(newInputSource(reader),EndpointReferenceType.class); reader.close(); StatefulPortType stub = new StatefulServiceAddressingLocator().getStatefulPortTypePort(resourceEPR); stub = GCUBERemotePortTypeContext.getProxy(stub, GCUBEScope.getScope(args[0])); logger.trace(stub.aboutSF(new VOID())); } } }
Here, we deserialise the resource following a process inverse to its serialisation (just take this code as boiler plate, really). The rest ought to be familiar by now, including the expectation of a scope as a test parameter.
Now, run CreateResource
once and then StatefulTest
multiple times to see the count of visits growing at each call.
With the two test clients, the service implementation ought to look as follows:
|-SampleService |--etc |---profile.xml |---deploy-jndi-config.xml |---deploy-server.wsdd |---build.properties | |--src |---org |----acme |-----sample |------ServiceContext.java |------stateless |-------Stateless.java |------stateful |-------Resource.java |-------Home.java |-------StatefulContext.java |-------Factory.java |-------Stateful.java |------tests |-------StatelessTest.java |-------CreateResource.java [new] |-------StatefulTest.java [new] | |--schema |---Stateless.wsdl |---Factory.wsdl |---Stateful.wsdl | | |--build.xml | |-Dependencies
WS-Resources and Standard Interfaces
At this stage, we have succesfully implemented the implied resource pattern promoted by WSRF. This is of value in itself, as a clean design approach to state identification and access. As discussed earlier on, however, the pattern opens possibilities for generic manipulations of state oriented towards discovery, lifetime management, and notification management. To move in that direction, we need to expose a uniform description of the WS-Resources and also augment their interfaces and implementations with generic operations. If we don't do this, the state will be uniformly accessible in principle, but it will also remain utterly opaque and inaccessible to generic clients.
WS-Resource Properties
WSRF proposes a standard for exposing state as an unordered set of Resource Properties. A Resource Property, or RP for short, is any piece of information that we wish to make public about our WS-Resources. A RP may be statically or dynamically computed, it may be constant or else change over time or not, it may occur once or many times, and it may or may not have internal structure. What it does matter is that a RP has a name that clients can use to refer to it.
In our example, we may decide to consider the name of the client associated with a WS-Resource as a single-valued and constant RP. Instead, we may decide to consider the number of client visits as a piece of private state and not expose it as a RP at all. In fact, unknown to us, our WS-Resources already include some 'hidden' state modelled as RPs. gCF augmented them implicitly with RPs that describe various systemic properties of the WS-Resources (e.g. the scope in which they operate, the identifier of the gHN in which they are hosted, the name and class of the service to which they belong, etc.). Collectively, we refer to these pre-defined RPs as the gCube RPs.
gCube RPs and service-specific RPs collectively form the public state of our WS-Resources, something that generic clients can target without knowing anything more specific about our WS-Resources. To actually act upon our WS-Resource, WSRF also defines standard interfaces with which clients can access, query, and change RPs. gCube has in turn implemented many key infrastructure-wide mechanisms that make use of these interfaces, and thus is important that our WS-Resources implement them. We don't need to worry too much about the cost of compliance, however, because gCF offers pre-defined implementations that can be 'plugged' into our services. Effectively, these implementations extend the stateful port-types with support for the operations defined in the WSRF interfaces. In particular, gCF defines one such implementation, called the gCube Provider, that supports the minimal set of WSRF operations that are mandatory for the WS-Resource of all gCube services.
To extend a stateful port-type with the gCube Provider, we need to perform three steps:
- extend the interface of the stateful port-type with the interface of the gCube Provider.
- extend the implementation of the stateful port-type with the implementation of the gCube provider.
- model the state of stateful resources as RPs.
After completing these three steps we will have added the operations of the gCube Provider to the stateful port-type and will have linked them to the implementation of our stateful resources. In other words, clients will be able to invoke the operations of the gCube Provider and the implementations of these operations will be able to access our stateful resources. As a net result, our WS-Resources will have become compliant with WSRF and thus with gCube. No small feat.
Let us now go through these steps for our Sample
service.
Extending WS-Resource Interface & Implementation
We start by extending the interface of the Stateful
port-type with the interface of the gCube Provider. In the WSDL of the Stateful
port-type we must proceed as follows:
we must first include a schema description of the available RPs in the WSDL of the port-type, where a generic client that obtains the WSDL can in principle discover them. This effectively amounts to describing the public state of our WS-Resources as a well-formed XML document, what WSRF calls the Resource Property Document (RPD). The RPD description is always a global, complex element which we are otherwise free to name. In our case, the element is called
statefulRPD
and includes the description of a single-valued RP called Name
:
<xsd:element name="statefulRPD"> <xsd:complexType> <xsd:sequence> <xsd:element ref="tns:Name" minOccurs="1" maxOccurs="1"/> </xsd:sequence> </xsd:complexType> </xsd:element>
we must add two special attributes to the
portType
element of the WSDL. The first points generic clients to the statefulRPD
element, so that they can identify it within the WSDL. The second indicates our will to extend the port-type interface with the operations defined in the WSDL of the gCube Provider. Clearly, we need also to import the new namespaces that come into play and bind them to some suffixes in the top-level definitions
element of the WSDL:
<definitions name="Stateful" .... xmlns:wsdlpp="http://www.globus.org/namespaces/2004/10/WSDLPreprocessor" xmlns:wsrp="http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceProperties-1.2-draft-01.xsd" xmlns:provider="http://gcube-system.org/namespaces/common/core/porttypes/GCUBEProvider"> ... <import namespace="http://gcube-system.org/namespaces/common/core/porttypes/GCUBEProvider" location="../gcube/common/core/providers/GCUBEProvider.wsdl"/> ... <portType name="StatefulPortType" wsdlpp:extends="provider:GCUBEProvider" wsrp:ResourceProperties="tns:statefulRPD"> ...
We now move to extending the implementation of the Stateful
port-type with the implementation of the gCube Provider. This will not require us to change any code, only the deployment descriptor of the Stateful
port-type. In particular:
we must add the following
parameter
to the service
dedicated to the port-type (in no particular place):
<parameter name="providers" value="GCUBEProvider"/>
That's it. Now when the operations of the gCube Provider are invoked on our Stateful
port-type their original implementations will be found and executed.
Modelling State as Resource Properties
One last step to complete the integration of the gCube Provider in our service implementation: when an operation of the gCube Provider is invoked on our Stateful
port-type, its implementation will try to access our stateful resources. The problem is that it will do so in terms of the abstractions it knows about, namely RPs.
Although our Resource
class defines a String
-valued field that corresponds to the Name
RP we have declared in the WSDL, the gCube Provider has no idea that this field corresponds to the RP, nor does it know what fields correspond to RPs and what fields are instead meant to be private state.
The cleanest and most general solution here is to comply with the provider's expectations and move from a String
-based model of client names to a more explicit RP-based model.
gCF offers classes to model RPs as well as a class to group RPs into a single container, the so-called Resource Property Set of the WS-Resource. The gCube Provider will then expect our Resource
class to expose the RP Set and then it will work with the RP objects it finds within it. In practice, the GCUBEWSResource
class extended by our Resource
class takes care of most requirements. All we have to do is:
indicate the names of the RPs. We do so by overriding the method
getPropertyNames()
inherited from GCUBEWSResource
and returning the names into an array of String
s:
private static final String NAME_RP_NAME = "Name"; ... /** {@inheritDoc} */ protected String[] getPropertyNames() {return new String[]{NAME_RP_NAME};}
refactor accessor methods in terms of RP objects:
public String getName() { return (String) this.getResourcePropertySet().get(NAME_RP_NAME).get(0); } public void setName(String name) { ResourceProperty property = this.getResourcePropertySet().get(NAME_RP_NAME); property.clear(); property.add(name); }
As you can see, we first obtain the whole RP Set (inherited method getResourcePropertySet()
), and then use it to lookup by name the required RP (method get()
).
As RPs may be multi-valued, working with RP objects is similar to working with lists; we obtain the single-value of our Name
property as the first element of the list (method get()
), and we set it by first emptying the list (method clear()
)) and then adding to it in the next place available, which is again the first (method set()
). As the accessors are no longer atomic operations we also synchronise them. Once the accessors have been re-factored in terms of RP objects, the rest of the code can remain unchanged.
After all these changes, our service implementation will look as follows:
|-SampleService |--etc |---profile.xml |---deploy-jndi-config.xml |---deploy-server.wsdd [changed] |---build.properties | |--src |---org |----acme |-----sample |------ServiceContext.java |------stateless |-------Stateless.java |------stateful |-------Resource.java [changed] |-------Home.java |-------StatefulContext.java |-------Factory.java |-------Stateful.java |------tests |-------StatelessTest.java |-------CreateResource.java |-------StatefulTest.java | |--schema |---Stateless.wsdl |---Factory.wsdl |---Stateful.wsdl [changed] | | |--build.xml | |-Dependencies
More Testing
After a new build and deployment of the service, we are ready to test the novelties. Here, we pretend to be generic clients and check whether the RPs of our WS-Resources can be accessed using the generic WSRF interfaces. In practice, we may well never need to act as generic clients. And yet some of the services we might interact with may take advantage of the standard interfaces and offer no other means to explore the state of their WS-Resources; in other words, they may treat specific and generic clients in the same way (no methods like getName()
on their port-type interfaces!). In any case, we need to test that we are truly compliant with WSRF and gCube requirements.
There are two ways to approach testing here. We can go down the usual programmatic route, or else use some pre-defined clients that ship with gCore.
In the first case, our testing client for the Stateful
port-type may contain code such as the following:
StatefulPortType statefulPT = new StatefulServiceAddressingLocator().getStatefulPortTypePort(..some-endpoint-reference..); logger.info(statefulPT.getResourceProperty(new QName("http://acme.org/sample","Name")).get_any()[0]);
where getResourceProperty
is just one of the standard operations defined by the WSDLs interface that our Stateful
port-type 'inherits' by the gCubeProvider.
The operation returns the RP named in input, although it is rather unimportant here to get into the details of its signature. For testing purposes, it suffices to confirm that we get back something logged as:
2009-04-22 16:16:17,816 INFO tests.StatefulTest [main,info:78] StatefulTest: <ns1:Name xmlns:ns1="http://acme.org/sample">...the current value of the RP...</ns1:Name>
The second and simplest way to test our port-type's compliance with WSRF is through scripts that launch pre-defined WSRF clients, one for each operation of the WSRF interfaces that the gCube Provider, and now our Stateful
port-type, implements. In what follows, for example, we show the invocation of a script that queries all the RPs of a WS-Resource whose endpoint is stored in a given file (incidentally, the same file produced by our test client CreateResource
). Do notice that our Name
RP co-exists with all the gCube RPs added by gCF.
...> wsrf-query -e /tmp/stateful.epr <ns1:statefulRPD xmlns:ns0="http://acme.org/sample" xmlns:ns1="http://gcube-system.org/namespaces/common/core/porttypes/GCUBEProvider" xmlns:ns2="http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime-1.2-draft-01.xsd" xmlns:ns3="http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <ns1:RI>6feeeed0-2f37-11de-92c8-a326c1a4b1b6</ns1:RI> <ns1:ServiceID>d202da90-2f38-11de-9805-a99465896164</ns1:ServiceID> <ns1:ServiceName>SampleService</ns1:ServiceName> <ns1:GHN>12994620-2e80-11de-b393-a6908a641d8e</ns1:GHN> <ns1:ServiceClass>Samples</ns1:ServiceClass> <ns1:Scope>/gcube/devsec</ns1:Scope> <ns1:CurrentTime xmlns:ns1="http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime-1.2-draft-01.xsd"> 2009-04-22T15:17:20.426Z</ns1:CurrentTime> <ns1:TerminationTime xsi:nil="true" xmlns:ns1="http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime-1.2-draft-01.xsd"/> <ns1:FixedTopicSet xmlns:ns1="http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-1.xsd">false</ns1:FixedTopicSet> <ns1:TopicExpressionDialects xmlns:ns1="http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd"> http://docs.oasis-open.org/wsn/2004/06/TopicExpression/Simple</ns1:TopicExpressionDialects> <ns1:Name xmlns:ns1="http://acme.org/sample">...the current value of the RP...</ns1:Name> </ns1:statefulRPD>
You can find more WSRF scripts junder
$GLOBUS_LOCATION/bin
. You can also find more information about the operations of RP-oriented WSRF interfaces in the definition of the corresponding standard.
The Lifetime of WS-Resources
Besides operations that deal directly with RPs, WSRF defines also an interface for the destruction of entire WS-Resources. This means that an important aspect of their lifetime management can now be handled remotely. Needless to say, gCube requires compliance with this interface too. The gCube provider implements the interface, however, so we have already done everything we need to do to comply with this further requirement.
There are two forms of destruction contemplated by WSRF, immediate and scheduled. To destroy a WS-Resource immediately it suffices to invoke a destroy()
operation on it, as shown in the following example:
StatefulPortType statefulPT = new StatefulServiceAddressingLocator().getStatefulPortTypePort(epr); statefulPT = GCUBERemotePortTypeContext.getProxy(statefulPT, ...some scope of the WS-Resource...")); statefulPT.destroy(new Destroy());
Two things to notice here:
The destruction of a WS-Resource must be relative to a scope, as the WS-Resource might operate in multiple scopes. We must then set a scope on the proxied stub of the
Stateful
port-type prior to invoking the destroy()
operation on it. Furthermore, the scope must be compatible with those in which the WS-Resource operates, or the invocation will result in a fault.
At the server's side, the gCube Provider executes the operation by invoking a method
remove()
that our Home
inherits from GCUBEWSHome
. You can also invoke this method from within the service implementation if, for some conditions that are specific to the semantics of your WS-Resources, you can conclude that it's time to remove any given one from one or more of its scopes.
The second form of destruction occurs implicitly when WS-Resources pass their 'expiry date'. By default, the are all born without a time to live, but you can rectify things if the semantics of your WS-Resources requires it. To do this, just define a lifeTime
environment in the JNDI configuration of your stateful port-type. In the following example, WS-Resources are granted a time to live of 30 seconds:
<environment name="lifeTime" value="30" type="java.lang.Integer" override="false"/>
When a WS-Resource is created, it first checks for the existence of a lifeTime<code> environment in the configuration of the associated stateful port-type. If it finds it, it adds the lifetime value to the current time and stores the resulting termination time in a dedicated gCube RP, called unsurprisingly <code>TerminationTime
. This is behaviour that all your WS-Resources inherit from gCF's GCUBEWSResource
class.
The termination time of a WS-Resource can then be acted upon in a number of ways. First and foremost, the resource home will periodically check the termination time of all the WS-Resources that it manages. It will then remove those that it finds expired, and it will do so from all the scopes in which they currently operate. Again, this is behaviour that all resource homes inherit from gCF's GCUBEWSHome
class.
Besides the resource home, you can also act upon the termination time of WS-Resources, typically to give them a new lease of life. Interestingly, remote clients can do the same! The same WSRF interface that offers the destroy
operation, offers also operations to extend the lifetime of WS-Resources. As usual, the gCube provider implements these operations and so do all the stateful port-types that extend the gCube Provider. Again, the details of these operations are beyond the scope of this Primer, so check out the standard for precise instructions.
Persistence for WS-Resources
How does a resource home keep track of the stateful resources it manages? Where does it retrieve them from when we ask for those required to satisfy client requests?
By default, all resource homes keep their stateful resources in good old memory. Our Home
was no exception in this respect.
This transient mode of operation guarantees the fastest access to state, of course, but it does not take long to see shortcomings too:
- the resources vanish as soon as the gHN experiences some downtime. This will bite at development time, when you are likely to start and stop the gHN at the rhythm of changes to the service implementation. It will then bite much more in production, where gHNs may be brought temporarily down for maintenance (e.g. upgrades), and for all sorts of failures of course. If our stateful resources are transient, all these scenarios will translate into the need for re-staging your service. For serious gCube services, this is a lenghty, error-prone, and costly process.
- the resources may ultimately clog your memory, depending on their size and number, and the overall performance of your service may degrade accordingly.
For these reasons, it is important that resource homes can operate in a persistent mode, i.e. rely on some longer-term storage medium to store their stateful resources.
Implementing persistence is not exactly a trivial task, because it impacts on virtually all other faces of state management. Fortunately, gCF hides most of the complexity from you.
It can do it all by itself, however, so you need to help in the way of configuration and, yes, some implementation too. We consider these requirements in the process of adding persistence for the WS-Resources of the Sample
service.
Persistence Delegates
Resource homes will rely on a separate object to store and load their stateful resources from long-term storage. This object is dedicated to persistence and is called the persistence delegate. gCF defines a whole framework for the design of persistence delegates, where different types of delegates can target different types of persistent stores. As long as you are happy with the file system as the persistence store, then you do not have to design a persistence delegate from scratch but can derive it from gCF's GCUBEWSFilePersistenceDelegate
. To do this, you must do the following:
you must override the
onStore()
method to explicitly store in a ObjectOutputStream
the properties of a stateful resource that you care to persist.
you must override the
onLoad()
method to explicitly restore from a ObjectInputStream
the properties of a stateful resource, in the exact order in which you persisted them in onStore()
of course.
The following example illustrates the point for our Resource
s, where both client name and visit count need to be persisted:
package org.acme.sample.stateful; import... public class ResourcePersistenceDelegate extends GCUBEWSFilePersistenceDelegate<Resource> { protected void onLoad(Resource resource,ObjectInputStream ois) throws Exception { /** {@inheritDoc} */ super.onLoad(resource,ois); resource.setName((String)ois.readObject()); int visits = (Integer)ois.readObject(); for (int i =0; i<visits; i++) resource.addVisit(); } /** {@inheritDoc} */ protected void onStore(Resource resource,ObjectOutputStream oos) throws Exception { super.onStore(resource,oos); oos.writeObject(resource.getName()); oos.writeObject(resource.getVisits()); } }
Notice the following:
GCUBEWSFilePersistenceDelegate
is parametric in the type of stateful resource that it handles. Accordingly, ResourcePersistenceDelegate
instantiates the type parameter to Resource
:
public class ResourcePersistenceDelegate extends GCUBEWSFilePersistenceDelegate<Resource> {...}
onStore()
and onLoad()
must delegate to the methods they override in GCUBEWSFilePersistenceDelegate
, so as to ensure that the gCube RPs are stored/loaded before more specific properties of the stateful resource. You can do this at the beginning or at the end of the methods, as long as you are consistent across the two methods. The usual convention is to do it straight away.
onStore()
and onLoad()
invoke the accessors of the Resource
they are storing and loading. As we have seen earlier, these accessors may well encapsulate access to RPs. You can here happily abstract over the way in which stateful resources store their state in memory.
Synchronisation issues are taken care of by gCF, in the context in which callbacks to your methods are issued. So no need to worry about that.
Where are our
Resource
s actually stored on the file system? Stateful resources are always stored under your home directory, in a file named with the plain identifier of the resource (not the key), with a wsresource
suffix, and in a directory with the following path:
<homedir>/.gcore/persisted/<hostname>-<port>/<servicename>/<resourceclassname>
In our example, a Resource
with identifier johndoe
may be stored in ~/.gcore/persisted/myhost.org-8080/SampleService/Resource/johndoe.wsresource
.
The next requirement is to let the resource home know about the existence of ResourcePersistenceDelegate
. We do this by adding a new parameter
element to the JNDI configuration of our Home
, as follows:
<resource name="home" type="org.acme.sample.stateful.Home"> <resourceParams> <parameter> <name>factory</name> <value>org.globus.wsrf.jndi.BeanFactory</value> </parameter> <parameter> <name>resourceClass</name> <value>org.acme.sample.stateful.Resource</value> </parameter> <parameter> <name>persistenceDelegateClass</name> <value>org.acme.sample.stateful.ResourcePersistenceDelegate</value> </parameter> </resource>
just notice that:
we must name the parameter
persistenceDelegateClass
and specify the fully qualified name of the ResourcePersistenceDelegate
class as its value.
There is of course one question that still needs to be answered. Who calls the onStore()
and onLoad()
methods of our ResourcePersistenceDelegate
? And when does this happen?
onLoad()
is invoked transparently by our Home
whenever a Resource
is needed and yet cannot be found in memory. Before giving up and concluding that the Resource
does not exist (or never did), the resource home will check for its existence on the persistence store targeted by our ResourcePersistenceDelegate
.
When is a resource not found in memory then? The first and foremost case is when the gHN has been restarted of course. We call this first-time load a hard load. All your stateful resources will be automatically reloaded at gHN startup. The other important case will become clearer in a Persistence Modes#moment, and it won't assume a gHN restart. We call these soft loads.
onStore()
is invoked by a related method store()
that our Resource
class inherits from GCUBEWSResource
. However, we are entirely responsible to invoke store()
on our Resource
s. Why is down to us? Well, because no one else knows when the state of our Resource
s changes and thus when they become stale in the persistent store. Typically, we will want to do this right at the end of any process that causes or is very likely to cause changes. In our example, we will want to store a Resource
after it has been created and right after each client visit. We will then need to change the implementation of the logon()
method of our Factory
port-type implementation as follows:
package org.acme.sample.stateful; import... public class Factory extends GCUBEPortType { ... public EndpointReferenceType logon(String name) throws GCUBEFault { try { ... GCUBEWSResource resource = home.create(key,name); resource.store(); return resource.getEPR(); } catch (Exception e) { ... } } }
We will also need to revise the implementation of the method aboutSF()
in our Stateful
port-type implementation, as follows:
package org.acme.sample.stateful; import... public class Stateful extends GCUBEPortType { ... public String aboutSF(VOID voidType) throws GCUBEFault { ... try { Resource resource = this.getResource() String name = resource.getName(); ... resource.addVisit(); resource.store(); return output.toString(); } catch (GCUBEException e) {...} catch (Exception e) {...} } ... }
A word of caution now:
You may be tempted to add an invocation of
store()
inside the addVisit()
of the Resource
class. More generally, you may consider to concentrate storing operations as close as possible to the point of change, in the accessors of the mutable properties of your stateful resources. Don't do it. This is a bad idea, for a number of reasons. First, it is potentially inefficient, as you may end up storing multiple times in a process that makes many fine-grained changes simultaneously. Second, the accessors are invoked during the loading of your stateful resources, as you have seen in the implementation of onLoad()
. This means that your resources would be stored as they are been loaded, which may be disastrous and is surely inefficient. Store instead as late possible, just before closing the process (typically, but not always, before returning to the client).
Persistence Modes
Given the pros and cons of memory-based storage, the interpretation of the persistence requirement may actually vary:
- we may want to guard our services from gHN downtime and retain maximum speed of access. In this case, we would like to rely on a persistent store to backup our resources, while keeping them in memory all the time. Perhaps we do not have huge resources, perhaps they are short-lived, perhaps we have arranged for deployment on memory-rich machines. What we really cannot loose is performance. In all these cases, we say that the requirement is for a resource home that operates in a hard persistence mode.
- alternatively, we may be happier with a more balanced compromise between memory consumption and access speed. We may accept that, while all stateful resources are still persistently stored to cope with gHN downtime, any of them may exist only in the persistent store. In particular, we may accept that a stateful resource remains in memory for a time that is proportional to the amount of available memory. The resource would then be transferred back to memory only and precisely when it is needed by clients, clearly with some delay. In this case, we say that the requirement is for a resource home that operates in a soft persistence mode.
- as a more refined compromise between memory consumption and access speed, we may wish that stateful resources remain in memory for a time that is proportional to the amount of available memory as well as the frequency with which they are used. In other words, we may require that stateful resources that are consumed often stay in memory for longer, and thus are more likely to be accessed quickly. In this case, we say that the requirement is for a resource home that operates in a cached persistence mode because the resource home keeps a cache of frequently used resources that forces them to stay in memory.
Resource homes in gCF can support all three modes of persistence. By default, configuring a persistence delegate for the resource home will make it operate in soft persistence mode. The other two modes can be easily configured as follows:
To configure a cached persistence mode, add a
cacheTimeout
parameter to the JNDI resource that configures the resource home, specifying the time in milliseconds after which a resource which has not been needed is kicked out of the cache:
<resource name="home" type="org.acme.sample.stateful.Home"> <resourceParams> <parameter> <name>factory</name> <value>org.globus.wsrf.jndi.BeanFactory</value> </parameter> <parameter> <name>resourceClass</name> <value>org.acme.sample.stateful.Resource</value> </parameter> <parameter> <name>persistenceDelegateClass</name> <value>org.acme.sample.stateful.ResourcePersistenceDelegate</value> </parameter> <parameter> <name>cacheTimeout</name> <value>60000</value> </parameter> </resource>
To configure a hard persistence mode, simply specify a value of 0 for the
cacheTimeout
parameter just discussed above.
After the changes induced by persistence, the snapshot of your service implementation ought to be as follows:
|-SampleService |--etc |---profile.xml |---deploy-jndi-config.xml [changed] |---deploy-server.wsdd |---build.properties | |--src |---org |----acme |-----sample |------ServiceContext.java |------stateless |-------Stateless.java |------stateful |-------Resource.java |-------Home.java |-------StatefulContext.java |-------Factory.java |-------Stateful.java |-------ResourcePersistentDelegate.java [new] |------tests |-------StatelessTest.java |-------CreateResource.java |-------StatefulTest.java | |--schema |---Stateless.wsdl |---Factory.wsdl |---Stateful.wsdl | | |--build.xml | |-Dependencies
Publishing WS-Resources
The first and foremost motivations for adopting WSRF standards in gCube concerns the publication of WS-Resources. Publishing a WS-Resource means to publish the values of its RPs with the gCube Information Services. The reason for doing so is to allow clients to dynamically discover the WS-Resource by querying the Information Services for the existence or current value of RPs. The Information Services themselves are thus a distinguished example of the class of generic clients for which we have bothered to adopt WSRF standards in the first place. We deal with WS-Resource publication here and discuss discovery later and in a much broader context.
gCF takes care of WS-Resource publication. All home resources, in particular, inherit from the GCUBEWSHome
the ability to publish a WS-Resource right after its initialisation. In response, the Information Services will come back at regular intervals and poll the WS-Resource via its WSRF interfaces to check that it is still alive and to get the latest value of its RPs. If the WS-Resource is not available after a number of attempts, its publication expires. When persistence is enabled, however, the unavailability of a WS-Resource may not be due to its actual destruction, but simply a gHN that is temporarily down. For this reason, the resource home will republish at start-up all the WS-Resources that it manages persistently. Furthermore, the resource home will take the initiative and signal the destruction of a WS-Resource to the Information Services as soon as this happens.
There is still something that is left to us, however. We need to tell the resource home:
- what RPs we wish to actually publish (typically all those we cared to define);
- how often we wish our RPs to be polled by the Information Services (depending on the frequency with which we expect our RPs to change).
We do both things via configuration. First we fill a dedicated 'registration' template and store it in a file in the <etc> folder of our service implementation, say registration.xml
. For the WS-Resources that encapsulate our Stateful
port-type, for example, the registration file may look as follows:
<ServiceGroupRegistrationParameters xmlns:sgc="http://mds.globus.org/servicegroup/client" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/03/addressing" xmlns:agg="http://mds.globus.org/aggregator/types" xmlns="http://mds.globus.org/servicegroup/client"> <RefreshIntervalSecs>60</RefreshIntervalSecs> <Content xsi:type="agg:AggregatorContent"> <agg:AggregatorConfig> <agg:GetMultipleResourcePropertiesPollType xmlns:sample="http://acme.org/sample"> <agg:PollIntervalMillis>60000</agg:PollIntervalMillis> <agg:ResourcePropertyNames>sample:Name</agg:ResourcePropertyNames> <agg:ResourcePropertyNames>sample:Visits</agg:ResourcePropertyNames> </agg:GetMultipleResourcePropertiesPollType> </agg:AggregatorConfig> <agg:AggregatorData/> </Content>
This is mostly a boiler plate format defined by the technologies that underlie gCube publication mechanisms. We just notice the following:
we must specify the polling interval as the value in milliseconds of the
PollIntervalMillis
element. Here we opted for a minute.
we must explicitly list the RPs that wish to have published as the values of the
ResourcePropertyNames
. Do note that the values include the namespace of the Stateful
port-type, and that this namespace is bound to the local default namespace.
The second piece of configuration we need is in the JNDI configuration of the Stateful
port-type. We have seen an example of JNDI resource
before, here is another one:
<resource name="publicationProfile" type="org.gcube.common.core.state.GCUBEPublicationProfile"> <resourceParams> <parameter> <name>factory</name> <value>org.globus.wsrf.jndi.BeanFactory</value> </parameter> <parameter> <name>fileName</name> <value>registration.xml</value> </parameter> </resourceParams> </resource>
we must name the configuration
publicationProfile
and we must give it a type of org.gcube.common.core.state.GCUBEPublicationProfile
. This is the class of the object that will model this piece of configuration at runtime.
we must specify a
param
called factory
that specifies the class responsible for creating the GCUBEPublicationProfile
object that models this piece of configuration at runtime. As usual, this is not expected to change from service to service.
finally, we must specify a
param
called fileName
that specifies the name of the registration file.
Finally, notice the following:
WS-Resource publication is not mandatory. If WS-Resources are meant to be generated and consumed by a single client and for the purposed of some fairly short-lived task, then sharing them within the infrastructure may simply not be a requirement. In these cases, simply avoid any configuration (the
publicationProfile
and, subsequently, the registration file) and gCF will understand your intentions. Of course you can also temporarily disable publication by keeping all your configuration but commenting out the publicationProfile
.
With publication configured, your service implementation ought to look as follows:
|-SampleService |--etc |---profile.xml |---deploy-jndi-config.xml [changed] |---deploy-server.wsdd |---build.properties |---registration.xml [new] | |--src |---org |----acme |-----sample |------ServiceContext.java |------stateless |-------Stateless.java |------stateful |-------Resource.java |-------Home.java |-------StatefulContext.java |-------Factory.java |-------Stateful.java |-------ResourcePersistenceDelegate.java |------tests |-------StatelessTest.java |-------CreateResource.java |-------StatefulTest.java | |--schema |---Stateless.wsdl |---Factory.wsdl |---Stateful.wsdl | | |--build.xml | |-Dependencies