vre-modeler/src/org/gcube/vremanagement/vremodeler/impl/thread/DeployVRE.java

package org.gcube.vremanagement.vremodeler.impl.thread;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import org.gcube.common.core.faults.GCUBEFault;
import org.gcube.common.core.resources.GCUBECollection;
import org.gcube.common.core.resources.GCUBEMCollection;
import org.gcube.common.core.resources.impl.kxml.KGCUBEResource;
import org.gcube.common.core.scope.GCUBEScope;
import org.gcube.common.core.utils.handlers.GCUBEServiceClientImpl;
import org.gcube.common.core.utils.logging.GCUBELog;
import org.gcube.vremanagement.vremanager.stubs.vremanager.AddResourcesParameters;
import org.gcube.vremanagement.vremanager.stubs.vremanager.OptionsParameters;
import org.gcube.vremanagement.vremanager.stubs.vremanager.ResourceItem;
import org.gcube.vremanagement.vremanager.stubs.vremanager.ResourceList;
import org.gcube.vremanagement.vremanager.stubs.vremanager.ScopeOption;
import org.gcube.vremanagement.vremanager.stubs.vremanager.ServiceItem;
import org.gcube.vremanagement.vremanager.stubs.vremanager.ServiceList;
import org.gcube.vremanagement.vremanager.stubs.vremanager.VREManagerPortType;
import org.gcube.vremanagement.vremodeler.db.DBInterface;
import org.gcube.vremanagement.vremodeler.impl.ModelerContext;
import org.gcube.vremanagement.vremodeler.impl.ModelerResource;
import org.gcube.vremanagement.vremodeler.impl.ModelerService;
import org.gcube.vremanagement.vremodeler.impl.util.Couple;
import org.gcube.vremanagement.vremodeler.impl.util.VREManagerServiceHandler;
import org.globus.wsrf.ResourceException;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class DeployVRE extends Thread{

	private static GCUBELog logger= new GCUBELog(ModelerService.class);
		
	private ModelerResource wsResource= null;
	private String resourceId;
	private GCUBEScope startingScope;
	private String vreName=null;	
	
	public DeployVRE(String resourceId, GCUBEScope scope){
		this.resourceId=resourceId;
		this.startingScope= scope;
	}
	
	private ModelerResource getResource() throws ResourceException{
		if (wsResource==null) wsResource= (ModelerResource)ModelerContext.getPortTypeContext().getWSHome().find(ModelerContext.getPortTypeContext().makeKey(resourceId));
		return wsResource;
	}
	
	public void run() {
		try {
			ResultSet resRelatedGHN=DBInterface.queryDB("select VRERELATEDGHN.ghnid from VRERELATEDGHN where VRERELATEDGHN.vreid='"+this.resourceId+"'; ");
			if (!resRelatedGHN.next()){
				DBInterface.ExecuteUpdate("UPDATE VRE SET STATUS='Failed' WHERE VRE.id='"+this.resourceId+"';");
			}
			String firstGHNId= resRelatedGHN.getString(1);
			List<String> GHNList= new ArrayList<String>();
			while (resRelatedGHN.next()) GHNList.add(resRelatedGHN.getString(1));
						
			deployManagerOnVRE(firstGHNId);
			createVRE(GHNList);
			logger.info("Deploying of the VRE with id "+this.resourceId+"  FINISHED");
		}catch(Exception e){
			logger.error("Error deploying the VRE with id "+this.resourceId+" "+e);
			e.printStackTrace();
		}
	}
	
	
	private void deployManagerOnVRE(String firstGHNId) throws GCUBEFault{
		String vreName= null; 
		try {
			DBInterface.ExecuteUpdate("UPDATE VRE SET STATUS='Deploying' WHERE VRE.id='"+this.resourceId+"';");
			ResultSet resGenericInfo = DBInterface.queryDB("select VRE.name from VRE where VRE.id='"+this.resourceId+"'; ");
			if (!resGenericInfo.next()) {
				throw new GCUBEFault("The VRE with ID "+this.resourceId+" cannot be retrieved on the DB");
			}
			vreName= resGenericInfo.getString(1);
			
		} catch (SQLException e) {
			logger.error("HSQLDB Error "+e);
			throw new GCUBEFault(e);
		}
		
		// Couple<GCUBEScope,Couple<String, String>>> is a triple with first GCUBEScope, second couple: first String is the VREName, second string is the GHNId 
		VREManagerServiceHandler<String, Couple<String, String>> vreManagerHandler= new VREManagerServiceHandler<String,Couple<String, String>>(){

			@SuppressWarnings("static-access")
			@Override
			protected String makeCall(VREManagerPortType mbportType)
					throws Exception {
				//System.out.println("makeCall called");
				try{
					AddResourcesParameters arp= new AddResourcesParameters();
					ServiceList services= new ServiceList();
					ServiceItem[] service= new ServiceItem[1];
					service[0]=new ServiceItem();
					service[0].setServiceClass("VREManagement");
					service[0].setServiceName("VREManager");
					service[0].setServiceVersion("1.00.00");
					services.setService(service);
					services.setGHN(new String[]{this.getParameter().second});
					arp.setServices(services);
					arp.setTargetScope(this.scope+"/"+this.getParameter().first);
					String reportId=mbportType.addResources(arp);
					
					String report;
					int attempt=0;
					do{
						Thread.currentThread().sleep(20000); 
						report=mbportType.getReport(reportId);
						attempt++;
						getResource().setReportFirstStep(report);
						System.out.println("---step 1------");
						System.out.println(report);
						System.out.println("---------");
					}while (!isDeploymentStatusFinished(report) && attempt<10);
				}catch(Exception e){e.printStackTrace(); throw e;}
				return "";
			}
		};
		
		vreManagerHandler.clearState();
		vreManagerHandler.setHandled(new GCUBEServiceClientImpl());
		Couple<String, String> coupleParams= new Couple<String, String>(vreName, firstGHNId);
		vreManagerHandler.setParameter(coupleParams);
		vreManagerHandler.scope=this.startingScope;
		
		try {
			vreManagerHandler.run();
		} catch (Exception e) {
			logger.error("DeployingVRE step 1 -- failed "+e);
			throw new GCUBEFault(e);
		}
		this.vreName= vreName;
	}
	
	
	private void createVRE(List<String> ghnList) throws GCUBEFault{
		VREManagerServiceHandler<Boolean, Couple<List<String>, String>> vreManagerHandler= new VREManagerServiceHandler<Boolean,Couple<List<String>, String>>(){
			
			//the parameter is resourceID
			@SuppressWarnings("static-access")
			@Override
			protected Boolean makeCall(VREManagerPortType vreManPortType)
					throws Exception {
				
				OptionsParameters ops;
				
				ResultSet resGenericInfo = DBInterface.queryDB("select VRE.name, VRE.vredesigner, VRE.vremanager, VRE.IntervalTo, VRE.IntervalFrom, VRE.description from VRE where VRE.id='"+this.getParameter().second+"'; ");
				if (!resGenericInfo.next()) throw new GCUBEFault("The VRE with ID "+this.getParameter()+" cannot be retrieved");
				
				ops=new OptionsParameters();
				ScopeOption[] scopeOptionList= new ScopeOption[6];
				ScopeOption soDesigner= new ScopeOption();
				soDesigner.setName("DESIGNER");
				soDesigner.setValue(resGenericInfo.getString("vredesigner"));
				scopeOptionList[0]= soDesigner;

				ScopeOption soCreator= new ScopeOption();
				soCreator.setName("CREATOR");
				soCreator.setValue(resGenericInfo.getString("vremanager"));
				scopeOptionList[1]= soCreator;

				ScopeOption soEndtime= new ScopeOption();
				soEndtime.setName("ENDTIME");
				soEndtime.setValue(KGCUBEResource.toXMLDateAndTime(resGenericInfo.getDate("IntervalTo")));
				scopeOptionList[2]= soEndtime;

				ScopeOption soStarttime= new ScopeOption();
				soStarttime.setName("STARTTIME");
				soStarttime.setValue(KGCUBEResource.toXMLDateAndTime(resGenericInfo.getDate("IntervalFrom")));
				scopeOptionList[3]= soStarttime;

				ScopeOption soDescription= new ScopeOption();
				soDescription.setName("DESCRIPTION");
				soDescription.setValue(resGenericInfo.getString("description"));
				scopeOptionList[4]= soDescription;

				ScopeOption soDisplayname= new ScopeOption();
				soDisplayname.setName("DISPLAYNAME");
				soDisplayname.setValue(resGenericInfo.getString("name"));
				scopeOptionList[5]= soDisplayname;

				ops.setScopeOptionList(scopeOptionList);
				vreManPortType.setScopeOptions(ops);
				
				//Adding the resources to the new VRE
				AddResourcesParameters arp= new AddResourcesParameters();
				ResourceList rl= new ResourceList();
				List<ResourceItem> resItemList= new ArrayList<ResourceItem>();
				//retrieving Collection
				try{
					
					ResourceItem resItem;
					ResultSet resRelatedCol =DBInterface.queryDB("select VRERELATEDCOLLECTION.collid from VRERELATEDCOLLECTION where VRERELATEDCOLLECTION.vreid='"+this.getParameter().second+"';");
					while (resRelatedCol.next()){
						resItem= new ResourceItem();
						resItem.setID(resRelatedCol.getString(1));
						resItem.setType(GCUBECollection.TYPE);
						resItemList.add(resItem);
					}
				}catch(SQLException sqle){logger.error("Error contacting HSQLDB "+sqle);}
				
				//retrieving MDCollection with native MDFormat
				try{
					ResourceItem resItem;
					ResultSet resMdColNative =DBInterface.queryDB("select s.mdcollid from SELECTEDNATIVEMDFORMAT AS s where s.vreid='"+this.getParameter().second+"';");
					while (resMdColNative.next()){
						resItem= new ResourceItem();
						resItem.setID(resMdColNative.getString(1));
						System.out.println(resItem.getID());
						resItem.setType(GCUBEMCollection.TYPE);
						resItemList.add(resItem);
					}
				}catch(SQLException sqle){logger.error("Error contacting HSQLDB "+sqle);}
				
				rl.setResource(resItemList.toArray(new ResourceItem[0]));
				arp.setResources(rl);
				
				//retrieve services
				ServiceList serviceList= new ServiceList();
				try{
					ServiceItem servItem;
					List<ServiceItem> listService= new ArrayList<ServiceItem>();
					ResultSet resMdColNative =DBInterface.queryDB("select s.name, s.class from VRERELATEDFUNCT AS vrf,  SERVICES AS s  where vrf.vreid='"+this.getParameter().second+"' AND s.id=vrf.funcid;");
					while (resMdColNative.next()){
						servItem= new ServiceItem();
						servItem.setServiceClass(resMdColNative.getString("class"));
						servItem.setServiceName(resMdColNative.getString("name"));
						servItem.setServiceVersion("1.00.00");
						listService.add(servItem);
					}
					serviceList.setService(listService.toArray(new ServiceItem[0]));
				}catch(SQLException sqle){logger.error("Error contacting HSQLDB "+sqle);}
						
				//sets the GHNs
				serviceList.setGHN(this.getParameter().first.toArray(new String[0]));
				
				
				arp.setServices(serviceList);
				
				String reportId=vreManPortType.addResources(arp);
				String report;
				int attempt=0;
				do{
					Thread.currentThread().sleep(20000); 
					report=vreManPortType.getReport(reportId);
					System.out.println("---step 2------");
					System.out.println(report);
					System.out.println("---------");
					attempt++;
					getResource().setReportSecondStep(report);
					
				}while (!isDeploymentStatusFinished(report) && attempt<20);
				return isSomethingFailed(report);
			}
		};
		
		vreManagerHandler.clearState();
		vreManagerHandler.setHandled(new GCUBEServiceClientImpl());
		vreManagerHandler.setParameter(new Couple<List<String>, String>(ghnList,this.resourceId));
		vreManagerHandler.scope=GCUBEScope.getScope(this.startingScope+"/"+this.vreName);
		try {
			vreManagerHandler.run();
		} catch (Exception e) {
			logger.error("DeployingVRE step 2 -- failed "+e);
			throw new GCUBEFault(e);
		}
			
	}
	

	/**
	 * controls if something is failed deploying 
	 * @param report the VRE deployment report
	 * @return true if Failed, else false
	 */
	private boolean isSomethingFailed(String report){
		boolean ret = false;
		String xpath = "/ResourceReport/DeploymentActivity/GHN/LastReportReceived/Packages/Package/Status";
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db;
		try {
			db = dbf.newDocumentBuilder();
			Document document = db.parse(new ByteArrayInputStream(report.getBytes()));
			XPath engine = XPathFactory.newInstance().newXPath();
			NodeList nl = (NodeList) engine.evaluate(xpath,document, XPathConstants.NODESET);
			for (int i = 0; i < nl.getLength(); i++) {
				if(nl.item(i).getFirstChild().getNodeValue().compareTo("FAILED")==0){
					return true;
				}
			}
		} catch (ParserConfigurationException e) {
			return true;
		} catch (SAXException e) {
			return true;
		} catch (IOException e) {
			return true;
		} catch (XPathExpressionException e) {
			return true;
		}
		return ret;
	}
	
	private boolean isDeploymentStatusFinished(String report) {
		boolean ret = false;
		String xpath = "/ResourceReport/DeploymentActivity/GHN/LastReportReceived/Status";
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db;
		try {
			db = dbf.newDocumentBuilder();
			Document document = db.parse(new ByteArrayInputStream(report.getBytes()));
			XPath engine = XPathFactory.newInstance().newXPath();
			NodeList nl = (NodeList) engine.evaluate(xpath,document, XPathConstants.NODESET);
			for (int i = 0; i < nl.getLength(); i++) {
				if(i==0){
					ret = true;
				}
				if(nl.item(i).getFirstChild().getNodeValue().compareTo("CLOSED")!=0){
					ret = false;
					break;
				}
			}
		} catch (ParserConfigurationException e) {
			return false;
		} catch (SAXException e) {
			return false;
		} catch (IOException e) {
			return false;
		} catch (XPathExpressionException e) {
			return false;
		}
		return ret;
	}
	
}