trans.java

Trans.java 对学习globus初学者很有帮助的

package org.gridsphere.dtmanage.services;

import java.net.URL;
import java.security.cert.X509Certificate;
import java.util.Calendar;

import javax.xml.rpc.Stub;

import org.globus.axis.message.addressing.EndpointReferenceType;
import org.globus.axis.util.Util;
import org.globus.delegation.DelegationConstants;
import org.globus.delegation.DelegationUtil;
import org.globus.gsi.GlobusCredential;
import org.globus.rft.generated.BaseRequestType;
import org.globus.rft.generated.CreateReliableFileTransferInputType;
import org.globus.rft.generated.CreateReliableFileTransferOutputType;
import org.globus.rft.generated.DeleteRequestType;
import org.globus.rft.generated.RFTOptionsType;
import org.globus.rft.generated.ReliableFileTransferFactoryPortType;
import org.globus.rft.generated.ReliableFileTransferPortType;
import org.globus.rft.generated.Start;
import org.globus.rft.generated.StartOutputType;
import org.globus.rft.generated.TransferRequestType;
import org.globus.rft.generated.TransferType;
import org.globus.rft.generated.service.ReliableFileTransferFactoryServiceAddressingLocator;
import org.globus.rft.generated.service.ReliableFileTransferServiceAddressingLocator;
import org.globus.transfer.reliable.client.BaseRFTClient;
import org.globus.wsrf.impl.security.authentication.Constants;
import org.globus.wsrf.impl.security.authorization.HostAuthorization;
import org.globus.wsrf.impl.security.descriptor.ClientSecurityDescriptor;
import org.globus.wsrf.utils.AddressingUtils;
import org.oasis.wsrf.lifetime.SetTerminationTime;
import org.oasis.wsrf.lifetime.SetTerminationTimeResponse;

//import org.gridsphere.vine.util.ServiceLog;
//import org.globus.transfer.reliable.client.BaseRFTClient;

public class Trans {
	
//				private static final ServiceLog log = ServiceLog.getInstance(Trans.class);
				private static final int TERM_TIME = 1000;
				private static final String PROTOCOL="gsiftp";
				private static final String SERVICE_URL_ROOT="/tmp";
		
		/*	public String getProtocol(){
						 String PROTOCOL=DEFAULT_PROTOCOL;	//添加判定条件，获得使用的协议， 需要修改.....
						 if(!PROTOCOL.equals("gsiftp"))
							 		PROTOCOL="gsiftp";
							 
						 return PROTOCOL;
				}
				
				public String getUrl(){
						String SERVICE_URL_ROOT=SERVICE_DEFAULT_URL_ROOT;	//需要修改
						if(!SERVICE_URL_ROOT.equals(/tmp))
									SERVICE_URL_ROOT="/so";
						return SERVICE_URL_ROOT;Stub 
				}
				*/
		
			/*
			 *  Contact the Delegation Factory Service and get an EPR
			 *  for the Delegation Resource that contains your delegated credential.
			 */
				public static EndpointReferenceType delegateCredential(String host, String port)
								throws Exception {
	
					ClientSecurityDescriptor desc = new ClientSecurityDescriptor();
					// Credential to sign with, assuming default credential
					GlobusCredential credential = GlobusCredential.getDefaultCredential();
					desc.setGSISecureTransport(Constants.ENCRYPTION);//GSI_TRANSPORT
					Util.registerTransport();
					desc.setAuthz(new HostAuthorization());//('host');

					String factoryUrl = PROTOCOL + "://" + host + ":"	+ port + SERVICE_URL_ROOT
																		+ DelegationConstants.FACTORY_PATH;

					// lifetime in seconds
					int lifetime = TERM_TIME * 60;

					// Get the public key to delegate on.
					EndpointReferenceType delegEpr = AddressingUtils.createEndpointReference(factoryUrl, null);
					
					X509Certificate[] certsToDelegateOn = DelegationUtil.getCertificateChainRP(delegEpr, desc);
					
					X509Certificate certToSign = certsToDelegateOn[0];
					
					return DelegationUtil.delegate(factoryUrl, credential, certToSign, lifetime, false, desc);
					
				}
			
			
			/*
			 * Now construct a TransferRequestType Object
			 */
				public static void TransferRequest() throws Exception {
						TransferType[] transferArray = new TransferType[1];
						transferArray[0] = new TransferType();
						transferArray[0].setSourceUrl("gsiftp://tmp/so");
						transferArray[0].setDestinationUrl("gsiftp://tmp/de");
						RFTOptionsType rftOptions = new RFTOptionsType();
						rftOptions.setBinary(true);
						// You can set more options like parallel streams, buffer sizes etc
						// Refer to Public Interface guide of RFT for more details
						TransferRequestType request = new TransferRequestType();
						request.setRftOptions(rftOptions);
						request.setTransfer(transferArray);
						String host="xys.lab.upcgrid.org";				////需要修改.................................
						String port="8443";						///////////////要改..................
						request.setTransferCredentialEndpoint(delegateCredential(host,port));
				}
				
				/*
				 * Now contact the RFT factory and create an RFT resource
				 */
				public static EndpointReferenceType createRFT(String rftFactoryAddress,
			            BaseRequestType request) throws Exception {
						URL endpoint = new URL(rftFactoryAddress);
						ReliableFileTransferFactoryServiceAddressingLocator rftFactoryLocator
											=new ReliableFileTransferFactoryServiceAddressingLocator();
						
						ReliableFileTransferFactoryPortType factoryPort
											= rftFactoryLocator.getReliableFileTransferFactoryPortTypePort(endpoint);
						
						CreateReliableFileTransferInputType input = new CreateReliableFileTransferInputType();
			     //input.setTransferJob(transferType);
			     if(request instanceof TransferRequestType) {
			    	 				input.setTransferRequest((TransferRequestType)request);
			        		} 
			     else {
			    	 				input.setDeleteRequest((DeleteRequestType)request);
			        		}
			     Calendar termTime = Calendar.getInstance();
			     termTime.add(Calendar.HOUR, 1);
			     input.setInitialTerminationTime(termTime);
			     BaseRFTClient.setSecurity((Stub)factoryPort);
			     CreateReliableFileTransferOutputType response = factoryPort.createReliableFileTransfer(input);

			     return response.getReliableTransferEPR();
			    }

				/*
				 * Now contact the RFT service Implementation and  
				 * call start to actually start the transfer
				 */
				public static void doTrans(String host, String port,EndpointReferenceType rftepr) throws Exception{
					
					ReliableFileTransferServiceAddressingLocator rftLocator
											= new ReliableFileTransferServiceAddressingLocator();

	//		   String rftFactoryAddress = PROTOCOL + "://"+ host+ ":" + port + SERVICE_URL_ROOT 
	//		        																+ "ReliableFileTransferFactoryService";
			   
	//				EndpointReferenceType rftepr = createRFT(rftFactoryAddress,transferType);
					
					ReliableFileTransferPortType rft 
											= rftLocator.getReliableFileTransferPortTypePort(rftepr);
					BaseRFTClient.setSecurity((Stub)rft);

					//For secure notifications
					BaseRFTClient.subscribe(rft);
					System.out.println("Subscribed for overall status");
					//End subscription code
					Calendar termTime = Calendar.getInstance();
					termTime.add(Calendar.MINUTE, TERM_TIME);
					SetTerminationTime reqTermTime = new SetTerminationTime();
					reqTermTime.setRequestedTerminationTime(termTime);
//					log.debug("Termination time to set: " + TERM_TIME + " minutes");
					System.out.println("Termination time to set: " + TERM_TIME	+ " minutes");
					SetTerminationTimeResponse termRes = rft.setTerminationTime(reqTermTime);
					StartOutputType startresp = rft.start(new Start());
	//				log.debug("RFT.start() ... done");
				}
	
}