/**
* 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;
}
}