/*******************************************************************************
* Copyright (c) 2007, 2010 The Planets Project Partners.
*
* All rights reserved. This program and the accompanying
* materials are made available under the terms of the
* Apache License, Version 2.0 which accompanies
* this distribution, and is available at
* http://www.apache.org/licenses/LICENSE-2.0
*
*******************************************************************************/
/**
*
*/
package eu.planets_project.tb.gui.backing;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import javax.faces.context.FacesContext;
import javax.faces.model.SelectItem;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.richfaces.component.UITree;
import org.richfaces.component.html.HtmlTree;
import org.richfaces.event.NodeSelectedEvent;
import org.richfaces.model.TreeNode;
import org.richfaces.model.TreeNodeImpl;
import eu.planets_project.ifr.core.servreg.api.ServiceRegistry;
import eu.planets_project.ifr.core.servreg.api.ServiceRegistryFactory;
import eu.planets_project.ifr.core.techreg.formats.Format;
import eu.planets_project.ifr.core.techreg.formats.FormatRegistry;
import eu.planets_project.ifr.core.techreg.formats.FormatRegistryFactory;
import eu.planets_project.services.characterise.Characterise;
import eu.planets_project.services.compare.Compare;
import eu.planets_project.services.compare.CompareProperties;
import eu.planets_project.services.datatypes.MigrationPath;
import eu.planets_project.services.datatypes.ServiceDescription;
import eu.planets_project.services.identify.Identify;
import eu.planets_project.services.migrate.Migrate;
import eu.planets_project.services.view.CreateView;
import eu.planets_project.tb.api.model.Experiment;
import eu.planets_project.tb.api.model.ExperimentExecutable;
import eu.planets_project.tb.api.persistency.ExperimentPersistencyRemote;
import eu.planets_project.tb.api.persistency.ServiceRecordPersistencyRemote;
import eu.planets_project.tb.gui.backing.service.FormatBean;
import eu.planets_project.tb.gui.backing.service.PathwayBean;
import eu.planets_project.tb.gui.backing.service.ServiceRecordBean;
import eu.planets_project.tb.gui.backing.service.ServiceRecordsByFormatBean;
import eu.planets_project.tb.gui.backing.service.ServiceRecordsByNameBean;
import eu.planets_project.tb.impl.model.exec.BatchExecutionRecordImpl;
import eu.planets_project.tb.impl.model.exec.ExecutionRecordImpl;
import eu.planets_project.tb.impl.model.exec.ExecutionStageRecordImpl;
import eu.planets_project.tb.impl.model.exec.ServiceRecordImpl;
import eu.planets_project.tb.impl.persistency.ExperimentPersistencyImpl;
import eu.planets_project.tb.impl.persistency.ServiceRecordPersistencyImpl;
import eu.planets_project.tb.impl.services.Service;
import eu.planets_project.tb.impl.services.ServiceRegistryManager;
/**
* TODO Merge in the ServiceTemplates and the IF Service Registry - all endpoints only once, of course.
* TODO Add in storage of service records.
* TODO Add in service active/inactive status, and service history information.
*
* @author <a href="mailto:Andrew.Jackson@bl.uk">Andy Jackson</a>
*
*/
public class ServiceBrowser {
/** */
private static final Log log = LogFactory.getLog(ServiceBrowser.class);
/** */
public static final String CATEGORY = "category";
public static final String SERVICE = "service";
public static final String UNKNOWN_SERVICE = "Unrecognised Services";
private List<Service> services;
private TreeNode<ServiceTreeItem> rootNode = null;
private Service selectedService = null;
private FormatBean selectedInputFormat = null;
private FormatBean selectedOutputFormat = null;
private ServiceRecordBean selectedServiceRecord = null;
private List<String> selectedServiceTypes = null;
private String nodeTitle;
// Get the format registry:
public static FormatRegistry fr = FormatRegistryFactory.getFormatRegistry();
// public static Format unknown = fr.getFormatForURI( Format.extensionToURI("unknown") );
//Instantiate a registry:
ServiceRegistry registry = ServiceRegistryFactory.getServiceRegistry();
/**
*
*/
public class ServiceTreeItem {
String type;
String category;
Service service;
/**
* @param s
*/
public ServiceTreeItem(Service s) {
this.type = SERVICE;
this.service = s;
}
/**
* @param type
*/
public ServiceTreeItem(String category) {
this.type = CATEGORY;
this.category = category;
}
/**
* @return the type
*/
public String getType() {
return type;
}
/**
* @return the category
*/
public String getCategory() {
return category;
}
/**
* @return the service
*/
public Service getService() {
return service;
}
}
/**
*
* @return
*/
public List<Service> getAvailableServices() {
if( services == null )
services = ServiceRegistryManager.listAvailableServices();
return services;
}
/**
*
*/
private void loadTree() {
rootNode = new TreeNodeImpl<ServiceTreeItem>();
// For PA services
TreeNode<ServiceTreeItem> paCat = addCategoryNode("Preservation Action", rootNode );
addServiceTypeTree("Migrate", "eu.planets_project.services.migrate", paCat );
// For PC services
TreeNode<ServiceTreeItem> pcCat = addCategoryNode("Preservation Characterisation", rootNode );
addServiceTypeTree("Identify", "eu.planets_project.services.identify", pcCat );
addServiceTypeTree("Validate", "eu.planets_project.services.validate", pcCat );
addServiceTypeTree("DetermineProperties", "eu.planets_project.services.characterise", pcCat );
// For unknown/unrecognised services:
addServiceTypeTree(UNKNOWN_SERVICE, "unknown", rootNode );
}
/**
*
* @param category
* @param parentNode
* @return
*/
private TreeNode<ServiceTreeItem> addCategoryNode( String category, TreeNode<ServiceTreeItem> parentNode ) {
TreeNodeImpl<ServiceTreeItem> categoryNode = new TreeNodeImpl<ServiceTreeItem>();
categoryNode.setData( new ServiceTreeItem(category) );
parentNode.addChild(category, categoryNode);
return categoryNode;
}
/**
*
* @param type
* @param typeClass
* @param node
*/
private void addServiceTypeTree( String type, String typeClass, TreeNode<ServiceTreeItem> node ) {
TreeNodeImpl<ServiceTreeItem> categoryNode = new TreeNodeImpl<ServiceTreeItem>();
categoryNode.setData( new ServiceTreeItem(type) );
node.addChild(type, categoryNode);
addNodes(typeClass, categoryNode, this.getAvailableServices());
}
/**
*
* @param type
* @param node
* @param slist
*/
private void addNodes(String type, TreeNode<ServiceTreeItem> node, List<Service> slist ) {
for( int i = 0; i < slist.size(); i++ ) {
Service s = slist.get(i);
if( s.getType().startsWith(type) ) {
TreeNodeImpl<ServiceTreeItem> nodeImpl = new TreeNodeImpl<ServiceTreeItem>();
nodeImpl.setData( new ServiceTreeItem(s) );
node.addChild(new Integer(i), nodeImpl);
}
}
}
/**
*
* @param event
*/
public void processSelection(NodeSelectedEvent event) {
//log.info("Dealing with event: "+event);
HtmlTree tree = (HtmlTree) event.getComponent();
ServiceTreeItem currentNode = (ServiceTreeItem) tree.getRowData();
if( currentNode.getType().equals(SERVICE) ) {
nodeTitle = currentNode.getService().getName();
selectedService = currentNode.getService();
} else if( currentNode.getType().equals(CATEGORY) ) {
// TODO Summarise the category?
}
}
/**
* This locks the tree into a particular state, and is not in use at present.
*
* @param uitree
* @return
*/
public boolean adviseNodeExpanded( UITree uitree )
{
ServiceTreeItem sti = (ServiceTreeItem) uitree.getTreeNode().getData();
log.info("Current ServiceTreeItem of type: " + sti.getType() + " : " + sti.getCategory() );
if( CATEGORY.equals(sti.getType()) ) {
if( UNKNOWN_SERVICE.equals(sti.getCategory())) {
return Boolean.FALSE;
} else {
return Boolean.TRUE;
}
} else {
return Boolean.FALSE;
}
}
public TreeNode<ServiceTreeItem> getTreeNode() {
if (rootNode == null) {
loadTree();
}
return rootNode;
}
public String getNodeTitle() {
return nodeTitle;
}
public void setNodeTitle(String nodeTitle) {
this.nodeTitle = nodeTitle;
}
/**
* @return the selectedService
*/
public Service getSelectedService() {
return selectedService;
}
/**
* @return A list of SelectItems populated with the identify service endpoints.
*/
public List<SelectItem> getIdentifyServicesSelectList() {
return createServiceList(Identify.class.getCanonicalName());
}
/**
* @return A list of Create View services
*/
public List<SelectItem> getCreateViewServicesSelectList() {
return createServiceList(CreateView.class.getCanonicalName());
}
/**
* @return A list of SelectItems populated with the identify service endpoints.
*/
public List<SelectItem> getMigrateServicesSelectList() {
return createServiceList(Migrate.class.getCanonicalName());
}
/**
* @param type
* @return
*/
private List<SelectItem> createServiceList( String type ) {
return mapServicesToSelectList( getListOfServices(type) );
}
/**
* @return Looks up the service registry, cached in ServiceBrowser in Session scope.
*/
private static ServiceRegistry instanciateServiceRegistry() {
return ServiceRegistryFactory.getServiceRegistry();
}
/**
* @param type
* @return
*/
public List<ServiceDescription> getListOfServices( String type ) {
// If no type specified, return all:
if( type == null) {
return registry.query(null);
}
// List particular services:
log.info("Looking for services of type: "+type);
ServiceDescription sdQuery = new ServiceDescription.Builder(null, type).build();
// This is the list:
return registry.query(sdQuery);
}
/**
*
* @return
*/
public List<ServiceDescription> getAllServices() {
return getListOfServices(null);
}
/**
*
* @return
*/
public List<PathwayBean> getAllPathways() {
List<ServiceDescription> sds = this.listAllMigrationServices();
List<PathwayBean> paths = new ArrayList<PathwayBean>();
for( ServiceDescription sd : sds ) {
log.info("Inspecting "+sd.getName());
for( MigrationPath path : sd.getPaths() ) {
ServiceRecordBean srb = new ServiceRecordBean(sd);
FormatBean in = new FormatBean( ServiceBrowser.fr.getFormatForUri( path.getInputFormat() ) );
FormatBean out = new FormatBean( ServiceBrowser.fr.getFormatForUri( path.getOutputFormat() ) );
PathwayBean pb = new PathwayBean( srb, in, out );
paths.add(pb);
}
}
return paths;
}
/**
* @return A list of all the formats that the available migration services can take.
*/
public List<FormatBean> getMigrationInputFormatBeans() {
// Look up the enabled formats:
String endpoint = null;
if( this.getSelectedServiceRecord() != null ) {
endpoint = this.getSelectedServiceRecord().getEndpoint().toString();
}
String out = null;
if( this.getSelectedOutputFormat() != null ) {
out = this.getSelectedOutputFormat().getUri().toString();
}
Set<Format> formats = this.getMigrationInputFormats( endpoint, out );
// Now build the full output:
Set<FormatBean> fmts = new HashSet<FormatBean>();
for( Format f : this.getMigrationInputFormats(null, null) ) {
FormatBean formatBean = new FormatBean(f);
// Make this modify if selected:
if( formatBean.equals( this.getSelectedInputFormat() ) ) formatBean.setSelected(true);
// Modify if enabled:
if( ( this.getSelectedInputFormat() != null && ! this.getSelectedInputFormat().equals(formatBean) )
|| ! formats.contains( f ) ) formatBean.setEnabled(false);
fmts.add( formatBean );
}
ArrayList<FormatBean> list = new ArrayList<FormatBean>(fmts);
Collections.sort(list);
return list;
}
/**
* @param endpoint
* @param outputFormat
* @return
*/
public Set<Format> getMigrationInputFormats(String endpoint, String outputFormat ) {
log.info("IN: getMigrationInputFormats");
Set<Format> formats = new HashSet<Format>();
for( ServiceDescription sd : this.listAllMigrationServices() ) {
for( MigrationPath path : sd.getPaths() ) {
if( ( endpoint == null ) || endpoint.equals(sd.getEndpoint().toString()) ) {
if( ( outputFormat == null ) || outputFormat.equals(path.getOutputFormat().toString()) ) {
Format fmt = fr.getFormatForUri( path.getInputFormat() );
formats.add(fmt);
}
}
}
}
log.info("OUT: getMigrationInputFormats");
return formats;
}
/**
* @param endpoint
* @param inputFormat
* @return
*/
public Set<Format> getMigrationOutputFormats(String endpoint, String inputFormat ) {
log.info("IN: getMigrationOutputFormats");
Set<Format> formats = new HashSet<Format>();
for( ServiceDescription sd : this.listAllMigrationServices() ) {
for( MigrationPath path : sd.getPaths() ) {
if( ( endpoint == null ) || endpoint.equals(sd.getEndpoint().toString()) ) {
if( ( inputFormat == null ) || inputFormat.equals(path.getInputFormat().toString()) ) {
Format fmt = fr.getFormatForUri( path.getOutputFormat() );
formats.add(fmt);
}
}
}
}
log.info("OUT: getMigrationOutputFormats");
return formats;
}
/**
* @return A list of all the output formats that the available migration services can create.
*/
public List<FormatBean> getMigrationOutputFormatBeans() {
// Look up the enabled formats:
String endpoint = null;
if( this.getSelectedServiceRecord() != null ) {
endpoint = this.getSelectedServiceRecord().getEndpoint().toString();
}
String in = null;
if( this.getSelectedInputFormat() != null ) {
in = this.getSelectedInputFormat().getUri().toString();
}
Set<Format> formats = this.getMigrationOutputFormats( endpoint, in );
// Now build the full output:
Set<FormatBean> fmts = new HashSet<FormatBean>();
for( Format f : this.getMigrationOutputFormats(null, null) ) {
FormatBean formatBean = new FormatBean(f);
// Modify if selected:
if( formatBean.equals( this.getSelectedOutputFormat() ) ) formatBean.setSelected(true);
// Modify if enabled:
if( ( this.getSelectedOutputFormat() != null && ! this.getSelectedOutputFormat().equals(formatBean) )
|| ! formats.contains( f ) ) formatBean.setEnabled(false);
fmts.add( formatBean );
}
ArrayList<FormatBean> list = new ArrayList<FormatBean>(fmts);
Collections.sort(list);
return list;
}
/**
* @param inputFormat
* @param outputFormat
* @return
*/
public List<ServiceDescription> getMigrationServices( String inputFormat, String outputFormat ) {
List<ServiceDescription> sdl = new Vector<ServiceDescription>();
for( ServiceDescription sd : this.listAllMigrationServices() ) {
boolean addThis = false;
for( MigrationPath path : sd.getPaths() ) {
if( ( inputFormat == null ) || inputFormat.equals(path.getInputFormat().toString()) ) {
if( ( outputFormat == null ) || outputFormat.equals(path.getOutputFormat().toString()) ) {
addThis = true;
}
}
}
if( addThis ) sdl.add(sd);
}
return sdl;
}
/**
* @return
*/
public List<ServiceRecordBean> getMigrationServiceBeans() {
List<ServiceRecordBean> srbs = new ArrayList<ServiceRecordBean>();
for( ServiceDescription sd : this.getMigrationServices() ) {
ServiceRecordBean srb = new ServiceRecordBean(sd);
// Check if this service is selected:
if( this.getSelectedServiceRecord() != null &&
sd.getEndpoint().equals( this.getSelectedServiceRecord().getEndpoint() )) {
srb.setSelected(true);
}
// Check if this service is compatible with the input and output formats:
List<ServiceDescription> migrationServices = this.getSelectableMigrationServices();
if( ( this.getSelectedServiceRecord() != null && ! this.getSelectedServiceRecord().equals(srb) )
|| ! migrationServices.contains(sd) ) {
srb.setEnabled(false);
}
srbs.add(srb);
}
return srbs;
}
/**
* @return
*/
private List<ServiceDescription> getSelectableMigrationServices() {
String in = null;
if( this.getSelectedInputFormat() != null ) {
in = this.getSelectedInputFormat().getUri().toString();
}
String out = null;
if( this.getSelectedOutputFormat() != null ) {
out = this.getSelectedOutputFormat().getUri().toString();
}
return this.getMigrationServices( in, out );
}
/**
* @return
*/
public List<ServiceDescription> getMigrationServices() {
return this.getMigrationServices(null,null);
}
/**
* @param sdlist
* @return
*/
public static List<SelectItem> mapServicesToSelectList( List<ServiceDescription> sdlist ) {
List<SelectItem> slist = new ArrayList<SelectItem>();
for( ServiceDescription sd : sdlist ) {
SelectItem si = createServiceSelectItem(sd);
if( si != null ) slist.add( si );
}
Collections.sort(slist, new SelectItemComparator() );
return slist;
}
static class SelectItemComparator implements Comparator<SelectItem> {
/* (non-Javadoc)
* @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
*/
public int compare(SelectItem s1, SelectItem s2) {
return s1.getLabel().compareTo(s2.getLabel());
}
}
/**
* @param sd
* @return
*/
private static SelectItem createServiceSelectItem( ServiceDescription sd ) {
if( sd.getEndpoint() == null ) return null;
String prefix = "";
if( sd.getType() != null ) {
prefix += sd.getType().substring(sd.getType().lastIndexOf(".")+1)+" using ";
}
String serviceName = sd.getName();
serviceName += " (@"+sd.getEndpoint().getHost()+")";
return new SelectItem( sd.getEndpoint(), prefix+serviceName );
}
/**
* @param formats
* @return
*/
public static List<SelectItem> mapFormatURIsToSelectList( Set<URI> formats ) {
List<SelectItem> slist = new ArrayList<SelectItem>();
List<URI> formatList = new ArrayList<URI>(formats);
Collections.sort(formatList);
for( URI fmt : formatList ) {
slist.add( createFormatURISelectItem(fmt) );
}
return slist;
}
public static List<SelectItem> mapFormatsToSelectList( Set<Format> formats ) {
List<SelectItem> slist = new ArrayList<SelectItem>();
List<FormatBean> fbList = new ArrayList<FormatBean>();
// Use the FormatBean to ensure consistent sorting.
for( Format fmt : formats ) {
fbList.add(new FormatBean(fmt));
}
Collections.sort(fbList);
// Now map:
for( FormatBean fb : fbList ) {
slist.add( createFormatSelectItem(fb.getFormat()) );
}
return slist;
}
/**
* @param fmt
* @return
*/
private static SelectItem createFormatURISelectItem( URI fmt ) {
return new SelectItem( fmt.toString(), fmt.toString() );
}
/**
* @param fmt
* @return
*/
private static SelectItem createFormatSelectItem( Format fmt ) {
String format = fmt.getSummary();
if( fmt.getVersion() != null ) format += " " + fmt.getVersion();
return new SelectItem( fmt.getUri().toString(), format );
}
/**
* @param string
* @return
*/
public static ServiceRecordImpl createServiceRecordFromEndpoint(long eid, URL endpoint, Calendar date) {
if( endpoint == null ) return null;
ServiceRecordImpl sr = null;
ServiceRegistry registry = instanciateServiceRegistry();
ServiceDescription sdQuery = new ServiceDescription.Builder(null, null).endpoint(endpoint).build();
List<ServiceDescription> result = registry.query(sdQuery);
log.info("Got matching results: "+result);
if( result != null && result.size() > 0 ) {
ServiceDescription sd = result.get(0);
sr = ServiceRecordImpl.createServiceRecordFromDescription(eid, sd, date);
}
return sr;
}
/**
*
* @return
*/
public String getExperimentServiceRecordFixLog() {
log.info("Looking through the experiments...");
long start = System.currentTimeMillis();
ExperimentPersistencyRemote ep = ExperimentPersistencyImpl.getInstance();
Collection<Experiment> allExps = ep.queryAllExperiments();
log.debug("Found "+allExps.size()+" experiment(s).");
// Loop through, looking for missing service records.
for( Experiment exp: allExps) {
log.info("Looking at experiment: "+exp.getExperimentSetup().getBasicProperties().getExperimentName());
ExperimentExecutable executable = exp.getExperimentExecutable();
if( executable != null && executable.getBatchExecutionRecords() != null ) {
for( BatchExecutionRecordImpl batch: executable.getBatchExecutionRecords() ) {
for( ExecutionRecordImpl run : batch.getRuns() ) {
for( ExecutionStageRecordImpl stage : run.getStages() ) {
log.info("Looking at stage: " + stage.getStage());
ServiceRecordImpl sr = stage.getServiceRecord();
if( sr != null ) {
log.info("Got old service name: " + sr.getServiceName() );
log.info("Got old service endpoint: " + sr.getEndpoint() );
log.info("Looking to patch in new service record... "+sr.getId());
if( sr.getServiceDescription() != null && sr.getId() <= 0 ) {
log.info("Got old service desc name: " + sr.getServiceDescription().getName() );
ServiceRecordImpl newSR = ServiceRecordImpl.createServiceRecordFromDescription(exp.getEntityID(), sr.getServiceDescription(), exp.getStartDate());
stage.setServiceRecord(newSR);
// FIXME Removed this for now - ep.updateExperiment(exp);
}
log.info("Got old service host: " + sr.getHost() );
// FIXME Go through and check parameters are consistent?
} else {
log.info("Got service record = null!");
}
}
}
}
}
}
long finish = System.currentTimeMillis();
log.info("Done looking: in " + (finish-start)/1000.0 + "s");
return "success";
}
/**
* @return
*/
public List<ServiceRecordsByNameBean> getAllServiceRecordsByName() {
HashMap<String,ServiceRecordsByNameBean> sbn = new HashMap<String,ServiceRecordsByNameBean>();
// Get all the known, unique service records.
List<ServiceRecordBean> records = this.getAllServicesAndRecords();
// Aggregate those into a list of new service-by-name:
for( ServiceRecordBean srb : records ) {
if( this.getSelectedServiceTypes().contains( srb.getType() ) ) {
if( sbn.containsKey(srb.getName()) ) {
// Add this SRB to the content:
sbn.get(srb.getName()).addServiceRecord(srb);
} else {
sbn.put(srb.getName(), new ServiceRecordsByNameBean(srb) );
}
}
}
return new ArrayList<ServiceRecordsByNameBean>( sbn.values() );
}
/**
* @return
*/
public List<ServiceRecordsByFormatBean> getAllServiceRecordsByFormat() {
HashMap<URI,ServiceRecordsByFormatBean> sbn = new HashMap<URI,ServiceRecordsByFormatBean>();
// Get all the known, unique service records.
List<ServiceRecordBean> records = this.getAllServicesAndRecords();
// Aggregate those into a list of new service-by-name:
for( ServiceRecordBean srb : records ) {
if( this.getSelectedServiceTypes().contains( srb.getType() ) ) {
if( srb.getInputs(true) != null ) {
for( URI fmt : srb.getInputs(true) ) {
if( sbn.get(fmt) == null ) {
sbn.put(fmt, new ServiceRecordsByFormatBean( fr.getFormatForUri(fmt) ) );
}
sbn.get(fmt).addAsInputService(srb);
}
}
if( srb.getOutputs() != null ) {
for( URI fmt : srb.getOutputs() ) {
if( sbn.get(fmt) == null ) {
sbn.put(fmt, new ServiceRecordsByFormatBean( fr.getFormatForUri(fmt) ) );
}
sbn.get(fmt).addAsOutputService(srb);
}
}
}
}
return new ArrayList<ServiceRecordsByFormatBean>( sbn.values() );
}
/**
* @return
*/
public List<String> getSelectedServiceTypes() {
if( this.selectedServiceTypes == null ) {
this.selectedServiceTypes = this.getServiceTypeValues();
}
return this.selectedServiceTypes;
}
/**
* @param selectedServiceTypes
*/
public void setSelectedServiceTypes( List<String> selectedServiceTypes ) {
this.selectedServiceTypes = selectedServiceTypes;
}
/**
* @return
*/
public List<SelectItem> getServiceTypes() {
List<SelectItem> stypes = new ArrayList<SelectItem>();
for( String type : this.getServiceTypeValues() ) {
stypes.add( new SelectItem( type ) );
}
return stypes;
}
/**
* @return
*/
private List<String> getServiceTypeValues() {
List<String> stypes = new ArrayList<String>();
List<ServiceRecordBean> records = this.getAllServicesAndRecords();
for( ServiceRecordBean srb : records ) {
String s = srb.getType() ;
if( ! stypes.contains( s )) stypes.add( s );
}
return stypes;
}
/** Name to store the look-up tables under. */
private final static String ALL_SERVICES_SD_CACHE_NAME = "CacheAllServicesCache";
/**
*
* @return
*/
@SuppressWarnings("unchecked")
public List<ServiceRecordBean> getAllServicesAndRecords() {
Map<String,Object> reqmap =
FacesContext.getCurrentInstance().getExternalContext().getRequestMap();
// Lookup or re-build:
List<ServiceRecordBean> all_sd = (List<ServiceRecordBean>) reqmap.get(ALL_SERVICES_SD_CACHE_NAME);
if( all_sd == null ) {
log.info("Refreshing list of all services...");
all_sd = this.lookupAllServicesAndRecords();
reqmap.put(ALL_SERVICES_SD_CACHE_NAME, all_sd);
log.info("Refreshed.");
}
return all_sd;
}
/**
* @return
*/
private List<ServiceRecordBean> lookupAllServicesAndRecords() {
// Use a hash map to build up the list.
HashMap<String,ServiceRecordBean> serviceMap = new HashMap<String,ServiceRecordBean>();
// Get the historical service records:
ServiceRecordPersistencyRemote srp = ServiceRecordPersistencyImpl.getInstance();
for( ServiceRecordImpl sr : srp.getAllServiceRecords() ) {
log.info("Putting service record: "+sr.getServiceName()+" : '"+sr.getServiceHash()+"'");
serviceMap.put(sr.getServiceHash(), new ServiceRecordBean(sr) );
}
// Now get the active services and patch these records in:
List<ServiceDescription> serviceList = getListOfServices(null);
//log.info("Query result: "+serviceList);
if( serviceList != null ) log.info("Matched services = "+serviceList.size());
for( ServiceDescription sd : serviceList ) {
if( serviceMap.containsKey(""+sd.hashCode()) ) {
log.info("Updating bean for service: "+sd.getName()+" : '"+sd.hashCode()+"'");
serviceMap.get(""+sd.hashCode()).setServiceDescription(sd);
} else {
serviceMap.put(""+sd.hashCode(), new ServiceRecordBean(sd) );
log.info("Putting in service: "+sd.getName()+" : '"+sd.hashCode()+"'");
}
}
return new ArrayList<ServiceRecordBean>(serviceMap.values());
}
/**
* @param the selectedInputFormat
*/
public void setSelectedInputFormat(FormatBean fb) {
this.selectedInputFormat = fb;
}
/**
* @return the selectedOutputFormat
*/
public FormatBean getSelectedOutputFormat() {
return selectedOutputFormat;
}
/**
* @param selectedOutputFormat the selectedOutputFormat to set
*/
public void setSelectedOutputFormat(FormatBean selectedOutputFormat) {
this.selectedOutputFormat = selectedOutputFormat;
}
/**
* @return the selectedInputFormat
*/
public FormatBean getSelectedInputFormat() {
return selectedInputFormat;
}
/**
* @return the selectedServiceRecord
*/
public ServiceRecordBean getSelectedServiceRecord() {
return selectedServiceRecord;
}
/**
* @param selectedServiceRecord the selectedServiceRecord to set
*/
public void setSelectedServiceRecord(ServiceRecordBean selectedServiceRecord) {
this.selectedServiceRecord = selectedServiceRecord;
}
/* ------------------------------------------------------------------------------------ */
// TODO Cache this stuff automatically, in getListOfServices method.
/** Name to store the look-up tables under. */
private final static String MIGRATE_SD_CACHE_NAME = "CacheMigrationServicesCache";
/**
* @return A list of all the migration services (cached in request-scope).
*/
@SuppressWarnings("unchecked")
private List<ServiceDescription> listAllMigrationServices() {
Map<String,Object> reqmap =
FacesContext.getCurrentInstance().getExternalContext().getRequestMap();
// Lookup or re-build:
List<ServiceDescription> migrators = (List<ServiceDescription>) reqmap.get(MIGRATE_SD_CACHE_NAME);
if( migrators == null ) {
log.info("Refreshing list of migration services...");
migrators = getListOfServices(Migrate.class.getCanonicalName());
reqmap.put(MIGRATE_SD_CACHE_NAME, migrators);
log.info("Refreshed.");
}
return migrators;
}
/**
* @return
*/
public List<ServiceDescription> getCharacteriseServices() {
return getListOfServices(Characterise.class.getCanonicalName());
}
/**
* @return
*/
public List<ServiceDescription> getCompareServices() {
return getListOfServices(Compare.class.getCanonicalName());
}
/**
* @return
*/
public List<ServiceDescription> getComparePropertiesServices() {
return getListOfServices(CompareProperties.class.getCanonicalName());
}
/**
* @return
*/
public List<ServiceDescription> getIdentifyServices() {
return getListOfServices(Identify.class.getCanonicalName());
}
}