Globus Toolkit 4 的预先体验版：WSRF

				
<wsa:EndpointReference>
	<!-- Web Service address over a network endpoint -->
	<wsa:Address>
		http://helloworld.com/myWebService
	</wsa:Address>

	<!-- Meta Data -->
	<!-- Endpoint reference properties -->
	<wsa:ReferenceProperties>
		<tns:resourceID> ID-12345 </tns:resourceID>
	</wsa:ReferenceProperties>
</wsa:EndpointReference>

				
<?xml version="1.0" encoding="UTF-8"?>
<definitions name="LIF"
    targetNamespace="http://lif.com"
    xmlns:tns="http://lif.com"
    xmlns:wsa="http://schemas.xmlsoap.org/ws/2004/03/addressing"
    xmlns="http://schemas.xmlsoap.org/wsdl/"
    xmlns:gtwsdl="http://www.globus.org/namespaces/2004/01/GTWSDLExtensions"
    xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
    xmlns:wsrlw=
"http://docs.oasis-open.org/wsrf/2004/06/
	wsrf-WS-ResourceLifetime-1.2-draft-01.wsdl"
    xmlns:wsrp=
"http://docs.oasis-open.org/wsrf/2004/06/
	wsrf-WS-ResourceProperties-1.2-draft-01.xsd"
    xmlns:wsrpw=
"http://docs.oasis-open.org/wsrf/2004/06/
	wsrf-WS-ResourceProperties-1.2-draft-01.wsdl"
    xmlns:wsntw=
"http://docs.oasis-open.org/wsn/2004/06/
	wsn-WS-BaseNotification-1.2-draft-01.wsdl"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema">

    <!-- LIF (Large Integer Factorization) Web Service description file -->
    <wsdl:import
        namespace=
"http://docs.oasis-open.org/wsrf/2004/06/
	wsrf-WS-ResourceProperties-1.2-draft-01.wsdl"
        location="../../../wsrf/properties/WS-ResourceProperties.wsdl" />

    <wsdl:import
        namespace=
"http://docs.oasis-open.org/wsrf/2004/06/
	wsrf-WS-ResourceLifetime-1.2-draft-01.wsdl"
        location="../../../wsrf/lifetime/WS-ResourceLifetime.wsdl" />

    <wsdl:import
        namespace=
"http://docs.oasis-open.org/wsn/2004/06/
	wsn-WS-BaseNotification-1.2-draft-01.wsdl"
        location="../../../wsrf/notification/WS-BaseN.wsdl" />

    <types>
        <xsd:schema targetNamespace="http://lif.com"
            xmlns:tns="http://lif.com"
            xmlns:xsd="http://www.w3.org/2001/XMLSchema">

            <xsd:import
                namespace=
                "http://schemas.xmlsoap.org/ws/2004/03/addressing"
                schemaLocation="../../../ws/addressing/WS-Addressing.xsd"
                />

            <xsd:element name="createLIF">
                <xsd:complexType/>
            </xsd:element>

            <xsd:element name="createLIFResponse">
               <xsd:complexType>
                 <xsd:sequence>
                   <xsd:element ref="wsa:EndpointReference"/>
                 </xsd:sequence>
              </xsd:complexType>
            </xsd:element>

            <xsd:element name="factor" type="xsd:string"/>
            <xsd:element name="factorResponse" type="xsd:string"/>

            <xsd:element name="Value" type="xsd:int"/>

            <xsd:element name="LIFRP">
                <xsd:complexType>
                    <xsd:sequence>
                        <xsd:element ref="tns:Value"
                            minOccurs="1" maxOccurs="1"/>
                    </xsd:sequence>
                </xsd:complexType>
            </xsd:element>

        </xsd:schema>
    </types>

    <message name="CreateLIFRequest">
        <part name="request" element="tns:createLIF"/>
    </message>
    <message name="CreateLIFResponse">
        <part name="response" element="tns:createLIFResponse"/>
    </message>

    <!-- factor operation input/output arguments -->
    <!-- Input is a string argument-->
    <message name="FactorInputMessage">
        <part name="parameters" element="tns:factor"/>
    </message>
    <!-- Output is a string value -->
    <message name="FactorOutputMessage">
        <part name="parameters" element="tns:factorResponse"/>
    </message>

    <portType name="LIFPortType"
        gtwsdl:implements="wsntw:NotificationProducer
                           wsrlw:ImmediateResourceTermination
                           wsrlw:ScheduledResourceTermination"
        wsrp:ResourceProperties ="tns:LIFRP">

        <!-- Operation invoked when creating the web service -->
        <operation name="createLIF">
            <input message="tns:CreateLIFRequest"/>
            <output message="tns:CreateLIFResponse"/>
        </operation>

        <!-- Factorization operation (factor) -->
        <operation name="factor">
            <input message="tns:FactorInputMessage"/>
            <output message="tns:FactorOutputMessage"/>
        </operation>
		
    </portType>
</definitions>

				
/**
 * Large Integer Factorization (LIF) WSRF Service
 * Description: A WSRF Service for large integer factorization
 *
 * @author Vladimir Silva
 */
package org.globus.wsrf.samples.lif;

import java.util.Calendar;

import javax.xml.namespace.QName;

import org.globus.wsrf.ResourceIdentifier;
import org.globus.wsrf.ResourceProperties;
import org.globus.wsrf.ResourceProperty;
import org.globus.wsrf.ResourcePropertySet;
import org.globus.wsrf.Topic;
import org.globus.wsrf.TopicList;
import org.globus.wsrf.TopicListAccessor;
import org.globus.wsrf.ResourceLifetime;
import org.globus.wsrf.WSRFConstants;
import org.globus.wsrf.impl.ReflectionResourceProperty;
import org.globus.wsrf.impl.ResourcePropertyTopic;
import org.globus.wsrf.impl.SimpleResourcePropertySet;
import org.globus.wsrf.impl.SimpleTopicList;
import org.globus.wsrf.impl.SimpleTopic;
import org.globus.wsrf.impl.SimpleResourceProperty;

/**
 * LIF Resource Implementation
 * A LIF resource is used to save the value of a specific
 * factorization
 */
public class LIF
   implements
   ResourceLifetime,
   ResourceIdentifier,
   ResourceProperties,
   TopicListAccessor {

   public static final QName KEY =
      new QName("http://lif.com", "LIFKey");
   public static final QName RP_SET =
      new QName("http://lif.com", "LIF");
   public static final QName VALUE =
      new QName("http://lif.com", "Value");

   private ResourcePropertySet propSet;
   private TopicList topicList;

   protected Calendar terminationTime = null;
   protected Object key;
   protected ResourceProperty value;

   /**
    * initialize Resource
    * @param key
    */
   protected void initialize(Object key) {
      this.key = key;
      this.propSet = new SimpleResourcePropertySet(RP_SET);
      this.topicList = new SimpleTopicList(this);
      ResourceProperty prop = null;

      try {
         this.value =
            new ResourcePropertyTopic(
            new SimpleResourceProperty(VALUE));
         this.propSet.add(this.value);
         this.topicList.addTopic( (Topic)this.value);
         this.value.add(new String());

         prop =
            new ReflectionResourceProperty(
            WSRFConstants.TERMINATION_TIME,
            this);
         this.propSet.add(prop);
         this.topicList.addTopic(
            new SimpleTopic(WSRFConstants.
                            TERMINATION_TOPIC));

         prop =
            new ReflectionResourceProperty(
            WSRFConstants.CURRENT_TIME,
            this);
         this.propSet.add(prop);
      }
      catch (Exception e) {
         throw new RuntimeException(e.getMessage());
      }
   }

   public ResourcePropertySet getResourcePropertySet() {
      return this.propSet;
   }

   public TopicList getTopicList() {
      return this.topicList;
   }

   /*
    * Methods to get or set the value of the resource
    */
   public String getValue(int idx) {
      return ( (String)this.value.get(idx));
   }

   public void setValue(String value) {
      this.value.set(0, value);
   }

   /**
    * Called when a new LIF resource is created.
    *
    * @return the resource key
    */
   public Object create() throws Exception {
      // just an example, might be a file already...
      this.key = new Integer(hashCode());
      initialize(key);
      return key;
   }

   public Object getID() {
      return this.key;
   }

   /* Service Lifetime Management methods
    *  (non-Javadoc)
    * @see org.globus.wsrf.ResourceLifetime
    #setTerminationTime(java.util.Calendar)
    */
   public void setTerminationTime(Calendar time) {
      this.terminationTime = time;
   }

   /*
    *  (non-Javadoc)
    * @see org.globus.wsrf.ResourceLifetime
    * #getTerminationTime()
    */
   public Calendar getTerminationTime() {
      return this.terminationTime;
   }

   public Calendar getCurrentTime() {
      return Calendar.getInstance();
   }
}

				
package org.globus.wsrf.samples.lif;

import java.rmi.RemoteException;
import org.apache.axis.message.addressing.EndpointReferenceType;

import org.globus.wsrf.ResourceContext;
import org.globus.wsrf.ResourceKey;
import org.globus.wsrf.utils.AddressingUtils;

import com.lif._createLIF;
import com.lif._createLIFResponse;

import javax.math.factorization.Factorizer;
import java.math.BigInteger;

/**
 * Large Integer Factorization (LIF) WSRF Service
 * Description: A WSRF Service for large integer factorization
 *
 * Service Implementation
 * @author Vladimir Silva
 */
public class LIFService {
   ResourceKey key = null;

   /**
    * OPERATION1: Fires when the Web service is created.
    * Creates a stateful resource (identified by a key)
    * and endpoint reference (EPR) which is returned
    * @param request
    * @return Response object containing an endpoint reference (EPR)
    * @throws RemoteException
    */
   public _createLIFResponse createLIF(_createLIF request) throws
      RemoteException {
      ResourceContext ctx = null;
      LIFHome home = null;

      /*
       * Create a Resource...
       */
      try {
         ctx = ResourceContext.getResourceContext();
         home = (LIFHome) ctx.getResourceHome();
         key = home.create();
      }
      catch (RemoteException e) {
         throw e;
      }
      catch (Exception e) {
         throw new RemoteException(", e);
      }

      /*
       * Add an endpoint reference to the response
       */
      EndpointReferenceType epr = null;
      try {
         epr = AddressingUtils.createEndpointReference(ctx, key);
      }
      catch (Exception e) {
         throw new RemoteException(", e);
      }

      _createLIFResponse response = new _createLIFResponse();
      response.setEndpointReference(epr);

      return response;
   }

   /**
    * OPERATION2: Find factors operation
    * @param largeInteger Large prime/integer string to be factored
    * @return Result of the form: f1^p1 * f2^p2 ... fn^pn
    * @throws RemoteException
    */
   public String factor(String largeInteger) 
   	throws RemoteException 
	{
      /*
       * Retrieve resource
       */
      Object resource = null;
      try {
         resource = ResourceContext.getResourceContext().
            getResource();
      }
      catch (RemoteException e) {
         throw e;
      }
      catch (Exception e) {
         throw new RemoteException(", e);
      }
      LIF lif = (LIF) resource;

      /*
       * Use a quadratic sieve to find factors
       */
      Factorizer f;
      try {
         // Factorize number, Timeout = 10 secs, verbose = false
         f = new Factorizer(new BigInteger(largeInteger), 10, false);
         f.factor();
      }
      catch (Exception ex) {
         throw new RemoteException("Factorizer", ex);
      }

      // save factors within the LIF resource
      lif.setValue(f.factorsAsString());
      return f.factorsAsString();
   }
}

				
package org.globus.wsrf.samples.lif.client;

/**
 * <p>Title: LIF (Large Integer Factorization) WSRF Service</p>
 * <p>Description: Large Integer Factorization service for GT4</p>
 * <p>Copyright: Copyright (c) 2004</p>
 * <p>Company: </p>
 * @author Vladimir Silva
 * @version 1.0
 */

import java.util.List;

import org.apache.axis.message.addressing.Address;
import org.apache.axis.message.addressing.EndpointReferenceType;
import org.globus.wsrf.NotificationConsumerManager;

import com.lif.LIFPortType;
import com.lif._createLIF;
import com.lif._createLIFResponse;
import com.lif.service.LIFServiceAddressingLocator;

import org.oasis.wsrf.lifetime._Destroy;

import javax.xml.rpc.Stub;
import org.globus.wsrf.impl.security.authentication.Constants;
import org.globus.wsrf.impl.security.authorization.SelfAuthorization;

import org.globus.wsrf.client.BaseClient;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.CommandLine;

/**
 * Large Integer Factorization (LIF) WSRF Service
 * Description: A WSRF Service for large integer factorization
 *
 * This class is used to create a resource which will be used
 * to save the result of a given factorization
 *
 * @author Vladimir Silva
 */
public class FactorClient
   extends BaseClient {
   public static void main(String[] args) {
      FactorClient client = new FactorClient();

      // client takes 1 arg : large integer
      client.setCustomUsage("{large integer}");

      LIFServiceAddressingLocator locator =
         new LIFServiceAddressingLocator();

      // GSI Secure Conversation, signature, 
	  // without delegation, self authz.
      String CLIENT_DESC =
         "org/globus/wsrf/samples/lif/client/client-security-config.xml";
      NotificationConsumerManager consumer = null;

      // large number to factor
      String largeInt;

      try {
         // Parse arguments: 1 arg => large number
         CommandLine line = client.parse(args);
         List options = line.getArgList();

         if (options == null || options.isEmpty()) {
            throw new ParseException("Expected large integer argument");
         }

         // get number to factor from cmd line
         largeInt = (String) options.get(0);

         // Service URL
         String servURL = line.getOptionValue("s");

         if (servURL == null) {
            servURL = "http://localhost:8080/wsrf/services/LIFService";

            // Use security? (Use security if the Service URL contains
            // Secure e.g SecureLIFService
         }
         boolean secure = (servURL.indexOf("Secure") > 0) ? true : false;

         //System.out.println("LIF service URL: " + servURL +
         //" Number:" + largeInt + " Secure:" + secure);

         // STEP1: Obtain a SOAP endpoint reference (EPR)
         // Contains the service URL and metadata
         // such as resource properties)
         EndpointReferenceType endpoint = new EndpointReferenceType();
         endpoint.setAddress(new Address(servURL));

         // STEP2: Obtain a Port (using the EPR) to create a
         // web service instance
         LIFPortType port = locator.getLIFPortTypePort(endpoint);

         if (secure) {
            ( (Stub) port)._setProperty(
               Constants.CLIENT_DESCRIPTOR_FILE,
               CLIENT_DESC);
         }

         // Create lif (Large Integer factorizer) resource
         // Returns the EPR of the new instance
         _createLIFResponse createResponse = 
		 	port.createLIF(new _createLIF());
         endpoint = createResponse.getEndpointReference();

         // STEP3: Use the new EPR to obtain a second Port used to 
         // factor the number
         LIFPortType factorPort = locator.getLIFPortTypePort(endpoint);

         if (secure) {
            // Secure message
            ( (Stub) factorPort)._setProperty(
               Constants.GSI_SEC_MSG,
               Constants.SIGNATURE);
            ( (Stub) factorPort)._setProperty(
               Constants.AUTHORIZATION,
               new SelfAuthorization());
         }

         // Show factorization result
         System.out.println(largeInt + "=" +
                            factorPort.factor(largeInt));

         // STEP3: Use the EPR to obtain a third port 
		 // to destroy the service
         LIFPortType destroyPort = locator.getLIFPortTypePort(endpoint);
         if (secure) {
            ( (Stub) destroyPort)._setProperty(
               Constants.CLIENT_DESCRIPTOR_FILE,
               CLIENT_DESC);
         }
         // Destroy the lif resource
         destroyPort.destroy(new _Destroy());

      }
      catch (Exception e) {
         e.printStackTrace();
      }
   }
}