| /** |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.oodt.pcs.tools; |
| |
| //OODT imports |
| import org.apache.oodt.pcs.listing.ListingConf; |
| import org.apache.oodt.pcs.metadata.PCSMetadata; |
| import org.apache.oodt.pcs.query.InputFilesQuery; |
| import org.apache.oodt.pcs.util.FileManagerUtils; |
| import org.apache.oodt.cas.filemgr.metadata.CoreMetKeys; |
| import org.apache.oodt.cas.filemgr.structs.Product; |
| import org.apache.oodt.cas.metadata.Metadata; |
| |
| //JDK imports |
| import java.io.File; |
| import java.util.Arrays; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Stack; |
| import java.util.Vector; |
| |
| /** |
| * |
| * The PCS Long Lister tool: mimics UNIX-ls and looks up descendant metadata for |
| * fields like TestTag, SubTestTag, TestCounter. Also displays Filename, |
| * StartDateTime, and EndDateTime for each listed file, and any of its met keys |
| * configured in the <code>pcs-ll-conf.xml</code> file. |
| * |
| * @author mattmann |
| * @version $Revision$ |
| * |
| */ |
| public class PCSLongLister implements PCSMetadata, CoreMetKeys { |
| |
| private FileManagerUtils fm; |
| |
| private ListingConf conf; |
| |
| public PCSLongLister(String fmUrlStr, String confFile) |
| throws InstantiationException { |
| fm = new FileManagerUtils(fmUrlStr); |
| try { |
| this.conf = new ListingConf(new File(confFile)); |
| } catch (Exception e) { |
| throw new InstantiationException(e.getMessage()); |
| } |
| } |
| |
| public void doList(List prodNames) { |
| if (prodNames != null && prodNames.size() > 0) { |
| System.out.println(getToolHeader()); |
| for (Iterator i = prodNames.iterator(); i.hasNext();) { |
| String prodName = (String) i.next(); |
| // check to see if the product name has a "/" in it |
| // (this is true in the case of someone using */* from |
| // a shell): if it does, we'll consider the prodName a |
| // path, and we'll clean it using new File(prodName).getName() |
| if (prodName.indexOf("/") != -1) { |
| // clean the prodName |
| prodName = new File(prodName).getName(); |
| } |
| |
| Product prod = fm.safeGetProductByName(prodName); |
| if (prod == null) { |
| // product not cataloged |
| System.out.println(prodName + "\tNot Cataloged!"); |
| continue; |
| } |
| Metadata met = fm.safeGetMetadata(prod); |
| outputListingLine(met, prodName); |
| } |
| } |
| |
| } |
| |
| public static void main(String[] args) throws Exception { |
| String usage = "PCSLongLister <conf file> <fmurl> [files]"; |
| List fileList; |
| |
| if (args.length < 2) { |
| System.err.println(usage); |
| System.exit(1); |
| } |
| |
| if (args.length == 2) { |
| // assume they gave us the current dir "." |
| // get a list of files from there |
| fileList = Arrays.asList(new File(".").list()); |
| } else if (args.length == 3 && new File(args[2]).isDirectory()) { |
| fileList = Arrays.asList(new File(args[2]).list()); |
| } else { |
| // it's going to be a list of files anyways |
| // so just treat the whole argList as a list of file names |
| List argList = Arrays.asList(args); |
| fileList = argList.subList(2, argList.size()); |
| } |
| |
| PCSLongLister lister = new PCSLongLister(args[0], args[1]); |
| lister.doList(fileList); |
| |
| } |
| |
| private String getToolHeader() { |
| StringBuffer header = new StringBuffer(); |
| for (String colName : this.conf.getHeaderColKeys()) { |
| header.append(this.conf.getHeaderColDisplayName(colName)); |
| header.append("\t"); |
| } |
| return header.toString(); |
| } |
| |
| private void outputListingLine(Metadata met, String prodName) { |
| StringBuffer output = new StringBuffer(); |
| for (String colNameKey : this.conf.getHeaderColKeys()) { |
| if (!this.conf.isCollectionField(colNameKey)) { |
| output.append(met.getMetadata(colNameKey)); |
| output.append("\t"); |
| } else { |
| output.append(outputOrBlank(getAllProductsByTag(met, prodName, |
| colNameKey))); |
| output.append("\t"); |
| } |
| } |
| System.out.println(output.toString()); |
| } |
| |
| private static String outputOrBlank(List items) { |
| if (items == null || (items != null && items.size() == 0)) { |
| return "N/A"; |
| } |
| |
| StringBuffer buf = new StringBuffer(); |
| for (Iterator i = items.iterator(); i.hasNext();) { |
| String item = (String) i.next(); |
| buf.append(item); |
| buf.append(","); |
| } |
| |
| buf.deleteCharAt(buf.length() - 1); |
| return buf.toString(); |
| } |
| |
| private List getAllProductsByTag(Metadata met, String productName, |
| String tagType) { |
| if (met.containsKey(tagType)) { |
| return met.getAllMetadata(tagType); |
| } |
| |
| // assume now that there are no test tags |
| // so what we want to do is to query the file catalog |
| // for InputFiles:productName and then keep doing this until |
| // we get an answer that has test tags: for each test tag (once |
| // they are found), we'll collect them in a list |
| List tags = new Vector(); |
| boolean foundTag = false; |
| Stack descendants = new Stack(); |
| descendants.push(productName); |
| |
| while (!descendants.empty() && !foundTag) { |
| String prodName = (String) descendants.pop(); |
| List products = fm.queryAllTypes(new InputFilesQuery(prodName, fm) |
| .buildQuery(), this.conf.getExcludedTypes()); |
| |
| // iterate over all the products |
| // get each set of metadata |
| // if you find one tag, then set foundTag = true, and we |
| // break |
| if (products != null && products.size() > 0) { |
| for (Iterator i = products.iterator(); i.hasNext();) { |
| Product prod = (Product) i.next(); |
| Metadata prodMet = fm.safeGetMetadata(prod); |
| |
| if (prodMet.containsKey(tagType)) { |
| // got one, done |
| if (!foundTag) |
| foundTag = true; |
| if (!tags.contains(prodMet.getMetadata(tagType))) { |
| tags.add(prodMet.getMetadata(tagType)); |
| } |
| } |
| } |
| |
| if (!foundTag) { |
| // continue the search |
| descendants.addAll(FileManagerUtils.toProductNameList(products)); |
| } |
| } |
| } |
| |
| return tags; |
| } |
| |
| } |