Repository: oodt Updated Branches: refs/heads/master 9d13beabc -> 8705ccf40
refactor for xmlrpc arghhh Project: http://git-wip-us.apache.org/repos/asf/oodt/repo Commit: http://git-wip-us.apache.org/repos/asf/oodt/commit/aa5e31a6 Tree: http://git-wip-us.apache.org/repos/asf/oodt/tree/aa5e31a6 Diff: http://git-wip-us.apache.org/repos/asf/oodt/diff/aa5e31a6 Branch: refs/heads/master Commit: aa5e31a618a9aa17de920b975c9443e7583ecd14 Parents: 9d13bea Author: Tom Barber <[email protected]> Authored: Wed Nov 4 09:40:57 2015 +0000 Committer: Tom Barber <[email protected]> Committed: Wed Nov 4 09:40:57 2015 +0000 ---------------------------------------------------------------------- .../oodt/cas/filemgr/catalog/LuceneCatalog.java | 112 ++--- .../cas/filemgr/system/XmlRpcFileManager.java | 447 ++++++++++++++++++- .../filemgr/system/XmlRpcFileManagerClient.java | 75 ++-- .../cas/filemgr/util/XmlRpcStructFactory.java | 361 ++++++++++++--- .../org/apache/oodt/cas/metadata/Metadata.java | 15 +- .../resource/system/XmlRpcResourceManager.java | 7 +- 6 files changed, 821 insertions(+), 196 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/oodt/blob/aa5e31a6/filemgr/src/main/java/org/apache/oodt/cas/filemgr/catalog/LuceneCatalog.java ---------------------------------------------------------------------- diff --git a/filemgr/src/main/java/org/apache/oodt/cas/filemgr/catalog/LuceneCatalog.java b/filemgr/src/main/java/org/apache/oodt/cas/filemgr/catalog/LuceneCatalog.java index e5985ad..d3c297a 100644 --- a/filemgr/src/main/java/org/apache/oodt/cas/filemgr/catalog/LuceneCatalog.java +++ b/filemgr/src/main/java/org/apache/oodt/cas/filemgr/catalog/LuceneCatalog.java @@ -154,27 +154,27 @@ public class LuceneCatalog implements Catalog { */ public synchronized void addMetadata(Metadata m, Product product) throws CatalogException { - CompleteProduct p = CATALOG_CACHE.get(product.getProductId()); - - if (p == null) { - // move product from index to cache - // it will be moved back after metadata is added - p = getCompleteProductById(product.getProductId(), true, true); - LOG.log(Level.FINE, "Product not found in local cache, retrieved from index"); - removeProduct(product); - } - - if (p != null) { - p.setMetadata(m); - if (hasMetadataAndRefs(p)) { - LOG.log(Level.FINE, + if(product.getProductId()!=null && CATALOG_CACHE.containsKey(product.getProductId())) { + CompleteProduct p = CATALOG_CACHE.get(product.getProductId()); + + p.setMetadata(m); + if (hasMetadataAndRefs(p)) { + LOG.log(Level.FINE, "metadata and references present for product: [" - + product.getProductId() + "]"); - addCompleteProductToIndex(p); - // now remove its entry from the cache - CATALOG_CACHE.remove(product.getProductId()); + + product.getProductId() + "]"); + addCompleteProductToIndex(p); + // now remove its entry from the cache + CATALOG_CACHE.remove(product.getProductId()); } } + else{ + // move product from index to cache + // it will be moved back after metadata is added + CompleteProduct p = getCompleteProductById(product.getProductId(), true, true); + LOG.log(Level.FINE, "Product not found in local cache, retrieved from index"); + removeProduct(product); + + } } /* @@ -185,15 +185,20 @@ public class LuceneCatalog implements Catalog { */ public synchronized void removeMetadata(Metadata m, Product product) throws CatalogException { - CompleteProduct p = CATALOG_CACHE.get(product.getProductId()); - - if (p == null) { - // not in local cache, get doc and rewrite index + CompleteProduct p=null; + + if(product.getProductId()!=null && CATALOG_CACHE.containsKey(product.getProductId())) { + p = CATALOG_CACHE.get(product.getProductId()); + } + else{ String prodId = product.getProductId(); p = getCompleteProductById(prodId, true, true); removeProductDocument(product); } + + + Metadata currMet = p.getMetadata(); List<String> metadataTypes = new ArrayList<String>(); @@ -238,29 +243,31 @@ public class LuceneCatalog implements Catalog { */ public synchronized void addProduct(Product product) throws CatalogException { - CompleteProduct p = CATALOG_CACHE.get(product - .getProductId()); + if(product.getProductId()!=null && CATALOG_CACHE.containsKey(product.getProductId())) { + throw new CatalogException( + "Attempt to add a product that already existed: product: [" + + product.getProductName() + "]"); + + - if (p == null) { + + + } else { // haven't cached this product yet, so let's cache it CompleteProduct completeProduct = new CompleteProduct(); // NOTE: reuse existing ID if possible if (product.getProductId() == null) { - synchronized (completeProduct) { - // now generate a unique ID for the product - UUID prodUUID = generator.generateTimeBasedUUID(); - product.setProductId(prodUUID.toString()); - } + synchronized (completeProduct) { + // now generate a unique ID for the product + UUID prodUUID = generator.generateTimeBasedUUID(); + product.setProductId(prodUUID.toString()); + } } completeProduct.setProduct(product); CATALOG_CACHE.put(product.getProductId(), completeProduct); - } else { - throw new CatalogException( - "Attempt to add a product that already existed: product: [" - + product.getProductName() + "]"); } } @@ -272,7 +279,7 @@ public class LuceneCatalog implements Catalog { */ public synchronized void modifyProduct(Product product) throws CatalogException { - if (CATALOG_CACHE.get(product.getProductId()) != null) { + if (product.getProductId()!=null && CATALOG_CACHE.containsKey(product.getProductId())) { LOG.log(Level.FINE, "Modifying product: [" + product.getProductId() + "]: found product in cache!"); CompleteProduct cp = CATALOG_CACHE.get(product @@ -326,29 +333,28 @@ public class LuceneCatalog implements Catalog { */ public synchronized void addProductReferences(Product product) throws CatalogException { - CompleteProduct p = CATALOG_CACHE.get(product + if(product.getProductId()!=null && CATALOG_CACHE.containsKey(product.getProductId())) { + CompleteProduct p = CATALOG_CACHE.get(product .getProductId()); - - if (p == null) { - // move product from index to cache - // it will be moved back after metadata is added - p = getCompleteProductById(product.getProductId(), true, true); - LOG.log(Level.FINE, "Product not found in local cache, retrieved from index"); - removeProduct(product); - } - - if (p != null) { p.getProduct().setProductReferences(product.getProductReferences()); - if (hasMetadataAndRefs(p)) { - LOG.log(Level.FINE, + if (hasMetadataAndRefs(p)) { + LOG.log(Level.FINE, "metadata and references present for product: [" - + product.getProductId() + "]"); - addCompleteProductToIndex(p); - // now remove its entry from the cache - CATALOG_CACHE.remove(product.getProductId()); - } + + product.getProductId() + "]"); + addCompleteProductToIndex(p); + // now remove its entry from the cache + CATALOG_CACHE.remove(product.getProductId()); + } + } + else{ + // move product from index to cache + // it will be moved back after metadata is added + CompleteProduct p = getCompleteProductById(product.getProductId(), true, true); + LOG.log(Level.FINE, "Product not found in local cache, retrieved from index"); + removeProduct(product); + } } /* http://git-wip-us.apache.org/repos/asf/oodt/blob/aa5e31a6/filemgr/src/main/java/org/apache/oodt/cas/filemgr/system/XmlRpcFileManager.java ---------------------------------------------------------------------- diff --git a/filemgr/src/main/java/org/apache/oodt/cas/filemgr/system/XmlRpcFileManager.java b/filemgr/src/main/java/org/apache/oodt/cas/filemgr/system/XmlRpcFileManager.java index 65b84a6..4be4dc1 100644 --- a/filemgr/src/main/java/org/apache/oodt/cas/filemgr/system/XmlRpcFileManager.java +++ b/filemgr/src/main/java/org/apache/oodt/cas/filemgr/system/XmlRpcFileManager.java @@ -65,12 +65,12 @@ import java.net.URI; import java.net.URISyntaxException; import java.net.URL; import java.util.Arrays; -import java.util.concurrent.ConcurrentHashMap; -import java.util.Map; +import java.util.Hashtable; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Vector; +import java.util.concurrent.ConcurrentHashMap; import java.util.logging.Level; import java.util.logging.Logger; @@ -228,7 +228,7 @@ public class XmlRpcFileManager { int pageNum) throws CatalogException { ProductType type = XmlRpcStructFactory .getProductTypeFromXmlRpc(productTypeHash); - Query query = XmlRpcStructFactory.getQueryFromXmlRpc(queryHash); + Query query = XmlRpcStructFactory.getQueryFromXmlRpcMap(queryHash); ProductPage prodPage; @@ -271,6 +271,21 @@ public class XmlRpcFileManager { return XmlRpcStructFactory.getXmlRpcProductPage(page); } + public Hashtable<String, Object> getFirstPage( + Hashtable<String, Object> productTypeHash) { + ProductType type = XmlRpcStructFactory + .getProductTypeFromXmlRpc(productTypeHash); + ProductPage page = catalog.getFirstPage(type); + try { + setProductType(page.getPageProducts()); + } catch (Exception e) { + LOG.log(Level.WARNING, + "Unable to set product types for product page list: [" + + page + "]"); + } + return XmlRpcStructFactory.getXmlRpcProductPage(page); + } + public Map<String, Object> getLastPage( Map<String, Object> productTypeHash) { ProductType type = XmlRpcStructFactory @@ -339,7 +354,15 @@ public class XmlRpcFileManager { return true; } - public int getNumProducts(Map<String, Object> productTypeHash) + public synchronized boolean setProductTransferStatus( + Hashtable<String, Object> productHash) + throws CatalogException { + Product product = XmlRpcStructFactory.getProductFromXmlRpc(productHash); + catalog.setProductTransferStatus(product); + return true; + } + + public int getNumProducts(Map<String, Object> productTypeHash) throws CatalogException { int numProducts; @@ -359,13 +382,33 @@ public class XmlRpcFileManager { return numProducts; } - public List<Map<String, Object>> getTopNProducts(int n) + public int getNumProducts(Hashtable<String, Object> productTypeHash) + throws CatalogException { + int numProducts; + + ProductType type = XmlRpcStructFactory + .getProductTypeFromXmlRpc(productTypeHash); + + try { + numProducts = catalog.getNumProducts(type); + } catch (CatalogException e) { + LOG.log(Level.SEVERE, e.getMessage()); + LOG.log(Level.WARNING, + "Exception when getting num products: Message: " + + e.getMessage()); + throw new CatalogException(e.getMessage(), e); + } + + return numProducts; + } + + public List<Map<String, Object>> getTopNProductsMap(int n) throws CatalogException { List<Product> topNProducts; try { topNProducts = catalog.getTopNProducts(n); - return XmlRpcStructFactory.getXmlRpcProductList(topNProducts); + return XmlRpcStructFactory.getXmlRpcProductListMap(topNProducts); } catch (Exception e) { LOG.log(Level.SEVERE, e.getMessage()); LOG.log(Level.WARNING, @@ -375,6 +418,42 @@ public class XmlRpcFileManager { } } + public List<Hashtable<String, Object>> getTopNProducts(int n) + throws CatalogException { + List<Product> topNProducts; + + try { + topNProducts = catalog.getTopNProducts(n); + return XmlRpcStructFactory.getXmlRpcProductList(topNProducts); + } catch (Exception e) { + LOG.log(Level.SEVERE, e.getMessage()); + LOG.log(Level.WARNING, + "Exception when getting topN products: Message: " + + e.getMessage()); + throw new CatalogException(e.getMessage(), e); + } + } + + public List<Hashtable<String, Object>> getTopNProducts(int n, + Hashtable<String, Object> productTypeHash) + throws CatalogException { + ProductType type = XmlRpcStructFactory + .getProductTypeFromXmlRpc(productTypeHash); + List<Product> topNProducts; + + try { + topNProducts = catalog.getTopNProducts(n, type); + return XmlRpcStructFactory.getXmlRpcProductList(topNProducts); + } catch (Exception e) { + LOG.log(Level.SEVERE, e.getMessage()); + LOG.log(Level.WARNING, + "Exception when getting topN products by product type: [" + + type.getProductTypeId() + "]: Message: " + + e.getMessage()); + throw new CatalogException(e.getMessage(), e); + } + + } public List<Map<String, Object>> getTopNProducts(int n, Map<String, Object> productTypeHash) throws CatalogException { @@ -384,7 +463,7 @@ public class XmlRpcFileManager { try { topNProducts = catalog.getTopNProducts(n, type); - return XmlRpcStructFactory.getXmlRpcProductList(topNProducts); + return XmlRpcStructFactory.getXmlRpcProductListMap(topNProducts); } catch (Exception e) { LOG.log(Level.SEVERE, e.getMessage()); LOG.log(Level.WARNING, @@ -408,6 +487,12 @@ public class XmlRpcFileManager { return this.getMetadata(product).getMap(); } + public Hashtable<String, Object> getMetadata( + Hashtable<String, Object> productHash) throws CatalogException { + Product product = XmlRpcStructFactory.getProductFromXmlRpc(productHash); + return this.getMetadata(product).getHashTable(); + } + public Map<String, Object> getReducedMetadata( Map<String, Object> productHash, Vector<String> elements) throws CatalogException { @@ -415,6 +500,12 @@ public class XmlRpcFileManager { return this.getReducedMetadata(product, elements).getMap(); } + public Hashtable<String, Object> getReducedMetadata( + Hashtable<String, Object> productHash, Vector<String> elements) + throws CatalogException { + Product product = XmlRpcStructFactory.getProductFromXmlRpc(productHash); + return this.getReducedMetadata(product, elements).getHashTable(); + } public List<Map<String, Object>> getProductTypes() throws RepositoryManagerException { List<ProductType> productTypeList; @@ -440,7 +531,7 @@ public class XmlRpcFileManager { try { referenceList = catalog.getProductReferences(product); - return XmlRpcStructFactory.getXmlRpcReferences(referenceList); + return XmlRpcStructFactory.getXmlRpcReferencesMap(referenceList); } catch (CatalogException e) { LOG.log(Level.SEVERE, e.getMessage()); LOG.log(Level.SEVERE, "Unable to obtain references for product: [" @@ -451,6 +542,24 @@ public class XmlRpcFileManager { } + public List<Hashtable<String, Object>> getProductReferences( + Hashtable<String, Object> productHash) + throws CatalogException { + List<Reference> referenceList; + Product product = XmlRpcStructFactory.getProductFromXmlRpc(productHash); + + try { + referenceList = catalog.getProductReferences(product); + return XmlRpcStructFactory.getXmlRpcReferences(referenceList); + } catch (CatalogException e) { + LOG.log(Level.SEVERE, e.getMessage()); + LOG.log(Level.SEVERE, "Unable to obtain references for product: [" + + product.getProductName() + "]: Message: " + + e.getMessage()); + throw new CatalogException(e.getMessage(), e); + } + + } public Map<String, Object> getProductById(String productId) throws CatalogException { Product product = null; @@ -517,7 +626,7 @@ public class XmlRpcFileManager { try { productList = catalog.getProductsByProductType(type); - return XmlRpcStructFactory.getXmlRpcProductList(productList); + return XmlRpcStructFactory.getXmlRpcProductListMap(productList); } catch (Exception e) { LOG.log(Level.SEVERE, e.getMessage()); LOG.log(Level.SEVERE, @@ -527,6 +636,24 @@ public class XmlRpcFileManager { } } + public List<Hashtable<String, Object>> getProductsByProductType( + Hashtable<String, Object> productTypeHash) + throws CatalogException { + ProductType type = XmlRpcStructFactory + .getProductTypeFromXmlRpc(productTypeHash); + List<Product> productList; + + try { + productList = catalog.getProductsByProductType(type); + return XmlRpcStructFactory.getXmlRpcProductList(productList); + } catch (Exception e) { + LOG.log(Level.SEVERE, e.getMessage()); + LOG.log(Level.SEVERE, + "Exception obtaining products by product type for type: [" + + type.getName() + "]: Message: " + e.getMessage()); + throw new CatalogException(e.getMessage(), e); + } + } public List<Map<String, Object>> getElementsByProductType( Map<String, Object> productTypeHash) throws ValidationLayerException { @@ -536,6 +663,7 @@ public class XmlRpcFileManager { try { elementList = catalog.getValidationLayer().getElements(type); + Map hm = new ConcurrentHashMap(); return XmlRpcStructFactory.getXmlRpcElementList(elementList); } catch (Exception e) { LOG.log(Level.SEVERE, e.getMessage()); @@ -578,11 +706,11 @@ public class XmlRpcFileManager { } } - public List<Map<String, Object>> complexQuery( + public List<Map<String, Object>> complexQueryMap( Map<String, Object> complexQueryHash) throws CatalogException { try { ComplexQuery complexQuery = XmlRpcStructFactory - .getComplexQueryFromXmlRpc(complexQueryHash); + .getComplexQueryFromXmlRpcMap(complexQueryHash); // get ProductTypes List<ProductType> productTypes; @@ -631,31 +759,108 @@ public class XmlRpcFileManager { .getSortByMetKey()); } - return XmlRpcStructFactory.getXmlRpcQueryResults(queryResults); + return XmlRpcStructFactory.getXmlRpcQueryResultsMap(queryResults); } catch (Exception e) { LOG.log(Level.SEVERE, e.getMessage()); throw new CatalogException("Failed to perform complex query : " + e.getMessage(), e); } } - + + public List<Hashtable<String, Object>> complexQuery( + Hashtable<String, Object> complexQueryHash) throws CatalogException { + try { + ComplexQuery complexQuery = XmlRpcStructFactory + .getComplexQueryFromXmlRpc(complexQueryHash); + + // get ProductTypes + List<ProductType> productTypes; + if (complexQuery.getReducedProductTypeNames() == null) { + productTypes = this.repositoryManager.getProductTypes(); + } else { + productTypes = new Vector<ProductType>(); + for (String productTypeName : complexQuery + .getReducedProductTypeNames()) { + productTypes.add(this.repositoryManager + .getProductTypeByName(productTypeName)); + } + } + + // get Metadata + List<QueryResult> queryResults = new LinkedList<QueryResult>(); + for (ProductType productType : productTypes) { + List<String> productIds = catalog.query(this.getCatalogQuery( + complexQuery, productType), productType); + for (String productId : productIds) { + Product product = catalog.getProductById(productId); + product.setProductType(productType); + QueryResult qr = new QueryResult(product, this + .getReducedMetadata(product, complexQuery + .getReducedMetadata())); + qr.setToStringFormat(complexQuery + .getToStringResultFormat()); + queryResults.add(qr); + } + } + + LOG.log(Level.INFO, "Query returned " + queryResults.size() + + " results"); + + // filter query results + if (complexQuery.getQueryFilter() != null) { + queryResults = applyFilterToResults(queryResults, complexQuery + .getQueryFilter()); + LOG.log(Level.INFO, "Filter returned " + queryResults.size() + + " results"); + } + + // sort query results + if (complexQuery.getSortByMetKey() != null) { + queryResults = sortQueryResultList(queryResults, complexQuery + .getSortByMetKey()); + } + + return XmlRpcStructFactory.getXmlRpcQueryResults(queryResults); + } catch (Exception e) { + LOG.log(Level.SEVERE, e.getMessage()); + throw new CatalogException("Failed to perform complex query : " + + e.getMessage(), e); + } + } public List<Map<String, Object>> query( Map<String, Object> queryHash, Map<String, Object> productTypeHash) throws CatalogException { - Query query = XmlRpcStructFactory.getQueryFromXmlRpc(queryHash); + Query query = XmlRpcStructFactory.getQueryFromXmlRpcMap(queryHash); ProductType type = XmlRpcStructFactory .getProductTypeFromXmlRpc(productTypeHash); - return XmlRpcStructFactory.getXmlRpcProductList(this.query(query, type)); + return XmlRpcStructFactory.getXmlRpcProductListMap(this.query(query, type)); } - public Map<String, Object> getProductTypeByName(String productTypeName) + public List<Hashtable<String, Object>> query( + Hashtable<String, Object> queryHash, + Hashtable<String, Object> productTypeHash) + throws CatalogException { + Query query = XmlRpcStructFactory.getQueryFromXmlRpc(queryHash); + ProductType type = XmlRpcStructFactory + .getProductTypeFromXmlRpc(productTypeHash); + return XmlRpcStructFactory.getXmlRpcProductList(this.query(query, type)); + } + + public Map<String, Object> getProductTypeByNameMap(String productTypeName) throws RepositoryManagerException { ProductType type = repositoryManager .getProductTypeByName(productTypeName); return XmlRpcStructFactory.getXmlRpcProductType(type); } + public Hashtable<String, Object> getProductTypeByName(String productTypeName) + throws RepositoryManagerException { + ProductType type = repositoryManager + .getProductTypeByName(productTypeName); + return XmlRpcStructFactory.getXmlRpcProductType(type); + } + public Map<String, Object> getProductTypeById(String productTypeId) throws RepositoryManagerException { ProductType type; @@ -683,12 +888,27 @@ public class XmlRpcFileManager { return true; } + public synchronized boolean updateMetadata(Hashtable<String, Object> productHash, + Hashtable<String, Object> metadataHash) throws CatalogException{ + Product product = XmlRpcStructFactory.getProductFromXmlRpc(productHash); + Metadata met = new Metadata(); + met.addMetadata(metadataHash); + Metadata oldMetadata = catalog.getMetadata(product); + catalog.removeMetadata(oldMetadata, product); + catalog.addMetadata(met, product); + return true; + } public synchronized String catalogProduct(Map<String, Object> productHash) throws CatalogException { Product p = XmlRpcStructFactory.getProductFromXmlRpc(productHash); return catalogProduct(p); } + public synchronized String catalogProduct(Hashtable<String, Object> productHash) + throws CatalogException { + Product p = XmlRpcStructFactory.getProductFromXmlRpc(productHash); + return catalogProduct(p); + } public synchronized boolean addMetadata(Map<String, Object> productHash, Map<String, String> metadata) throws CatalogException { Product p = XmlRpcStructFactory.getProductFromXmlRpc(productHash); @@ -697,13 +917,27 @@ public class XmlRpcFileManager { return addMetadata(p, m) != null; } + public synchronized boolean addMetadata(Hashtable<String, Object> productHash, + Hashtable<String, String> metadata) throws CatalogException { + Product p = XmlRpcStructFactory.getProductFromXmlRpc(productHash); + Metadata m = new Metadata(); + m.addMetadata((Map)metadata); + return addMetadata(p, m) != null; + } public synchronized boolean addProductReferences(Map<String, Object> productHash) throws CatalogException { Product product = XmlRpcStructFactory.getProductFromXmlRpc(productHash); return addProductReferences(product); } - public String ingestProduct(Map<String, Object> productHash, + public synchronized boolean addProductReferences(Hashtable<String, Object> productHash) + throws CatalogException { + Product product = XmlRpcStructFactory.getProductFromXmlRpc(productHash); + return addProductReferences(product); + } + + + public String ingestProduct(Map<String, Object> productHash, Map<String, String> metadata, boolean clientTransfer) throws CatalogException { @@ -779,6 +1013,81 @@ public class XmlRpcFileManager { } + public String ingestProduct(Hashtable<String, Object> productHash, + Hashtable<String, String> metadata, boolean clientTransfer) + throws + CatalogException { + + Product p = XmlRpcStructFactory.getProductFromXmlRpc(productHash); + + try { + // first, create the product + p.setTransferStatus(Product.STATUS_TRANSFER); + catalogProduct(p); + + // now add the metadata + Metadata m = new Metadata(); + m.addMetadata((Map)metadata); + Metadata expandedMetdata = addMetadata(p, m); + + // version the product + if (!clientTransfer || (Boolean.getBoolean("org.apache.oodt.cas.filemgr.serverside.versioning"))) { + Versioner versioner; + try { + versioner = GenericFileManagerObjectFactory + .getVersionerFromClassName(p.getProductType().getVersioner()); + if (versioner != null) { + versioner.createDataStoreReferences(p, expandedMetdata); + } + } catch (Exception e) { + LOG.log(Level.SEVERE, + "ingestProduct: VersioningException when versioning Product: " + + p.getProductName() + " with Versioner " + + p.getProductType().getVersioner() + ": Message: " + + e.getMessage()); + throw new VersioningException(e); + } + + // add the newly versioned references to the data store + addProductReferences(p); + } + + if (!clientTransfer) { + LOG.log(Level.FINEST, + "File Manager: ingest: no client transfer enabled, " + + "server transfering product: [" + p.getProductName() + "]"); + + // now transfer the product + try { + dataTransfer.transferProduct(p); + // now update the product's transfer status in the data store + p.setTransferStatus(Product.STATUS_RECEIVED); + + try { + catalog.setProductTransferStatus(p); + } catch (CatalogException e) { + LOG.log(Level.SEVERE, "ingestProduct: CatalogException " + + "when updating product transfer status for Product: " + + p.getProductName() + " Message: " + e.getMessage()); + throw e; + } + } catch (Exception e) { + LOG.log(Level.SEVERE, + "ingestProduct: DataTransferException when transfering Product: " + + p.getProductName() + ": Message: " + e.getMessage()); + throw new DataTransferException(e); + } + } + + // that's it! + return p.getProductId(); + } catch (Exception e) { + LOG.log(Level.SEVERE, e.getMessage()); + throw new CatalogException("Error ingesting product [" + p + "] : " + + e.getMessage(),e); + } + + } public byte[] retrieveFile(String filePath, int offset, int numBytes) throws DataTransferException { FileInputStream is = null; @@ -933,6 +1242,73 @@ public class XmlRpcFileManager { } } + public boolean moveProduct(Hashtable<String, Object> productHash, String newPath) + throws DataTransferException { + + Product p = XmlRpcStructFactory.getProductFromXmlRpc(productHash); + + // first thing we care about is if the product is flat or heirarchical + if (p.getProductStructure().equals(Product.STRUCTURE_FLAT)) { + // we just need to get its first reference + if (p.getProductReferences() == null || (p.getProductReferences().size() != 1)) { + throw new DataTransferException( + "Flat products must have a single reference: cannot move"); + } + + // okay, it's fine to move it + // first, we need to update the data store ref + Reference r = p.getProductReferences().get(0); + if (r.getDataStoreReference().equals( + new File(newPath).toURI().toString())) { + throw new DataTransferException("cannot move product: [" + + p.getProductName() + "] to same location: [" + + r.getDataStoreReference() + "]"); + } + + // create a copy of the current data store path: we'll need it to + // do the data transfer + Reference copyRef = new Reference(r); + + // update the copyRef to have the data store ref as the orig ref + // the the newLoc as the new ref + copyRef.setOrigReference(r.getDataStoreReference()); + copyRef.setDataStoreReference(new File(newPath).toURI().toString()); + + p.getProductReferences().clear(); + p.getProductReferences().add(copyRef); + + // now transfer it + try { + this.dataTransfer.transferProduct(p); + } catch (IOException e) { + throw new DataTransferException(e); + } + + // now delete the original copy + try { + if (!new File(new URI(copyRef.getOrigReference())).delete()) { + LOG.log(Level.WARNING, "Deletion of original file: [" + + r.getDataStoreReference() + + "] on product move returned false"); + } + } catch (URISyntaxException e) { + throw new DataTransferException( + "URI Syntax exception trying to remove original product ref: Message: " + + e.getMessage(), e); + } + + // now save the updated reference + try { + this.catalog.modifyProduct(p); + return true; + } catch (CatalogException e) { + throw new DataTransferException(e.getMessage(),e); + } + } else { + throw new UnsupportedOperationException( + "Moving of heirarhical and stream products not supported yet"); + } + } public boolean removeFile(String filePath) throws DataTransferException, IOException { // TODO(bfoster): Clean this up so that it deletes by product not file. Product product = new Product(); @@ -980,8 +1356,18 @@ public class XmlRpcFileManager { ProductType productType = XmlRpcStructFactory.getProductTypeFromXmlRpc(productTypeHash); return this.getCatalogValues(m, productType).getMap(); } - - public Map<String, Object> getOrigValues( + + public Hashtable<String, Object> getCatalogValues( + Hashtable<String, Object> metadataHash, + Hashtable<String, Object> productTypeHash) + throws RepositoryManagerException { + Metadata m = new Metadata(); + m.addMetadata(metadataHash); + ProductType productType = XmlRpcStructFactory.getProductTypeFromXmlRpc(productTypeHash); + return this.getCatalogValues(m, productType).getHashTable(); + } + + public Map<String, Object> getOrigValues( Map<String, Object> metadataHash, Map<String, Object> productTypeHash) throws RepositoryManagerException { @@ -990,17 +1376,36 @@ public class XmlRpcFileManager { ProductType productType = XmlRpcStructFactory.getProductTypeFromXmlRpc(productTypeHash); return this.getOrigValues(m, productType).getMap(); } + + public Hashtable<String, Object> getOrigValues( + Hashtable<String, Object> metadataHash, + Hashtable<String, Object> productTypeHash) + throws RepositoryManagerException { + Metadata m = new Metadata(); + m.addMetadata(metadataHash); + ProductType productType = XmlRpcStructFactory.getProductTypeFromXmlRpc(productTypeHash); + return this.getOrigValues(m, productType).getHashTable(); + } public Map<String, Object> getCatalogQuery( Map<String, Object> queryHash, Map<String, Object> productTypeHash) throws RepositoryManagerException, QueryFormulationException { - Query query = XmlRpcStructFactory.getQueryFromXmlRpc(queryHash); + Query query = XmlRpcStructFactory.getQueryFromXmlRpcMap(queryHash); ProductType productType = XmlRpcStructFactory.getProductTypeFromXmlRpc(productTypeHash); return XmlRpcStructFactory.getXmlRpcQuery(this.getCatalogQuery(query, productType)); } - public static void main(String[] args) throws IOException { + public Hashtable<String, Object> getCatalogQuery( + Hashtable<String, Object> queryHash, + Hashtable<String, Object> productTypeHash) + throws RepositoryManagerException, QueryFormulationException { + Query query = XmlRpcStructFactory.getQueryFromXmlRpc(queryHash); + ProductType productType = XmlRpcStructFactory.getProductTypeFromXmlRpc(productTypeHash); + return XmlRpcStructFactory.getXmlRpcQuery(this.getCatalogQuery(query, productType)); + } + + public static void main(String[] args) throws IOException { int portNum = -1; String usage = "FileManager --portNum <port number for xml rpc service>\n"; http://git-wip-us.apache.org/repos/asf/oodt/blob/aa5e31a6/filemgr/src/main/java/org/apache/oodt/cas/filemgr/system/XmlRpcFileManagerClient.java ---------------------------------------------------------------------- diff --git a/filemgr/src/main/java/org/apache/oodt/cas/filemgr/system/XmlRpcFileManagerClient.java b/filemgr/src/main/java/org/apache/oodt/cas/filemgr/system/XmlRpcFileManagerClient.java index 268f32d..5c471d9 100644 --- a/filemgr/src/main/java/org/apache/oodt/cas/filemgr/system/XmlRpcFileManagerClient.java +++ b/filemgr/src/main/java/org/apache/oodt/cas/filemgr/system/XmlRpcFileManagerClient.java @@ -54,6 +54,7 @@ import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.net.URL; +import java.util.Hashtable; import java.util.Map; import java.util.List; import java.util.Vector; @@ -222,7 +223,7 @@ public class XmlRpcFileManagerClient { public boolean transferringProduct(Product product) throws DataTransferException { Vector<Object> argList = new Vector<Object>(); - Map<String, Object> productHash = XmlRpcStructFactory + Hashtable<String, Object> productHash = XmlRpcStructFactory .getXmlRpcProduct(product); argList.add(productHash); @@ -635,10 +636,10 @@ public class XmlRpcFileManagerClient { Vector<Object> argList = new Vector<Object>(); argList.add(n); - Vector<Map<String, Object>> topNProducts; + Vector<Hashtable<String, Object>> topNProducts; try { - topNProducts = (Vector<Map<String, Object>>) client.execute( + topNProducts = (Vector<Hashtable<String, Object>>) client.execute( "filemgr.getTopNProducts", argList); } catch (XmlRpcException e) { throw new CatalogException(e); @@ -659,10 +660,10 @@ public class XmlRpcFileManagerClient { .getXmlRpcProductType(type); argList.add(productTypeHash); - Vector<Map<String, Object>> topNProducts; + Vector<Hashtable<String, Object>> topNProducts; try { - topNProducts = (Vector<Map<String, Object>>) client.execute( + topNProducts = (Vector<Hashtable<String, Object>>) client.execute( "filemgr.getTopNProducts", argList); } catch (XmlRpcException e) { throw new CatalogException(e); @@ -711,7 +712,7 @@ public class XmlRpcFileManagerClient { Vector<Object> argList = new Vector<Object>(); argList.add(XmlRpcStructFactory.getXmlRpcProduct(product)); - argList.add(metadata.getMap()); + argList.add(metadata.getHashTable()); try { client.execute("filemgr.addMetadata", argList); @@ -726,7 +727,7 @@ public class XmlRpcFileManagerClient { throws CatalogException { Vector<Object> argList = new Vector<Object>(); argList.add(XmlRpcStructFactory.getXmlRpcProduct(product)); - argList.add(met.getMap()); + argList.add(met.getHashTable()); boolean result; @@ -868,10 +869,10 @@ public class XmlRpcFileManagerClient { .getXmlRpcProductType(type); argList.add(productTypeHash); - Vector<Map<String, Object>> productVector; + Vector<Hashtable<String, Object>> productVector; try { - productVector = (Vector<Map<String, Object>>) client.execute( + productVector = (Vector<Hashtable<String, Object>>) client.execute( "filemgr.getProductsByProductType", argList); } catch (XmlRpcException e) { throw new CatalogException(e); @@ -895,10 +896,10 @@ public class XmlRpcFileManagerClient { argList.add(productTypeHash); - Vector<Map<String, Object>> elementVector; + Vector<Hashtable<String, Object>> elementVector; try { - elementVector = (Vector<Map<String, Object>>) client.execute( + elementVector = (Vector<Hashtable<String, Object>>) client.execute( "filemgr.getElementsByProductType", argList); } catch (XmlRpcException e) { throw new ValidationLayerException(e); @@ -919,10 +920,10 @@ public class XmlRpcFileManagerClient { Vector<Object> argList = new Vector<Object>(); argList.add(elementId); - Map<String, Object> elementHash; + Hashtable<String, Object> elementHash; try { - elementHash = (Map<String, Object>) client.execute( + elementHash = (Hashtable<String, Object>) client.execute( "filemgr.getElementById", argList); } catch (XmlRpcException e) { throw new ValidationLayerException(e); @@ -943,10 +944,10 @@ public class XmlRpcFileManagerClient { Vector<Object> argList = new Vector<Object>(); argList.add(elementName); - Map<String, Object> elementHash; + Hashtable<String, Object> elementHash; try { - elementHash = (Map<String, Object>) client.execute( + elementHash = (Hashtable<String, Object>) client.execute( "filemgr.getElementByName", argList); } catch (XmlRpcException e) { throw new ValidationLayerException(e); @@ -968,10 +969,10 @@ public class XmlRpcFileManagerClient { argList.add(elementName); argList.add(XmlRpcStructFactory.getXmlRpcProductType(type)); - Map<String, Object> elementHash; + Hashtable<String, Object> elementHash; try { - elementHash = (Map<String, Object>) client.execute( + elementHash = (Hashtable<String, Object>) client.execute( "filemgr.getElementByName", argList); } catch (XmlRpcException e) { throw new ValidationLayerException(e); @@ -989,12 +990,12 @@ public class XmlRpcFileManagerClient { public List<QueryResult> complexQuery(ComplexQuery complexQuery) throws CatalogException { try { - Map<String, Object> complexQueryHash = XmlRpcStructFactory + Hashtable<String, Object> complexQueryHash = XmlRpcStructFactory .getXmlRpcComplexQuery(complexQuery); Vector<Object> argList = new Vector<Object>(); argList.add(complexQueryHash); @SuppressWarnings("unchecked") - Vector<Map<String, Object>> queryResultHashVector = (Vector<Map<String, Object>>) client + Vector<Hashtable<String, Object>> queryResultHashVector = (Vector<Hashtable<String, Object>>) client .execute("filemgr.complexQuery", argList); return XmlRpcStructFactory .getQueryResultsFromXmlRpc(queryResultHashVector); @@ -1015,10 +1016,10 @@ public class XmlRpcFileManagerClient { argList.add(queryHash); argList.add(typeHash); - Vector<Map<String, Object>> productVector; + Vector<Hashtable<String, Object>> productVector; try { - productVector = (Vector<Map<String, Object>>) client.execute( + productVector = (Vector<Hashtable<String, Object>>) client.execute( "filemgr.query", argList); } catch (XmlRpcException e) { LOG.log(Level.SEVERE, e.getMessage()); @@ -1039,12 +1040,12 @@ public class XmlRpcFileManagerClient { @SuppressWarnings("unchecked") public ProductType getProductTypeByName(String productTypeName) throws RepositoryManagerException { - Map<String, Object> productTypeHash; + Hashtable<String, Object> productTypeHash; Vector<Object> argList = new Vector<Object>(); argList.add(productTypeName); try { - productTypeHash = (Map<String, Object>) client.execute( + productTypeHash = (Hashtable<String, Object>) client.execute( "filemgr.getProductTypeByName", argList); } catch (XmlRpcException e) { throw new RepositoryManagerException(e.getLocalizedMessage()); @@ -1063,12 +1064,12 @@ public class XmlRpcFileManagerClient { @SuppressWarnings("unchecked") public ProductType getProductTypeById(String productTypeId) throws RepositoryManagerException { - Map<String, Object> productTypeHash; + Hashtable<String, Object> productTypeHash; Vector<Object> argList = new Vector<Object>(); argList.add(productTypeId); try { - productTypeHash = (Map<String, Object>) client.execute( + productTypeHash = (Hashtable<String, Object>) client.execute( "filemgr.getProductTypeById", argList); } catch (XmlRpcException e) { throw new RepositoryManagerException(e); @@ -1113,13 +1114,13 @@ public class XmlRpcFileManagerClient { throws CatalogException { Vector<Object> argList = new Vector<Object>(); - Vector<Map<String, Object>> productReferenceVector; - Map<String, Object> productHash = XmlRpcStructFactory + Vector<Hashtable<String, Object>> productReferenceVector; + Hashtable<String, Object> productHash = XmlRpcStructFactory .getXmlRpcProduct(product); argList.add(productHash); try { - productReferenceVector = (Vector<Map<String, Object>>) client + productReferenceVector = (Vector<Hashtable<String, Object>>) client .execute("filemgr.getProductReferences", argList); } catch (XmlRpcException e) { throw new CatalogException(e); @@ -1139,11 +1140,11 @@ public class XmlRpcFileManagerClient { public Product getProductById(String productId) throws CatalogException { Vector<Object> argList = new Vector<Object>(); - Map<String, Object> productHash; + Hashtable<String, Object> productHash; argList.add(productId); try { - productHash = (Map<String, Object>) client.execute( + productHash = (Hashtable<String, Object>) client.execute( "filemgr.getProductById", argList); } catch (XmlRpcException e) { throw new CatalogException(e); @@ -1162,11 +1163,11 @@ public class XmlRpcFileManagerClient { public Product getProductByName(String productName) throws CatalogException { Vector<Object> argList = new Vector<Object>(); - Map<String, Object> productHash; + Hashtable<String, Object> productHash; argList.add(productName); try { - productHash = (Map<String, Object>) client.execute( + productHash = (Hashtable<String, Object>) client.execute( "filemgr.getProductByName", argList); } catch (XmlRpcException e) { throw new CatalogException(e); @@ -1186,10 +1187,10 @@ public class XmlRpcFileManagerClient { try { // ingest product Vector<Object> argList = new Vector<Object>(); - Map<String, Object> productHash = XmlRpcStructFactory + Hashtable<String, Object> productHash = XmlRpcStructFactory .getXmlRpcProduct(product); argList.add(productHash); - argList.add(metadata.getMap()); + argList.add(metadata.getHashTable()); argList.add(clientTransfer); String productId = (String) client.execute("filemgr.ingestProduct", argList); @@ -1321,7 +1322,7 @@ public class XmlRpcFileManagerClient { public Metadata getCatalogValues(Metadata metadata, ProductType productType) throws XmlRpcException, IOException { Vector<Object> args = new Vector<Object>(); - args.add(metadata.getMap()); + args.add(metadata.getHashTable()); args.add(XmlRpcStructFactory.getXmlRpcProductType(productType)); Metadata m = new Metadata(); @@ -1335,7 +1336,7 @@ public class XmlRpcFileManagerClient { public Metadata getOrigValues(Metadata metadata, ProductType productType) throws XmlRpcException, IOException { Vector<Object> args = new Vector<Object>(); - args.add(metadata.getMap()); + args.add(metadata.getHashTable()); args.add(XmlRpcStructFactory.getXmlRpcProductType(productType)); Metadata m = new Metadata(); @@ -1352,7 +1353,7 @@ public class XmlRpcFileManagerClient { args.add(XmlRpcStructFactory.getXmlRpcQuery(query)); args.add(XmlRpcStructFactory.getXmlRpcProductType(productType)); return XmlRpcStructFactory - .getQueryFromXmlRpc((Map<String, Object>) this.client + .getQueryFromXmlRpc((Hashtable<String, Object>) this.client .execute("filemgr.getCatalogQuery", args)); } http://git-wip-us.apache.org/repos/asf/oodt/blob/aa5e31a6/filemgr/src/main/java/org/apache/oodt/cas/filemgr/util/XmlRpcStructFactory.java ---------------------------------------------------------------------- diff --git a/filemgr/src/main/java/org/apache/oodt/cas/filemgr/util/XmlRpcStructFactory.java b/filemgr/src/main/java/org/apache/oodt/cas/filemgr/util/XmlRpcStructFactory.java index 3ce0db1..a7b4964 100644 --- a/filemgr/src/main/java/org/apache/oodt/cas/filemgr/util/XmlRpcStructFactory.java +++ b/filemgr/src/main/java/org/apache/oodt/cas/filemgr/util/XmlRpcStructFactory.java @@ -37,11 +37,13 @@ import org.apache.oodt.cas.filemgr.structs.query.filter.FilterAlgor; import org.apache.oodt.cas.filemgr.structs.type.TypeHandler; import org.apache.oodt.cas.metadata.Metadata; -import java.util.concurrent.ConcurrentHashMap; +import java.util.HashMap; +import java.util.Hashtable; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.Vector; +import java.util.concurrent.ConcurrentHashMap; /** @@ -80,8 +82,8 @@ public final class XmlRpcStructFactory { FileTransferStatus status = new FileTransferStatus(); status.setBytesTransferred(Long.parseLong(statusHash .get("bytesTransferred").toString())); - status.setParentProduct(getProductFromXmlRpc((Map<String, Object>) statusHash.get("parentProduct"))); - status.setFileRef(getReferenceFromXmlRpc((Map<String, Object>) statusHash.get("fileRef"))); + status.setParentProduct(getProductFromXmlRpc((Hashtable<String, Object>) statusHash.get("parentProduct"))); + status.setFileRef(getReferenceFromXmlRpc((Hashtable<String, Object>) statusHash.get("fileRef"))); return status; } @@ -111,7 +113,17 @@ public final class XmlRpcStructFactory { return statuses; } - public static Map<String, Object> getXmlRpcProductPage(ProductPage page) { + public static Hashtable<String, Object> getXmlRpcProductPage(ProductPage page) { + Hashtable<String, Object>productPageHash = new Hashtable<String, Object>(); + productPageHash.put("totalPages", page.getTotalPages()); + productPageHash.put("pageNum", page.getPageNum()); + productPageHash.put("pageSize", page.getPageSize()); + productPageHash.put("pageProducts", getXmlRpcProductList(page + .getPageProducts())); + return productPageHash; + } + + public static Map<String, Object> getXmlRpcProductPageMap(ProductPage page) { Map<String, Object>productPageHash = new ConcurrentHashMap<String, Object>(); productPageHash.put("totalPages", page.getTotalPages()); productPageHash.put("pageNum", page.getPageNum()); @@ -128,12 +140,36 @@ public final class XmlRpcStructFactory { page .setPageSize((Integer) productPageHash.get("pageSize")); page.setTotalPages((Integer) productPageHash.get("totalPages")); - page.setPageProducts(getProductListFromXmlRpc((Vector<Map<String, Object>>) productPageHash + page.setPageProducts(getProductListFromXmlRpc((Vector<Hashtable<String, Object>>) productPageHash .get("pageProducts"))); return page; } - - public static Map<String, Object> getXmlRpcComplexQuery(ComplexQuery complexQuery) { + + public static Hashtable<String, Object> getXmlRpcComplexQuery(ComplexQuery complexQuery) { + Hashtable<String, Object> complexQueryHash = getXmlRpcQuery(complexQuery); + if (complexQuery.getReducedProductTypeNames() != null) { + complexQueryHash + .put("reducedProductTypeNames", new Vector<String>(complexQuery.getReducedProductTypeNames())); + } else { + complexQueryHash.put("reducedProductTypeNames", new Vector<String>()); + } + if (complexQuery.getReducedMetadata() != null) { + complexQueryHash.put("reducedMetadata", new Vector<String>(complexQuery.getReducedMetadata())); + } else { + complexQueryHash.put("reducedMetadata", new Vector<String>()); + } + if (complexQuery.getSortByMetKey() != null) { + complexQueryHash.put("sortByMetKey", complexQuery.getSortByMetKey()); + } + if (complexQuery.getToStringResultFormat() != null) { + complexQueryHash.put("toStringResultFormat", complexQuery.getToStringResultFormat()); + } + if (complexQuery.getQueryFilter() != null) { + complexQueryHash.put("queryFilter", getXmlRpcQueryFilter(complexQuery.getQueryFilter())); + } + return complexQueryHash; + } + public static Map<String, Object> getXmlRpcComplexQueryMap(ComplexQuery complexQuery) { Map<String, Object> complexQueryHash = getXmlRpcQuery(complexQuery); if (complexQuery.getReducedProductTypeNames() != null) { complexQueryHash @@ -157,9 +193,8 @@ public final class XmlRpcStructFactory { } return complexQueryHash; } - @SuppressWarnings("unchecked") - public static ComplexQuery getComplexQueryFromXmlRpc(Map<String, Object> complexQueryHash) { + public static ComplexQuery getComplexQueryFromXmlRpc(Hashtable<String, Object> complexQueryHash) { ComplexQuery complexQuery = new ComplexQuery(); complexQuery.setCriteria(getQueryFromXmlRpc(complexQueryHash).getCriteria()); if (((Vector<String>) complexQueryHash.get("reducedProductTypeNames")).size() > 0) { @@ -176,7 +211,24 @@ public final class XmlRpcStructFactory { } return complexQuery; } - + + public static ComplexQuery getComplexQueryFromXmlRpcMap(Map<String, Object> complexQueryHash) { + ComplexQuery complexQuery = new ComplexQuery(); + complexQuery.setCriteria(getQueryFromXmlRpcMap(complexQueryHash).getCriteria()); + if (((Vector<String>) complexQueryHash.get("reducedProductTypeNames")).size() > 0) { + complexQuery.setReducedProductTypeNames((Vector<String>) complexQueryHash.get("reducedProductTypeNames")); + } + if (((Vector<String>) complexQueryHash.get("reducedMetadata")).size() > 0) { + complexQuery.setReducedMetadata((Vector<String>) complexQueryHash.get("reducedMetadata")); + } + complexQuery.setSortByMetKey((String) complexQueryHash.get("sortByMetKey")); + complexQuery.setToStringResultFormat((String) complexQueryHash.get("toStringResultFormat")); + if (complexQueryHash.get("queryFilter") != null) { + complexQuery.setQueryFilter( + getQueryFilterFromXmlRpc((Map<String, Object>) complexQueryHash.get("queryFilter"))); + } + return complexQuery; + } public static Map<String, Object> getXmlRpcQueryFilter(QueryFilter queryFilter) { Map<String, Object> queryFilterHash = new ConcurrentHashMap<String, Object>(); queryFilterHash.put("startDateTimeMetKey", queryFilter.getStartDateTimeMetKey()); @@ -213,23 +265,48 @@ public final class XmlRpcStructFactory { return filterAlgor; } - public static Vector<Map<String, Object>> getXmlRpcQueryResults(List<QueryResult> queryResults) { + public static Vector<Hashtable<String, Object>> getXmlRpcQueryResults(List<QueryResult> queryResults) { + Vector<Hashtable<String, Object>> queryResultHashVector = new Vector<Hashtable<String, Object>>(); + for (QueryResult queryResult : queryResults) { + queryResultHashVector.add(getXmlRpcQueryResult(queryResult)); + } + return queryResultHashVector; + } + + public static Vector<Map<String, Object>> getXmlRpcQueryResultsMap(List<QueryResult> queryResults) { Vector<Map<String, Object>> queryResultHashVector = new Vector<Map<String, Object>>(); for (QueryResult queryResult : queryResults) { queryResultHashVector.add(getXmlRpcQueryResult(queryResult)); } return queryResultHashVector; } - - public static List<QueryResult> getQueryResultsFromXmlRpc(Vector<Map<String, Object>> queryResultHashVector) { + + public static List<QueryResult> getQueryResultsFromXmlRpc(Vector<Hashtable<String, Object>> queryResultHashVector) { + List<QueryResult> queryResults = new Vector<QueryResult>(); + for (Hashtable<String, Object> queryResultHash : queryResultHashVector) { + queryResults.add(getQueryResultFromXmlRpc(queryResultHash)); + } + return queryResults; + } + + public static List<QueryResult> getQueryResultsFromXmlRpcMap(Vector<Map<String, Object>> + queryResultHashVector) { List<QueryResult> queryResults = new Vector<QueryResult>(); for (Map<String, Object> queryResultHash : queryResultHashVector) { queryResults.add(getQueryResultFromXmlRpc(queryResultHash)); } return queryResults; } - - public static Map<String, Object> getXmlRpcQueryResult(QueryResult queryResult) { + public static Hashtable<String, Object> getXmlRpcQueryResult(QueryResult queryResult) { + Hashtable<String, Object> queryResultHash = new Hashtable<String, Object>(); + if (queryResult.getToStringFormat() != null) { + queryResultHash.put("toStringFormat", queryResult.getToStringFormat()); + } + queryResultHash.put("product", getXmlRpcProduct(queryResult.getProduct())); + queryResultHash.put("metadata", queryResult.getMetadata().getMap()); + return queryResultHash; + } + public static Map<String, Object> getXmlRpcQueryResultMap(QueryResult queryResult) { Map<String, Object> queryResultHash = new ConcurrentHashMap<String, Object>(); if (queryResult.getToStringFormat() != null) { queryResultHash.put("toStringFormat", queryResult.getToStringFormat()); @@ -241,7 +318,7 @@ public final class XmlRpcStructFactory { @SuppressWarnings("unchecked") public static QueryResult getQueryResultFromXmlRpc(Map<String, Object> queryResultHash) { - Product product = getProductFromXmlRpc((Map<String, Object>) queryResultHash.get("product")); + Product product = getProductFromXmlRpc((Hashtable<String, Object>) queryResultHash.get("product")); Metadata metadata = new Metadata(); metadata.addMetadata((Map<String, Object>) queryResultHash.get("metadata")); QueryResult queryResult = new QueryResult(product, metadata); @@ -249,8 +326,8 @@ public final class XmlRpcStructFactory { return queryResult; } - public static Map<String, Object> getXmlRpcProduct(Product product) { - Map<String, Object> productHash = new ConcurrentHashMap<String, Object>(); + public static Hashtable<String, Object> getXmlRpcProduct(Product product) { + Hashtable<String, Object> productHash = new Hashtable<String, Object>(); if (product.getProductId() != null) { productHash.put("id", product.getProductId()); } @@ -277,33 +354,57 @@ public final class XmlRpcStructFactory { return productHash; } - @SuppressWarnings("unchecked") public static Product getProductFromXmlRpc(Map<?, ?> productHash) { + /*Hashtable ht = new Hashtable(); + ht.putAll(productHash);*/ + Product product = new Product(); + product.setProductId((String) productHash.get("id")); + product.setProductName((String) productHash.get("name")); + if (productHash.get("type") != null) { + product.setProductType(getProductTypeFromXmlRpc( + (Hashtable<String, Object>) productHash.get("type"))); + } + product.setProductStructure((String) productHash.get("structure")); + product.setTransferStatus((String) productHash.get("transferStatus")); + if (productHash.get("references") != null) { + product.setProductReferences(getReferencesFromXmlRpc( + (Vector<Hashtable<String, Object>>) productHash + .get("references"))); + } + if (productHash.get("rootReference") != null) { + product.setRootRef(getReferenceFromXmlRpc( + (Hashtable<String, Object>) productHash.get("rootReference"))); + } + return product; + } + + @SuppressWarnings("unchecked") + public static Product getProductFromXmlRpc(Hashtable<?, ?> productHash) { Product product = new Product(); product.setProductId((String) productHash.get("id")); product.setProductName((String) productHash.get("name")); if (productHash.get("type") != null) { product.setProductType(getProductTypeFromXmlRpc( - (Map<String, Object>) productHash.get("type"))); + (Hashtable<String, Object>) productHash.get("type"))); } product.setProductStructure((String) productHash.get("structure")); product.setTransferStatus((String) productHash.get("transferStatus")); if (productHash.get("references") != null) { product.setProductReferences(getReferencesFromXmlRpc( - (Vector<Map<String, Object>>) productHash + (Vector<Hashtable<String, Object>>) productHash .get("references"))); } if (productHash.get("rootReference") != null) { product.setRootRef(getReferenceFromXmlRpc( - (Map<String, Object>) productHash.get("rootReference"))); + (Hashtable<String, Object>) productHash.get("rootReference"))); } return product; } - public static List<Product> getProductListFromXmlRpc(Vector<Map<String, Object>> productVector) { + public static List<Product> getProductListFromXmlRpc(Vector<Hashtable<String, Object>> productVector) { List<Product> productList = new Vector<Product>(); - for (Map<String, Object> productHash : productVector) { + for (Hashtable<String, Object> productHash : productVector) { Product product = getProductFromXmlRpc(productHash); productList.add(product); } @@ -311,7 +412,7 @@ public final class XmlRpcStructFactory { return productList; } - public static Vector<Map<String, Object>> getXmlRpcProductList(List<Product> products) { + public static Vector<Map<String, Object>> getXmlRpcProductListMap(List<Product> products) { Vector<Map<String, Object>> productVector = new Vector<Map<String, Object>>(); if (products == null) { @@ -326,6 +427,21 @@ public final class XmlRpcStructFactory { return productVector; } + public static Vector<Hashtable<String, Object>> getXmlRpcProductList(List<Product> products) { + Vector<Hashtable<String, Object>> productVector = new Vector<Hashtable<String, Object>>(); + + if (products == null) { + return productVector; + } + + for (Product product : products) { + Hashtable<String, Object> productHash = getXmlRpcProduct(product); + productVector.add(productHash); + } + + return productVector; + } + public static Vector<Map<String, Object>> getXmlRpcProductTypeList(List<ProductType> productTypes) { Vector<Map<String, Object>> productTypeVector = new Vector<Map<String, Object>>(); @@ -350,7 +466,7 @@ public final class XmlRpcStructFactory { return productTypeList; } - public static Map<String, Object> getXmlRpcProductType(ProductType type) { + public static Map<String, Object> getXmlRpcProductTypeMap(ProductType type) { Map<String, Object> productTypeHash = new ConcurrentHashMap<String, Object>(); // TODO(bfoster): ProductType ID is currently required by XmlRpcFileManager. productTypeHash.put("id", type.getProductTypeId()); @@ -378,6 +494,34 @@ public final class XmlRpcStructFactory { return productTypeHash; } + public static Hashtable<String, Object> getXmlRpcProductType(ProductType type) { + Hashtable<String, Object> productTypeHash = new Hashtable<String, Object>(); + // TODO(bfoster): ProductType ID is currently required by XmlRpcFileManager. + productTypeHash.put("id", type.getProductTypeId()); + if (type.getName() != null) { + productTypeHash.put("name", type.getName()); + } + if (type.getDescription() != null) { + productTypeHash.put("description", type.getDescription()); + } + if (type.getProductRepositoryPath() != null) { + productTypeHash.put("repositoryPath",type.getProductRepositoryPath()); + } + if (type.getVersioner() != null) { + productTypeHash.put("versionerClass", type.getVersioner()); + } + if (type.getTypeMetadata() != null) { + productTypeHash.put("typeMetadata", type.getTypeMetadata().getHashTable()); + } + if (type.getExtractors() != null) { + productTypeHash.put("typeExtractors", getXmlRpcTypeExtractors(type.getExtractors())); + } + if (type.getHandlers() != null) { + productTypeHash.put("typeHandlers", getXmlRpcTypeHandlers(type.getHandlers())); + } + return productTypeHash; + } + @SuppressWarnings("unchecked") public static ProductType getProductTypeFromXmlRpc(Map<String, Object> productTypeHash) { ProductType type = new ProductType(); @@ -393,18 +537,29 @@ public final class XmlRpcStructFactory { } if (productTypeHash.get("typeExtractors") != null) { type.setExtractors(getTypeExtractorsFromXmlRpc( - (Vector<Map<String, Object>>) productTypeHash + (Vector<Hashtable<String, Object>>) productTypeHash .get("typeExtractors"))); } if (productTypeHash.get("typeHandlers") != null) { type.setHandlers(getTypeHandlersFromXmlRpc( - (Vector<Map<String, Object>>) productTypeHash + (Vector<Hashtable<String, Object>>) productTypeHash .get("typeHandlers"))); } return type; } - public static Vector<Map<String, Object>> getXmlRpcTypeExtractors(List<ExtractorSpec> extractors) { + public static Vector<Hashtable<String, Object>> getXmlRpcTypeExtractors(List<ExtractorSpec> extractors) { + Vector<Hashtable<String, Object>> extractorsVector = new Vector<Hashtable<String, Object>>(); + + if (extractors != null && extractors.size() > 0) { + for (ExtractorSpec spec : extractors) { + extractorsVector.add(getXmlRpcExtractorSpec(spec)); + } + } + + return extractorsVector; + } + public static Vector<Map<String, Object>> getXmlRpcTypeExtractorsMap(List<ExtractorSpec> extractors) { Vector<Map<String, Object>> extractorsVector = new Vector<Map<String, Object>>(); if (extractors != null && extractors.size() > 0) { @@ -416,15 +571,26 @@ public final class XmlRpcStructFactory { return extractorsVector; } - public static Map<String, Object> getXmlRpcExtractorSpec(ExtractorSpec spec) { - Map<String, Object> extractorHash = new ConcurrentHashMap<String, Object>(); + public static Hashtable<String, Object> getXmlRpcExtractorSpec(ExtractorSpec spec) { + Hashtable<String, Object> extractorHash = new Hashtable<String, Object>(); extractorHash.put("className", spec.getClassName()); extractorHash.put("config", getXmlRpcProperties(spec.getConfiguration())); return extractorHash; } - - public static Vector<Map<String, Object>> getXmlRpcTypeHandlers(List<TypeHandler> typeHandlers) { + + public static Vector<Hashtable<String, Object>> getXmlRpcTypeHandlers(List<TypeHandler> typeHandlers) { + Vector<Hashtable<String, Object>> handlersVector = new Vector<Hashtable<String, Object>>(); + + if (typeHandlers != null && typeHandlers.size() > 0) { + for (TypeHandler typeHandler : typeHandlers) { + handlersVector.add(getXmlRpcTypeHandler(typeHandler)); + } + } + + return handlersVector; + } + public static Vector<Map<String, Object>> getXmlRpcTypeHandlersMap(List<TypeHandler> typeHandlers) { Vector<Map<String, Object>> handlersVector = new Vector<Map<String, Object>>(); if (typeHandlers != null && typeHandlers.size() > 0) { @@ -435,8 +601,17 @@ public final class XmlRpcStructFactory { return handlersVector; } - - public static Map<String, Object> getXmlRpcTypeHandler(TypeHandler typeHandler) { + + public static Hashtable<String, Object> getXmlRpcTypeHandler(TypeHandler typeHandler) { + Hashtable<String, Object> handlerHash = new Hashtable<String, Object>(); + handlerHash.put("className", typeHandler != null ? + typeHandler.getClass().getCanonicalName():""); + handlerHash.put("elementName", typeHandler != null ? + typeHandler.getElementName():""); + return handlerHash; + } + + public static Map<String, Object> getXmlRpcTypeHandlerMap(TypeHandler typeHandler) { Map<String, Object> handlerHash = new ConcurrentHashMap<String, Object>(); handlerHash.put("className", typeHandler != null ? typeHandler.getClass().getCanonicalName():""); @@ -445,11 +620,11 @@ public final class XmlRpcStructFactory { return handlerHash; } - public static List<ExtractorSpec> getTypeExtractorsFromXmlRpc(Vector<Map<String, Object>> extractorsVector) { + public static List<ExtractorSpec> getTypeExtractorsFromXmlRpc(Vector<Hashtable<String, Object>> extractorsVector) { List<ExtractorSpec> extractors = new Vector<ExtractorSpec>(); if (extractorsVector != null && extractorsVector.size() > 0) { - for (Map<String, Object> extractorSpecHash : extractorsVector) { + for (Hashtable<String, Object> extractorSpecHash : extractorsVector) { extractors.add(getExtractorSpecFromXmlRpc(extractorSpecHash)); } } @@ -463,16 +638,16 @@ public final class XmlRpcStructFactory { ExtractorSpec spec = new ExtractorSpec(); spec.setClassName((String) extractorSpecHash.get("className")); spec - .setConfiguration(getPropertiesFromXmlRpc((Map<String, String>) extractorSpecHash + .setConfiguration(getPropertiesFromXmlRpc((Hashtable<String, String>) extractorSpecHash .get("config"))); return spec; } - public static List<TypeHandler> getTypeHandlersFromXmlRpc(Vector<Map<String, Object>> handlersVector) { + public static List<TypeHandler> getTypeHandlersFromXmlRpc(Vector<Hashtable<String, Object>> handlersVector) { List<TypeHandler> handlers = new Vector<TypeHandler>(); if (handlersVector != null && handlersVector.size() > 0) { - for (Map<String, Object> typeHandlerHash : handlersVector) { + for (Hashtable<String, Object> typeHandlerHash : handlersVector) { handlers.add(getTypeHandlerFromXmlRpc(typeHandlerHash)); } } @@ -481,7 +656,7 @@ public final class XmlRpcStructFactory { } public static TypeHandler getTypeHandlerFromXmlRpc( - Map<String, Object> typeHandlerHash) { + Hashtable<String, Object> typeHandlerHash) { TypeHandler typeHandler = GenericFileManagerObjectFactory .getTypeHandlerFromClassName((String) typeHandlerHash.get("className")); if(typeHandler != null) { @@ -495,7 +670,7 @@ public final class XmlRpcStructFactory { if (propHash != null && propHash.keySet().size() > 0) { for (Map.Entry<String, String> propName : propHash.entrySet()) { - String propValue = propHash.get(propName); + String propValue = propName.getValue(); props.setProperty(propName.getKey(), propValue); } } @@ -503,8 +678,8 @@ public final class XmlRpcStructFactory { return props; } - public static Map<String, String> getXmlRpcProperties(Properties props) { - Map<String, String> propHash = new ConcurrentHashMap<String, String>(); + public static Hashtable<String, String> getXmlRpcProperties(Properties props) { + Hashtable<String, String> propHash = new Hashtable<String, String>(); if (props != null && props.keySet().size() > 0) { for (Object o : props.keySet()) { @@ -517,7 +692,7 @@ public final class XmlRpcStructFactory { return propHash; } - public static Vector<Map<String, Object>> getXmlRpcReferences(List<Reference> references) { + public static Vector<Map<String, Object>> getXmlRpcReferencesMap(List<Reference> references) { Vector<Map<String, Object>> refVector = new Vector<Map<String, Object>>(); if (references == null) { @@ -532,17 +707,31 @@ public final class XmlRpcStructFactory { return refVector; } - public static List<Reference> getReferencesFromXmlRpc(Vector<Map<String, Object>> referenceVector) { + public static Vector<Hashtable<String, Object>> getXmlRpcReferences(List<Reference> references) { + Vector<Hashtable<String, Object>> refVector = new Vector<Hashtable<String, Object>>(); + + if (references == null) { + return refVector; + } + + for (Reference reference : references) { + Hashtable<String, Object> refHash = getXmlRpcReference(reference); + refVector.add(refHash); + } + + return refVector; + } + public static List<Reference> getReferencesFromXmlRpc(Vector<Hashtable<String, Object>> referenceVector) { List<Reference> references = new Vector<Reference>(); - for (Map<String, Object> aReferenceVector : referenceVector) { + for (Hashtable<String, Object> aReferenceVector : referenceVector) { Reference r = getReferenceFromXmlRpc(aReferenceVector); references.add(r); } return references; } - public static Map<String, Object> getXmlRpcReference(Reference reference) { - Map<String, Object> referenceHash = new ConcurrentHashMap<String, Object>(); + public static Hashtable<String, Object> getXmlRpcReference(Reference reference) { + Hashtable<String, Object> referenceHash = new Hashtable<String, Object>(); referenceHash.put("origReference", reference.getOrigReference()); referenceHash.put("dataStoreReference", reference .getDataStoreReference() != null ? reference @@ -564,26 +753,45 @@ public final class XmlRpcStructFactory { return reference; } + public static Reference getReferenceFromXmlRpcHashtable(Hashtable<String, Object> referenceHash) { + Reference reference = new Reference(); + reference.setDataStoreReference((String) referenceHash + .get("dataStoreReference")); + reference.setOrigReference((String) referenceHash.get("origReference")); + reference.setFileSize(Long.parseLong(referenceHash.get("fileSize").toString())); + reference.setMimeType((String) referenceHash.get("mimeType")); + return reference; + } + + public static Vector<Hashtable<String, Object>> getXmlRpcElementListHashtable(List<Element> elementList) { + Vector<Hashtable<String, Object>> elementVector = new Vector<Hashtable<String, Object>>(elementList.size()); + for (Element element : elementList) { + Hashtable<String, Object> elementHash = getXmlRpcElementHashTable(element); + elementVector.add(elementHash); + } + return elementVector; + } + public static Vector<Map<String, Object>> getXmlRpcElementList(List<Element> elementList) { Vector<Map<String, Object>> elementVector = new Vector<Map<String, Object>>(elementList.size()); for (Element element : elementList) { - Map<String, Object> elementHash = getXmlRpcElement(element); + HashMap<String, Object> elementHash = getXmlRpcElement(element); elementVector.add(elementHash); } return elementVector; } - public static List<Element> getElementListFromXmlRpc(Vector<Map<String, Object>> elementVector) { + public static List<Element> getElementListFromXmlRpc(Vector<Hashtable<String, Object>> elementVector) { List<Element> elementList = new Vector<Element>(elementVector.size()); - for (Map<String, Object> elementHash : elementVector) { + for (Hashtable<String, Object> elementHash : elementVector) { Element element = getElementFromXmlRpc(elementHash); elementList.add(element); } return elementList; } - public static Map<String, Object> getXmlRpcElement(Element element) { - Map<String, Object> elementHash = new ConcurrentHashMap<String, Object>(); + public static HashMap<String, Object> getXmlRpcElement(Element element) { + HashMap<String, Object> elementHash = new HashMap<String, Object>(); elementHash.put("id", element.getElementId()); elementHash.put("name", element.getElementName()); @@ -595,8 +803,20 @@ public final class XmlRpcStructFactory { return elementHash; } + public static Hashtable<String, Object> getXmlRpcElementHashTable(Element element) { + Hashtable<String, Object> elementHash = new Hashtable<String, Object>(); - public static Element getElementFromXmlRpc(Map<String, Object> elementHash) { + elementHash.put("id", element.getElementId()); + elementHash.put("name", element.getElementName()); + elementHash.put("dcElement", element.getDCElement() != null ? element + .getDCElement() : ""); + elementHash.put("description", + element.getDescription() != null ? element.getDescription() + : ""); + + return elementHash; + } + public static Element getElementFromXmlRpc(Hashtable<String, Object> elementHash) { Element element = new Element(); element.setElementId((String) elementHash.get("id")); element.setElementName((String) elementHash.get("name")); @@ -606,14 +826,14 @@ public final class XmlRpcStructFactory { return element; } - public static Map<String, Object> getXmlRpcQuery(Query query) { - Map<String, Object> queryHash = new ConcurrentHashMap<String, Object>(); - Vector<Map<String, Object>> criteriaVector = getXmlRpcQueryCriteriaList(query.getCriteria()); + public static Hashtable<String, Object> getXmlRpcQuery(Query query) { + Hashtable<String, Object> queryHash = new Hashtable<String, Object>(); + Vector<Hashtable<String, Object>> criteriaVector = getXmlRpcQueryCriteriaList(query.getCriteria()); queryHash.put("criteria", criteriaVector); return queryHash; } - public static Query getQueryFromXmlRpc(Map<String, Object> queryHash) { + public static Query getQueryFromXmlRpc(Hashtable<String, Object> queryHash) { Query query = new Query(); @SuppressWarnings("unchecked") List<QueryCriteria> criteria = getQueryCriteriaListFromXmlRpc((Vector<Map<String, Object>>) queryHash @@ -622,10 +842,19 @@ public final class XmlRpcStructFactory { return query; } - public static Vector<Map<String, Object>> getXmlRpcQueryCriteriaList(List<QueryCriteria> criteriaList) { - Vector<Map<String, Object>> criteriaVector = new Vector<Map<String, Object>>(criteriaList.size()); + public static Query getQueryFromXmlRpcMap(Map<String, Object> queryHash) { + Query query = new Query(); + @SuppressWarnings("unchecked") + List<QueryCriteria> criteria = getQueryCriteriaListFromXmlRpc((Vector<Map<String, Object>>) queryHash + .get("criteria")); + query.setCriteria(criteria); + return query; + } + + public static Vector<Hashtable<String, Object>> getXmlRpcQueryCriteriaList(List<QueryCriteria> criteriaList) { + Vector<Hashtable<String, Object>> criteriaVector = new Vector<Hashtable<String, Object>>(criteriaList.size()); for (QueryCriteria criteria : criteriaList) { - Map<String, Object> criteriaHash = getXmlRpcQueryCriteria(criteria); + Hashtable<String, Object> criteriaHash = getXmlRpcQueryCriteria(criteria); criteriaVector.add(criteriaHash); } @@ -642,8 +871,8 @@ public final class XmlRpcStructFactory { return criteriaList; } - public static Map<String, Object> getXmlRpcQueryCriteria(QueryCriteria criteria) { - Map<String, Object> criteriaHash = new ConcurrentHashMap<String, Object>(); + public static Hashtable<String, Object> getXmlRpcQueryCriteria(QueryCriteria criteria) { + Hashtable<String, Object> criteriaHash = new Hashtable<String, Object>(); criteriaHash.put("class",criteria.getClass().getCanonicalName()); if(criteria instanceof TermQueryCriteria){ @@ -659,11 +888,11 @@ public final class XmlRpcStructFactory { } else if(criteria instanceof BooleanQueryCriteria){ BooleanQueryCriteria boolQuery = (BooleanQueryCriteria) criteria; criteriaHash.put("operator", boolQuery.getOperator()); - Vector<Map<String, Object>> termsHash = new Vector<Map<String, Object>>(); + Vector<Hashtable<String, Object>> termsHash = new Vector<Hashtable<String, Object>>(); List<QueryCriteria> terms = boolQuery.getTerms(); for (QueryCriteria term : terms) { - Map<String, Object> termHash = getXmlRpcQueryCriteria(term); + Hashtable<String, Object> termHash = getXmlRpcQueryCriteria(term); termsHash.add(termHash); } criteriaHash.put("terms", termsHash); http://git-wip-us.apache.org/repos/asf/oodt/blob/aa5e31a6/metadata/src/main/java/org/apache/oodt/cas/metadata/Metadata.java ---------------------------------------------------------------------- diff --git a/metadata/src/main/java/org/apache/oodt/cas/metadata/Metadata.java b/metadata/src/main/java/org/apache/oodt/cas/metadata/Metadata.java index 44b9220..73a21dc 100644 --- a/metadata/src/main/java/org/apache/oodt/cas/metadata/Metadata.java +++ b/metadata/src/main/java/org/apache/oodt/cas/metadata/Metadata.java @@ -405,7 +405,7 @@ public class Metadata { * combined. */ @Deprecated - public void addMetadata(ConcurrentHashMap<String, Object> metadata, boolean replace) { + public void addMetadata(Map<String, Object> metadata, boolean replace) { // for back compat: the old method allowed us to give it a // Map<String,String> and it still worked for (Map.Entry<String, Object> key : metadata.entrySet()) { @@ -419,19 +419,6 @@ public class Metadata { } } - public void addMetadata(Map<String, Object> metadata, boolean replace) { - // for back compat: the old method allowed us to give it a - // Map<String,String> and it still worked - for (Map.Entry<String, Object> key : metadata.entrySet()) { - List<String> vals = (key.getValue() instanceof List) ? (List<String>) key.getValue() - : Collections.singletonList(key.getValue().toString()); - if (replace) { - this.replaceMetadata(key.getKey(), vals); - } else { - this.addMetadata(key.getKey(), vals); - } - } - } public void replaceMetadata(Map<String, Object> metadata) { this.root = this.createNewRoot(); http://git-wip-us.apache.org/repos/asf/oodt/blob/aa5e31a6/resource/src/main/java/org/apache/oodt/cas/resource/system/XmlRpcResourceManager.java ---------------------------------------------------------------------- diff --git a/resource/src/main/java/org/apache/oodt/cas/resource/system/XmlRpcResourceManager.java b/resource/src/main/java/org/apache/oodt/cas/resource/system/XmlRpcResourceManager.java index c767bf3..dbba32c 100644 --- a/resource/src/main/java/org/apache/oodt/cas/resource/system/XmlRpcResourceManager.java +++ b/resource/src/main/java/org/apache/oodt/cas/resource/system/XmlRpcResourceManager.java @@ -58,9 +58,6 @@ import java.util.logging.Logger; */ public class XmlRpcResourceManager { - /* the port to run the XML RPC web server on, default is 2000 */ - private int webServerPort = 2000; - /* our log stream */ private Logger LOG = Logger .getLogger(XmlRpcResourceManager.class.getName()); @@ -93,10 +90,10 @@ public class XmlRpcResourceManager { // start up the scheduler new Thread(scheduler).start(); - webServerPort = port; + // start up the web server - webServer = new WebServer(webServerPort); + webServer = new WebServer(port); webServer.addHandler("resourcemgr", this); webServer.start();
